4. Exceptions to the PMIx Standard

Exceptions to the base PMIx Standard are listed here. These exceptions are not indicative of any intent to stray from the Standard, but instead represent the difference between the pace of development of the library versus the normal Standard’s process. Accordingly, it is expected that the exceptions listed below will make their way into a future release of the PMIx Standard and then be removed from the list of exceptions in some future OpenPMIx release.

4.1. Extensions

OpenPMIx v4.2.9 is based on the PMIx 4.2 Standard. In addition to Extensions to the Standard, this release includes the conversion of all support macros to PMIx function APIs — e.g., the PMIX_LOAD_PROCID macro is now the PMIx_Load_procid() function — in accordance with planned changes to the Standard. The macro versions have been retained as deprecated (without warnings) for backward compatibility.

4.2. Utility APIs

Load a key:

void PMIx_Load_key(pmix_key_t key, const char *src);

Check a key:

bool PMIx_Check_key(const char *key, const char *str);

Check to see if a key is a “reserved” key:

bool PMIx_Check_reserved_key(const char *key);

Load a string into a pmix_nspace_t struct:

void PMIx_Load_nspace(pmix_nspace_t nspace, const char *str);

Check two nspace structs for equality:

bool PMIx_Check_nspace(const char *key1, const char *key2);

Check if a namespace is invalid:

bool PMIx_Nspace_invalid(const char *nspace);

Load a process ID struct:

void PMIx_Load_procid(pmix_proc_t *p,
                      const char *ns,
                      pmix_rank_t rk);

Transfer a process ID struct (non-destructive):

void PMIx_Xfer_procid(pmix_proc_t *dst,
                      const pmix_proc_t *src);

Check two proc IDs for equality:

bool PMIx_Check_procid(const pmix_proc_t *a,
                       const pmix_proc_t *b);

Check two ranks for equality:

bool PMIx_Check_rank(pmix_rank_t a,
                     pmix_rank_t b);

Check if proc ID is invalid:

bool PMIx_Procid_invalid(const pmix_proc_t *p);

Check if the tool is connected to a PMIx server:
```
bool PMIx_tool_is_connected(void);
```

4.3. Argv Handling

Functions for handling of argv arrays (NULL-terminated array of strings)

Count the number of entries

int PMIx_Argv_count(char **a);

Append a string to the array

pmix_status_t PMIx_Argv_append_nosize(char ***argv, const char *arg);

Prepend a string to the array

pmix_status_t PMIx_Argv_prepend_nosize(char ***argv, const char *arg);

Append a string to the array, but only if it doesn’t already appear on the array (ignore if it does)

pmix_status_t PMIx_Argv_append_unique_nosize(char ***argv, const char *arg);

Free an array, including each string on the array

void PMIx_Argv_free(char **argv);

Split a string into an argv array, dividing the string on each occurrence of the specified delimiter character. Retain empty entries in the array when more than one copy of the delimiter character appears in a sequence.

char **PMIx_Argv_split_inter(const char *src_string,
                             int delimiter,
                             bool include_empty);

Split a string into an argv array, dividing the string on each occurrence of the specified delimiter character. Retain empty entries in the array when more than one copy of the delimiter character appears in a sequence. Acts as a wrapper to PMIx_Argv_split_inter with include_empty set to true

char **PMIx_Argv_split_with_empty(const char *src_string, int delimiter);

Split a string into an argv array, dividing the string on each occurrence of the specified delimiter character. Discard empty entries in the array when more than one copy of the delimiter character appears in a sequence. Acts as a wrapper to PMIx_Argv_split_inter with include_empty set to false

char **PMIx_Argv_split(const char *src_string, int delimiter);

Join all the elements of an argv array into a single newly-allocated string, with the specified delimiter character at the join points.

char *PMIx_Argv_join(char **argv, int delimiter);

Copy a NULL-terminated argv array.

char **PMIx_Argv_copy(char **argv);

Set environment variable:

pmix_status_t PMIx_Setenv(const char *name,
                          const char *value,
                          bool overwrite,
                          char ***env);

4.4. Value Struct Functions

Initialize a value struct:

void PMIx_Value_construct(pmix_value_t *val);

Free memory stored inside a value struct:

void PMIx_Value_destruct(pmix_value_t *val);

Create and initialize an array of value structs:
```
pmix_value_t* PMIx_Value_create(size_t n);
```
Free memory stored inside an array of coord structs (does not free the struct memory itself):
```
void PMIx_Value_free(pmix_value_t *v, size_t n);
```
Check the given value struct to determine if it includes a boolean value (includes strings for true and false, including abbreviations such as t or f), and if so, then its value. A value type of PMIX_UNDEF is taken to imply a boolean true.
```
pmix_boolean_t PMIx_Value_true(const pmix_value_t *v);
```

Compare the contents of two pmix_value_t structures:

pmix_value_cmp_t PMIx_Value_compare(pmix_value_t *v1,
                                    pmix_value_t *v2);

Get the size of the contents of a pmix_value_t structure:

pmix_status_t PMIx_Value_get_size(const pmix_value_t *val,
                                  size_t *size);

4.5. Data Array Functions

Construct a data array object, allocating the memory for the indicated number of the specified data type. Memory for the provided data array object must have previously been allocated or statically declared:
```
void PMIx_Data_array_construct(pmix_data_array_t *p,
                               size_t num, pmix_data_type_t type);
```

Initialize the fields of a data array object without allocating any memory for the included array:

void PMIx_Data_array_init(pmix_data_array_t *p,
                          pmix_data_type_t type);

Destroy a data array object, releasing all memory included in it:
```
void PMIx_Data_array_destruct(pmix_data_array_t *d);
```
Create and initialize a pmix_data_array_t structure, allocating the memory for the indicated number of the specified data type as well as the pmix_data_array_t object itself:
```
pmix_data_array_t* PMIx_Data_array_create(size_t n, pmix_data_type_t type);
```
Free memory stored inside a pmix_data_array_t structure (does not free the provided pmix_data_array_t object itself):
```
void PMIx_Data_array_free(pmix_data_array_t *p);
```

4.6. Info Struct Functions

Initialize an info struct. Memory for the provided object must have previously been allocated or statically declared:
```
void PMIx_Info_construct(pmix_info_t *p);
```

Free memory stored inside an info struct:

void PMIx_Info_destruct(pmix_info_t *p);

Create and initialize an array of info structs:
```
pmix_info_t* PMIx_Info_create(size_t n);
```
Free memory stored inside an array of coord structs (does not free the struct memory itself):
```
void PMIx_Info_free(pmix_info_t *p, size_t n);
```
Check the given info struct to determine if it includes a boolean value (includes strings for true and false, including abbreviations such as t or f), and if so, then its value. A value type of PMIX_UNDEF is taken to imply a boolean true as the presence of the key defaults to indicating true.
```
pmix_boolean_t PMIx_Info_true(const pmix_info_t *p);
```

Mark the info struct as required:

void PMIx_Info_required(pmix_info_t *p);

Mark the info struct as optional:

void PMIx_Info_optional(pmix_info_t *p);

Check if the info struct is required:

bool PMIx_Info_is_required(const pmix_info_t *p);

Check if the info struct is optional:

bool PMIx_Info_is_optional(const pmix_info_t *p);

Mark the info struct as processed:

void PMIx_Info_processed(pmix_info_t *p);

Check if the info struct has been processed:

bool PMIx_Info_was_processed(const pmix_info_t *p);

Mark the info struct as the end of an array:
```
void PMIx_Info_set_end(pmix_info_t *p);
```

Check if the info struct is the end of an array:

bool PMIx_Info_is_end(const pmix_info_t *p);

Mark the info as a qualifier:

void PMIx_Info_qualifier(pmix_info_t *p);

Check if the info struct is a qualifier:

bool PMIx_Info_is_qualifier(const pmix_info_t *p);

Mark the info struct as persistent — do not release its contents:
```
void PMIx_Info_persistent(pmix_info_t *p);
```

Check if the info struct is persistent:

bool PMIx_Info_is_persistent(const pmix_info_t *p);

Get the size of a pmix_info_t structure:

pmix_status_t PMIx_Info_get_size(const pmix_info_t *val,
                                 size_t *size);

4.7. Coordinate Struct Functions

Initialize a coord struct. Memory for the provided object must have previously been allocated or statically declared:
```
void PMIx_Coord_construct(pmix_coord_t *m);
```

Free memory stored inside a coord struct:

void PMIx_Coord_destruct(pmix_coord_t *m);

Create and initialize an array of coord structs:

pmix_coord_t* PMIx_Coord_create(size_t dims,
                                size_t number);

Free memory stored inside an array of coord structs (does not free the struct memory itself):
```
void PMIx_Coord_free(pmix_coord_t *m, size_t number);
```

4.8. Topology Functions

Initialize a topology struct. Memory for the provided object must have previously been allocated or statically declared:
```
void PMIx_Topology_construct(pmix_topology_t *t);
```

Create and initialize an array of topology structs:

pmix_topology_t* PMIx_Topology_create(size_t n);

Free memory stored inside an array of topology structs (does not free the struct memory itself):
```
void PMIx_Topology_free(pmix_topology_t *t, size_t n);
```

4.9. Cpuset Functions

Initialize a cpuset struct. Memory for the provided object must have previously been allocated or statically declared:
```
void PMIx_Cpuset_construct(pmix_cpuset_t *cpuset);
```

Free memory stored inside a cpuset struct:

void PMIx_Cpuset_destruct(pmix_cpuset_t *cpuset);

Create and initialize an array of cpuset structs:
```
pmix_cpuset_t* PMIx_Cpuset_create(size_t n);
```
Free memory stored inside an array of cpuset structs (does not free the struct memory itself):
```
void PMIx_Cpuset_free(pmix_cpuset_t *c, size_t n);
```

4.10. Geometry Functions

Initialize a geometry struct. Memory for the provided object must have previously been allocated or statically declared:
```
void PMIx_Geometry_construct(pmix_geometry_t *g);
```

Free memory stored inside a cpuset struct:

void PMIx_Geometry_destruct(pmix_geometry_t *g);

Create and initialize an array of cpuset structs:

pmix_geometry_t* PMIx_Geometry_create(size_t n);

Free memory stored inside an array of cpuset structs (does not free the struct memory itself):
```
void PMIx_Geometry_free(pmix_geometry_t *g, size_t n);
```

4.11. Device Distance Functions

Initialize a device distance struct. Memory for the provided object must have previously been allocated or statically declared:
```
void PMIx_Device_distance_construct(pmix_device_distance_t *d);
```

Free memory stored inside a device distance struct:

void PMIx_Device_distance_destruct(pmix_device_distance_t *d);

Create and initialize an array of device distance structs:

pmix_device_distance_t* PMIx_Device_distance_create(size_t n);

Free memory stored inside an array of device distance structs (does not free the struct memory itself):
```
void PMIx_Device_distance_free(pmix_device_distance_t *d, size_t n);
```

4.12. Byte Object Functions

Initialize a byte object struct. Memory for the provided object must have previously been allocated or statically declared:
```
void PMIx_Byte_object_construct(pmix_byte_object_t *b);
```

Free memory stored inside a byte object struct:

void PMIx_Byte_object_destruct(pmix_byte_object_t *g);

Create and initialize an array of byte object structs:

pmix_byte_object_t* PMIx_Byte_object_create(size_t n);

Free memory stored inside an array of byte object structs (does not free the struct memory itself):
```
void PMIx_Byte_object_free(pmix_byte_object_t *g, size_t n);
```

Load a byte object:

void PMIx_Byte_object_load(pmix_byte_object_t *b,
                           char *d, size_t sz);

4.13. Endpoint Functions

Initialize an endpoint struct. Memory for the provided object must have previously been allocated or statically declared:
```
void PMIx_Endpoint_construct(pmix_endpoint_t *e);
```

Free memory stored inside an endpoint struct:

void PMIx_Endpoint_destruct(pmix_endpoint_t *e);

Create and initialize an array of endpoint structs:

pmix_endpoint_t* PMIx_Endpoint_create(size_t n);

Free memory stored inside an array of endpoint structs (does not free the struct memory itself):
```
void PMIx_Endpoint_free(pmix_endpoint_t *e, size_t n);
```

4.14. Envar Functions

Initialize an envar struct. Memory for the provided object must have previously been allocated or statically declared:
```
void PMIx_Envar_construct(pmix_envar_t *e);
```

Free memory stored inside an envar struct:

void PMIx_Envar_destruct(pmix_envar_t *e);

Create and initialize an array of envar structs:
```
pmix_envar_t* PMIx_Envar_create(size_t n);
```
Free memory stored inside an array of envar structs (does not free the struct memory itself):
```
void PMIx_Envar_free(pmix_envar_t *e, size_t n);
```

Load an envar struct:

void PMIx_Envar_load(pmix_envar_t *e,
                     char *var,
                     char *value,
                     char separator);

4.15. Data Buffer Functions

Initialize a data buffer struct. Memory for the provided object must have previously been allocated or statically declared:
```
void PMIx_Data_buffer_construct(pmix_data_buffer_t *b);
```

Free memory stored inside a data buffer struct:

void PMIx_Data_buffer_destruct(pmix_data_buffer_t *b);

Create a data buffer struct:

pmix_data_buffer_t* PMIx_Data_buffer_create(void);

Free memory stored inside a data buffer struct:

void PMIx_Data_buffer_release(pmix_data_buffer_t *b);

Load a data buffer struct:

void PMIx_Data_buffer_load(pmix_data_buffer_t *b,
                           char *bytes, size_t sz);

Unload a data buffer struct:

void PMIx_Data_buffer_unload(pmix_data_buffer_t *b,
                             char **bytes, size_t *sz);

4.16. Proc Struct Functions

Initialize a proc struct. Memory for the provided object must have previously been allocated or statically declared:
```
void PMIx_Proc_construct(pmix_proc_t *p);
```

Clear memory inside a proc struct:

void PMIx_Proc_destruct(pmix_proc_t *p);

Create and initialize an array of proc structs:
```
pmix_proc_t* PMIx_Proc_create(size_t n);
```
Free memory stored inside an array of proc structs (does not free the struct memory itself):
```
void PMIx_Proc_free(pmix_proc_t *p, size_t n);
```

Load a proc struct:

void PMIx_Proc_load(pmix_proc_t *p,
                    char *nspace, pmix_rank_t rank);

Construct a multicluster nspace struct from cluster and nspace values:

void PMIx_Multicluster_nspace_construct(pmix_nspace_t target,
                                        pmix_nspace_t cluster,
                                        pmix_nspace_t nspace);

Parse a multicluster nspace struct to separate out the cluster and nspace portions:

void PMIx_Multicluster_nspace_parse(pmix_nspace_t target,
                                    pmix_nspace_t cluster,
                                    pmix_nspace_t nspace);

4.17. Proc Info Functions

Initialize a proc info struct. Memory for the provided object must have previously been allocated or statically declared:
```
void PMIx_Proc_info_construct(pmix_proc_info_t *p);
```

Clear memory inside a proc info struct:

void PMIx_Proc_info_destruct(pmix_proc_info_t *p);

Create and initialize an array of proc info structs:

pmix_proc_info_t* PMIx_Proc_info_create(size_t n);

Free memory stored inside an array of proc info structs (does not free the struct memory itself):
```
void PMIx_Proc_info_free(pmix_proc_info_t *p, size_t n);
```

4.18. Proc Stats Functions

Initialize a proc stats struct. Memory for the provided object must have previously been allocated or statically declared:
```
void PMIx_Proc_stats_construct(pmix_proc_stats_t *p);
```

Clear memory inside a proc stats struct:

void PMIx_Proc_stats_destruct(pmix_proc_stats_t *p);

Create and initialize an array of proc stats structs:

pmix_proc_stats_t* PMIx_Proc_stats_create(size_t n);

Free memory stored inside an array of proc stats structs (does not free the struct memory itself):
```
void PMIx_Proc_stats_free(pmix_proc_stats_t *p, size_t n);
```

4.19. Disk Stats Functions

Initialize a disk stats struct. Memory for the provided object must have previously been allocated or statically declared:
```
void PMIx_Disk_stats_construct(pmix_disk_stats_t *p);
```

Clear memory inside a disk stats struct:

void PMIx_Disk_stats_destruct(pmix_disk_stats_t *p);

Create and initialize an array of disk stats structs:

pmix_disk_stats_t* PMIx_Disk_stats_create(size_t n);

Free memory stored inside an array of disk stats structs (does not free the struct memory itself):
```
void PMIx_Disk_stats_free(pmix_disk_stats_t *p, size_t n);
```

4.20. Net Stats Functions

Initialize a net stats struct. Memory for the provided object must have previously been allocated or statically declared:
```
void PMIx_Net_stats_construct(pmix_net_stats_t *p);
```

Clear memory inside a net stats struct:

void PMIx_Net_stats_destruct(pmix_net_stats_t *p);

Create and initialize an array of net stats structs:

pmix_net_stats_t* PMIx_Net_stats_create(size_t n);

Free memory stored inside an array of net stats structs (does not free the struct memory itself):
```
void PMIx_Net_stats_free(pmix_net_stats_t *p, size_t n);
```

4.21. Process Data Functions

Initialize a pdata struct. Memory for the provided object must have previously been allocated or statically declared:
```
void PMIx_Pdata_construct(pmix_pdata_t *p);
```

Clear memory inside a pdata struct:

void PMIx_Pdata_destruct(pmix_pdata_t *p);

Create and initialize an array of pdata structs:
```
pmix_pdata_t* PMIx_Pdata_create(size_t n);
```
Free memory stored inside an array of pdata structs (does not free the struct memory itself):
```
void PMIx_Pdata_free(pmix_pdata_t *p, size_t n);
```

4.22. App Struct Functions

Initialize a pmix_app_t struct. Memory for the provided object must have previously been allocated or statically declared:
```
void PMIx_App_construct(pmix_app_t *p);
```
Clear memory inside an app struct:
```
void PMIx_App_destruct(pmix_app_t *p);
```
Create and initialize an array of app structs:
```
pmix_app_t* PMIx_App_create(size_t n);
```
Create and initialize an array of pmix_info_t structs in the provided pmix_app_t object:
```
void PMIx_App_info_create(pmix_app_t *p, size_t n);
```
Free memory stored inside an array of app structs (does not free the struct memory itself):
```
void PMIx_App_free(pmix_app_t *p, size_t n);
```
Free memory stored inside a pmix_app_t object
```
void PMIx_App_release(pmix_app_t *p);
```

4.23. PMIx Info List Functions

Constructing arrays of pmix_info_t for passing to an API can be tedious since the pmix_info_t itself is not a “list object”. Since this is a very frequent operation, a set of APIs has been provided that opaquely manipulates internal PMIx list structures for this purpose. The user only need provide a void* pointer to act as the caddy for the internal list object. The base functions for these operations are in the Standard, but the following functions have been added here:

Retrieve the next pmix_info_t from the provided list, given the current pointer. Passing a NULL to the prev parameter will return the first object on the list. A NULL is returned upon reaching the end of the list:
pmix_info_t* PMIx_Info_list_get_info(void *ptr, void *prev, void **next);
Insert a pmix_info_t` struct into the provided list. This directly copies the contents of the provided pmix_info_t struct, preserving any included pointers. The object on the list is subsequently marked as persistent to avoid free’ing any objects pointed to in the struct:
pmix_status_t PMIx_Info_list_insert(void *ptr, pmix_info_t *info);

Prepend a value onto the provided list:

pmix_status_t PMIx_Info_list_prepend(void *ptr,
                                     const char *key,
                                     const void *value,
                                     pmix_data_type_t type);

4.24. Pretty-Print Functions

The following pretty-print support APIs have been added:

Print a pmix_value_cmp_t value

const char* PMIx_Value_comparison_string(pmix_value_cmp_t cmp);

Print the contents of a pmix_app_t struct. Note that the returned string must be free’d by the caller:
char* PMIx_App_string(const pmix_app_t *app);

The following pretty-print support APIs have been slightly modified to add a const qualifier to their input parameter:

const char* PMIx_Get_attribute_string(const char *attribute);
const char* PMIx_Get_attribute_name(const char *attrstring);
char* PMIx_Info_string(const pmix_info_t *info);
char* PMIx_Value_string(const pmix_value_t *value);

This is not expected to cause any issues for users.

The following function has been added to return the pmix_status_t corresponding to the string name of the constant:

pmix_status_t PMIx_Error_code(const char *errname);

4.25. Constants

PMIX_DATA_BUFFER: data type for packing/unpacking of pmix_data_buffer_t objects
PMIX_DISK_STATS: data type for packing/unpacking of pmix_disk_stats_t objects
PMIX_NET_STATS: data type for packing/unpacking of pmix_net_stats_t objects
PMIX_NODE_STATS: data type for packing/unpacking of pmix_node_stats_t objects
PMIX_PROC_STATS: data type for packing/unpacking of pmix_proc_stats_t objects
PMIX_ERR_JOB_EXE_NOT_FOUND: specified executable not found
PMIX_ERR_JOB_INSUFFICIENT_RESOURCES: insufficient resources to spawn job
PMIX_ERR_JOB_SYS_OP_FAILED: system library operation failed
PMIX_ERR_JOB_WDIR_NOT_FOUND: specified working directory not found
PMIX_READY_FOR_DEBUG: event indicating job/proc is ready for debug (accompanied by PMIX_BREAKPOINT indicating where proc is waiting)
PMIX_ERR_PROC_REQUESTED_ABORT: process called PMIx_Abort
PMIX_ERR_PROC_KILLED_BY_CMD: process was terminated by RTE command
PMIX_ERR_PROC_FAILED_TO_START: process failed to start
PMIX_ERR_PROC_ABORTED_BY_SIG: process aborted by signal (e.g., segmentation fault)
PMIX_ERR_PROC_SENSOR_BOUND_EXCEEDED: process terminated due to exceeding a sensor boundary
PMIX_ERR_EXIT_NONZERO_TERM: process exited normally, but with a non-zero status
PMIX_INFO_QUALIFIER (value: 0x00000008): Info is a qualifier to the primary value
PMIX_INFO_PERSISTENT (value: 0x00000010): Do not release included value

Note

OpenPMIx version v4.2.9 renamed the PMIX_DEBUG_WAIT_FOR_NOTIFY to PMIX_READY_FOR_DEBUG. The prior name is retained as deprecated for backward compatibility.

4.26. Attributes

Attribute	Type	Description
`PMIX_EXTERNAL_AUX_EVENT_BASE` `"pmix.evaux"`	`(void*)`	event base to be used for auxiliary functions (e.g., capturing signals) that would otherwise interfere with the host
`PMIX_CONNECT_TO_SCHEDULER` `"pmix.cnct.sched"`	`(bool)`	Connect to the system scheduler
`PMIX_BIND_PROGRESS_THREAD` `"pmix.bind.pt"`	`(char*)`	Comma-delimited ranges of CPUs that the internal PMIx progress thread shall be bound to
`PMIX_BIND_REQUIRED` `"pmix.bind.reqd"`	`(bool)`	Return error if the internal PMIx progress thread cannot be bound
`PMIX_COLOCATE_PROCS` `"pmix.colproc"`	`(pmix_data_array_t*)`	Array of `pmix_proc_t` identifying the procs with which the new job’s procs are to be colocated
`PMIX_COLOCATE_NPERPROC` `"pmix.colnum.proc"`	`(uint16_t)`	Number of procs to colocate with each identified proc
`PMIX_COLOCATE_NPERNODE` `"pmix.colnum.node"`	`(uint16_t)`	Number of procs to colocate on the node of each identified proc
`PMIX_EVENT_ONESHOT` `pmix.evone`	`(bool)`	when registering, indicate that this event handler is to be deleted after being invoked
`PMIX_GROUP_ADD_MEMBERS` `pmix.grp.add`	`(pmix_data_array_t*)`	Array of `pmix_proc_t` identifying procs that are not included in the membership specified in the procs array passed to the `PMIx_Group_construct[_nb]()` call, but are to be included in the final group. The identified procs will be sent an invitation to join the group during the construction procedure. This is used when some members of the proposed group do not know the full membership and therefore cannot include all members in the call to construct.
`PMIX_GROUP_LOCAL_CID` `pmix.grp.lclid`	`(size_t)`	Local context ID for the specified process member of a group
`PMIX_GROUP_INFO` `pmix.grp.info`	`pmix_data_array_t`	Array of pmix_info_t containing data that is to be shared across all members of a group during group construction
`PMIX_IOF_TAG_DETAILED_OUTPUT` `pmix.iof.tagdet`	`(bool)`	Tag output with the [local jobid,rank][hostname:pid] and channel it comes from
`PMIX_IOF_TAG_FULLNAME_OUTPUT` `pmix.iof.tagfull`	`(bool)`	Tag output with the [nspace,rank] and channel it comes from
`PMIX_LOG_AGG` `pmix.log.agg`	`(bool)`	Whether to aggregate and prevent duplicate logging messages based on key value pairs.
`PMIX_LOG_KEY` `pmix.log.key`	`(char*)`	key to a logging message
`PMIX_LOG_VAL` `pmix.log.val`	`(char*)`	value to a logging message
`PMIX_MYSERVER_URI` `pmix.mysrvr.uri`	`(char*)`	URI of this proc’s listener socket
`PMIX_QUALIFIED_VALUE` `pmix.qual.val`	`(pmix_data_array_t*)`	Value being provided consists of the primary key-value pair in first position, followed by one or more key-value qualifiers to be used when subsequently retrieving the primary value
`PMIX_WDIR_USER_SPECIFIED` `pmix.wdir.user`	`(bool)`	User specified the working directory
`PMIX_RUNTIME_OPTIONS` `pmix.runopt`	`(char*)`	Environment-specific runtime directives that control job behavior
`PMIX_ABORT_NON_ZERO_TERM` `pmix.abnz`	`(bool)`	Abort the spawned job if any process terminates with non-zero status
`PMIX_DO_NOT_LAUNCH` `pmix.dnl`	`(bool)`	Execute all procedures to prepare the requested job for launch, but do not launch it. Typically combined with the PMIX_DISPLAY_MAP or PMIX_DISPLAY_MAP_DETAILED for debugging purposes.
`PMIX_SHOW_LAUNCH_PROGRESS` `pmix.showprog`	`(bool)`	Provide periodic progress reports on job launch procedure (e.g., after every 100 processes have been spawned)
`PMIX_AGGREGATE_HELP` `pmix.agg.help`	`(bool)`	Aggregate help messages, reporting each unique help message once accompanied by the number of processes that reported it
`PMIX_REPORT_CHILD_SEP` `pmix.rptchildsep`	`(bool)`	Report the exit status of any child jobs spawned by the primary job separately. If false, then the final exit status reported will be zero if the primary job and all spawned jobs exit normally, or the first non-zero status returned by either primary or child jobs.
`PMIX_DISPLAY_MAP_DETAILED` `pmix.dispmapdet`	`(bool)`	display a highly detailed placement map upon spawn
`PMIX_DISPLAY_ALLOCATION` `pmix.dispalloc`	`(bool)`	display the resource allocation
`PMIX_DISPLAY_TOPOLOGY` `pmix.disptopo`	`(char*)`	comma-delimited list of hosts whose topology is to be displayed
`PMIX_DISPLAY_PROCESSORS` `pmix.dispcpus`	`(char*)`	comma-delimited list of hosts whose available CPUs are to be displayed
`PMIX_DISPLAY_PARSEABLE_OUTPUT` `pmix.dispparse`	`(bool)`	display requested info in a format more amenable to machine parsing
`PMIX_SORTED_PROC_ARRAY` `pmix.sorted.parr`	`(bool)`	Proc array being passed has been sorted
`PMIX_QUERY_PROVISIONAL_ABI_VERSION` `pmix.qry.prabiver`	`(char*)`	The PMIx Standard Provisional ABI version(s) supported, returned in the form of a comma separated list of “MAJOR.MINOR” pairs
`PMIX_QUERY_STABLE_ABI_VERSION` `pmix.qry.stabiver`	`(char*)`	The PMIx Standard Stable ABI version(s) supported, returned in the form of a comma separated list of “MAJOR.MINOR” pairs

Note

The attribute PMIX_DEBUG_STOP_IN_APP has been modified to only support a PMIX_BOOL value instead of an optional array of ranks due to questions over the use-case calling for stopping a subset of a job’s processes while allowing others to run “free”.

4.27. Datatypes

pmix_value_cmp_t: an enum indicating the relative value of two pmix_value_t objects. Values include:
- PMIX_EQUAL
- PMIX_VALUE1_GREATER
- PMIX_VALUE2_GREATER
- PMIX_VALUE_TYPE_DIFFERENT
- PMIX_VALUE_INCOMPATIBLE_OBJECTS
- PMIX_VALUE_COMPARISON_NOT_AVAIL
pmix_boolean_t: an enum indicating boolean state of a pmix_value_t (possibly contained in a pmix_info_t object):
- PMIX_BOOL_TRUE
- PMIX_BOOL_FALSE
- PMIX_NON_BOOL
pmix_disk_stats_t: contains statistics on disk read/write operations
pmix_net_stats_t: contains statistics on network activity
pmix_node_stats_t: contains statistics on node resource usage
pmix_proc_stats_t: contains statistics on process resource usage

4.27.1. Datatype static initializers

Static initializers were added for each complex data type (i.e., a data type defined as a struct). Most are contained in the Standard, but the following extensions have been provided:

PMIX_PROC_STATS_STATIC_INIT
PMIX_DISK_STATS_STATIC_INIT
PMIX_NET_STATS_STATIC_INIT
PMIX_NODE_STATS_STATIC_INIT

4.28. Macros

Although the convenience macros have been deprecated, several were added (in deprecated form) that previously were missing. These are added for symmetry to support those who continue to use the macros, and include:

PMIX_XFER_PROCID: transfer a pmix_proc_t to another one (non-destructive copy)
PMIX_INFO_SET_END: mark this pmix_info_t as being at the end of an array
PMIX_INFO_SET_PERSISTENT: mark that the data in this pmix_info_t is not to be released by PMIX_Info_destruct() (or its macro form)
PMIX_INFO_SET_QUALIFIER: mark this pmix_info_t as a qualifier to the primary key
PMIX_INFO_IS_PERSISTENT: test if this pmix_info_t has been marked as persistent
PMIX_INFO_IS_QUALIFIER: test if this pmix_info_t has been marked as a qualifier
PMIX_DATA_ARRAY_INIT: initialize a pmix_data_array_t
PMIX_CHECK_TRUE: check if a pmix_value_t is boolean true (supports string as well as traditional boolean values)
PMIX_CHECK_BOOL: check if a pmix_value_t is a boolean value (supports string as well as traditional boolean values)

Macros supporting pmix_disk_stats_t objects:

PMIX_DISK_STATS_CONSTRUCT
PMIX_DISK_STATS_CREATE
PMIX_DISK_STATS_DESTRUCT
PMIX_DISK_STATS_FREE
PMIX_DISK_STATS_RELEASE

Macros supporting pmix_net_stats_t objects:

PMIX_NET_STATS_CONSTRUCT
PMIX_NET_STATS_CREATE
PMIX_NET_STATS_DESTRUCT
PMIX_NET_STATS_FREE
PMIX_NET_STATS_RELEASE

Macros supporting pmix_node_stats_t objects:

PMIX_NODE_STATS_CONSTRUCT
PMIX_NODE_STATS_CREATE
PMIX_NODE_STATS_DESTRUCT
PMIX_NODE_STATS_RELEASE

Macros supporting pmix_proc_stats_t objects:

PMIX_PROC_STATS_CONSTRUCT
PMIX_PROC_STATS_CREATE
PMIX_PROC_STATS_DESTRUCT
PMIX_PROC_STATS_FREE
PMIX_PROC_STATS_RELEASE