No changes to the test logic

Conflicts:
	doc/man/man1/sacct.1
	doc/man/man1/srun.1
	src/sacct/sacct.h

Bug 1578

Bug 1550

their own jobs.

Bug 1469

This seems to apply only to Cray/ALPS systems.
This partially reverts commit 5fc68cae
It also adds a new check for NULL job_ptr

_entity_add_data() in src/common/entity.c defined as "static" to avoid
    confusion with same function name in src/common/layouts_mgr.c
_entity_get_node_walkfunc() in src/common/entity.c defined as "static"
Removed redundant set of "rc" variable _layouts_autoupdate_layout_if_allowed(),
    src/common/layouts_mgr.c
Initialized variable "rc" in _layouts_read_state(), src/common/layouts_mgr.c
    in case the named file does not exist (stat() returns an error)
The CLANG tool reported a possible error in _autoupdate_layout_tree(),
    src/common/layouts_mgr.c in the event that xtree_node_get_data()
    returns a NULL value and that pointer is used later in the function for
    "cnode->entity". I added "return 1" if xtree_node_get_data() returns NULL,
    but am not yet sure if that is the correct action.
The CLANG tool reported possible errors related to a NULL value pointer in
    s_p_parse_pair_with_op(), src/common/parse_config.c which have been fixed.

Having MAX_PREFIX_CNT to 1k limits the number of elements that can be
expressed using expressions like node[1-1025].ib[0] to 1024.

As 64k is the max number of nodes that can be handled by Slurm, increase
that value to 64k in order to be able to express at least that number of
elements using a[x]b[y] when y is the same value for all the elements.

Note: also required by the layouts parsing logic when parsing float values
in expressions like : 'Entity=node[1-64000] FloatKey=[1-64000].[0]'

layouts plugins inheritances among entities KVs like KEYSPEC_UPDATE_CHILDREN_SUM
(see layouts_mgr.h) are now fully managed by the layouts manager.

An extra third stage is added while loading the configuration and state
informations during startup in order to automatically update the layouts
entities KVs based on the relationships defined in the plugin among the keys.
The third stage is executed right after the second one that is in charge of
establishing the relations among the entities.

When an update is performed using the API laouts_update_layout call, the
autoupdate logic is also applied.

Note that a layout plugin must explicitely ask for autoupdate support by the
layouts manager using the autoupdate field of its layouts_plugin_spec_t internal
structure 'plugin_spec'.

layouts API calls using the push/pull logic also leverage the autoupdate
mechanism.

Note that for now, the autoupdate is "full" whenever it is called.
Improvements should be considered in the future to improve the performance
of the logic when possible, especially in push/pull contexts.

> layouts_entity_{set,get,setpush,pullget}_kv[_ref] calls

These new calls enable to perform the get/set operations on the key/value pairs
of a particular entity in a defined layout. The push/pull operations enable to
call for the automatic update of the linked entities in the layouts (i.e. parent)
for push and for the automatic update of the requested entity using the linked
entities information for pull.

Note that 2 variations are proposed for each call, differentiated by the _ref
suffix. When _ref is suffixed, then the calls only deal with references and no
copy of the data is performed, only data references (pointers) are set/get. The
_ref suffixed calls should then be considered as more efficient but can lead to
issues if the pointers are modified after the get operations occur but before
their real use. For that reason, layouts_{lock,unlock} calls would certainly
appear in a next commit as well as _nolock suffixed calls in order to better
handle those scenarios.

Note that the ...pull/push... calls are just stubbed in that commit. The logic
will be added later.

> layouts_entity_get_mkv[_ref] calls

These new calls enable to perform the get operations on a set of key/value pairs
of a particular entity in a defined layout. (mkv stands for multiple k/v pairs)

When _ref is suffixed, then the calls only deal with references and no copy of
the data is performed, only data references (pointers) are got. The _ref suffixed
calls should then be considered as more efficient but can lead to issues if the
pointers are modified after the get operations occur but before their real use.

For that reason, layouts_{lock,unlock} calls would certainly appear in a next
commit as well as _nolock suffixed calls in order to better handle these
scenarios.

The previous logic directly associated xtree_node_t elements with entities.
The list of nodes associated to an entity was thus directly made of xtree_node_t
elements each one pointing directly to the entity.

An entity being layout agnostic, that is to say not bound to a particular layout
it was not possible to look for the xtree_node_t element associated with a
particular layout in an entity. This was due to the fact that the entity_node
element was not used as an intermediate level to link the entities and their
different xtree_node_t elements. Indeed, this is the role of the entity_node to
associate a position in a particular layout with an entity.

The new logic ensures that when building a layout relational structure :

- (1) an entity node associated with the targeted layout is created for the
  entity and references both the layout and the entity it is associated too.
- (2) the entity node is the element that is added to the (tree) relational
  structure of the layout resulting in the creation of a relational node
  (xtree_node_t) that will reference it directly.
- (3) the created relational node (xtree_node_t) is referenced in the associated
  entity node in order to provide a way to go back to the position in the
  relational structure from the entity node, thus enabling to search the
  neighborhood of an entity for a particular layout only knowing the entity
  and the layout to look at.

The packing logic was modified to take into account the new level of indirection
(the entity_node element) when walking the relational structure of a particular
layout. The debug dump logic was modified too to reflect the changes.