EIC code displayed by LXR |
|
|
|
|||
File indexing completed on 2026-05-09 09:01:22
0001 /* include/pmix_common.h. Generated from pmix_common.h.in by configure. */ 0002 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */ 0003 /* 0004 * Copyright (c) 2013-2020 Intel, Inc. All rights reserved. 0005 * Copyright (c) 2016-2019 Research Organization for Information Science 0006 * and Technology (RIST). All rights reserved. 0007 * Copyright (c) 2016-2022 IBM Corporation. All rights reserved. 0008 * Copyright (c) 2016-2019 Mellanox Technologies, Inc. 0009 * All rights reserved. 0010 * Copyright (c) 2021 Triad National Security, LLC. All rights 0011 * reserved. 0012 * 0013 * 0014 * Redistribution and use in source and binary forms, with or without 0015 * modification, are permitted provided that the following conditions are 0016 * met: 0017 * 0018 * - Redistributions of source code must retain the above copyright 0019 * notice, this list of conditions and the following disclaimer. 0020 * 0021 * - Redistributions in binary form must reproduce the above copyright 0022 * notice, this list of conditions and the following disclaimer listed 0023 * in this license in the documentation and/or other materials 0024 * provided with the distribution. 0025 * 0026 * - Neither the name of the copyright holders nor the names of its 0027 * contributors may be used to endorse or promote products derived from 0028 * this software without specific prior written permission. 0029 * 0030 * The copyright holders provide no reassurances that the source code 0031 * provided does not infringe any patent, copyright, or any other 0032 * intellectual property rights of third parties. The copyright holders 0033 * disclaim any liability to any recipient for claims brought against 0034 * recipient by any third party for infringement of that parties 0035 * intellectual property rights. 0036 * 0037 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 0038 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 0039 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 0040 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 0041 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 0042 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 0043 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 0044 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 0045 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 0046 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 0047 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 0048 * 0049 * Copyright (c) 2020 Cisco Systems, Inc. All rights reserved 0050 * Copyright (c) 2021-2026 Nanook Consulting All rights reserved. 0051 * $COPYRIGHT$ 0052 * 0053 * Additional copyrights may follow 0054 * 0055 * $HEADER$ 0056 */ 0057 0058 #ifndef PMIx_COMMON_H 0059 #define PMIx_COMMON_H 0060 0061 #include <stdbool.h> 0062 #include <stdlib.h> 0063 #include <stdint.h> 0064 #include <stdio.h> 0065 #include <string.h> 0066 #include <time.h> 0067 #include <ctype.h> 0068 #include <sys/time.h> /* for struct timeval */ 0069 #include <unistd.h> /* for uid_t and gid_t */ 0070 #include <sys/types.h> /* for uid_t and gid_t */ 0071 0072 /* Whether C compiler supports -fvisibility */ 0073 #define PMIX_HAVE_VISIBILITY 1 0074 0075 #if PMIX_HAVE_VISIBILITY == 1 0076 #define PMIX_EXPORT __attribute__((__visibility__("default"))) 0077 #else 0078 #define PMIX_EXPORT 0079 #endif 0080 0081 0082 #include <pmix_version.h> 0083 0084 #if defined(c_plusplus) || defined(__cplusplus) 0085 extern "C" { 0086 #endif 0087 0088 /**** PMIX CONSTANTS ****/ 0089 0090 /* define maximum value and key sizes */ 0091 #define PMIX_MAX_NSLEN 255 0092 #define PMIX_MAX_KEYLEN 511 0093 0094 /* define abstract types for namespaces and keys */ 0095 typedef char pmix_nspace_t[PMIX_MAX_NSLEN+1]; 0096 typedef char pmix_key_t[PMIX_MAX_KEYLEN+1]; 0097 0098 /* define a type for rank values */ 0099 typedef uint32_t pmix_rank_t; 0100 0101 /* define a value for requests for job-level data 0102 * where the info itself isn't associated with any 0103 * specific rank, or when a request involves 0104 * a rank that isn't known - e.g., when someone requests 0105 * info thru one of the legacy interfaces where the rank 0106 * is typically encoded into the key itself since there is 0107 * no rank parameter in the API itself */ 0108 #define PMIX_RANK_UNDEF UINT32_MAX 0109 /* define a value to indicate that the user wants the 0110 * data for the given key from every rank that posted 0111 * that key */ 0112 #define PMIX_RANK_WILDCARD UINT32_MAX-1 0113 /* other special rank values will be used to define 0114 * groups of ranks for use in collectives */ 0115 #define PMIX_RANK_LOCAL_NODE UINT32_MAX-2 // all ranks on local node 0116 #define PMIX_RANK_LOCAL_PEERS UINT32_MAX-4 // all peers (i.e., all procs within the same nspace) on local node 0117 /* define an invalid value */ 0118 #define PMIX_RANK_INVALID UINT32_MAX-3 0119 /* define a boundary for valid ranks */ 0120 #define PMIX_RANK_VALID UINT32_MAX-50 0121 /* define a macro for testing for valid ranks */ 0122 #define PMIX_RANK_IS_VALID(r) \ 0123 ((r) < PMIX_RANK_VALID) 0124 0125 /* define a value to indicate that data applies 0126 * to all apps in a job */ 0127 #define PMIX_APP_WILDCARD UINT32_MAX 0128 0129 /**** PMIX ENVIRONMENTAL PARAMETERS ****/ 0130 /* URI of tool waiting for launcher to rendezvous back to it */ 0131 #define PMIX_LAUNCHER_RNDZ_URI "PMIX_LAUNCHER_RNDZ_URI" 0132 0133 /* PMIX_LAUNCHER_RNDZ_FILE - if set, contains the full pathname 0134 * of a file the launcher is to write that contains its connection info. 0135 * Works in addition to anything else the launcher may output. 0136 */ 0137 #define PMIX_LAUNCHER_RNDZ_FILE "PMIX_LAUNCHER_RNDZ_FILE" 0138 0139 /* pipe to be monitored that indicates when the parent process 0140 * terminates - used by fork'd tools to identify when the tool 0141 * that started them has died */ 0142 #define PMIX_KEEPALIVE_PIPE "PMIX_KEEPALIVE_PIPE" 0143 0144 0145 /* define a set of "standard" PMIx attributes that can 0146 * be queried. Implementations (and users) are free to extend as 0147 * desired, so the get functions need to be capable 0148 * of handling the "not found" condition. Note that these 0149 * are attributes of the system and the job as opposed to 0150 * values the application (or underlying MPI library) 0151 * might choose to expose - i.e., they are values provided 0152 * by the resource manager as opposed to the application. Thus, 0153 * these keys are RESERVED */ 0154 #define PMIX_ATTR_UNDEF "pmix.undef" 0155 0156 /* initialization attributes */ 0157 #define PMIX_EXTERNAL_PROGRESS "pmix.evext" // (bool) The host shall progress the PMIx library via 0158 // calls to PMIx_Progress 0159 #define PMIX_PROGRESS_THREAD_FLUSH "pmix.evflush" // (bool) Flush the internal progress thread before stopping 0160 #define PMIX_PROGRESS_THREAD_NAME "pmix.evname" // (char*) Name of specific progress thread to stop. NULL is 0161 // interpreted to mean all threads 0162 #define PMIX_EXTERNAL_AUX_EVENT_BASE "pmix.evaux" // (void*) event base to be used for auxiliary 0163 // functions (e.g., capturing signals) that would 0164 // otherwise interfere with the host 0165 #define PMIX_SERVER_TOOL_SUPPORT "pmix.srvr.tool" // (bool) The host RM wants to declare itself as willing 0166 // to accept tool connection requests - rendezvous 0167 // files will be readable only by the host's user ID 0168 #define PMIX_SERVER_ALLOW_FOREIGN_TOOLS "pmix.srvr.ftools" // (bool) Mark the tool rendezvous files as readable 0169 // by all users and allow tools from user IDs other 0170 // than that of the server to connect. Note that the 0171 // host has ultimate authority over such connections, 0172 // and can restrict execution of tool requests as per 0173 // host policy (e.g., limit foreign tools to "queries") 0174 #define PMIX_ALLOW_CLIENT_CLONES "pmix.allow.clones" // (bool) Allow connections from forks of client processes 0175 #define PMIX_SERVER_REMOTE_CONNECTIONS "pmix.srvr.remote" // (bool) Allow connections from remote tools (do not use 0176 // loopback device) 0177 #define PMIX_SERVER_SYSTEM_SUPPORT "pmix.srvr.sys" // (bool) The host RM wants to declare itself as being 0178 // the local system server for PMIx connection 0179 // requests - rendezvous files will be readable 0180 // only by the host's user ID 0181 #define PMIX_SERVER_SESSION_SUPPORT "pmix.srvr.sess" // (bool) The host RM wants to declare itself as being 0182 // the local session server for PMIx connection 0183 // requests 0184 #define PMIX_SERVER_TMPDIR "pmix.srvr.tmpdir" // (char*) temp directory where PMIx server will place 0185 // client rendezvous points and contact info 0186 #define PMIX_SYSTEM_TMPDIR "pmix.sys.tmpdir" // (char*) temp directory for this system, where PMIx 0187 // server will place tool rendezvous points and 0188 // contact info 0189 #define PMIX_SERVER_SHARE_TOPOLOGY "pmix.srvr.share" // (bool) server is to share its copy of the local node 0190 // topology (whether given to it or self-discovered) with any clients. 0191 #define PMIX_SERVER_ENABLE_MONITORING "pmix.srv.monitor" // (bool) Enable PMIx internal monitoring by server 0192 #define PMIX_SERVER_NSPACE "pmix.srv.nspace" // (char*) Name of the nspace to use for this server 0193 #define PMIX_SERVER_RANK "pmix.srv.rank" // (pmix_rank_t) Rank of this server 0194 #define PMIX_SERVER_GATEWAY "pmix.srv.gway" // (bool) Server is acting as a gateway for PMIx requests 0195 // that cannot be serviced on backend nodes 0196 // (e.g., logging to email) 0197 #define PMIX_SERVER_SYS_CONTROLLER "pmix.srv.ctrlr" // (bool) Server is hosted by the system controller for 0198 // the cluster 0199 #define PMIX_SERVER_SCHEDULER "pmix.srv.sched" // (bool) Server is hosted by the system scheduler 0200 #define PMIX_SERVER_START_TIME "pmix.srv.strtime" // (char*) Time when the server started - i.e., when the server created 0201 // it's rendezvous file (given in ctime string format) 0202 #define PMIX_HOMOGENEOUS_SYSTEM "pmix.homo" // (bool) The nodes comprising the session are homogeneous - i.e., they 0203 // each contain the same number of identical packages, fabric interfaces, 0204 // GPU, and other devices 0205 #define PMIX_SINGLETON "pmix.singleton" // (char*) String representation (nspace.rank) of proc ID for the singleton 0206 // the server was started to support 0207 #define PMIX_BIND_PROGRESS_THREAD "pmix.bind.pt" // (char*) Comma-delimited ranges of CPUs that the internal PMIx progress 0208 // thread shall be bound to 0209 #define PMIX_BIND_REQUIRED "pmix.bind.reqd" // (bool) Return error if the internal PMIx progress thread cannot be bound 0210 0211 0212 /* tool-related attributes */ 0213 #define PMIX_TOOL_NSPACE "pmix.tool.nspace" // (char*) Name of the nspace to use for this tool 0214 #define PMIX_TOOL_RANK "pmix.tool.rank" // (uint32_t) Rank of this tool 0215 #define PMIX_SERVER_PIDINFO "pmix.srvr.pidinfo" // (pid_t) pid of the target server for a tool 0216 #define PMIX_CONNECT_TO_SYSTEM "pmix.cnct.sys" // (bool) The requestor requires that a connection be made only to 0217 // a local system-level PMIx server 0218 #define PMIX_CONNECT_SYSTEM_FIRST "pmix.cnct.sys.first" // (bool) Preferentially look for a system-level PMIx server first 0219 #define PMIX_CONNECT_TO_SCHEDULER "pmix.cnct.sched" // (bool) Connect to the system scheduler 0220 #define PMIX_CONNECT_TO_SYS_CONTROLLER "pmix.cnct.ctrlr" // (bool) Connect to the system controller 0221 #define PMIX_CONNECTION_ORDER "pmix.cnct.ord" // (char*) Comma-delimited list of attributes defining the order in which 0222 // connections should be attempted, from first to last. If the 0223 // final entry is not an "only" flag (e.g., PMIX_CONNECT_TO_SYSTEM), 0224 // then connection will default to the local server if no preceding 0225 // option succeeds. Thus, the following list: 0226 // PMIX_CONNECT_TO_SCHEDULER 0227 // PMIX_CONNECT_TO_SYS_CONTROLLER 0228 // PMIX_CONNECT_TO_SYSTEM 0229 // would first attempt to connect to the scheduler, then the system 0230 // controller, and then the local system-level server. If none of those 0231 // succeed, then the connection attempt will error out. 0232 // However, if the last entry were PMIX_CONNECT_SYSTEM_FIRST, then the 0233 // connection procedure would (after failing to connect to a local 0234 // system-level server) continue to include an attempt to connect 0235 // to any local server that accepted the connection request. 0236 #define PMIX_SERVER_URI "pmix.srvr.uri" // (char*) URI of server to be contacted 0237 #define PMIX_MYSERVER_URI "pmix.mysrvr.uri" // (char*) URI of this proc's listener socket 0238 #define PMIX_SERVER_HOSTNAME "pmix.srvr.host" // (char*) node where target server is located 0239 #define PMIX_CONNECT_MAX_RETRIES "pmix.tool.mretries" // (uint32_t) maximum number of times to try to connect to server 0240 #define PMIX_CONNECT_RETRY_DELAY "pmix.tool.retry" // (uint32_t) time in seconds between connection attempts 0241 #define PMIX_TOOL_DO_NOT_CONNECT "pmix.tool.nocon" // (bool) the tool wants to use internal PMIx support, but does 0242 // not want to connect to a PMIx server 0243 // from the specified processes to this tool 0244 #define PMIX_TOOL_CONNECT_OPTIONAL "pmix.tool.conopt" // (bool) tool shall connect to a server if available, but otherwise 0245 // continue to operate unconnected 0246 #define PMIX_LAUNCHER "pmix.tool.launcher" // (bool) tool is a launcher and needs rendezvous files created 0247 #define PMIX_LAUNCHER_RENDEZVOUS_FILE "pmix.tool.lncrnd" // (char*) Pathname of file where connection info is to be stored 0248 #define PMIX_TOOL_ATTACHMENT_FILE "pmix.tool.attach" // (char*) File containing connection info to be used for attaching to server 0249 #define PMIX_PRIMARY_SERVER "pmix.pri.srvr" // (bool) The server to which the tool is connecting shall be designated 0250 // the primary server once connection has been accomplished. 0251 #define PMIX_NOHUP "pmix.nohup" // (bool) Any processes started on behalf of the calling tool (or the 0252 // specified namespace, if such specification is included in the 0253 // list of attributes) should continue after the tool disconnects 0254 // from its server 0255 #define PMIX_LAUNCHER_DAEMON "pmix.lnch.dmn" // (char*) Path to executable that is to be used as the backend daemon 0256 // for the launcher. This replaces the launcher's own daemon with 0257 // the specified executable. Note that the user is therefore 0258 // responsible for ensuring compatibility of the specified 0259 // executable and the host launcher. 0260 #define PMIX_EXEC_AGENT "pmix.exec.agnt" // (char*) Path to executable that the launcher's backend daemons are to 0261 // fork/exec in place of the actual application processes. The 0262 // launcher's daemon shall pass the full command line of the 0263 // application on the command line of the exec agent, which shall 0264 // not connect back to the launcher's daemon. The exec agent is 0265 // responsible for exec'ing the specified application process in 0266 // its own place. 0267 #define PMIX_LAUNCH_DIRECTIVES "pmix.lnch.dirs" // (pmix_data_array_t*) Array of pmix_info_t containing directives for 0268 // the launcher - a convenience attribute for retrieving all 0269 // directives with a single call to PMIx_Get 0270 0271 /* identification attributes */ 0272 #define PMIX_REALUID "pmix.ruid" // (uint32_t) real user id 0273 #define PMIX_USERID "pmix.euid" // (uint32_t) effective user id 0274 #define PMIX_REALGID "pmix.rgid" // (uint32_t) real group id 0275 #define PMIX_GRPID "pmix.egid" // (uint32_t) effective group id 0276 #define PMIX_REQUESTOR "pmix.requestor" // (pmix_proc_t*) ID of the process requesting the 0277 // specified operation. Used when relaying 0278 // a request to the PMIx library on behalf 0279 // of someone else where the API doesn't 0280 // include a "requestor" parameter 0281 #define PMIX_VERSION_INFO "pmix.version" // (char*) PMIx version of contactor 0282 #define PMIX_REQUESTOR_IS_TOOL "pmix.req.tool" // (bool) requesting process is a tool 0283 #define PMIX_REQUESTOR_IS_CLIENT "pmix.req.client" // (bool) requesting process is a client process 0284 #define PMIX_PSET_NAME "pmix.pset.nm" // (char*) The name of the newly defined process set. 0285 #define PMIX_PSET_NAMES "pmix.pset.nms" // (pmix_data_array_t*) Returns an array of string names of the 0286 // process sets in which the given process is a member. 0287 #define PMIX_PSET_MEMBERS "pmix.pset.mems" // (pmix_data_array_t*) An array of pmix_proc_t containing 0288 // the members of the newly defined process set. 0289 #define PMIX_REINCARNATION "pmix.reinc" // (uint32_t) number of times this process has been instantiated - i.e., 0290 // tracks the number of times it has been restarted 0291 0292 /* model attributes */ 0293 #define PMIX_PROGRAMMING_MODEL "pmix.pgm.model" // (char*) programming model being initialized (e.g., "MPI" or "OpenMP") 0294 #define PMIX_MODEL_LIBRARY_NAME "pmix.mdl.name" // (char*) programming model implementation ID (e.g., "OpenMPI" or "MPICH") 0295 #define PMIX_MODEL_LIBRARY_VERSION "pmix.mld.vrs" // (char*) programming model version string (e.g., "2.1.1") 0296 #define PMIX_THREADING_MODEL "pmix.threads" // (char*) threading model used (e.g., "pthreads") 0297 #define PMIX_MODEL_NUM_THREADS "pmix.mdl.nthrds" // (uint64_t) number of active threads being used by the model 0298 #define PMIX_MODEL_NUM_CPUS "pmix.mdl.ncpu" // (uint64_t) number of cpus being used by the model 0299 #define PMIX_MODEL_CPU_TYPE "pmix.mdl.cputype" // (char*) granularity - "hwthread", "core", etc. 0300 #define PMIX_MODEL_PHASE_NAME "pmix.mdl.phase" // (char*) user-assigned name for a phase in the application execution - e.g., 0301 // "cfd reduction" 0302 #define PMIX_MODEL_PHASE_TYPE "pmix.mdl.ptype" // (char*) type of phase being executed - e.g., "matrix multiply" 0303 #define PMIX_MODEL_AFFINITY_POLICY "pmix.mdl.tap" // (char*) thread affinity policy - e.g.: 0304 // "master" (thread co-located with master thread), 0305 // "close" (thread located on cpu close to master thread) 0306 // "spread" (threads load-balanced across available cpus) 0307 0308 /* attributes for TCP connections */ 0309 #define PMIX_TCP_REPORT_URI "pmix.tcp.repuri" // (char*) output URI - '-' => stdout, '+' => stderr, or filename 0310 #define PMIX_TCP_URI "pmix.tcp.uri" // (char*) URI of server to connect to, or file:<name of file containing it> 0311 #define PMIX_TCP_IF_INCLUDE "pmix.tcp.ifinclude" // (char*) comma-delimited list of devices and/or CIDR notation 0312 #define PMIX_TCP_IF_EXCLUDE "pmix.tcp.ifexclude" // (char*) comma-delimited list of devices and/or CIDR notation 0313 #define PMIX_TCP_IPV4_PORT "pmix.tcp.ipv4" // (int) IPv4 port to be used 0314 #define PMIX_TCP_IPV6_PORT "pmix.tcp.ipv6" // (int) IPv6 port to be used 0315 #define PMIX_TCP_DISABLE_IPV4 "pmix.tcp.disipv4" // (bool) true to disable IPv4 family 0316 #define PMIX_TCP_DISABLE_IPV6 "pmix.tcp.disipv6" // (bool) true to disable IPv6 family 0317 0318 0319 /* general proc-level attributes */ 0320 #define PMIX_CPUSET "pmix.cpuset" // (char*) String representation of bitmap applied to process upon launch 0321 #define PMIX_CPUSET_BITMAP "pmix.bitmap" // (pmix_cpuset_t*) Bitmap applied to process at launch 0322 #define PMIX_CREDENTIAL "pmix.cred" // (char*) security credential assigned to proc 0323 #define PMIX_SPAWNED "pmix.spawned" // (bool) true if this proc resulted from a call to PMIx_Spawn 0324 #define PMIX_NODE_OVERSUBSCRIBED "pmix.ndosub" // (bool) true if number of procs from this job on this node 0325 // exceeds the number of slots allocated to it 0326 0327 /* scratch directory locations for use by applications */ 0328 #define PMIX_TMPDIR "pmix.tmpdir" // (char*) top-level tmp dir assigned to session 0329 #define PMIX_NSDIR "pmix.nsdir" // (char*) sub-tmpdir assigned to namespace 0330 #define PMIX_PROCDIR "pmix.pdir" // (char*) sub-nsdir assigned to proc 0331 #define PMIX_TDIR_RMCLEAN "pmix.tdir.rmclean" // (bool) Resource Manager will clean session directories 0332 0333 0334 /* information about relative ranks as assigned by the RM */ 0335 #define PMIX_CLUSTER_ID "pmix.clid" // (char*) a string name for the cluster this proc is executing on 0336 #define PMIX_PROCID "pmix.procid" // (pmix_proc_t*) process identifier 0337 #define PMIX_NSPACE "pmix.nspace" // (char*) nspace of a job 0338 #define PMIX_JOBID "pmix.jobid" // (char*) jobid assigned by scheduler 0339 #define PMIX_APPNUM "pmix.appnum" // (uint32_t) app number within the job 0340 #define PMIX_RANK "pmix.rank" // (pmix_rank_t) process rank within the job 0341 #define PMIX_GLOBAL_RANK "pmix.grank" // (pmix_rank_t) rank spanning across all jobs in this session 0342 #define PMIX_APP_RANK "pmix.apprank" // (pmix_rank_t) rank within this app 0343 #define PMIX_NPROC_OFFSET "pmix.offset" // (pmix_rank_t) starting global rank of this job 0344 #define PMIX_LOCAL_RANK "pmix.lrank" // (uint16_t) rank on this node within this job 0345 #define PMIX_NODE_RANK "pmix.nrank" // (uint16_t) rank on this node spanning all jobs 0346 #define PMIX_PACKAGE_RANK "pmix.pkgrank" // (uint16_t) rank within this job on the package where this proc resides 0347 #define PMIX_LOCALLDR "pmix.lldr" // (pmix_rank_t) lowest rank on this node within this job 0348 #define PMIX_APPLDR "pmix.aldr" // (pmix_rank_t) lowest rank in this app within this job 0349 #define PMIX_PROC_PID "pmix.ppid" // (pid_t) pid of specified proc 0350 #define PMIX_SESSION_ID "pmix.session.id" // (uint32_t) session identifier 0351 #define PMIX_NODE_LIST "pmix.nlist" // (char*) comma-delimited list of nodes running procs for the specified nspace 0352 #define PMIX_ALLOCATED_NODELIST "pmix.alist" // (char*) comma-delimited list of all nodes in this allocation regardless of 0353 // whether or not they currently host procs. 0354 #define PMIX_HOSTNAME "pmix.hname" // (char*) name of the host the specified proc is on 0355 #define PMIX_HOSTNAME_ALIASES "pmix.alias" // (char*) comma-delimited list of names by which this node is known 0356 #define PMIX_HOSTNAME_KEEP_FQDN "pmix.fqdn" // (bool) FQDN hostnames are being retained 0357 #define PMIX_NODEID "pmix.nodeid" // (uint32_t) node identifier where the specified proc is located 0358 #define PMIX_LOCAL_PEERS "pmix.lpeers" // (char*) comma-delimited string of ranks on this node within the specified nspace 0359 #define PMIX_LOCAL_PROCS "pmix.lprocs" // (pmix_data_array_t*) array of pmix_proc_t of procs on the specified node 0360 #define PMIX_LOCAL_CPUSETS "pmix.lcpus" // (char*) colon-delimited cpusets of local peers within the specified nspace 0361 #define PMIX_PARENT_ID "pmix.parent" // (pmix_proc_t*) identifier of the process that called PMIx_Spawn 0362 // to launch this proc's application 0363 #define PMIX_EXIT_CODE "pmix.exit.code" // (int) exit code returned when proc terminated 0364 0365 /* size info */ 0366 #define PMIX_UNIV_SIZE "pmix.univ.size" // (uint32_t) #slots in this session 0367 #define PMIX_JOB_SIZE "pmix.job.size" // (uint32_t) #procs in this job 0368 #define PMIX_JOB_NUM_APPS "pmix.job.napps" // (uint32_t) #apps in this job 0369 #define PMIX_APP_SIZE "pmix.app.size" // (uint32_t) #procs in this application 0370 #define PMIX_LOCAL_SIZE "pmix.local.size" // (uint32_t) #procs in this job on this node 0371 #define PMIX_NODE_SIZE "pmix.node.size" // (uint32_t) #procs across all jobs on this node 0372 #define PMIX_MAX_PROCS "pmix.max.size" // (uint32_t) max #procs for this job 0373 #define PMIX_NUM_SLOTS "pmix.num.slots" // (uint32_t) #slots allocated 0374 #define PMIX_NUM_NODES "pmix.num.nodes" // (uint32_t) #nodes currently hosting processes in the specified realm. 0375 #define PMIX_NUM_ALLOCATED_NODES "pmix.num.anodes" // (uint32_t) #nodes in the specified realm regardless of whether or 0376 // not they currently host processes. 0377 0378 /* Memory info */ 0379 #define PMIX_AVAIL_PHYS_MEMORY "pmix.pmem" // (uint64_t) total available physical memory on this node 0380 #define PMIX_DAEMON_MEMORY "pmix.dmn.mem" // (float) Mbytes of memory currently used by daemon 0381 #define PMIX_CLIENT_AVG_MEMORY "pmix.cl.mem.avg" // (float) Average Mbytes of memory used by client processes 0382 0383 0384 /* topology info */ 0385 #define PMIX_TOPOLOGY2 "pmix.topo2" // (pmix_topology_t*) pointer to a PMIx topology object 0386 #define PMIX_LOCALITY_STRING "pmix.locstr" // (char*) string describing a proc's location 0387 #define PMIX_TOPOLOGY_INDEX "pmix.topo.index" // (int) index of a topology in a storage array 0388 0389 0390 /* request-related info */ 0391 #define PMIX_COLLECT_DATA "pmix.collect" // (bool) collect data and return it at the end of the operation 0392 #define PMIX_ALL_CLONES_PARTICIPATE "pmix.clone.part" // (bool) All clones of the calling process must participate in the collective operation. 0393 #define PMIX_COLLECT_GENERATED_JOB_INFO "pmix.collect.gen" // (bool) Collect all job-level information (i.e., reserved keys) that was locally 0394 // generated by PMIx servers. Some job-level information (e.g., distance between 0395 // processes and fabric devices) is best determined on a distributed basis as it 0396 // primarily pertains to local processes. Should remote processes need to access 0397 // the information, it can either be obtained collectively using the PMIx_Fence 0398 // operation with this directive, or can be retrieved one peer at a time using 0399 // PMIx_Get without first having performed the job-wide collection. 0400 #define PMIX_TIMEOUT "pmix.timeout" // (int) time in sec before specified operation should time out (0 => infinite) 0401 #define PMIX_IMMEDIATE "pmix.immediate" // (bool) specified operation should immediately return an error from the PMIx 0402 // server if requested data cannot be found - do not request it from 0403 // the host RM 0404 #define PMIX_WAIT "pmix.wait" // (int) caller requests that the server wait until at least the specified 0405 // #values are found (0 => all and is the default) 0406 #define PMIX_NOTIFY_COMPLETION "pmix.notecomp" // (bool) notify parent process upon termination of child job 0407 #define PMIX_RANGE "pmix.range" // (pmix_data_range_t) value for calls to publish/lookup/unpublish or for 0408 // monitoring event notifications 0409 #define PMIX_PERSISTENCE "pmix.persist" // (pmix_persistence_t) value for calls to publish 0410 #define PMIX_DATA_SCOPE "pmix.scope" // (pmix_scope_t) scope of the data to be found in a PMIx_Get call 0411 #define PMIX_OPTIONAL "pmix.optional" // (bool) look only in the client's local data store for the requested value - do 0412 // not request data from the server if not found 0413 #define PMIX_GET_STATIC_VALUES "pmix.get.static" // (bool) Request that the data be returned in the provided storage location 0414 #define PMIX_GET_POINTER_VALUES "pmix.get.pntrs" // (bool) Request that any pointers in the returned value point directly 0415 // to values in the key-value store 0416 #define PMIX_EMBED_BARRIER "pmix.embed.barrier" // (bool) execute a blocking fence operation before executing the 0417 // specified operation 0418 #define PMIX_JOB_TERM_STATUS "pmix.job.term.status" // (pmix_status_t) status returned upon job termination 0419 #define PMIX_PROC_TERM_STATUS "pmix.proc.term.status" // (pmix_status_t) status returned upon process termination 0420 #define PMIX_PROC_STATE_STATUS "pmix.proc.state" // (pmix_proc_state_t) process state 0421 #define PMIX_GET_REFRESH_CACHE "pmix.get.refresh" // (bool) when retrieving data for a remote process, refresh the existing 0422 // local data cache for the process in case new values have been 0423 // put and committed by it since the last refresh 0424 #define PMIX_ACCESS_PERMISSIONS "pmix.aperms" // (pmix_data_array_t*) Define access permissions for the published 0425 // data. The value shall contain an array of pmix_info_t structs 0426 // containing the specified permissions. 0427 #define PMIX_ACCESS_USERIDS "pmix.auids" // (pmix_data_array_t*) Array of effective UIDs that are allowed to 0428 // access the published data 0429 #define PMIX_ACCESS_GRPIDS "pmix.agids" // (pmix_data_array_t*) Array of effective GIDs that are allowed to 0430 // access the published data 0431 #define PMIX_WAIT_FOR_CONNECTION "pmix.wait.conn" // (bool) wait until the specified connection has been made 0432 #define PMIX_QUALIFIED_VALUE "pmix.qual.val" // (pmix_data_array_t*) Value being provided consists of the primary 0433 // key-value pair in first position, followed by one or more 0434 // key-value qualifiers to be used when subsequently retrieving 0435 // the primary value 0436 0437 0438 /* attributes used by host server to pass data to/from the server convenience library - the 0439 * data will then be parsed and provided to the local clients. Not generally accessible by users */ 0440 #define PMIX_REGISTER_NODATA "pmix.reg.nodata" // (bool) Registration is for nspace only, do not copy job data 0441 #define PMIX_NODE_MAP "pmix.nmap" // (char*) regex of nodes containing procs for this job 0442 #define PMIX_NODE_MAP_RAW "pmix.nmap.raw" // (char*) comma-delimited list of nodes containing procs for this job 0443 #define PMIX_PROC_MAP "pmix.pmap" // (char*) regex describing procs on each node within this job 0444 #define PMIX_PROC_MAP_RAW "pmix.pmap.raw" // (char*) semi-colon delimited list of strings, each string containing 0445 // a comma-delimited list of ranks on the corresponding node 0446 #define PMIX_ANL_MAP "pmix.anlmap" // (char*) process mapping in ANL notation (used in PMI-1/PMI-2) 0447 #define PMIX_APP_MAP_TYPE "pmix.apmap.type" // (char*) type of mapping used to layout the application (e.g., cyclic) 0448 #define PMIX_APP_MAP_REGEX "pmix.apmap.regex" // (char*) regex describing the result of the mapping 0449 #define PMIX_REQUIRED_KEY "pmix.req.key" // (char*) key the user needs prior to responding from a dmodex request 0450 #define PMIX_LOCAL_COLLECTIVE_STATUS "pmix.loc.col.st" // (pmix_status_t) status code for local collective operation being 0451 // reported to host by server library 0452 #define PMIX_SORTED_PROC_ARRAY "pmix.sorted.parr" // (bool) Proc array being passed has been sorted 0453 0454 0455 /* event handler registration and notification info keys */ 0456 #define PMIX_EVENT_HDLR_NAME "pmix.evname" // (char*) string name identifying this handler 0457 #define PMIX_EVENT_HDLR_FIRST "pmix.evfirst" // (bool) invoke this event handler before any other handlers 0458 #define PMIX_EVENT_HDLR_LAST "pmix.evlast" // (bool) invoke this event handler after all other handlers have been called 0459 #define PMIX_EVENT_HDLR_FIRST_IN_CATEGORY "pmix.evfirstcat" // (bool) invoke this event handler before any other handlers in this category 0460 #define PMIX_EVENT_HDLR_LAST_IN_CATEGORY "pmix.evlastcat" // (bool) invoke this event handler after all other handlers in this category have been called 0461 #define PMIX_EVENT_HDLR_BEFORE "pmix.evbefore" // (char*) put this event handler immediately before the one specified in the (char*) value 0462 #define PMIX_EVENT_HDLR_AFTER "pmix.evafter" // (char*) put this event handler immediately after the one specified in the (char*) value 0463 #define PMIX_EVENT_HDLR_PREPEND "pmix.evprepend" // (bool) prepend this handler to the precedence list within its category 0464 #define PMIX_EVENT_HDLR_APPEND "pmix.evappend" // (bool) append this handler to the precedence list within its category 0465 #define PMIX_EVENT_CUSTOM_RANGE "pmix.evrange" // (pmix_data_array_t*) array of pmix_proc_t defining range of event notification 0466 #define PMIX_EVENT_AFFECTED_PROC "pmix.evproc" // (pmix_proc_t*) single proc that was affected 0467 #define PMIX_EVENT_AFFECTED_PROCS "pmix.evaffected" // (pmix_data_array_t*) array of pmix_proc_t defining affected procs 0468 #define PMIX_EVENT_NON_DEFAULT "pmix.evnondef" // (bool) event is not to be delivered to default event handlers 0469 #define PMIX_EVENT_RETURN_OBJECT "pmix.evobject" // (void*) object to be returned whenever the registered cbfunc is invoked 0470 // NOTE: the object will _only_ be returned to the process that 0471 // registered it 0472 #define PMIX_EVENT_DO_NOT_CACHE "pmix.evnocache" // (bool) instruct the PMIx server not to cache the event 0473 #define PMIX_EVENT_SILENT_TERMINATION "pmix.evsilentterm" // (bool) do not generate an event when this job normally terminates 0474 #define PMIX_EVENT_PROXY "pmix.evproxy" // (pmix_proc_t*) PMIx server that sourced the event 0475 #define PMIX_EVENT_TEXT_MESSAGE "pmix.evtext" // (char*) text message suitable for output by recipient - e.g., describing 0476 // the cause of the event 0477 #define PMIX_EVENT_TIMESTAMP "pmix.evtstamp" // (time_t) System time when the associated event occurred. 0478 #define PMIX_EVENT_ONESHOT "pmix.evone" // (bool) when registering, indicate that this event handler is to be deleted 0479 // after being invoked 0480 #define PMIX_EVENT_STAYS_LOCAL "pmix.evlocal" // (bool) Event is not to be passed up to the host environment - used 0481 // when the range is custom to also indicate range=local and prevent 0482 // infinite loops with the host 0483 0484 /* fault tolerance-related events */ 0485 #define PMIX_EVENT_TERMINATE_SESSION "pmix.evterm.sess" // (bool) RM intends to terminate session 0486 #define PMIX_EVENT_TERMINATE_JOB "pmix.evterm.job" // (bool) RM intends to terminate this job 0487 #define PMIX_EVENT_TERMINATE_NODE "pmix.evterm.node" // (bool) RM intends to terminate all procs on this node 0488 #define PMIX_EVENT_TERMINATE_PROC "pmix.evterm.proc" // (bool) RM intends to terminate just this process 0489 #define PMIX_EVENT_ACTION_TIMEOUT "pmix.evtimeout" // (int) time in sec before RM will execute error response 0490 0491 0492 /* attributes used to describe "spawn" directives */ 0493 #define PMIX_PERSONALITY "pmix.pers" // (char*) name of personality to use 0494 #define PMIX_HOST "pmix.host" // (char*) comma-delimited list of hosts to use for spawned procs 0495 #define PMIX_HOSTFILE "pmix.hostfile" // (char*) hostfile to use for spawned procs 0496 #define PMIX_ADD_HOST "pmix.addhost" // (char*) comma-delimited list of hosts to add to allocation 0497 #define PMIX_ADD_HOSTFILE "pmix.addhostfile" // (char*) hostfile to add to existing allocation 0498 #define PMIX_PREFIX "pmix.prefix" // (char*) prefix to be used by an app to look for its 0499 // PMIx installation on remote nodes. A NULL 0500 // value indicates that no prefix is to be given 0501 #define PMIX_WDIR "pmix.wdir" // (char*) working directory for spawned procs 0502 #define PMIX_WDIR_USER_SPECIFIED "pmix.wdir.user" // (bool) User specified the working directory 0503 #define PMIX_DISPLAY_MAP "pmix.dispmap" // (bool) display placement map upon spawn 0504 #define PMIX_DISPLAY_MAP_DETAILED "pmix.dispmapdet" // (bool) display a highly detailed placement map upon spawn 0505 #define PMIX_DISPLAY_ALLOCATION "pmix.dispalloc" // (bool) display the resource allocation 0506 #define PMIX_DISPLAY_TOPOLOGY "pmix.disptopo" // (char*) comma-delimited list of hosts whose topology is 0507 // to be displayed 0508 #define PMIX_DISPLAY_PROCESSORS "pmix.dispcpus" // (char*) comma-delimited list of hosts whose available 0509 // CPUs are to be displayed 0510 #define PMIX_DISPLAY_PARSEABLE_OUTPUT "pmix.dispparse" // (bool) display requested info in a format more amenable 0511 // to machine parsing 0512 #define PMIX_PPR "pmix.ppr" // (char*) #procs to spawn on each identified resource 0513 #define PMIX_MAPBY "pmix.mapby" // (char*) mapping policy 0514 #define PMIX_RANKBY "pmix.rankby" // (char*) ranking policy 0515 #define PMIX_BINDTO "pmix.bindto" // (char*) binding policy 0516 #define PMIX_PRELOAD_BIN "pmix.preloadbin" // (bool) preload binaries 0517 #define PMIX_PRELOAD_FILES "pmix.preloadfiles" // (char*) comma-delimited list of files to pre-position 0518 #define PMIX_STDIN_TGT "pmix.stdin" // (pmix_proc_t*) proc that is to receive stdin 0519 // (PMIX_RANK_WILDCARD = all in given nspace) 0520 #define PMIX_DEBUGGER_DAEMONS "pmix.debugger" // (bool) spawned app consists of debugger daemons 0521 #define PMIX_COSPAWN_APP "pmix.cospawn" // (bool) designated app is to be spawned as a disconnected 0522 // job - i.e., not part of the "comm_world" of the job 0523 #define PMIX_COLOCATE_PROCS "pmix.colproc" // (pmix_data_array_t*) Array of pmix_proc_t identifying the procs 0524 // with which the new job's procs are to be colocated 0525 #define PMIX_COLOCATE_NPERPROC "pmix.colnum.proc" // (uint16_t) Number of procs to colocate with each identified proc 0526 #define PMIX_COLOCATE_NPERNODE "pmix.colnum.node" // (uint16_t) Number of procs to colocate on the node of each identified proc 0527 #define PMIX_SET_SESSION_CWD "pmix.ssncwd" // (bool) set the application's current working directory to 0528 // the session working directory assigned by the RM 0529 #define PMIX_INDEX_ARGV "pmix.indxargv" // (bool) mark the argv with the rank of the proc 0530 #define PMIX_CPUS_PER_PROC "pmix.cpuperproc" // (uint32_t) #cpus to assign to each rank 0531 #define PMIX_NO_PROCS_ON_HEAD "pmix.nolocal" // (bool) do not place procs on the head node 0532 #define PMIX_NO_OVERSUBSCRIBE "pmix.noover" // (bool) do not oversubscribe the cpus 0533 #define PMIX_REPORT_BINDINGS "pmix.repbind" // (bool) report bindings of the individual procs 0534 #define PMIX_REPORT_PHYSICAL_CPUS "pmix.repphys.cpus" // (bool) report bindings using physical cpu IDs 0535 #define PMIX_CPU_LIST "pmix.cpulist" // (char*) list of cpus to use for this job 0536 #define PMIX_JOB_RECOVERABLE "pmix.recover" // (bool) application supports recoverable operations 0537 #define PMIX_JOB_CONTINUOUS "pmix.continuous" // (bool) application is continuous, all failed procs should 0538 // be immediately restarted 0539 #define PMIX_MAX_RESTARTS "pmix.maxrestarts" // (uint32_t) max number of times to restart a job 0540 #define PMIX_FWD_STDIN "pmix.fwd.stdin" // (bool) forward the stdin from this process to the target processes 0541 #define PMIX_FWD_STDOUT "pmix.fwd.stdout" // (bool) forward stdout from the spawned processes to this process (typically used by a tool) 0542 #define PMIX_FWD_STDERR "pmix.fwd.stderr" // (bool) forward stderr from the spawned processes to this process (typically used by a tool) 0543 #define PMIX_FWD_STDDIAG "pmix.fwd.stddiag" // (bool) if a diagnostic channel exists, forward any output on it 0544 // from the spawned processes to this process (typically used by a tool) 0545 #define PMIX_SPAWN_TOOL "pmix.spwn.tool" // (bool) job being spawned is a tool 0546 #define PMIX_CMD_LINE "pmix.cmd.line" // (char*) command line executing in the specified nspace 0547 #define PMIX_FORKEXEC_AGENT "pmix.fe.agnt" // (char*) command line of fork/exec agent to be used for starting 0548 // local processes 0549 #define PMIX_JOB_TIMEOUT "pmix.job.time" // (int) time in sec before job should time out (0 => infinite) 0550 #define PMIX_SPAWN_TIMEOUT "pmix.sp.time" // (int) time in sec before spawn operation should time out (0 => infinite) 0551 // Logically equivalent to passing the PMIX_TIMEOUT attribute to the 0552 // PMIx_Spawn API, it is provided as a separate attribute to distinguish 0553 // it from the PMIX_JOB_TIMEOUT attribute 0554 #define PMIX_TIMEOUT_STACKTRACES "pmix.tim.stack" // (bool) include process stacktraces in timeout report from a job 0555 #define PMIX_TIMEOUT_REPORT_STATE "pmix.tim.state" // (bool) report process states in timeout report from a job 0556 #define PMIX_APP_ARGV "pmix.app.argv" // (char*) consolidated argv passed to the spawn command for the given app 0557 #define PMIX_NOTIFY_JOB_EVENTS "pmix.note.jev" // (bool) Requests that the launcher generate the PMIX_EVENT_JOB_START, 0558 // PMIX_LAUNCH_COMPLETE, and PMIX_EVENT_JOB_END events. Each event is to 0559 // include at least the namespace of the corresponding job and a 0560 // PMIX_EVENT_TIMESTAMP indicating the time the event occurred. 0561 #define PMIX_NOTIFY_PROC_TERMINATION "pmix.noteproc" // (bool) Requests that the launcher generate the PMIX_EVENT_PROC_TERMINATED 0562 // event whenever a process either normally or abnormally terminates. 0563 #define PMIX_NOTIFY_PROC_ABNORMAL_TERMINATION "pmix.noteabproc" // (bool) Requests that the launcher generate the PMIX_EVENT_PROC_TERMINATED 0564 // event only when a process abnormally terminates. 0565 #define PMIX_ENVARS_HARVESTED "pmix.evar.hvstd" // (bool) Envars have been harvested by the spawn requestor 0566 #define PMIX_RUNTIME_OPTIONS "pmix.runopt" // (char*) Environment-specific runtime directives that control job behavior 0567 #define PMIX_ABORT_NON_ZERO_TERM "pmix.abnz" // (bool) Abort the spawned job if any process terminates with non-zero status 0568 #define PMIX_DO_NOT_LAUNCH "pmix.dnl" // (bool) Execute all procedures to prepare the requested job for launch, 0569 // but do not launch it. Typically combined with the PMIX_DISPLAY_MAP 0570 // or PMIX_DISPLAY_MAP_DETAILED for debugging purposes. 0571 #define PMIX_SHOW_LAUNCH_PROGRESS "pmix.showprog" // (bool) Provide periodic progress reports on job launch procedure (e.g., after 0572 // every 100 processes have been spawned) 0573 #define PMIX_AGGREGATE_HELP "pmix.agg.help" // (bool) Aggregate help messages, reporting each unique help message once 0574 // accompanied by the number of processes that reported it 0575 #define PMIX_REPORT_CHILD_SEP "pmix.rptchildsep" // (bool) Report the exit status of any child jobs spawned by the primary job 0576 // separately. If false, then the final exit status reported will be 0577 // zero if the primary job and all spawned jobs exit normally, or the 0578 // first non-zero status returned by either primary or child jobs. 0579 #define PMIX_SPAWN_CHILD_SEP "pmix.spchildsep" // (bool) Treat the spawned job as independent from the parent - i.e, do not 0580 // terminate the spawned job if the parent terminates. 0581 #define PMIX_FWD_ENVIRONMENT "pmix.fwdenv" // (bool) Forward the local environment to each spawned process 0582 #define PMIX_SPAWN_PTY "pmix.spawn.pty" // (bool) Spawn a pseudo-terminal 0583 #define PMIX_PTY_TERMIO "pmix.pty.termio" // (pmix_byte_object_t) Contents of a termio structure 0584 #define PMIX_PTY_WSIZE "pmix.pty.wsize" // (pmix_byte_object_t) Contents of a window size structure 0585 0586 0587 /* query keys - value type shown is the type of the value that will be RETURNED by that key */ 0588 #define PMIX_QUERY_SUPPORTED_KEYS "pmix.qry.keys" // (char*) returns comma-delimited list of keys supported by the query 0589 // function. NO QUALIFIERS 0590 #define PMIX_QUERY_NAMESPACES "pmix.qry.ns" // (char*) returns a comma-delimited list of active namespaces. NO QUALIFIERS 0591 #define PMIX_QUERY_NAMESPACE_INFO "pmix.qry.nsinfo" // (pmix_data_array_t*) returns an array of active nspace information - each 0592 // element will contain an array including the namespace plus the 0593 // command line of the application executing within it 0594 // SUPPORTED QUALIFIERS: PMIX_NSPACE of specific nspace whose info 0595 // is being requested 0596 #define PMIX_QUERY_JOB_STATUS "pmix.qry.jst" // (pmix_status_t) returns status of a specified currently executing job 0597 // REQUIRES a PMIX_NSPACE qualifier indicating the nspace being queried 0598 #define PMIX_QUERY_QUEUE_LIST "pmix.qry.qlst" // (char*) request a comma-delimited list of scheduler queues. NO QUALIFIERS 0599 #define PMIX_QUERY_QUEUE_STATUS "pmix.qry.qst" // (pmix_data_array_t*) returns array where each element contains the name and 0600 // status of a scheduler queue 0601 // SUPPORTED QUALIFIERS: PMIX_ALLOC_QUEUE naming specific queue whose status 0602 // is being requested 0603 #define PMIX_QUERY_PROC_TABLE "pmix.qry.ptable" // (pmix_data_array_t*) returns (pmix_data_array_t*) an array of pmix_proc_info_t 0604 // REQUIRES a PMIX_NSPACE qualifier indicating the nspace being queried 0605 #define PMIX_QUERY_LOCAL_PROC_TABLE "pmix.qry.lptable" // (pmix_data_array_t*) returns (pmix_data_array_t*) an array of pmix_proc_info_t 0606 // for procs in job on same node 0607 // REQUIRES a PMIX_NSPACE qualifier indicating the nspace being queried 0608 #define PMIX_QUERY_AUTHORIZATIONS "pmix.qry.auths" // (pmix_data_array_t*) return operations tool is authorized to perform. The contents 0609 // of the array elements have not yet been standardized. NO QUALIFIERS 0610 #define PMIX_QUERY_SPAWN_SUPPORT "pmix.qry.spawn" // (char*) return a comma-delimited list of supported spawn attributes. NO QUALIFIERS 0611 #define PMIX_QUERY_DEBUG_SUPPORT "pmix.qry.debug" // (char*) return a comma-delimited list of supported debug attributes. NO QUALIFIERS 0612 #define PMIX_QUERY_MEMORY_USAGE "pmix.qry.mem" // (pmix_data_array_t*) return info on memory usage for the procs indicated in the qualifiers 0613 // SUPPORTED QUALIFIERS: PMIX_NSPACE/PMIX_RANK, or PMIX_PROCID of specific proc(s) 0614 // whose info is being requested 0615 #define PMIX_QUERY_ALLOC_STATUS "pmix.query.alloc" // (char*) return a string reporting status of an allocation request 0616 // REQUIRES a PMIX_ALLOC_REQUEST_ID qualifier indicating the allocation request 0617 // being queried 0618 #define PMIX_QUERY_ALLOCATION "pmix.query.allc" // (pmix_data_array_t*) returns an array of pmix_info_t describing the nodes known to the 0619 // server. Each array element will consist of the PMIX_NODE_INFO key containing 0620 // a pmix_data_array_t of pmix_info_t - the first element of the array must be 0621 // the hostname of that node, with additional info on the node in subsequent entries. 0622 // SUPPORTED_QUALIFIER: a PMIX_ALLOC_ID qualifier indicating the specific 0623 // allocation of interest 0624 #define PMIX_TIME_REMAINING "pmix.time.remaining" // (uint32_t) returns number of seconds remaining in allocation 0625 // for the specified nspace (defaults to allocation containing the caller) 0626 // SUPPORTED QUALIFIERS: PMIX_NSPACE of the nspace whose info is being requested 0627 #define PMIX_QUERY_NUM_PSETS "pmix.qry.psetnum" // (size_t) returns the number of psets defined 0628 // in the specified range (defaults to session) 0629 // SUPPORTED QUALIFIERS: PMIX_RANGE whose info is being requested 0630 #define PMIX_QUERY_PSET_NAMES "pmix.qry.psets" // (char*) returns a comma-delimited list of the names of the 0631 // psets defined in the specified range (defaults to session) 0632 // SUPPORTED QUALIFIERS: PMIX_RANGE whose info is being requested 0633 #define PMIX_QUERY_PSET_MEMBERSHIP "pmix.qry.pmems" // (pmix_data_array_t*) Return an array of pmix_proc_t containing the members of 0634 // the specified process set. 0635 #define PMIX_QUERY_NUM_GROUPS "pmix.qry.pgrpnum" // (size_t) Return the number of process groups defined in the specified range 0636 // (defaults to session). OPTIONAL QUALIFERS: PMIX_RANGE. 0637 #define PMIX_QUERY_GROUP_NAMES "pmix.qry.pgrp" // (pmix_data_array_t*) Return a pmix_data_array_t containing an array of string 0638 // names of the process groups defined in the specified range (defaults 0639 // to session). OPTIONAL QUALIFERS: PMIX_RANGE 0640 #define PMIX_QUERY_GROUP_MEMBERSHIP "pmix.qry.pgrpmems" // (pmix_data_array_t*) Return a pmix_data_array_t of pmix_proc_t containing 0641 // the members of the specified process group. REQUIRED QUALIFIERS: 0642 // PMIX_GROUP_ID. 0643 #define PMIX_QUERY_ATTRIBUTE_SUPPORT "pmix.qry.attrs" // (pmix_data_array_t*) returns array of pmix_info_t where each element consists 0644 // of a key containing the name of the function, and an array of pmix_regattr_t 0645 // detailing the attribute support for that function 0646 // SUPPORTED QUALIFIERS: PMIX_CLIENT_FUNCTIONS, PMIX_SERVER_FUNCTIONS, 0647 // PMIX_TOOL_FUNCTIONS, and/or PMIX_HOST_FUNCTIONS 0648 #define PMIX_CLIENT_FUNCTIONS "pmix.client.fns" // (char*) returns a comma-delimited list of supported PMIx client functions. NO QUALIFIERS 0649 #define PMIX_SERVER_FUNCTIONS "pmix.srvr.fns" // (char*) returns a comma-delimited list of supported PMIx server functions. NO QUALIFIERS 0650 #define PMIX_TOOL_FUNCTIONS "pmix.tool.fns" // (char*) returns a comma-delimited list of supported PMIx tool functions. NO QUALIFIERS 0651 #define PMIX_HOST_FUNCTIONS "pmix.host.fns" // (char*) returns a comma-delimited list of PMIx functions supported by the host environment 0652 #define PMIX_QUERY_AVAIL_SERVERS "pmix.qry.asrvrs" // (pmix_data_array_t*) array of pmix_info_t, each element containing an array of 0653 // pmix_info_t of available data for servers on this node 0654 // to which the caller might be able to connect. NO QUALIFIERS 0655 #define PMIX_QUERY_QUALIFIERS "pmix.qry.quals" // (pmix_data_array_t*) Contains an array of qualifiers that were included in the 0656 // query that produced the provided results. This attribute is solely for 0657 // reporting purposes and cannot be used in PMIx_Get or other query 0658 // operations 0659 #define PMIX_QUERY_RESULTS "pmix.qry.res" // (pmix_data_array_t*) Contains an array of query results for a given pmix_query_t passed to the 0660 // PMIx_Query_info APIs. If qualifiers were included in the query, then the first element 0661 // of the array shall be the PMIX_QUERY_QUALIFIERS attribute containing those qualifiers. 0662 // Each of the remaining elements of the array is a pmix_info_t containing the query key 0663 // and the corresponding value returned by the query. This attribute is solely for 0664 // reporting purposes and cannot be used in PMIx_Get or other query operations 0665 #define PMIX_QUERY_MIN_ALLOC_UNIT "pmix.qry.minau" // (pmix_data_array_t*) array of pmix_info_t identifying the resources 0666 // composing the minimum allocatable unit for this system 0667 #define PMIX_QUERY_RES_BLOCKS "pmix.qry.resblks" // (pmix_data_array_t*) array of string names for currently defined 0668 // resource blocks 0669 #define PMIX_QUERY_RES_BLOCK_DEF "pmix.qry.resdef" // (pmix_data_array_t*) given the name of a resource block as its qualifier, 0670 // return an array of pmix_resource_unit_t describing the resources contained 0671 // in the block 0672 #define PMIX_QUERY_DEVICES "pmix.qry.dev" // (pmix_data_array_t*) Return an array of pmix_device_t containing the devices 0673 // within the current topology that meet the specified query qualifications. This 0674 // includes specifying return of all devices of a given type via the PMIX_DEVICE_TYPE 0675 // attribute. 0676 #define PMIX_QUERY_AVAILABLE_SLOTS "pmix.qry.aslots" // (uint32_t) Number of slots currently available 0677 // in the session. This is a snapshot in 0678 // time as the number may have changed 0679 // (e.g., if another job was submitted after 0680 // the host generated its response). Request 0681 // may optionally specify the session using 0682 // the PMIX_SESSION_ID attribute - default 0683 // is the session of the requestor 0684 #define PMIX_QUERY_RESOLVE_PEERS "pmix.qry.peers" // (pmix_data_array_t*) Return an array of pmix_proc_t containing the process IDs 0685 // of procs from the given nspace that are executing on the specified node. 0686 // Effectively asking the host respond to a PMIx_Resolve_peers request on the 0687 // caller's behalf 0688 #define PMIX_QUERY_RESOLVE_NODE "pmix.qry.node" // (char*) Return a comma-delimited string of nodes where procs from the specified 0689 // nspace have been placed (may or may not be executing at the time of request). 0690 // Effectively asking the host respond to a PMIx_Resolve_node request on the 0691 // caller's behalf 0692 #define PMIX_QUERY_PROC_RESOURCE_USAGE "pmix.qry.pres" // (pmix_proc_t*) Return the resource usage statistics for the specified process in a 0693 // PMIX_PROC_RESOURCE_USAGE assembly. If a namespace is combined with 0694 // PMIX_RANK_WILDCARD,then results for all processes in the given job shall be 0695 // returned in a pmix_data_array_t, each element containing a 0696 // PMIX_PROC_RESOURCE_USAGE assembly for one of the processes. OPTIONAL QUALIFIERS: 0697 // PMIX_SESSION_ID to identify the session of the namespace whose statistics are being 0698 // requested; PMIX_NODEID or PMIX_HOSTNAME to restrict a wildcard request to processes 0699 // on a given node 0700 #define PMIX_QUERY_NODE_RESOURCE_USAGE "pmix.qry.nres" // (char*) Return the resource usage statistics for the specified node in a 0701 // PMIX_NODE_RESOURCE_USAGE assembly. If no node is specified, then results for all 0702 // nodes hosting processes with the job of the requestor will be returned in a 0703 // pmix_data_array_t, each element containing a PMIX_NODE_RESOURCE_USAGE assembly for 0704 // one of the nodes. OPTIONAL QUALIFIERS: PMIX_SESSION_ID to identify the session of 0705 // the job whose node statistics are being requested; PMIX_NSPACE or PMIX_JOBID to 0706 // identify the job whose node usage is being requested (if other than the job of 0707 // the requestor) 0708 0709 0710 /* query qualifiers - these are used to provide information to narrow/modify the query. Value type shown is the type of data expected 0711 * to be provided with the key */ 0712 #define PMIX_QUERY_REFRESH_CACHE "pmix.qry.rfsh" // (bool) retrieve updated information from server 0713 // to update local cache 0714 #define PMIX_QUERY_LOCAL_ONLY "pmix.qry.local" // (bool) constrain the query to local information only 0715 #define PMIX_QUERY_REPORT_AVG "pmix.qry.avg" // (bool) report average values 0716 #define PMIX_QUERY_REPORT_MINMAX "pmix.qry.minmax" // (bool) report minimum and maximum value 0717 #define PMIX_CLIENT_ATTRIBUTES "pmix.client.attrs" // (char*) comma-delimited list of functions, including "all" 0718 // when used in a query, indicates whether or not to include 0719 // attributes supported by the PMIx client library 0720 #define PMIX_SERVER_ATTRIBUTES "pmix.srvr.attrs" // (char*) comma-delimited list of functions, including "all" 0721 // when used in a query, indicates whether or not to include 0722 // attributes supported by the PMIx server library 0723 #define PMIX_HOST_ATTRIBUTES "pmix.host.attrs" // (char*) comma-delimited list of functions, including "all" 0724 // when used in a query, indicates whether or not to include 0725 // attributes supported by the host environment 0726 #define PMIX_TOOL_ATTRIBUTES "pmix.tool.attrs" // (char*) comma-delimited list of functions, including "all" 0727 // when used in a query, indicates whether or not to include 0728 // attributes supported by the PMIx tool library 0729 #define PMIX_QUERY_SUPPORTED_QUALIFIERS "pmix.qry.quals" // (bool) return comma-delimited list of qualifiers supported by 0730 // a query on the provided key, instead of actually performing 0731 // the query on the key. 0732 #define PMIX_RESOURCE_BLOCK_NAME "pmix.resblkname" // (char*) Name of the resource block being queried about 0733 0734 0735 /* PMIx_Get information retrieval qualifiers */ 0736 #define PMIX_SESSION_INFO "pmix.ssn.info" // (bool) Return information about the specified session. If information 0737 // about a session other than the one containing the requesting 0738 // process is desired, then the attribute array must contain a 0739 // PMIX_SESSION_ID attribute identifying the desired target. 0740 #define PMIX_JOB_INFO "pmix.job.info" // (bool) Return information about the specified job or namespace. If 0741 // information about a job or namespace other than the one containing 0742 // the requesting process is desired, then the attribute array must 0743 // contain a PMIX_JOBID or PMIX_NSPACE attribute identifying the 0744 // desired target. Similarly, if information is requested about a 0745 // job or namespace in a session other than the one containing the 0746 // requesting process, then an attribute identifying the target 0747 // session must be provided. 0748 #define PMIX_APP_INFO "pmix.app.info" // (bool) Return information about the specified application. If information 0749 // about an application other than the one containing the requesting 0750 // process is desired, then the attribute array must contain a 0751 // PMIX_APPNUM attribute identifying the desired target. Similarly, 0752 // if information is requested about an application in a job or session 0753 // other than the one containing the requesting process, then attributes 0754 // identifying the target job and/or session must be provided. 0755 #define PMIX_NODE_INFO "pmix.node.info" // (bool) Return information about the specified node. If information about a 0756 // node other than the one containing the requesting process is desired, 0757 // then the attribute array must contain either the PMIX_NODEID or 0758 // PMIX_HOSTNAME attribute identifying the desired target. 0759 0760 0761 /* information storage attributes */ 0762 #define PMIX_SESSION_INFO_ARRAY "pmix.ssn.arr" // (pmix_data_array_t*) Provide an array of pmix_info_t containing 0763 // session-level information. The PMIX_SESSION_ID attribute is required 0764 // to be included in the array. 0765 #define PMIX_JOB_INFO_ARRAY "pmix.job.arr" // (pmix_data_array_t*) Provide an array of pmix_info_t containing job-level 0766 // information. Information is registered one job (aka namespace) at a time 0767 // via the PMIx_server_register_nspace API. Thus, there is no requirement that 0768 // the array contain either the PMIX_NSPACE or PMIX_JOBID attributes, though 0769 // either or both of them may be included. 0770 #define PMIX_APP_INFO_ARRAY "pmix.app.arr" // (pmix_data_array_t*) Provide an array of pmix_info_t containing app-level 0771 // information. The PMIX_NSPACE or PMIX_JOBID attributes of the job containing 0772 // the application, plus its PMIX_APPNUM attribute, are required to be 0773 // included in the array. 0774 #define PMIX_PROC_INFO_ARRAY "pmix.pdata" // (pmix_data_array_t*) Provide an array of pmix_info_t containing process-realm 0775 // information. The PMIX_RANK and PMIX_NSPACE attributes, or the 0776 // PMIX_PROCID attribute, are required to be included in the array when 0777 // the array is not included as part of a call to 0778 // PMIx_server_register_nspace - i.e., when the job containing the process 0779 // is ambiguous. All three may be included if desired. When the array is 0780 // included in some broader structure that identifies the job, then only 0781 // the PMIX_RANK or the PMIX_PROCID attribute must be included (the others 0782 // are optional). 0783 #define PMIX_NODE_INFO_ARRAY "pmix.node.arr" // (pmix_data_array_t*) Provide an array of pmix_info_t containing node-level 0784 // information. At a minimum, either the PMIX_NODEID or PMIX_HOSTNAME 0785 // attribute is required to be included in the array, though both may be 0786 // included. 0787 #define PMIX_SERVER_INFO_ARRAY "pmix.srv.arr" // (pmix_data_array_t*) array of data on a given server, starting with its nspace 0788 0789 0790 /* log attributes */ 0791 #define PMIX_LOG_SOURCE "pmix.log.source" // (pmix_proc_t*) ID of source of the log request 0792 #define PMIX_LOG_STDERR "pmix.log.stderr" // (char*) log string to stderr 0793 #define PMIX_LOG_STDOUT "pmix.log.stdout" // (char*) log string to stdout 0794 #define PMIX_LOG_SYSLOG "pmix.log.syslog" // (char*) log message to syslog - defaults to ERROR priority. Will log 0795 // to global syslog if available, otherwise to local syslog 0796 #define PMIX_LOG_LOCAL_SYSLOG "pmix.log.lsys" // (char*) log msg to local syslog - defaults to ERROR priority 0797 #define PMIX_LOG_GLOBAL_SYSLOG "pmix.log.gsys" // (char*) forward data to system "master" and log msg to that syslog 0798 #define PMIX_LOG_SYSLOG_PRI "pmix.log.syspri" // (int) syslog priority level 0799 0800 #define PMIX_LOG_TIMESTAMP "pmix.log.tstmp" // (time_t) timestamp for log report 0801 #define PMIX_LOG_GENERATE_TIMESTAMP "pmix.log.gtstmp" // (bool) generate timestamp for log 0802 #define PMIX_LOG_TAG_OUTPUT "pmix.log.tag" // (bool) label the output stream with the channel name (e.g., "stdout") 0803 #define PMIX_LOG_TIMESTAMP_OUTPUT "pmix.log.tsout" // (bool) print timestamp in output string 0804 #define PMIX_LOG_XML_OUTPUT "pmix.log.xml" // (bool) print the output stream in xml format 0805 #define PMIX_LOG_ONCE "pmix.log.once" // (bool) only log this once with whichever channel can first support it 0806 #define PMIX_LOG_MSG "pmix.log.msg" // (pmix_byte_object_t) message blob to be sent somewhere 0807 #define PMIX_LOG_KEY "pmix.log.key" // (char*) key to a logging message 0808 #define PMIX_LOG_VAL "pmix.log.val" // (char*) value to a logging message 0809 #define PMIX_LOG_AGG "pmix.log.agg" // (bool) Whether to aggregate and prevent duplicate logging messages 0810 // based on key value pairs. 0811 0812 #define PMIX_LOG_EMAIL "pmix.log.email" // (pmix_data_array_t*) log via email based on array of pmix_info_t 0813 // containing directives 0814 #define PMIX_LOG_EMAIL_ADDR "pmix.log.emaddr" // (char*) comma-delimited list of email addresses that are to recv msg 0815 #define PMIX_LOG_EMAIL_SENDER_ADDR "pmix.log.emfaddr" // (char*) return email address of sender 0816 #define PMIX_LOG_EMAIL_SUBJECT "pmix.log.emsub" // (char*) subject line for email 0817 #define PMIX_LOG_EMAIL_MSG "pmix.log.emmsg" // (char*) msg to be included in email 0818 #define PMIX_LOG_EMAIL_SERVER "pmix.log.esrvr" // (char*) hostname (or IP addr) of estmp server 0819 #define PMIX_LOG_EMAIL_SRVR_PORT "pmix.log.esrvrprt" // (int32_t) port the email server is listening to 0820 0821 #define PMIX_LOG_GLOBAL_DATASTORE "pmix.log.gstore" // (bool) log the provided data to a global datastore 0822 #define PMIX_LOG_JOB_RECORD "pmix.log.jrec" // (bool) log the provided information to the RM's job record 0823 #define PMIX_LOG_PROC_TERMINATION "pmix.logproc" // (bool) Requests that the launcher log the PMIX_EVENT_PROC_TERMINATED event 0824 // whenever a process either normally or abnormally terminates. 0825 #define PMIX_LOG_PROC_ABNORMAL_TERMINATION "pmix.logabproc" // (bool) Requests that the launcher log the PMIX_EVENT_PROC_TERMINATED event 0826 // only when a process abnormally terminates. 0827 #define PMIX_LOG_JOB_EVENTS "pmix.log.jev" // (bool) Requests that the launcher log the PMIX_EVENT_JOB_START, 0828 // PMIX_LAUNCH_COMPLETE, and PMIX_EVENT_JOB_END events using PMIx_Log 0829 #define PMIX_LOG_COMPLETION "pmix.logcomp" // (bool) Requests that the launcher log the PMIX_EVENT_JOB_END event 0830 // for normal or abnormal termination of the spawned job using 0831 // PMIx_Log. The event shall include the returned status code 0832 // (PMIX_JOB_TERM_STATUS) for the corresponding job; the identity 0833 // (PMIX_PROCID) and exit status (PMIX_EXIT_CODE) of the first failed 0834 // process, if applicable; and a PMIX_EVENT_TIMESTAMP indicating the time 0835 // the termination occurred. 0836 0837 0838 /* debugger attributes */ 0839 #define PMIX_DEBUG_STOP_ON_EXEC "pmix.dbg.exec" // (varies) stop specified rank(s) on exec and notify ready-to-debug 0840 // Can be any of three data types: 0841 // (a) bool - true indicating all ranks, false indicating none 0842 // (b) pmix_rank_t - the rank of one proc, or WILDCARD for all 0843 // (c) a pmix_data_array_t if an array of individual processes 0844 // are specified 0845 #define PMIX_DEBUG_STOP_IN_INIT "pmix.dbg.init" // (varies) stop specified rank(s) in PMIx_Init and notify ready-to-debug 0846 // Can be any of three data types: 0847 // (a) bool - true indicating all ranks, false indicating none 0848 // (b) pmix_rank_t - the rank of one proc, or WILDCARD for all 0849 // (c) a pmix_data_array_t if an array of individual processes 0850 // are specified 0851 #define PMIX_DEBUG_STOP_IN_APP "pmix.dbg.notify" // (varies) direct specified ranks to stop at application-specific point and 0852 // notify ready-to-debug. Can be any of three data types: 0853 // (a) bool - true indicating all ranks, false indicating none 0854 // (b) pmix_rank_t - the rank of one proc, or WILDCARD for all 0855 // (c) a pmix_data_array_t if an array of individual processes 0856 // are specified 0857 #define PMIX_BREAKPOINT "pmix.brkpnt" // (char*) string ID of the breakpoint where the process(es) is(are) waiting 0858 #define PMIX_DEBUG_TARGET "pmix.dbg.tgt" // (pmix_proc_t*) Identifier of proc(s) to be debugged 0859 #define PMIX_DEBUG_DAEMONS_PER_PROC "pmix.dbg.dpproc" // (uint16_t) Number of debugger daemons to be spawned per application 0860 // process. The launcher is to pass the identifier of the namespace to 0861 // be debugged by including the PMIX_DEBUG_TARGET attribute in the 0862 // daemon's job-level information. The debugger daemons spawned on a 0863 // given node are responsible for self-determining their specific 0864 // target process(es) - e.g., by referencing their own PMIX_LOCAL_RANK 0865 // in the daemon debugger job versus the corresponding PMIX_LOCAL_RANK 0866 // of the target processes on the node. 0867 #define PMIX_DEBUG_DAEMONS_PER_NODE "pmix.dbg.dpnd" // (uint16_t) Number of debugger daemons to be spawned on each node where the 0868 // target job is executing. The launcher is to pass the identifier of 0869 // the namespace to be debugged by including the PMIX_DEBUG_TARGET 0870 // attribute in the daemon's job-level information. The debugger 0871 // daemons spawned on a given node are responsible for 0872 // self-determining their specific target process(es) - e.g., by 0873 // referencing their own PMIX_LOCAL_RANK in the daemon debugger job 0874 // versus the corresponding PMIX_LOCAL_RANK of the target processes on 0875 // the node. 0876 0877 0878 /* Resource Manager identification */ 0879 #define PMIX_RM_NAME "pmix.rm.name" // (char*) string name of the resource manager 0880 #define PMIX_RM_VERSION "pmix.rm.version" // (char*) RM version string 0881 0882 /* environmental variable operation attributes */ 0883 #define PMIX_SET_ENVAR "pmix.envar.set" // (pmix_envar_t*) set the envar to the given value, 0884 // overwriting any pre-existing one 0885 #define PMIX_ADD_ENVAR "pmix.envar.add" // (pmix_envar_t*) add envar, but do not overwrite any existing one 0886 #define PMIX_UNSET_ENVAR "pmix.envar.unset" // (char*) unset the envar, if present 0887 #define PMIX_PREPEND_ENVAR "pmix.envar.prepnd" // (pmix_envar_t*) prepend the given value to the 0888 // specified envar using the separator 0889 // character, creating the envar if it doesn't already exist 0890 #define PMIX_APPEND_ENVAR "pmix.envar.appnd" // (pmix_envar_t*) append the given value to the specified 0891 // envar using the separator character, 0892 // creating the envar if it doesn't already exist 0893 #define PMIX_FIRST_ENVAR "pmix.envar.first" // (pmix_envar_t*) ensure the given value appears first in the 0894 // specified envar using the separator 0895 // character, creating the envar if it doesn't already exist 0896 0897 /* attributes relating to allocations */ 0898 #define PMIX_ALLOC_REQ_ID "pmix.alloc.reqid" // (char*) User-provided string identifier for this allocation request 0899 // which can later be used to query status of the request. 0900 #define PMIX_ALLOC_ID "pmix.alloc.id" // (char*) A string identifier (provided by the host environment) for 0901 // the resulting allocation which can later be used to reference 0902 // the allocated resources in, for example, a call to PMIx_Spawn 0903 #define PMIX_ALLOC_NUM_NODES "pmix.alloc.nnodes" // (uint64_t) number of nodes 0904 #define PMIX_ALLOC_NODE_LIST "pmix.alloc.nlist" // (char*) regex of specific nodes 0905 #define PMIX_ALLOC_EXCLUDE "pmix.alloc.exclude" // (char*) regex of nodes to exclude from scheduling consideration 0906 #define PMIX_ALLOC_NUM_CPUS "pmix.alloc.ncpus" // (uint64_t) number of cpus 0907 #define PMIX_ALLOC_NUM_CPU_LIST "pmix.alloc.ncpulist" // (char*) regex of #cpus for each node 0908 #define PMIX_ALLOC_CPU_LIST "pmix.alloc.cpulist" // (char*) regex of specific cpus indicating the cpus involved. 0909 #define PMIX_ALLOC_MEM_SIZE "pmix.alloc.msize" // (float) number of Mbytes 0910 #define PMIX_ALLOC_FABRIC "pmix.alloc.net" // (pmix_data_array_t*) Array of pmix_info_t describing 0911 // fabric resource request. This must include at least: 0912 // * PMIX_ALLOC_FABRIC_ID 0913 // * PMIX_ALLOC_FABRIC_TYPE 0914 // * PMIX_ALLOC_FABRIC_ENDPTS 0915 // plus whatever other descriptors are desired 0916 #define PMIX_ALLOC_FABRIC_ID "pmix.alloc.netid" // (char*) key to be used when accessing this requested fabric allocation. The 0917 // allocation will be returned/stored as a pmix_data_array_t of 0918 // pmix_info_t indexed by this key and containing at least one 0919 // entry with the same key and the allocated resource description. 0920 // The type of the included value depends upon the fabric 0921 // support. For example, a TCP allocation might consist of a 0922 // comma-delimited string of socket ranges such as 0923 // "32000-32100,33005,38123-38146". Additional entries will consist 0924 // of any provided resource request directives, along with their 0925 // assigned values. Examples include: 0926 // * PMIX_ALLOC_FABRIC_TYPE - the type of resources provided 0927 // * PMIX_ALLOC_FABRIC_PLANE - if applicable, what plane the 0928 // resources were assigned from 0929 // * PMIX_ALLOC_FABRIC_QOS - the assigned QoS 0930 // * PMIX_ALLOC_BANDWIDTH - the allocated bandwidth 0931 // * PMIX_ALLOC_FABRIC_SEC_KEY - a security key for the requested 0932 // fabric allocation 0933 // NOTE: the assigned values may differ from those requested, 0934 // especially if the "required" flag was not set in the request 0935 #define PMIX_ALLOC_BANDWIDTH "pmix.alloc.bw" // (float) Mbits/sec 0936 #define PMIX_ALLOC_FABRIC_QOS "pmix.alloc.netqos" // (char*) quality of service level 0937 #define PMIX_ALLOC_TIME "pmix.alloc.time" // (char*) time that the allocation shall remain valid. Time is specified in 0938 // usual time format of months:days:hours:minutes:seconds, scanning 0939 // from right to left (i.e., a value of "2" equates to 2 seconds) 0940 #define PMIX_ALLOC_FABRIC_TYPE "pmix.alloc.nettype" // (char*) type of desired transport (e.g., tcp, udp) 0941 #define PMIX_ALLOC_FABRIC_PLANE "pmix.alloc.netplane" // (char*) id string for the NIC (aka plane) to be used for this allocation 0942 // (e.g., CIDR for Ethernet) 0943 #define PMIX_ALLOC_FABRIC_ENDPTS "pmix.alloc.endpts" // (size_t) number of endpoints to allocate per process 0944 #define PMIX_ALLOC_FABRIC_ENDPTS_NODE "pmix.alloc.endpts.nd" // (size_t) number of endpoints to allocate per node 0945 #define PMIX_ALLOC_FABRIC_SEC_KEY "pmix.alloc.nsec" // (pmix_byte_object_t) fabric security key 0946 #define PMIX_ALLOC_QUEUE "pmix.alloc.queue" // (char*) name of queue being referenced 0947 #define PMIX_ALLOC_PREEMPTIBLE "pmix.alloc.preempt" // (bool) by default, all jobs in the resulting allocation are to be 0948 // considered preemptible (overridable at per-job level) 0949 #define PMIX_ALLOC_LEND "pmix.alloc.lend" // (char*) estimated time before the lent resources shall be available for 0950 // return. Time is specified in usual time format of 0951 // months:days:hours:minutes:seconds, scanning from right to left 0952 // (i.e., a value of "2" equates to 2 seconds) 0953 #define PMIX_ALLOC_IMAGE "pmix.alloc.image" // (char*) name of the image that the requested nodes are to have on them 0954 #define PMIX_ALLOC_WAIT_ALL_NODES "pmix.alloc.waitall" // (bool) whether or not to wait for all nodes to be scheduled before 0955 // starting to initialize and release nodes for use 0956 #define PMIX_ALLOC_SHARE "pmix.alloc.share" // (bool) Allow non-exclusive use of specified resources 0957 #define PMIX_ALLOC_NOSHELL "pmix.alloc.noshell" // (bool) Immediately exit after allocating resources, without running a command. 0958 #define PMIX_ALLOC_DEPENDENCY "pmix.alloc.depend" // (char*) Defer the start of allocation until the specified dependencies have 0959 // successfully completed. 0960 #define PMIX_ALLOC_BEGIN "pmix.alloc.begin" // (char*) Direct the scheduler to defer allocation until the specified time. Time 0961 // may be of the form HH:MM:SS to schedule the session to start at a specific 0962 // time of day (seconds are optional). If that time is already past, the 0963 // next day is assumed. You may also specify "midnight" or "noon", and you 0964 // can have a time-of-day suffixed with AM or PM for running in the morning 0965 // or the evening. You can also say what day the session should start by 0966 // specifying a date of the form MMDDYY or MM/DD/YY YYYY-MM-DD. Combine date 0967 // and time using the usual format YYYY-MM-DD[THH:MM[:SS]]. You can also give 0968 // times like "now + count" time-units, where the time-units can be "seconds" 0969 // (default), "minutes", "hours", days, or weeks, or you can ask that the 0970 // allocation be made "today" or "tomorrow". 0971 #define PMIX_ALLOC_NOT_WAITING "pmix.alloc.notwait" // (bool) Requestor is not waiting for the allocation to be issued. When allocation 0972 // is made, start the provided job - if one is not provided, then setup the 0973 // allocated session and leave it idle. The requestor will discover the 0974 // allocation by either monitoring for the "allocated" event or by querying 0975 // the system 0976 0977 #define PMIX_ALLOC_RES_BLOCK "pmix.alloc.blk" // (char*) name of the previously-defined resource block to be allocated 0978 #define PMIX_ALLOC_NUM_BLOCKS "pmix.alloc.nblks" // (uint64_t) number of specified resource blocks to allocate 0979 #define PMIX_ALLOC_MAU "pmix.alloc.mau" // (pmix_data_array_t*) Minimum allocatable unit for the system. This attribute 0980 // is used by the system scheduler to inform the system controller 0981 // of the MAU so the information can be passed along. Alternatively, 0982 // a host can pass the information into its PMIx server. Array consists 0983 // of pmix_resource_unit_t structs. 0984 #define PMIX_ALLOC_CHILD_SEP "pmix.alloc.sep" // (bool) Treat the resulting allocation as independent from its parent - i.e., 0985 // do not terminate the allocation upon termination of the parent. 0986 #define PMIX_MEM_ALLOC_KIND "pmix.alloc.mkind" // (char*) Comma-delimited list of memory kinds 0987 // being allocated (e.g., system,mpi,rocm:device) 0988 #define PMIX_GPU_SUPPORT "pmix.gpu.support" // (bool) Direct application to either enable (true) or 0989 // disable (false) its internal library's GPU support 0990 0991 0992 /* job control attributes */ 0993 #define PMIX_JOB_CTRL_ID "pmix.jctrl.id" // (char*) provide a string identifier for this request 0994 #define PMIX_JOB_CTRL_PAUSE "pmix.jctrl.pause" // (bool) pause the specified processes 0995 #define PMIX_JOB_CTRL_RESUME "pmix.jctrl.resume" // (bool) "un-pause" the specified processes 0996 #define PMIX_JOB_CTRL_CANCEL "pmix.jctrl.cancel" // (char*) cancel the specified request 0997 // (NULL => cancel all requests from this requestor) 0998 #define PMIX_JOB_CTRL_KILL "pmix.jctrl.kill" // (bool) forcibly terminate the specified processes and cleanup 0999 #define PMIX_JOB_CTRL_RESTART "pmix.jctrl.restart" // (char*) restart the specified processes using the given checkpoint ID 1000 #define PMIX_JOB_CTRL_CHECKPOINT "pmix.jctrl.ckpt" // (char*) checkpoint the specified processes and assign the given ID to it 1001 #define PMIX_JOB_CTRL_CHECKPOINT_EVENT "pmix.jctrl.ckptev" // (bool) use event notification to trigger process checkpoint 1002 #define PMIX_JOB_CTRL_CHECKPOINT_SIGNAL "pmix.jctrl.ckptsig" // (int) use the given signal to trigger process checkpoint 1003 #define PMIX_JOB_CTRL_CHECKPOINT_TIMEOUT "pmix.jctrl.ckptsig" // (int) time in seconds to wait for checkpoint to complete 1004 #define PMIX_JOB_CTRL_CHECKPOINT_METHOD "pmix.jctrl.ckmethod" // (pmix_data_array_t*) array of pmix_info_t declaring each 1005 // method and value supported by this application 1006 #define PMIX_JOB_CTRL_SIGNAL "pmix.jctrl.sig" // (int) send given signal to specified processes 1007 #define PMIX_JOB_CTRL_PROVISION "pmix.jctrl.pvn" // (char*) regex identifying nodes that are to be provisioned 1008 #define PMIX_JOB_CTRL_PROVISION_IMAGE "pmix.jctrl.pvnimg" // (char*) name of the image that is to be provisioned 1009 #define PMIX_JOB_CTRL_PREEMPTIBLE "pmix.jctrl.preempt" // (bool) job can be pre-empted 1010 #define PMIX_JOB_CTRL_TERMINATE "pmix.jctrl.term" // (bool) politely terminate the specified procs 1011 #define PMIX_JOB_CTRL_DEFINE_PSET "pmix.jctrl.defpset" // (char*) Pset name to be assigned to the targets 1012 #define PMIX_REGISTER_CLEANUP "pmix.reg.cleanup" // (char*) comma-delimited list of files to 1013 // be removed upon process termination 1014 #define PMIX_REGISTER_CLEANUP_DIR "pmix.reg.cleanupdir" // (char*) comma-delimited list of directories to 1015 // be removed upon process termination 1016 #define PMIX_CLEANUP_RECURSIVE "pmix.clnup.recurse" // (bool) recursively cleanup all subdirectories under the 1017 // specified one(s) 1018 #define PMIX_CLEANUP_EMPTY "pmix.clnup.empty" // (bool) only remove empty subdirectories 1019 #define PMIX_CLEANUP_IGNORE "pmix.clnup.ignore" // (char*) comma-delimited list of filenames that are not 1020 // to be removed 1021 #define PMIX_CLEANUP_LEAVE_TOPDIR "pmix.clnup.lvtop" // (bool) when recursively cleaning subdirs, do not remove 1022 // the top-level directory (the one given in the 1023 // cleanup request) 1024 #define PMIX_JOB_CTRL_SEP "pmix.jctrl.sep" // (bool) Separate the specified nspace from its parent - i.e., allow 1025 // the two to independently terminate. 1026 1027 1028 /* session control attributes */ 1029 #define PMIX_SESSION_CTRL_ID "pmix.ssnctrl.id" // (char*) provide a string identifier for this request 1030 1031 /* session instantiation attributes - called by scheduler 1032 * Schedulers calling to create a session are required to provide: 1033 * - the effective userID and groupID that the session should have 1034 * when instantiated. 1035 * - description of the resources that are to be included in the session 1036 * - if applicable, the image that should be provisioned on nodes 1037 * included in the session 1038 * - an array of applications (if any) that are to be started in the 1039 * session once instantiated 1040 */ 1041 #define PMIX_SESSION_INSTANTIATE "pmix.ssn.inst" // (bool) Instantiate the specified session 1042 #define PMIX_SESSION_RESOURCES "pmix.ssn.res" // (pmix_data_array_t*) Array of pmix_info_t describing the 1043 // resources to be included in the session. This can 1044 // include a regex of node names, array of resource blocks, 1045 // etc. 1046 #define PMIX_SESSION_JOB "pmix.ssn.job" // (pmix_data_array_t*) Array of pmix_info_t describing the job info 1047 // to be applied in conjunction with specified PMIX_SESSION_APP 1048 // definitions. Error if given without a PMIX_SESSION_APP description. 1049 #define PMIX_SESSION_APP "pmix.ssn.app" // (pmix_data_array_t*) Array of pmix_app_t to be executed in the assigned 1050 // session upon session instantiation 1051 #define PMIX_SESSION_PROVISION_NODES "pmix.ssn.pvnnds" // (char*) regex identifying nodes that are to be provisioned 1052 #define PMIX_SESSION_PROVISION_IMAGE "pmix.ssn.pvnimg" // (char*) name of the image that is to be provisioned 1053 1054 /* session operational attributes - called by scheduler */ 1055 #define PMIX_SESSION_PAUSE "pmix.ssn.pause" // (bool) pause all jobs in the specified session 1056 #define PMIX_SESSION_RESUME "pmix.ssn.resume" // (bool) "un-pause" all jobs in the specified session 1057 #define PMIX_SESSION_TERMINATE "pmix.ssn.terminate" // (bool) terminate all jobs in the specified session and recover all 1058 // resources included in the session. 1059 #define PMIX_SESSION_PREEMPT "pmix.ssn.preempt" // (bool) preempt indicated jobs (given in accompanying pmix_info_t via 1060 // the PMIX_NSPACE attribute) in the specified session and recover 1061 // all their resources. If no PMIX_NSPACE is specified, then preempt 1062 // all jobs in the session. 1063 #define PMIX_SESSION_RESTORE "pmix.ssn.restore" // (bool) restore indicated jobs (given in accompanying pmix_info_t via 1064 // the PMIX_NSPACE attribute) in the specified session, including 1065 // all their resources. If no PMIX_NSPACE is specified, then restore 1066 // all jobs in the session. 1067 #define PMIX_SESSION_SIGNAL "pmix.ssn.sig" // (int) send given signal to all processes of every job in the session 1068 #define PMIX_SESSION_SEP "pmix.ssn.sep" // (bool) Separate the specified session from its parent - i.e., allow 1069 // the two to independently terminate. 1070 #define PMIX_SESSION_EXTEND "pmix.ssn.xtend" // (bool) Extend the specified session either in terms of time or resources, 1071 // based on additional provided attributes 1072 1073 /* session operational attributes - called by RTE */ 1074 #define PMIX_SESSION_COMPLETE "pmix.ssn.complete" // (bool) specified session has completed, all resources have been 1075 // recovered and are available for scheduling. Must include 1076 // pmix_info_t indicating returned status of any jobs 1077 // executed in the session. 1078 1079 1080 /* monitoring attributes */ 1081 #define PMIX_MONITOR_ID "pmix.monitor.id" // (char*) provide a string identifier for this request 1082 #define PMIX_MONITOR_PROXY "pmix.monitor.proxy" // (pmix_proc_t*) Process requesting monitoring information, if different 1083 // from the process calling the API 1084 #define PMIX_MONITOR_CANCEL "pmix.monitor.cancel" // (char*) identifier to be canceled (NULL = cancel all 1085 // monitoring for this process) 1086 #define PMIX_MONITOR_APP_CONTROL "pmix.monitor.appctrl" // (bool) the application desires to control the response to 1087 // a monitoring event 1088 #define PMIX_MONITOR_HEARTBEAT "pmix.monitor.mbeat" // (bool) register to have the server monitor the requestor for heartbeats 1089 #define PMIX_SEND_HEARTBEAT "pmix.monitor.beat" // (bool) send heartbeat to local server 1090 #define PMIX_MONITOR_HEARTBEAT_TIME "pmix.monitor.btime" // (uint32_t) time in seconds before declaring heartbeat missed 1091 #define PMIX_MONITOR_HEARTBEAT_DROPS "pmix.monitor.bdrop" // (uint32_t) number of heartbeats that can be missed before 1092 // generating the event 1093 #define PMIX_MONITOR_FILE "pmix.monitor.fmon" // (char*) register to monitor file for signs of life 1094 #define PMIX_MONITOR_FILE_SIZE "pmix.monitor.fsize" // (bool) monitor size of given file is growing to determine app is running 1095 #define PMIX_MONITOR_FILE_ACCESS "pmix.monitor.faccess" // (char*) monitor time since last access of given file to determine app is running 1096 #define PMIX_MONITOR_FILE_MODIFY "pmix.monitor.fmod" // (char*) monitor time since last modified of given file to determine app is running 1097 #define PMIX_MONITOR_FILE_CHECK_TIME "pmix.monitor.ftime" // (uint32_t) time in seconds between checking file 1098 #define PMIX_MONITOR_FILE_DROPS "pmix.monitor.fdrop" // (uint32_t) number of file checks that can be missed before 1099 // generating the event 1100 #define PMIX_MONITOR_RESOURCE_RATE "pmix.monitor.resrate" // (uint32_t) Monitor resource usage every N seconds, where N is the value provided 1101 // by the attribute. 1102 #define PMIX_MONITOR_TARGET_PROCS "pmix.monitor.tgtproc" // (pmix_data_array_t*) Arrray of process IDs specifying the processes to be monitored. 1103 // Can include a PMIX_RANK_WILDCARD to indicate that all processes from a given 1104 // namespace are to be included. If omitted, then all processesin the session will 1105 // be monitored. May be included multiple times to fully specify all processes to 1106 // be included. 1107 #define PMIX_MONITOR_TARGET_PIDS "pmix.monitor.tgtpid" // (pmix_data_array_t*) Array of pmix_node_pid_t structures to be monitored. Can include a 1108 // structure containing a hostname with a pid value of -1 to indicate all 1109 // processes on that node are to be included. May be included multiple times to 1110 // fully specify all processes to be included. 1111 #define PMIX_MONITOR_TARGET_NODES "pmix.monitor.tgtnode" // (pmix_data_array_t*) Array of string host names to be monitored 1112 #define PMIX_MONITOR_TARGET_NODEIDS "pmix.monitor.tgtndids" // (pmix_data_array_t*) Array of uint32_t node IDs to be monitored 1113 #define PMIX_MONITOR_TARGET_DISKS "pmix.monitor.tgtdks" // (pmix_data_array_t*) Array of strings representing PMIX_DISK_IDs to be monitored 1114 #define PMIX_MONITOR_TARGET_NETS "pmix.monitor.tgtnets" // (pmix_data_array_t*) Array of strings representing PMIX_NETWORK_IDs to be monitored 1115 #define PMIX_MONITOR_PROC_RESOURCE_USAGE "pmix.monitor.presuse" // (pmix_data_array_t*) Monitor the resources specified in the provided array of pmix_info_t. 1116 // If the provided array is NULL, then all resources shall be monitored. If no 1117 // targets are provided in the associated directives array, then all processes in 1118 // the session will be monitored. Note that the values in the provided structures 1119 // will be ignored (i.e., only the attribute keys are relevant) except where noted, 1120 // and that the PMIX_PROC_SAMPLE_TIME will always be included in the returned data 1121 // (there is no need to include it in the request) 1122 #define PMIX_MONITOR_NODE_RESOURCE_USAGE "pmix.monitor.ndresuse" // (pmix_data_array_t*) Monitor the resources specified in the provided array of pmix_info_t. 1123 // If the provided array is NULL, then all resources shall be monitored. If no 1124 // targets are provided in the associated directives array, then all nodes in 1125 // the session will be monitored. Note that the values in the provided structures 1126 // will be ignored (i.e., only the attribute keys are relevant) except where noted, 1127 // and that the PMIX_NODE_SAMPLE_TIME will always be included in the returned data 1128 // (there is no need to include it in the request) 1129 #define PMIX_MONITOR_DISK_RESOURCE_USAGE "pmix.monitor.dkresuse" // (pmix_data_array_t*) Monitor the resources specified in the provided array of pmix_info_t. 1130 // If the provided array is NULL, then all resources shall be monitored. If no 1131 // PMIX_DISK_ID targets are provided in the associated directives array, then all 1132 // disks on the local node (or on the specified target nodes, if given) will be monitored. 1133 // Note that the values in the provided structures will be ignored (i.e., only the 1134 // attribute keys are relevant) except where noted, and that the 1135 // PMIX_DISK_SAMPLE_TIME will always be included in the returned data 1136 // (there is no need to include it in the request) 1137 #define PMIX_MONITOR_NET_RESOURCE_USAGE "pmix.monitor.netresuse" // (pmix_data_array_t*) Monitor the resources specified in the provided array of pmix_info_t. 1138 // If the provided array is NULL, then all resources shall be monitored. If no 1139 // PMIX_NETWORK_ID targets are provided in the associated directives array, then all 1140 // networks on the local node (or on the specified target nodes, if given) will be monitored. 1141 // Note that the values in the provided structures will be ignored (i.e., only the 1142 // attribute keys are relevant) except where noted, and that the 1143 // PMIX_NET_SAMPLE_TIME will always be included in the returned data 1144 // (there is no need to include it in the request) 1145 #define PMIX_MONITOR_LOCAL_ONLY "pmix.monitor.local" // (bool) Restrict data collection to the local host, regardless of any provided targets 1146 /* resource usage attributes */ 1147 #define PMIX_PROC_RESOURCE_USAGE "pmix.proc.res" // (pmix_data_array_t*) An array of pmix_info_t describing the resource usage 1148 // of the specified process, with the first element containing the ID 1149 // of the process (marked by the PMIX_PROCID key) whose usage is reported 1150 // in the array. The list of included information may vary across 1151 // implementations and OSs, depending upon availability and access 1152 // restrictions. Except for the process ID as the first element, ordering 1153 // of information in the array is arbitrary. 1154 #define PMIX_PROC_OS_STATE "pmix.proc.osstate" // (char*) The state of the process as reported by the OS - for Linux, this is 1155 // expressed as a single character 1156 #define PMIX_PROC_TIME "pmix.proc.time" // (struct timeval) Cumulative CPU time 1157 #define PMIX_PROC_PERCENT_CPU "pmix.proc.pcpu" // (float) Percent cpu utilization by the process. Often, it is the CPU time used 1158 // divided by the time the process has been running (cputime/realtime ratio), 1159 // expressed as a percentage. 1160 #define PMIX_PROC_PRIORITY "pmix.proc.pri" // (int32_t) Priority of the process. Higher number means higher priority 1161 #define PMIX_PROC_NUM_THREADS "pmix.proc.nthr" // (uint16_t) Number of threads operating in the process 1162 #define PMIX_PROC_PSS "pmix.proc.pss" // (float) Proportional share size, the non-swapped physical memory, with 1163 // shared memory proportionally accounted to all tasks mappint it (MBytes) 1164 #define PMIX_PROC_VSIZE "pmix.proc.vsize" // (float) Virtual memory size of the process (MBytes) 1165 #define PMIX_PROC_RSS "pmix.proc.rss" // (float) Resident set size, the non-swapped physical memory that a task 1166 // has used (MBytes) 1167 #define PMIX_PROC_PEAK_VSIZE "pmix.proc.pkvsize" // (float) Peak virtual memory size of the process (MBytes) 1168 #define PMIX_PROC_CPU "pmix.proc.cpu" // (uint16_t) Processor that process last executed on 1169 #define PMIX_PROC_SAMPLE_TIME "pmix.proc.samptime" // (time_t) Time when sample was taken 1170 1171 #define PMIX_DISK_RESOURCE_USAGE "pmix.disk.res" // (pmix_data_array_t*) An array of pmix_info_t describing the resource usage of 1172 // the specified disk, with the first element containing the string name 1173 // of the disk (marked by the PMIX_DISK_ID key) whose usage is reported in 1174 // the array. The list of included information may vary across implementations 1175 // and OSs, depending upon availability and access restrictions. Except for 1176 // the disk ID as the first element, ordering of information in the array 1177 // is arbitrary. 1178 #define PMIX_DISK_ID "pmix.disk.id" // (char*) String identifier of a disk 1179 #define PMIX_DISK_READ_COMPLETED "pmix.disk.rdscomp" // (uint64_t) Number of completed read operations 1180 #define PMIX_DISK_READ_MERGED "pmix.disk.rdsmrgd" // (uint64_t) Number of merged reads 1181 #define PMIX_DISK_READ_SECTORS "pmix.disk.rdsct" // (uint64_t) Number of sectors read 1182 #define PMIX_DISK_READ_MILLISEC "pmix.disk.rdms" // (uint64_t) Number of milliseconds spent reading the disk 1183 #define PMIX_DISK_WRITE_COMPLETED "pmix.disk.wtscomp" // (uint64_t) Number of completed write operations 1184 #define PMIX_DISK_WRITE_MERGED "pmix.disk.wtsmrgd" // (uint64_t) Number of merged writes 1185 #define PMIX_DISK_WRITE_SECTORS "pmix.disk.wtsct" // (uint64_t) Number of sectors written 1186 #define PMIX_DISK_WRITE_MILLISEC "pmix.disk.wtms" // (uint64_t) Number of milliseconds spent writing to the disk 1187 #define PMIX_DISK_IO_IN_PROGRESS "pmix.disk.ios" // (uint64_t) Number of disk IO operations in progress 1188 #define PMIX_DISK_IO_MILLISEC "pmix.disk.ioms" // (uint64_t) Number of milliseconds spent in IO operations 1189 #define PMIX_DISK_IO_WEIGHTED "pmix.disk.iowght" // (uint64_t) Number of IOs in progress times the number of milliseconds spent 1190 // doing IO since last update of the field - indicator of backlog that 1191 // may be accumulating 1192 #define PMIX_DISK_SAMPLE_TIME "pmix.disk.samptime" // (time_t) Time when sample was taken 1193 1194 1195 #define PMIX_NETWORK_RESOURCE_USAGE "pmix.net.res" // (pmix_data_array_t*) An array of pmix_info_t describing the resource usage of 1196 // the specified network, with the first element containing the string name 1197 // of the interface (marked by the PMIX_NETWORK_ID key) whose usage is reported in 1198 // the array. The list of included information may vary across implementations 1199 // and OSs, depending upon availability and access restrictions. Except for 1200 // the network ID as the first element, ordering of information in the array 1201 // is arbitrary. 1202 #define PMIX_NETWORK_ID "pmix.net.id" // (char*) String identifier of a network interface 1203 #define PMIX_NET_RECVD_BYTES "pmix.net.rcb" // (uint64_t) Number of bytes received 1204 #define PMIX_NET_RECVD_PCKTS "pmix.net.rcp" // (uint64_t) Number of packets received 1205 #define PMIX_NET_RECVD_ERRS "pmix.net.rcerr" // (uint64_t) Number of receive errors 1206 #define PMIX_NET_SENT_BYTES "pmix.net.sntb" // (uint64_t) Number of bytes sent 1207 #define PMIX_NET_SENT_PCKTS "pmix.net.sntp" // (uint64_t) Number of packets sent 1208 #define PMIX_NET_SENT_ERRS "pmix.net.snterr" // (uint64_t) Number of send errors 1209 #define PMIX_NET_SAMPLE_TIME "pmix.net.samptime" // (time_t) Time when sample was taken 1210 1211 1212 #define PMIX_NODE_RESOURCE_USAGE "pmix.node.res" // (pmix_data_array_t*) An array of pmix_info_t describing the resource usage of 1213 // the specified node, with the first element containing the ID of the node 1214 // (marked by the PMIX_HOSTNAME or PMIX_NODEID key) whose usage is reported in 1215 // the array. The list of included information may vary across implementations 1216 // and OSs, depending upon availability and access restrictions. Except for 1217 // the node ID as the first element, ordering of information in the array 1218 // is arbitrary. 1219 #define PMIX_NODE_LOAD_AVG "pmix.node.la" // (float) Load average of last minute 1220 #define PMIX_NODE_LOAD_AVG5 "pmix.node.la5" // (float) Load average of last five minutes 1221 #define PMIX_NODE_LOAD_AVG15 "pmix.node.la15" // (float) Load average of last fifteen minutes 1222 #define PMIX_NODE_MEM_TOTAL "pmix.node.mtot" // (float) Total usable RAM - i.e., physical RAM minus reserved bits and kernel 1223 // binary code (MBytes) 1224 #define PMIX_NODE_MEM_FREE "pmix.node.mfree" // (float) Total free RAM (MBytes) 1225 #define PMIX_NODE_MEM_BUFFERS "pmix.node.mbuf" // (float) Temporary storage for raw disk blocks (MBytes) 1226 #define PMIX_NODE_MEM_CACHED "pmix.node.mcache" // (float) In-memory cache for files read from disk (the pagecache) as well as tmpfs 1227 // and shmem. Doesn't include PMIX_NODE_MEM_SWAP_CACHED. (MBytes) 1228 #define PMIX_NODE_MEM_SWAP_CACHED "pmix.node.mswpc" // (float) Memory that once was swapped out, is swapped back in but still also in the 1229 // swapfile (MBytes) 1230 #define PMIX_NODE_SWAP_TOTAL "pmix.node.mswpt" // (float) Total amount of swap space available (MBytes) 1231 #define PMIX_NODE_MEM_SWAP_FREE "pmix.node.mswpfree" // (float) Memory which has been evicted from RA<M and is temporarily on the disk (MBytes) 1232 #define PMIX_NODE_MEM_MAPPED "pmix.node.mmap" // (float) Files which have been mmapped, such as libraries. Note that some kernel 1233 // configurations might consider all pages part of a larger allocation (e.g., THP) 1234 // as mapped, as soon as a single page is mapped (MBytes) 1235 #define PMIX_NODE_SAMPLE_TIME "pmix.node.samptime" // (time_t) Time when sample was taken 1236 1237 1238 /* security attributes */ 1239 #define PMIX_CRED_TYPE "pmix.sec.ctype" // (char*) when passed in PMIx_Get_credential, a prioritized, 1240 // comma-delimited list of desired credential types for use 1241 // in environments where multiple authentication mechanisms 1242 // may be available. When returned in a callback function, a 1243 // string identifier of the credential type 1244 #define PMIX_CRYPTO_KEY "pmix.sec.key" // (pmix_byte_object_t) blob containing crypto key 1245 1246 1247 /* IO Forwarding Attributes */ 1248 #define PMIX_IOF_CACHE_SIZE "pmix.iof.csize" // (uint32_t) requested size of the server cache in bytes for each specified channel. 1249 // By default, the server is allowed (but not required) to drop 1250 // all bytes received beyond the max size 1251 #define PMIX_IOF_DROP_OLDEST "pmix.iof.old" // (bool) in an overflow situation, drop the oldest bytes to make room in the cache 1252 #define PMIX_IOF_DROP_NEWEST "pmix.iof.new" // (bool) in an overflow situation, drop any new bytes received until room becomes 1253 // available in the cache (default) 1254 #define PMIX_IOF_BUFFERING_SIZE "pmix.iof.bsize" // (uint32_t) basically controls grouping of IO on the specified channel(s) to 1255 // avoid being called every time a bit of IO arrives. The library 1256 // will execute the callback whenever the specified number of bytes 1257 // becomes available. Any remaining buffered data will be "flushed" 1258 // upon call to deregister the respective channel 1259 #define PMIX_IOF_BUFFERING_TIME "pmix.iof.btime" // (uint32_t) max time in seconds to buffer IO before delivering it. Used in conjunction 1260 // with buffering size, this prevents IO from being held indefinitely 1261 // while waiting for another payload to arrive 1262 #define PMIX_IOF_COMPLETE "pmix.iof.cmp" // (bool) indicates whether or not the specified IO channel has been closed 1263 // by the source 1264 #define PMIX_IOF_PUSH_STDIN "pmix.iof.stdin" // (bool) Used by a tool to request that the PMIx library collect 1265 // the tool's stdin and forward it to the procs specified in 1266 // the PMIx_IOF_push call 1267 #define PMIX_IOF_TAG_OUTPUT "pmix.iof.tag" // (bool) Tag output with the [local jobid,rank] and channel it comes from 1268 #define PMIX_IOF_TAG_DETAILED_OUTPUT "pmix.iof.tagdet" // (bool) Tag output with the [local jobid,rank][hostname:pid] and channel it comes from 1269 #define PMIX_IOF_TAG_FULLNAME_OUTPUT "pmix.iof.tagfull" // (bool) Tag output with the [nspace,rank] and channel it comes from 1270 #define PMIX_IOF_RANK_OUTPUT "pmix.iof.rank" // (bool) Tag output with the rank it came from 1271 #define PMIX_IOF_TIMESTAMP_OUTPUT "pmix.iof.ts" // (bool) Timestamp output 1272 #define PMIX_IOF_MERGE_STDERR_STDOUT "pmix.iof.mrg" // (bool) merge stdout and stderr streams from application procs 1273 #define PMIX_IOF_XML_OUTPUT "pmix.iof.xml" // (bool) Format output in XML 1274 #define PMIX_IOF_OUTPUT_TO_FILE "pmix.iof.file" // (char*) direct application output into files of form 1275 // "<filename>.rank" with both stdout and stderr redirected into it 1276 #define PMIX_IOF_FILE_PATTERN "pmix.iof.fpt" // (bool) Specified output file is to be treated as a pattern and not 1277 // automatically annotated by nspace, rank, or other parameters 1278 #define PMIX_IOF_OUTPUT_TO_DIRECTORY "pmix.iof.dir" // (char*) direct application output into files of form 1279 // "<directory>/<jobid>/rank.<rank>/stdout[err]" 1280 #define PMIX_IOF_FILE_ONLY "pmix.iof.fonly" // (bool) output only into designated files - do not also output 1281 // a copy to stdout/stderr 1282 #define PMIX_IOF_COPY "pmix.iof.cpy" // (bool) Requests that the host environment deliver a copy of the 1283 // specified output stream(s) to the tool, letting the stream(s) 1284 // continue to also be delivered to the default location. This 1285 // allows the tool to tap into the output stream(s) without 1286 // redirecting it from its current final destination. 1287 #define PMIX_IOF_REDIRECT "pmix.iof.redir" // (bool) Requests that the host environment intercept the specified 1288 // output stream(s) and deliver it to the requesting tool instead 1289 // of its current final destination. This might be used, for 1290 // example, during a debugging procedure to avoid injection of 1291 // debugger-related output into the application's results file. 1292 // The original output stream(s) destination is restored upon 1293 // termination of the tool. 1294 #define PMIX_IOF_LOCAL_OUTPUT "pmix.iof.local" // (bool) Write output streams to local stdout/err 1295 #define PMIX_IOF_OUTPUT_RAW "pmix.iof.raw" // (bool) Do not buffer output to be written as complete lines - output 1296 // characters as the stream delivers them 1297 1298 /* Attributes for controlling contents of application setup data */ 1299 #define PMIX_SETUP_APP_ENVARS "pmix.setup.env" // (bool) harvest and include relevant envars 1300 #define PMIX_SETUP_APP_NONENVARS "pmix.setup.nenv" // (bool) include all non-envar data 1301 #define PMIX_SETUP_APP_ALL "pmix.setup.all" // (bool) include all relevant data 1302 1303 /* Attributes supporting the PMIx Groups APIs */ 1304 #define PMIX_GROUP_ID "pmix.grp.id" // (char*) user-provided group identifier 1305 #define PMIX_GROUP_LEADER "pmix.grp.ldr" // (bool) this process is the leader of the group 1306 #define PMIX_GROUP_OPTIONAL "pmix.grp.opt" // (bool) participation is optional - do not return an error if any of the 1307 // specified processes terminate without having joined. The default 1308 // is false 1309 #define PMIX_GROUP_NOTIFY_TERMINATION "pmix.grp.notterm" // (bool) notify remaining members when another member terminates without first 1310 // leaving the group. The default is false 1311 #define PMIX_GROUP_FT_COLLECTIVE "pmix.grp.ftcoll" // (bool) adjust internal tracking for terminated processes. Default is false 1312 #define PMIX_GROUP_MEMBERSHIP "pmix.grp.mbrs" // (pmix_data_array_t*) array of group member ID's 1313 #define PMIX_GROUP_ASSIGN_CONTEXT_ID "pmix.grp.actxid" // (bool) request that the RM assign a unique numerical (size_t) ID to this group 1314 #define PMIX_GROUP_CONTEXT_ID "pmix.grp.ctxid" // (size_t) context ID assigned to group 1315 #define PMIX_GROUP_LOCAL_ONLY "pmix.grp.lcl" // (bool) group operation only involves local procs 1316 #define PMIX_GROUP_ENDPT_DATA "pmix.grp.endpt" // (pmix_byte_object_t) data collected to be shared during construction 1317 #define PMIX_GROUP_NAMES "pmix.pgrp.nm" // (pmix_data_array_t*) Returns an array of string names of the process groups 1318 // in which the given process is a member. 1319 #define PMIX_GROUP_INFO "pmix.grp.info" // (pmix_data_array_t*) Array of pmix_info_t containing data that is to be 1320 // shared across all members of a group during group construction. When 1321 // passed to the host, the array must start with the process ID 1322 // of the proc that provided it 1323 #define PMIX_GROUP_INFO_ARRAY "pmix.grp.infoarray" // (pmix_data_array_t*) Array of pmix_info_t, each containing a PMIX_GROUP_INFO array 1324 #define PMIX_GROUP_LOCAL_CID "pmix.grp.lclid" // (size_t) local context ID for the specified process member of a group 1325 #define PMIX_GROUP_ADD_MEMBERS "pmix.grp.add" // (pmix_data_array_t*) Array of pmix_proc_t identifying procs that are not 1326 // included in the membership specified in the procs array passed to 1327 // the PMIx_Group_construct[_nb] call, but are to be included in the 1328 // final group. See PMIX_GROUP_BOOTSTRAP for description of this operation. 1329 #define PMIX_GROUP_BOOTSTRAP "pmix.grp.btstrp" // (size_t) Group construct call will not include all members as individual 1330 // participants don't know the entire list. The provided number indicates 1331 // the number of procs that will start the construction. Additional 1332 // members will be provided via the PMIX_GROUP_ADD_MEMBERS attribute. 1333 // Non-bootstrap participants will still call PMIx_Group_construct, but 1334 // with a NULL for the procs parameter. This indicates that the caller 1335 // wishes to be included via a group invite, and so the library will 1336 // handle the necessary event registrations on behalf of the caller. 1337 #define PMIX_GROUP_JOB_INFO "pmix.grp.jinfo" // (pmix_byte_object_t) Job-level info for group construction 1338 #define PMIX_GROUP_FINAL_MEMBERSHIP_ORDER "pmix.grp.finord" // (pmix_data_array_t*) Array of pmix_proc_t specifying the order of processes 1339 // in the group membership. This can be specified by individual processes 1340 // or by namespace (with a wildcard rank). If multiple participants 1341 // provide this attribute, then the values must match - i.e., the 1342 // desired final membership order must be identical. 1343 1344 1345 /* Storage-Related Attributes */ 1346 #define PMIX_QUERY_STORAGE_LIST "pmix.strg.list" // (char*) return comma-delimited list of identifiers for all available storage systems 1347 #define PMIX_STORAGE_CAPACITY_LIMIT "pmix.strg.cap" // (uint64_t) return overall capacity (in Megabytes[base2]) of specified storage system 1348 #define PMIX_STORAGE_OBJECT_LIMIT "pmix.strg.obj" // (uint64_t) return overall limit on number of objects (e.g., inodes) of specified storage system 1349 1350 #define PMIX_STORAGE_ID "pmix.strg.id" // (char*) identifier of the storage system being referenced 1351 #define PMIX_STORAGE_PATH "pmix.strg.path" // (char*) Mount point corresponding to a specified storage ID 1352 #define PMIX_STORAGE_TYPE "pmix.strg.type" // (char*) Qualifier indicating the type of storage being referenced by a query 1353 // (e.g., lustre, gpfs, online, fabric-attached, ...) 1354 #define PMIX_STORAGE_ACCESSIBILITY "pmix.strg.access" // (pmix_storage_accessibility_t) Accessibility level of the storage system 1355 // (e.g., within same node, within same session) 1356 #define PMIX_STORAGE_ACCESS_TYPE "pmix.strg.atype" // (pmix_storage_access_type_t) Qualifier describing the type of storage access to return 1357 // information for (e.g., for qualifying PMIX_STORAGE_BW_CUR, PMIX_STORAGE_IOPS_CUR, 1358 // or PMIX_STORAGE_SUGGESTED_XFER_SIZE attributes) 1359 #define PMIX_STORAGE_BW_CUR "pmix.strg.bwcur" // (double) Observed bandwidth (in bytes/sec) for storage system - provided as a 1360 // recently observed bandwidth value, with the exact measurement interval 1361 // depending on the storage system and/or PMIx library implementation 1362 #define PMIX_STORAGE_BW_MAX "pmix.strg.bwmax" // (double) Maximum bandwidth (in bytes/sec) for storage system - provided as the 1363 // theoretical maximum or the maximum observed bandwidth value 1364 #define PMIX_STORAGE_CAPACITY_USED "pmix.strg.capuse" // (double) Overall used capacity (in bytes) for the storage system 1365 #define PMIX_STORAGE_IOPS_CUR "pmix.strg.iopscur" // (double) Observed IOPS (in I/O operations per second) for storage system - provided 1366 // as a recently observed IOPS value, with the exact measurement interval depending 1367 // on the storage system and/or PMIx library implementation 1368 #define PMIX_STORAGE_IOPS_MAX "pmix.strg.iopsmax" // (double) Maximum IOPS (in I/O operations per second) for storage system - provided 1369 // as the theoretical maximum or the maximum observed IOPS value 1370 #define PMIX_STORAGE_MEDIUM "pmix.strg.medium" // (pmix_storage_medium_t) Types of storage mediums utilized by the storage system 1371 // (e.g., SSDs, HDDs, tape) 1372 #define PMIX_STORAGE_MINIMAL_XFER_SIZE "pmix.strg.minxfer" // (double) Minimal transfer size (in bytes) for the storage system - this is the 1373 // storage system's atomic unit of transfer (e.g., block size) 1374 #define PMIX_STORAGE_OBJECTS_USED "pmix.strg.objuse" // (uint64_t) Overall used number of objects (e.g., inodes) for the storage system 1375 #define PMIX_STORAGE_PERSISTENCE "pmix.strg.persist" // (pmix_storage_persistence_t) Persistence level of the storage system 1376 // (e.g., sratch storage or archive storage) 1377 #define PMIX_STORAGE_SUGGESTED_XFER_SIZE "pmix.strg.sxfer" // (double) Suggested transfer size (in bytes) for the storage system 1378 #define PMIX_STORAGE_VERSION "pmix.strg.ver" // (char*) Version string for the storage system 1379 1380 1381 /* Fabric-related Attributes */ 1382 #define PMIX_FABRIC_COST_MATRIX "pmix.fab.cm" // (pointer) Pointer to a two-dimensional array of point-to-point relative 1383 // communication costs expressed as uint16_t values 1384 #define PMIX_FABRIC_GROUPS "pmix.fab.grps" // (char*) A string delineating the group membership of nodes in the system, 1385 // where each fabric group consists of the group number followed by 1386 // a colon and a comma-delimited list of nodes in that group, with the 1387 // groups delimited by semi-colons (e.g., 1388 // 0:node000,node002,node004,node006;1:node001,node003,node005,node007) 1389 #define PMIX_FABRIC_VENDOR "pmix.fab.vndr" // (char*) Name of fabric vendor (e.g., Amazon, Mellanox, HPE, Intel) 1390 #define PMIX_FABRIC_IDENTIFIER "pmix.fab.id" // (char*) An identifier for the fabric (e.g., MgmtEthernet, Slingshot-11, 1391 // OmniPath-1) 1392 #define PMIX_FABRIC_INDEX "pmix.fab.idx" // (size_t) The index of the fabric as returned in pmix_fabric_t 1393 #define PMIX_FABRIC_COORDINATES "pmix.fab.coord" // (pmix_data_array_t*) Array of pmix_geometry_t fabric coordinates for 1394 // devices on the specified node. The array will contain the 1395 // coordinates of all devices on the node, including values for 1396 // all supported coordinate views. The information for devices 1397 // on the local node shall be provided if the node is not 1398 // specified in the request. 1399 #define PMIX_FABRIC_DEVICE_VENDORID "pmix.fabdev.vendid" // (char*) This is a vendor-provided identifier for the device or product. 1400 #define PMIX_FABRIC_NUM_DEVICES "pmix.fab.nverts" // (size_t) Total number of fabric devices in the system - corresponds to 1401 // the number of rows or columns in the cost matrix 1402 #define PMIX_FABRIC_DIMS "pmix.fab.dims" // (uint32_t) Number of dimensions in the specified fabric plane/view. If no 1403 // plane is specified in a request, then the dimensions of all planes 1404 // in the overall system will be returned as a pmix_data_array_t 1405 // containing an array of uint32_t values. Default is to 1406 // provide dimensions in logical view. 1407 1408 #define PMIX_FABRIC_PLANE "pmix.fab.plane" // (char*) ID string of a fabric plane (e.g., CIDR for Ethernet). When used as 1409 // a modifier in a request for information, specifies the plane whose 1410 // information is to be returned. When used directly as a key in a 1411 // request, returns a pmix_data_array_t of string 1412 // identifiers for all fabric planes in the overall system. 1413 1414 #define PMIX_FABRIC_SWITCH "pmix.fab.switch" // (char*) ID string of a fabric switch. When used as a modifier in a request 1415 // for information, specifies the switch whose information is to be 1416 // returned. When used directly as a key in a request, returns a 1417 // pmix_data_array_t of string identifiers for all fabric switches in 1418 // the overall system. 1419 1420 #define PMIX_FABRIC_ENDPT "pmix.fab.endpt" // (pmix_data_array_t*) Fabric endpoints for a specified process. As multiple 1421 // endpoints may be assigned to a given process (e.g., in the case 1422 // where multiple devices are associated with a package to which the 1423 // process is bound), the returned values will be provided in a 1424 // pmix_data_array_t of pmix_endpoint_t elements. 1425 1426 #define PMIX_FABRIC_SHAPE "pmix.fab.shape" // (pmix_data_array_t*) The size of each dimension in the specified fabric 1427 // plane/view, returned in a pmix_data_array_t containing an array of 1428 // uint32_t values. The size is defined as the number of elements 1429 // present in that dimension - e.g., the number of devices in one 1430 // dimension of a physical view of a fabric plane. If no plane is 1431 // specified, then the shape of each plane in the overall system will 1432 // be returned in a pmix_data_array_t array where each element is 1433 // itself a two-element array containing the PMIX_FABRIC_PLANE 1434 // followed by that plane's fabric shape. Default is to provide the 1435 // shape in logical view. 1436 1437 #define PMIX_FABRIC_SHAPE_STRING "pmix.fab.shapestr" // (char*) Network shape expressed as a string (e.g., "10x12x2"). If no plane 1438 // is specified, then the shape of each plane in the overall system 1439 // will be returned in a pmix_data_array_t array where 1440 // each element is itself a two-element array containing the 1441 // PMIX_FABRIC_PLANE followed by that plane's fabric shape string. 1442 // Default is to provide the shape in logical view. 1443 1444 #define PMIX_SWITCH_PEERS "pmix.speers" // (char*) Peer ranks that share the same switch as the process specified in 1445 // the call to PMIx_Get. Returns a pmix_data_array_t array of 1446 // pmix_info_t results, each element containing the PMIX_SWITCH_PEERS 1447 // key with a three-element pmix_data_array_t array of pmix_info_t 1448 // containing the PMIX_FABRIC_DEVICE_ID of the local fabric device, 1449 // the PMIX_FABRIC_SWITCH identifying the switch to which it is 1450 // connected, and a comma-delimited string of peer ranks sharing the 1451 // switch to which that device is connected. 1452 #define PMIX_FABRIC_DEVICE "pmix.fabdev" // (pmix_data_array_t*) An array of pmix_info_t describing a particular 1453 // fabric device. The first element in the array shall be the 1454 // PMIX_FABRIC_DEVICE_ID of the device 1455 #define PMIX_FABRIC_DEVICES "pmix.fab.devs" // (pmix_data_array_t*) Array of pmix_info_t containing information for all 1456 // devices on the specified node. Each element of the array will contain 1457 // a PMIX_FABRIC_DEVICE entry, which in turn will contain an array of 1458 // information on a given device. 1459 #define PMIX_FABRIC_DEVICE_NAME "pmix.fabdev.nm" // (char*) The operating system name associated with the device. This may be 1460 // a logical fabric interface name (e.g. eth0 or eno1) or an absolute 1461 // filename. 1462 #define PMIX_FABRIC_DEVICE_INDEX "pmix.fabdev.idx" // (uint32_t) Index of the device within an associated communication cost 1463 // matrix. 1464 1465 #define PMIX_FABRIC_DEVICE_VENDOR "pmix.fabdev.vndr" // (char*) Indicates the name of the vendor that distributes the NIC. 1466 #define PMIX_FABRIC_DEVICE_BUS_TYPE "pmix.fabdev.btyp" // (char*) The type of bus to which the device is attached (e.g., "PCI", 1467 // "GEN-Z"). 1468 #define PMIX_FABRIC_DEVICE_DRIVER "pmix.fabdev.driver" // (char*) The name of the driver associated with the device 1469 #define PMIX_FABRIC_DEVICE_FIRMWARE "pmix.fabdev.fmwr" // (char*) The device's firmware version 1470 #define PMIX_FABRIC_DEVICE_ADDRESS "pmix.fabdev.addr" // (char*) The primary link-level address associated with the device, such as a 1471 // MAC address. If multiple addresses are available, only one will be 1472 // reported. 1473 #define PMIX_FABRIC_DEVICE_COORDINATES "pmix.fab.coord" // (pmix_geometry_t) The pmix_geometry_t fabric coordinates for the device, including 1474 // values for all supported coordinate views. 1475 #define PMIX_FABRIC_DEVICE_MTU "pmix.fabdev.mtu" // (size_t) The maximum transfer unit of link level frames or packets, 1476 // in bytes. 1477 #define PMIX_FABRIC_DEVICE_SPEED "pmix.fabdev.speed" // (size_t) The active link data rate, given in bits per second. 1478 #define PMIX_FABRIC_DEVICE_STATE "pmix.fabdev.state" // (pmix_link_state_t) The last available physical port state. Possible values 1479 // are PMIX_LINK_STATE_UNKNOWN, PMIX_LINK_DOWN, and PMIX_LINK_UP, to 1480 // indicate if the port state is unknown or not applicable (unknown), 1481 // inactive (down), or active (up). 1482 #define PMIX_FABRIC_DEVICE_TYPE "pmix.fabdev.type" // (char*) Specifies the type of fabric interface currently active on the 1483 // device, such as Ethernet or InfiniBand. 1484 #define PMIX_FABRIC_DEVICE_PCI_DEVID "pmix.fabdev.pcidevid" // (char*) A node-level unique identifier for a PCI device. Provided only if the 1485 // device is located on a \ac{PCI} bus. The identifier is constructed as 1486 // a four-part tuple delimited by colons comprised of the \ac{PCI} 16-bit 1487 // domain, 8-bit bus, 8-bit device, and 8-bit function IDs, each expressed 1488 // in zero-extended hexadecimal form. Thus, an example identifier might be 1489 // "abc1:0f:23:01". The combination of node identifier PMIX_HOSTNAME or 1490 // PMIX_NODEID and PMIX_FABRIC_DEVICE_PCI_DEVID shall be unique within the 1491 // system. 1492 1493 1494 /* Distance Attributes */ 1495 #define PMIX_DEVICE_DISTANCES "pmix.dev.dist" // (pmix_data_array_t*) Return an array of pmix_device_distance_t containing the 1496 // minimum and maximum distances of the given process location to all 1497 // devices of the specified type on the local node. 1498 #define PMIX_DEVICE_TYPE "pmix.dev.type" // (pmix_device_type_t) Bitmask specifying the type(s) of device(s) whose 1499 // information is being requested. Only used as a directive/qualifier. 1500 #define PMIX_DEVICE_ID "pmix.dev.id" // (char*) System-wide UUID or node-local OS name of a particular device. 1501 1502 1503 /* Descriptive Attributes */ 1504 #define PMIX_MAX_VALUE "pmix.descr.maxval" // (varies) Used in pmix_regattr_t to describe the maximum valid value 1505 // for the associated attribute. 1506 #define PMIX_MIN_VALUE "pmix.descr.minval" // (varies) Used in pmix_regattr_t to describe the minimum valid value 1507 // for the associated attribute. 1508 #define PMIX_ENUM_VALUE "pmix.descr.enum" // (char*) Used in pmix_regattr_t to describe accepted values for the 1509 // associated attribute. Numerical values shall be presented in 1510 // a form convertible to the attribute's declared data type. 1511 // Named values (i.e., values defined by constant names via a 1512 // typical C-language enum declaration) must be provided as 1513 // their numerical equivalent. 1514 #define PMIX_QUERY_STABLE_ABI_VERSION "pmix.qry.stabiver" // (char*) The PMIx Standard Stable ABI version supported returned in the form of a comma separated list of "MAJOR.MINOR" 1515 // This attribute can be used with PMIx_Query_info outside of the init/finalize region. 1516 #define PMIX_QUERY_PROVISIONAL_ABI_VERSION "pmix.qry.prabiver" // (char*) The PMIx Standard Provisional ABI version supported returned in the form of a comma separated "MAJOR.MINOR" 1517 // This attribute can be used with PMIx_Query_info outside of the init/finalize region. 1518 1519 #define PMIX_VERSION_NUMERIC "pmix.vers.num" // (uint32_t) Numeric representation of the version of the PMIx library 1520 // being used 1521 1522 1523 /**** PROCESS STATE DEFINITIONS ****/ 1524 typedef uint8_t pmix_proc_state_t; 1525 #define PMIX_PROC_STATE_UNDEF 0 /* undefined process state */ 1526 #define PMIX_PROC_STATE_PREPPED 1 /* process is ready to be launched */ 1527 #define PMIX_PROC_STATE_LAUNCH_UNDERWAY 2 /* launch process underway */ 1528 #define PMIX_PROC_STATE_RESTART 3 /* the proc is ready for restart */ 1529 #define PMIX_PROC_STATE_TERMINATE 4 /* process is marked for termination */ 1530 #define PMIX_PROC_STATE_RUNNING 5 /* daemon has locally fork'd process */ 1531 #define PMIX_PROC_STATE_CONNECTED 6 /* proc connected to PMIx server */ 1532 /* 1533 * Define a "boundary" so users can easily and quickly determine 1534 * if a proc is still running or not - any value less than 1535 * this one means that the proc has not terminated 1536 */ 1537 #define PMIX_PROC_STATE_UNTERMINATED 15 1538 1539 #define PMIX_PROC_STATE_TERMINATED 20 /* process has terminated and is no longer running */ 1540 /* Define a boundary so users can easily and quickly determine 1541 * if a proc abnormally terminated - leave a little room 1542 * for future expansion 1543 */ 1544 #define PMIX_PROC_STATE_ERROR 50 1545 /* Define specific error code values */ 1546 #define PMIX_PROC_STATE_KILLED_BY_CMD (PMIX_PROC_STATE_ERROR + 1) /* process was killed by cmd */ 1547 #define PMIX_PROC_STATE_ABORTED (PMIX_PROC_STATE_ERROR + 2) /* process aborted */ 1548 #define PMIX_PROC_STATE_FAILED_TO_START (PMIX_PROC_STATE_ERROR + 3) /* process failed to start */ 1549 #define PMIX_PROC_STATE_ABORTED_BY_SIG (PMIX_PROC_STATE_ERROR + 4) /* process aborted by signal */ 1550 #define PMIX_PROC_STATE_TERM_WO_SYNC (PMIX_PROC_STATE_ERROR + 5) /* process exit'd w/o calling PMIx_Finalize */ 1551 #define PMIX_PROC_STATE_COMM_FAILED (PMIX_PROC_STATE_ERROR + 6) /* process communication has failed */ 1552 #define PMIX_PROC_STATE_SENSOR_BOUND_EXCEEDED (PMIX_PROC_STATE_ERROR + 7) /* process exceeded a sensor limit */ 1553 #define PMIX_PROC_STATE_CALLED_ABORT (PMIX_PROC_STATE_ERROR + 8) /* process called "PMIx_Abort" */ 1554 #define PMIX_PROC_STATE_HEARTBEAT_FAILED (PMIX_PROC_STATE_ERROR + 9) /* process failed to send heartbeat w/in time limit */ 1555 #define PMIX_PROC_STATE_MIGRATING (PMIX_PROC_STATE_ERROR + 10) /* process failed and is waiting for resources before restarting */ 1556 #define PMIX_PROC_STATE_CANNOT_RESTART (PMIX_PROC_STATE_ERROR + 11) /* process failed and cannot be restarted */ 1557 #define PMIX_PROC_STATE_TERM_NON_ZERO (PMIX_PROC_STATE_ERROR + 12) /* process exited with a non-zero status, indicating abnormal */ 1558 #define PMIX_PROC_STATE_FAILED_TO_LAUNCH (PMIX_PROC_STATE_ERROR + 13) /* unable to launch process */ 1559 1560 1561 /**** JOB STATE DEFINITIONS ****/ 1562 typedef uint8_t pmix_job_state_t; 1563 #define PMIX_JOB_STATE_UNDEF 0 // undefined process state 1564 #define PMIX_JOB_STATE_AWAITING_ALLOC 1 // Job is waiting for resources to be allocated to it 1565 #define PMIX_JOB_STATE_LAUNCH_UNDERWAY 2 // job launch underway 1566 #define PMIX_JOB_STATE_RUNNING 3 // all procs have been spawned 1567 #define PMIX_JOB_STATE_SUSPENDED 4 // job has been suspended 1568 #define PMIX_JOB_STATE_CONNECTED 5 // all procs have connected to their PMIx server 1569 1570 /* 1571 * Define a "boundary" so users can easily and quickly determine 1572 * if a job is still running or not - any value less than 1573 * this one means that the job has not terminated 1574 */ 1575 #define PMIX_JOB_STATE_UNTERMINATED 15 1576 1577 #define PMIX_JOB_STATE_TERMINATED 20 // job has terminated and is no longer running - typically will 1578 // be accompanied by the job exit status in response to a query 1579 1580 /* Define a boundary so users can easily and quickly determine 1581 * if a job abnormally terminated - leave a little room 1582 * for future expansion 1583 */ 1584 #define PMIX_JOB_STATE_TERMINATED_WITH_ERROR 50 // job has terminated and is no longer running - typically will 1585 // be accompanied by a job-related error code in response to a query 1586 1587 1588 /**** PMIX ERROR CONSTANTS ****/ 1589 /* PMIx errors are always negative, with 0 reserved for success */ 1590 typedef int pmix_status_t; 1591 1592 /* v1.x error values - must be fixed in place for backward 1593 * compatibility. Note that some number of these have been 1594 * deprecated and may not be returned by v2.x and above 1595 * clients or servers. However, they must always be 1596 * at least defined to ensure older codes will compile */ 1597 #define PMIX_SUCCESS 0 1598 #define PMIX_ERROR -1 // general error 1599 /* fault tolerance */ 1600 #define PMIX_ERR_PROC_RESTART -4 1601 #define PMIX_ERR_PROC_CHECKPOINT -5 1602 #define PMIX_ERR_PROC_MIGRATE -6 1603 #define PMIX_ERR_EXISTS -11 1604 /* communication failures */ 1605 #define PMIX_ERR_INVALID_CRED -12 1606 #define PMIX_ERR_WOULD_BLOCK -15 1607 #define PMIX_ERR_UNKNOWN_DATA_TYPE -16 1608 #define PMIX_ERR_TYPE_MISMATCH -18 1609 #define PMIX_ERR_UNPACK_INADEQUATE_SPACE -19 1610 #define PMIX_ERR_UNPACK_FAILURE -20 1611 #define PMIX_ERR_PACK_FAILURE -21 1612 #define PMIX_ERR_NO_PERMISSIONS -23 1613 #define PMIX_ERR_TIMEOUT -24 1614 #define PMIX_ERR_UNREACH -25 1615 #define PMIX_ERR_BAD_PARAM -27 1616 #define PMIX_ERR_RESOURCE_BUSY -28 1617 #define PMIX_ERR_OUT_OF_RESOURCE -29 1618 #define PMIX_ERR_INIT -31 1619 #define PMIX_ERR_NOMEM -32 1620 #define PMIX_ERR_NOT_FOUND -46 1621 #define PMIX_ERR_NOT_SUPPORTED -47 1622 #define PMIX_ERR_PARAM_VALUE_NOT_SUPPORTED -59 1623 #define PMIX_ERR_COMM_FAILURE -49 1624 #define PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER -50 1625 #define PMIX_ERR_CONFLICTING_CLEANUP_DIRECTIVES -51 1626 #define PMIX_ERR_PARTIAL_SUCCESS -52 1627 #define PMIX_ERR_DUPLICATE_KEY -53 1628 #define PMIX_ERR_EMPTY -60 1629 #define PMIX_ERR_LOST_CONNECTION -61 1630 #define PMIX_ERR_EXISTS_OUTSIDE_SCOPE -62 1631 #define PMIX_ERR_NOT_AVAILABLE -64 1632 1633 /* Process set */ 1634 #define PMIX_PROCESS_SET_DEFINE -55 1635 #define PMIX_PROCESS_SET_DELETE -56 1636 1637 /* Debugger ops */ 1638 #define PMIX_DEBUGGER_RELEASE -3 // replaced deprecated PMIX_ERR_DEBUGGER_RELEASE 1639 #define PMIX_READY_FOR_DEBUG -58 // accompanied by PMIX_BREAKPOINT indicating where proc is waiting 1640 1641 /* query errors */ 1642 #define PMIX_QUERY_PARTIAL_SUCCESS -104 1643 1644 /* job control */ 1645 #define PMIX_JCTRL_CHECKPOINT -106 // monitored by client to trigger checkpoint operation 1646 #define PMIX_JCTRL_CHECKPOINT_COMPLETE -107 // sent by client and monitored by server to notify that requested 1647 // checkpoint operation has completed 1648 #define PMIX_JCTRL_PREEMPT_ALERT -108 // monitored by client to detect RM intends to preempt 1649 1650 /* monitoring */ 1651 #define PMIX_MONITOR_HEARTBEAT_ALERT -109 1652 #define PMIX_MONITOR_FILE_ALERT -110 1653 #define PMIX_PROC_TERMINATED -111 1654 #define PMIX_MONITOR_RESUSAGE_UPDATE -114 1655 1656 /* operational */ 1657 #define PMIX_ERR_EVENT_REGISTRATION -144 1658 #define PMIX_MODEL_DECLARED -147 1659 #define PMIX_MODEL_RESOURCES -151 // model resource usage has changed 1660 #define PMIX_OPENMP_PARALLEL_ENTERED -152 // an OpenMP parallel region has been entered 1661 #define PMIX_OPENMP_PARALLEL_EXITED -153 // an OpenMP parallel region has completed 1662 #define PMIX_LAUNCHER_READY -155 1663 #define PMIX_OPERATION_IN_PROGRESS -156 1664 #define PMIX_OPERATION_SUCCEEDED -157 1665 #define PMIX_ERR_INVALID_OPERATION -158 1666 #define PMIX_GROUP_INVITED -159 1667 #define PMIX_GROUP_LEFT -160 1668 #define PMIX_GROUP_INVITE_ACCEPTED -161 1669 #define PMIX_GROUP_INVITE_DECLINED -162 1670 #define PMIX_GROUP_INVITE_FAILED -163 1671 #define PMIX_GROUP_MEMBERSHIP_UPDATE -164 1672 #define PMIX_GROUP_CONSTRUCT_ABORT -165 1673 #define PMIX_GROUP_CONSTRUCT_COMPLETE -166 1674 #define PMIX_GROUP_LEADER_SELECTED -167 1675 #define PMIX_GROUP_LEADER_FAILED -168 1676 #define PMIX_GROUP_CONTEXT_ID_ASSIGNED -169 1677 #define PMIX_GROUP_MEMBER_FAILED -170 1678 #define PMIX_ERR_REPEAT_ATTR_REGISTRATION -171 1679 #define PMIX_ERR_IOF_FAILURE -172 1680 #define PMIX_ERR_IOF_COMPLETE -173 1681 #define PMIX_LAUNCH_COMPLETE -174 // include nspace of the launched job with notification 1682 #define PMIX_FABRIC_UPDATED -175 1683 #define PMIX_FABRIC_UPDATE_PENDING -176 1684 #define PMIX_FABRIC_UPDATE_ENDPOINTS -113 1685 1686 /* job-related errors */ 1687 #define PMIX_ERR_JOB_APP_NOT_EXECUTABLE -177 1688 #define PMIX_ERR_JOB_NO_EXE_SPECIFIED -178 1689 #define PMIX_ERR_JOB_FAILED_TO_MAP -179 1690 #define PMIX_ERR_JOB_CANCELED -180 1691 #define PMIX_ERR_JOB_FAILED_TO_LAUNCH -181 1692 #define PMIX_ERR_JOB_ABORTED -182 1693 #define PMIX_ERR_JOB_KILLED_BY_CMD -183 1694 #define PMIX_ERR_JOB_ABORTED_BY_SIG -184 1695 #define PMIX_ERR_JOB_TERM_WO_SYNC -185 1696 #define PMIX_ERR_JOB_SENSOR_BOUND_EXCEEDED -186 1697 #define PMIX_ERR_JOB_NON_ZERO_TERM -187 1698 #define PMIX_ERR_JOB_ALLOC_FAILED -188 1699 #define PMIX_ERR_JOB_ABORTED_BY_SYS_EVENT -189 1700 #define PMIX_ERR_JOB_EXE_NOT_FOUND -190 1701 #define PMIX_ERR_JOB_WDIR_NOT_FOUND -233 1702 #define PMIX_ERR_JOB_INSUFFICIENT_RESOURCES -234 1703 #define PMIX_ERR_JOB_SYS_OP_FAILED -235 1704 1705 /* job/session-related non-error events */ 1706 #define PMIX_EVENT_JOB_START -191 1707 #define PMIX_EVENT_JOB_END -145 1708 #define PMIX_EVENT_SESSION_START -192 1709 #define PMIX_EVENT_SESSION_END -193 1710 1711 /* process-related events */ 1712 #define PMIX_ERR_PROC_REQUESTED_ABORT -8 1713 #define PMIX_ERR_PROC_TERM_WO_SYNC -200 1714 #define PMIX_EVENT_PROC_TERMINATED -201 1715 #define PMIX_ERR_PROC_KILLED_BY_CMD -400 1716 #define PMIX_ERR_PROC_FAILED_TO_START -401 1717 #define PMIX_ERR_PROC_ABORTED_BY_SIG -402 1718 #define PMIX_ERR_PROC_SENSOR_BOUND_EXCEEDED -403 1719 #define PMIX_ERR_EXIT_NONZERO_TERM -404 1720 1721 /* system failures */ 1722 #define PMIX_EVENT_SYS_BASE -230 1723 #define PMIX_EVENT_NODE_DOWN -231 1724 #define PMIX_EVENT_NODE_OFFLINE -232 1725 #define PMIX_EVENT_SYS_OTHER -330 1726 1727 1728 /* define a macro for identifying system event values */ 1729 #define PMIX_SYSTEM_EVENT(a) \ 1730 ((a) <= PMIX_EVENT_SYS_BASE && PMIX_EVENT_SYS_OTHER <= (a)) 1731 1732 /* used by event handlers */ 1733 #define PMIX_EVENT_NO_ACTION_TAKEN -331 1734 #define PMIX_EVENT_PARTIAL_ACTION_TAKEN -332 1735 #define PMIX_EVENT_ACTION_DEFERRED -333 1736 #define PMIX_EVENT_ACTION_COMPLETE -334 1737 1738 /* conversion errors */ 1739 #define PMIX_ERR_LOST_PRECISION -400 1740 #define PMIX_ERR_CHANGE_SIGN -401 1741 1742 /* define a starting point for user-level defined error 1743 * constants - negative values larger than this are guaranteed 1744 * not to conflict with PMIx values. Definitions should always 1745 * be based on the PMIX_EXTERNAL_ERR_BASE constant and -not- a 1746 * specific value as the value of the constant may change */ 1747 #define PMIX_EXTERNAL_ERR_BASE -3000 1748 1749 /* define the results values for comparisons */ 1750 typedef enum { 1751 PMIX_EQUAL, 1752 PMIX_VALUE1_GREATER, 1753 PMIX_VALUE2_GREATER, 1754 PMIX_VALUE_TYPE_DIFFERENT, 1755 PMIX_VALUE_INCOMPATIBLE_OBJECTS, 1756 PMIX_VALUE_COMPARISON_NOT_AVAIL 1757 } pmix_value_cmp_t; 1758 1759 /**** PMIX DATA TYPES ****/ 1760 typedef uint16_t pmix_data_type_t; 1761 #define PMIX_UNDEF 0 1762 #define PMIX_BOOL 1 // converted to/from native true/false to uint8 for pack/unpack 1763 #define PMIX_BYTE 2 // a byte of data 1764 #define PMIX_STRING 3 // NULL-terminated string 1765 #define PMIX_SIZE 4 // size_t 1766 #define PMIX_PID 5 // OS-pid 1767 #define PMIX_INT 6 1768 #define PMIX_INT8 7 1769 #define PMIX_INT16 8 1770 #define PMIX_INT32 9 1771 #define PMIX_INT64 10 1772 #define PMIX_UINT 11 1773 #define PMIX_UINT8 12 1774 #define PMIX_UINT16 13 1775 #define PMIX_UINT32 14 1776 #define PMIX_UINT64 15 1777 #define PMIX_FLOAT 16 1778 #define PMIX_DOUBLE 17 1779 #define PMIX_TIMEVAL 18 1780 #define PMIX_TIME 19 1781 #define PMIX_STATUS 20 // needs to be tracked separately from integer for those times 1782 // when we are embedded and it needs to be converted to the 1783 // host error definitions 1784 #define PMIX_VALUE 21 1785 #define PMIX_PROC 22 1786 #define PMIX_APP 23 1787 #define PMIX_INFO 24 1788 #define PMIX_PDATA 25 1789 // Hole left by deprecation/removal of PMIX_BUFFER 1790 #define PMIX_BYTE_OBJECT 27 1791 #define PMIX_KVAL 28 1792 // Hole left by deprecation/removal of PMIX_MODEX 1793 #define PMIX_PERSIST 30 1794 #define PMIX_POINTER 31 1795 #define PMIX_SCOPE 32 1796 #define PMIX_DATA_RANGE 33 1797 #define PMIX_COMMAND 34 1798 #define PMIX_INFO_DIRECTIVES 35 1799 #define PMIX_DATA_TYPE 36 1800 #define PMIX_PROC_STATE 37 1801 #define PMIX_PROC_INFO 38 1802 #define PMIX_DATA_ARRAY 39 1803 #define PMIX_PROC_RANK 40 1804 #define PMIX_QUERY 41 1805 #define PMIX_COMPRESSED_STRING 42 // string compressed with zlib 1806 #define PMIX_ALLOC_DIRECTIVE 43 1807 // Hole left by deprecation/removal of PMIX_INFO_ARRAY 1808 #define PMIX_IOF_CHANNEL 45 1809 #define PMIX_ENVAR 46 1810 #define PMIX_COORD 47 1811 #define PMIX_REGATTR 48 1812 #define PMIX_REGEX 49 1813 #define PMIX_JOB_STATE 50 1814 #define PMIX_LINK_STATE 51 1815 #define PMIX_PROC_CPUSET 52 1816 #define PMIX_GEOMETRY 53 1817 #define PMIX_DEVICE_DIST 54 1818 #define PMIX_ENDPOINT 55 1819 #define PMIX_TOPO 56 1820 #define PMIX_DEVTYPE 57 1821 #define PMIX_LOCTYPE 58 1822 #define PMIX_COMPRESSED_BYTE_OBJECT 59 1823 #define PMIX_PROC_NSPACE 60 1824 #define PMIX_DATA_BUFFER 65 1825 #define PMIX_STOR_MEDIUM 66 1826 #define PMIX_STOR_ACCESS 67 1827 #define PMIX_STOR_PERSIST 68 1828 #define PMIX_STOR_ACCESS_TYPE 69 1829 #define PMIX_DEVICE 70 1830 #define PMIX_RESBLOCK_DIRECTIVE 71 1831 #define PMIX_RESOURCE_UNIT 72 1832 #define PMIX_NODE_PID 73 1833 /********************/ 1834 1835 /* define a boundary for implementers so they can add their own data types */ 1836 #define PMIX_DATA_TYPE_MAX 500 1837 1838 1839 /* define a scope for data "put" by PMIx per the following: 1840 * 1841 * PMI_LOCAL - the data is intended only for other application 1842 * processes on the same node. Data marked in this way 1843 * will not be included in data packages sent to remote requestors 1844 * PMI_REMOTE - the data is intended solely for applications processes on 1845 * remote nodes. Data marked in this way will not be shared with 1846 * other processes on the same node 1847 * PMI_GLOBAL - the data is to be shared with all other requesting processes, 1848 * regardless of location 1849 */ 1850 typedef uint8_t pmix_scope_t; 1851 #define PMIX_SCOPE_UNDEF 0 1852 #define PMIX_LOCAL 1 // share to procs also on this node 1853 #define PMIX_REMOTE 2 // share with procs not on this node 1854 #define PMIX_GLOBAL 3 // share with all procs (local + remote) 1855 #define PMIX_INTERNAL 4 // store data in the internal tables 1856 1857 /* define a range for data "published" by PMIx 1858 */ 1859 typedef uint8_t pmix_data_range_t; 1860 #define PMIX_RANGE_UNDEF 0 1861 #define PMIX_RANGE_RM 1 // data is intended for the host resource manager 1862 #define PMIX_RANGE_LOCAL 2 // available on local node only 1863 #define PMIX_RANGE_NAMESPACE 3 // data is available to procs in the same nspace only 1864 #define PMIX_RANGE_SESSION 4 // data available to all procs in session 1865 #define PMIX_RANGE_GLOBAL 5 // data available to all procs 1866 #define PMIX_RANGE_CUSTOM 6 // range is specified in a pmix_info_t 1867 #define PMIX_RANGE_PROC_LOCAL 7 // restrict range to the local proc 1868 #define PMIX_RANGE_INVALID UINT8_MAX 1869 1870 /* define a "persistence" policy for data published by clients */ 1871 typedef uint8_t pmix_persistence_t; 1872 #define PMIX_PERSIST_INDEF 0 // retain until specifically deleted 1873 #define PMIX_PERSIST_FIRST_READ 1 // delete upon first access 1874 #define PMIX_PERSIST_PROC 2 // retain until publishing process terminates 1875 #define PMIX_PERSIST_APP 3 // retain until application terminates 1876 #define PMIX_PERSIST_SESSION 4 // retain until session/allocation terminates 1877 #define PMIX_PERSIST_INVALID UINT8_MAX 1878 1879 /* define a set of bit-mask flags for specifying behavior of 1880 * command directives via pmix_info_t arrays */ 1881 typedef uint32_t pmix_info_directives_t; 1882 #define PMIX_INFO_REQD 0x00000001 1883 #define PMIX_INFO_ARRAY_END 0x00000002 // mark the end of an array created by PMIX_INFO_CREATE 1884 #define PMIX_INFO_REQD_PROCESSED 0x00000004 // reqd attribute has been processed 1885 #define PMIX_INFO_QUALIFIER 0x00000008 // info is a qualifier to the primary value 1886 #define PMIX_INFO_PERSISTENT 0x00000010 // do not release included value 1887 /* the top 16-bits are reserved for internal use by 1888 * implementers - these may be changed inside the 1889 * PMIx library */ 1890 #define PMIX_INFO_DIR_RESERVED 0xffff0000 1891 1892 /* define a set of directives for allocation requests */ 1893 typedef uint8_t pmix_alloc_directive_t; 1894 #define PMIX_ALLOC_NEW 1 // new allocation is being requested. The resulting allocation will be 1895 // disjoint (i.e., not connected in a job sense) from the requesting allocation 1896 #define PMIX_ALLOC_EXTEND 2 // extend the existing allocation, either in time or as additional resources 1897 #define PMIX_ALLOC_RELEASE 3 // release part or all of the existing allocation. Attributes in the accompanying 1898 // pmix\_info\_t array may be used to specify "lending" of those resources 1899 // for some period of time. 1900 #define PMIX_ALLOC_REAQUIRE 4 // reacquire resources that were previously "lent" back to the scheduler 1901 #define PMIX_ALLOC_REQ_CANCEL 5 // Cancel the indicated allocation request 1902 1903 /* define a value boundary beyond which implementers are free 1904 * to define their own directive values */ 1905 #define PMIX_ALLOC_EXTERNAL 128 1906 1907 /* define a set of directives for resource block requests */ 1908 typedef uint8_t pmix_resource_block_directive_t; 1909 #define PMIX_RESOURCE_BLOCK_DEFINE 1 // define a new resource block 1910 #define PMIX_RESOURCE_BLOCK_EXTEND 2 // extend an existing block definition by adding the specified resources 1911 // to the block 1912 #define PMIX_RESOURCE_BLOCK_REMOVE 3 // remove the specified resources from the block definition 1913 #define PMIX_RESOURCE_BLOCK_DELETE 4 // delete the resource block definition 1914 1915 /* define a value boundary beyond which implementers are free 1916 * to define their own directive values */ 1917 #define PMIX_RESOURCE_BLOCK_EXTERNAL 128 1918 1919 1920 /* define a set of bit-mask flags for specifying IO 1921 * forwarding channels. These can be OR'd together 1922 * to reference multiple channels */ 1923 typedef uint16_t pmix_iof_channel_t; 1924 #define PMIX_FWD_NO_CHANNELS 0x0000 1925 #define PMIX_FWD_STDIN_CHANNEL 0x0001 1926 #define PMIX_FWD_STDOUT_CHANNEL 0x0002 1927 #define PMIX_FWD_STDERR_CHANNEL 0x0004 1928 #define PMIX_FWD_STDDIAG_CHANNEL 0x0008 1929 #define PMIX_FWD_ALL_CHANNELS 0x00ff 1930 1931 /* define values associated with PMIx_Group_join 1932 * to indicate accept and decline - this is 1933 * done for readability of user code */ 1934 typedef enum { 1935 PMIX_GROUP_DECLINE, 1936 PMIX_GROUP_ACCEPT 1937 } pmix_group_opt_t; 1938 1939 typedef enum { 1940 PMIX_GROUP_CONSTRUCT, 1941 PMIX_GROUP_DESTRUCT, 1942 PMIX_GROUP_NONE 1943 } pmix_group_operation_t; 1944 1945 /* define storage medium values 1946 * The pmix_storage_medium_t is a uint64_t type that defines 1947 * a set of bit-mask flags for specifying different types of 1948 * storage mediums. These can be bitwise OR'd together to 1949 * accommodate storage systems that mix storage medium types. */ 1950 typedef uint64_t pmix_storage_medium_t; 1951 #define PMIX_STORAGE_MEDIUM_UNKNOWN 0x0000000000000001 1952 #define PMIX_STORAGE_MEDIUM_TAPE 0x0000000000000002 1953 #define PMIX_STORAGE_MEDIUM_HDD 0x0000000000000004 1954 #define PMIX_STORAGE_MEDIUM_SSD 0x0000000000000008 1955 #define PMIX_STORAGE_MEDIUM_NVME 0x0000000000000010 1956 #define PMIX_STORAGE_MEDIUM_PMEM 0x0000000000000020 1957 #define PMIX_STORAGE_MEDIUM_RAM 0x0000000000000040 1958 1959 /* define storage accessibility values 1960 * The pmix_storage_accessibility_t is a uint64_t type that 1961 * defines a set of bit-mask flags for specifying different 1962 * levels of storage accessibility (i.e,. from where a storage 1963 * system may be accessed). These can be bitwise OR'd together 1964 * to accommodate storage systems that are accessibile in 1965 * multiple ways. */ 1966 typedef uint64_t pmix_storage_accessibility_t; 1967 #define PMIX_STORAGE_ACCESSIBILITY_NODE 0x0000000000000001 1968 #define PMIX_STORAGE_ACCESSIBILITY_SESSION 0x0000000000000002 1969 #define PMIX_STORAGE_ACCESSIBILITY_JOB 0x0000000000000004 1970 #define PMIX_STORAGE_ACCESSIBILITY_RACK 0x0000000000000008 1971 #define PMIX_STORAGE_ACCESSIBILITY_CLUSTER 0x0000000000000010 1972 #define PMIX_STORAGE_ACCESSIBILITY_REMOTE 0x0000000000000020 1973 1974 /* define storage persistence values 1975 * The pmix_storage_persistence_t is a uint64_t type that defines 1976 * a set of bit-mask flags for specifying different levels of 1977 * persistence for a particular storage system. */ 1978 typedef uint64_t pmix_storage_persistence_t; 1979 #define PMIX_STORAGE_PERSISTENCE_TEMPORARY 0x0000000000000001 1980 #define PMIX_STORAGE_PERSISTENCE_NODE 0x0000000000000002 1981 #define PMIX_STORAGE_PERSISTENCE_SESSION 0x0000000000000004 1982 #define PMIX_STORAGE_PERSISTENCE_JOB 0x0000000000000008 1983 #define PMIX_STORAGE_PERSISTENCE_SCRATCH 0x0000000000000010 1984 #define PMIX_STORAGE_PERSISTENCE_PROJECT 0x0000000000000020 1985 #define PMIX_STORAGE_PERSISTENCE_ARCHIVE 0x0000000000000040 1986 1987 /* define storage access values 1988 * The pmix_storage_access_type_t is a uint16_t type that defines 1989 * a set of bit-mask flags for specifying different storage system 1990 * access types. */ 1991 typedef uint16_t pmix_storage_access_type_t; 1992 #define PMIX_STORAGE_ACCESS_RD 0x0001 1993 #define PMIX_STORAGE_ACCESS_WR 0x0002 1994 #define PMIX_STORAGE_ACCESS_RDWR 0x0003 1995 1996 1997 /* define some "hooks" external libraries can use to 1998 * intercept memory allocation/release operations */ 1999 static inline void* pmix_malloc(size_t n) 2000 { 2001 return malloc(n); 2002 } 2003 2004 static inline void pmix_free(void *m) 2005 { 2006 free(m); 2007 } 2008 2009 static inline void* pmix_calloc(size_t n, size_t m) 2010 { 2011 return calloc(n, m); 2012 } 2013 2014 2015 /** 2016 * Provide a safe version of strncpy that doesn't generate 2017 * a ton of spurious warnings. Note that not every environment 2018 * provides nice string functions, and we aren't concerned about 2019 * max performance here 2020 * 2021 * @param dest Destination string. 2022 * @param src Source string. 2023 * @param len Size of the dest array - 1 2024 * 2025 */ 2026 static inline void pmix_strncpy(char *dest, 2027 const char *src, 2028 size_t len) 2029 { 2030 size_t i; 2031 2032 /* use an algorithm that also protects against 2033 * non-NULL-terminated src strings */ 2034 for (i=0; i < len; ++i, ++src, ++dest) { 2035 *dest = *src; 2036 if ('\0' == *src) { 2037 break; 2038 } 2039 } 2040 *dest = '\0'; 2041 } 2042 2043 static inline size_t pmix_keylen(const char *src) 2044 { 2045 size_t i, maxlen; 2046 2047 if (NULL == src) { 2048 return 0; 2049 } 2050 maxlen = PMIX_MAX_KEYLEN + 1; 2051 /* use an algorithm that also protects against 2052 * non-NULL-terminated src strings */ 2053 for (i=0; i < maxlen; ++i, ++src) { 2054 if ('\0' == *src) { 2055 break; 2056 } 2057 } 2058 return i; 2059 } 2060 2061 static inline size_t pmix_nslen(const char *src) 2062 { 2063 size_t i, maxlen; 2064 2065 if (NULL == src) { 2066 return 0; 2067 } 2068 maxlen = PMIX_MAX_NSLEN + 1; 2069 /* use an algorithm that also protects against 2070 * non-NULL-terminated src strings */ 2071 for (i=0; i < maxlen; ++i, ++src) { 2072 if ('\0' == *src) { 2073 break; 2074 } 2075 } 2076 return i; 2077 } 2078 2079 2080 /**** PMIX COORD ****/ 2081 /* define coordinate system views */ 2082 typedef uint8_t pmix_coord_view_t; 2083 #define PMIX_COORD_VIEW_UNDEF 0x00 2084 #define PMIX_COORD_LOGICAL_VIEW 0x01 2085 #define PMIX_COORD_PHYSICAL_VIEW 0x02 2086 2087 /* define a structure for a proc's fabric coordinate */ 2088 typedef struct pmix_coord { 2089 pmix_coord_view_t view; 2090 uint32_t *coord; 2091 size_t dims; 2092 } pmix_coord_t; 2093 2094 #define PMIX_COORD_STATIC_INIT \ 2095 { \ 2096 .view = PMIX_COORD_VIEW_UNDEF, \ 2097 .coord = NULL, \ 2098 .dims = 0 \ 2099 } 2100 2101 2102 /**** PMIX LINK STATES ****/ 2103 typedef uint8_t pmix_link_state_t; 2104 #define PMIX_LINK_STATE_UNKNOWN 0 // The port state is unknown or not applicable 2105 #define PMIX_LINK_DOWN 1 // The port is inactive. 2106 #define PMIX_LINK_UP 2 // The port is active. 2107 2108 2109 /**** PMIX CPUSET ****/ 2110 typedef struct{ 2111 char *source; 2112 void *bitmap; 2113 } pmix_cpuset_t; 2114 2115 #define PMIX_CPUSET_STATIC_INIT \ 2116 { \ 2117 .source = NULL, \ 2118 .bitmap = NULL \ 2119 } 2120 2121 2122 /**** PMIX BIND ENVELOPE ****/ 2123 typedef uint8_t pmix_bind_envelope_t; 2124 #define PMIX_CPUBIND_PROCESS 0 2125 #define PMIX_CPUBIND_THREAD 1 2126 2127 2128 /**** PMIX TOPOLOGY ****/ 2129 typedef struct { 2130 char *source; 2131 void *topology; 2132 } pmix_topology_t; 2133 2134 #define PMIX_TOPOLOGY_STATIC_INIT \ 2135 { \ 2136 .source = NULL, \ 2137 .topology = NULL \ 2138 } 2139 2140 2141 /**** PMIX RELATIVE LOCALITY ****/ 2142 typedef uint16_t pmix_locality_t; 2143 #define PMIX_LOCALITY_UNKNOWN 0x0000 2144 #define PMIX_LOCALITY_NONLOCAL 0x8000 2145 #define PMIX_LOCALITY_SHARE_HWTHREAD 0x0001 2146 #define PMIX_LOCALITY_SHARE_CORE 0x0002 2147 #define PMIX_LOCALITY_SHARE_L1CACHE 0x0004 2148 #define PMIX_LOCALITY_SHARE_L2CACHE 0x0008 2149 #define PMIX_LOCALITY_SHARE_L3CACHE 0x0010 2150 #define PMIX_LOCALITY_SHARE_PACKAGE 0x0020 2151 #define PMIX_LOCALITY_SHARE_NUMA 0x0040 2152 #define PMIX_LOCALITY_SHARE_NODE 0x4000 2153 2154 2155 /**** PMIX GEOMETRY ****/ 2156 typedef struct pmix_geometry { 2157 size_t fabric; 2158 char *uuid; 2159 char *osname; 2160 pmix_coord_t *coordinates; 2161 size_t ncoords; 2162 } pmix_geometry_t; 2163 2164 #define PMIX_GEOMETRY_STATIC_INIT \ 2165 { \ 2166 .fabric = 0, \ 2167 .uuid = NULL, \ 2168 .osname = NULL, \ 2169 .coordinates = NULL, \ 2170 .ncoords = 0 \ 2171 } 2172 2173 2174 /**** PMIX_DEVICE_TYPE ****/ 2175 typedef uint64_t pmix_device_type_t; 2176 #define PMIX_DEVTYPE_UNKNOWN 0x0000000000000000 2177 #define PMIX_DEVTYPE_BLOCK 0x0000000000000001 2178 #define PMIX_DEVTYPE_GPU 0x0000000000000002 2179 #define PMIX_DEVTYPE_NETWORK 0x0000000000000004 2180 #define PMIX_DEVTYPE_OPENFABRICS 0x0000000000000008 2181 #define PMIX_DEVTYPE_DMA 0x0000000000000010 2182 #define PMIX_DEVTYPE_COPROC 0x0000000000000020 2183 /* devices used by resource units */ 2184 #define PMIX_DEVTYPE_MEMORY 0x0000000000000040 2185 #define PMIX_DEVTYPE_CORE 0x0000000000000080 2186 #define PMIX_DEVTYPE_HWT 0x0000000000000100 2187 #define PMIX_DEVTYPE_CPU 0x0000000000000200 2188 #define PMIX_DEVTYPE_NODE 0x0000000000000400 2189 2190 /**** PMIX_DEVICE ****/ 2191 typedef struct pmix_device { 2192 char *uuid; 2193 char *osname; 2194 pmix_device_type_t type; 2195 } pmix_device_t; 2196 2197 #define PMIX_DEVICE_STATIC_INIT \ 2198 { \ 2199 .uuid = NULL, \ 2200 .osname = NULL, \ 2201 .type = PMIX_DEVTYPE_UNKNOWN \ 2202 } 2203 2204 2205 /**** PMIX_RESOURCE_UNIT ****/ 2206 typedef struct pmix_resource_unit { 2207 pmix_device_type_t type; 2208 size_t count; 2209 } pmix_resource_unit_t; 2210 2211 #define PMIX_RESOURCE_UNIT_STATIC_INIT \ 2212 { \ 2213 .type = PMIX_DEVTYPE_UNKNOWN, \ 2214 .count = 0 \ 2215 } 2216 2217 2218 /**** PMIX_DISTANCE ****/ 2219 typedef struct pmix_device_distance { 2220 char *uuid; 2221 char *osname; 2222 pmix_device_type_t type; 2223 uint16_t mindist; 2224 uint16_t maxdist; 2225 } pmix_device_distance_t; 2226 2227 #define PMIX_DEVICE_DIST_STATIC_INIT \ 2228 { \ 2229 .uuid = NULL, \ 2230 .osname = NULL, \ 2231 .type = PMIX_DEVTYPE_UNKNOWN, \ 2232 .mindist = 0, \ 2233 .maxdist = 0 \ 2234 } 2235 2236 2237 /**** PMIX NODE PID ****/ 2238 typedef struct pmix_node_pid { 2239 char *hostname; 2240 uint32_t nodeid; 2241 pid_t pid; 2242 } pmix_node_pid_t; 2243 2244 #define PMIX_NODE_PID_STATIC_INIT \ 2245 { \ 2246 .hostname = NULL, \ 2247 .nodeid = UINT32_MAX, \ 2248 .pid = -1 \ 2249 } 2250 2251 2252 /**** PMIX BYTE OBJECT ****/ 2253 typedef struct pmix_byte_object { 2254 char *bytes; 2255 size_t size; 2256 } pmix_byte_object_t; 2257 2258 #define PMIX_BYTE_OBJECT_STATIC_INIT \ 2259 { \ 2260 .bytes = NULL, \ 2261 .size = 0 \ 2262 } 2263 2264 2265 /**** PMIX ENDPOINT ****/ 2266 typedef struct pmix_endpoint { 2267 char *uuid; 2268 char *osname; 2269 pmix_byte_object_t endpt; 2270 } pmix_endpoint_t; 2271 2272 #define PMIX_ENDPOINT_STATIC_INIT \ 2273 { \ 2274 .uuid = NULL, \ 2275 .osname = NULL, \ 2276 .endpt = PMIX_BYTE_OBJECT_STATIC_INIT \ 2277 } 2278 2279 2280 /**** PMIX ENVAR STRUCT ****/ 2281 /* Provide a structure for specifying environment variable modifications 2282 * Standard environment variables (e.g., PATH, LD_LIBRARY_PATH, and LD_PRELOAD) 2283 * take multiple arguments separated by delimiters. Unfortunately, the delimiters 2284 * depend upon the variable itself - some use semi-colons, some colons, etc. Thus, 2285 * the operation requires not only the name of the variable to be modified and 2286 * the value to be inserted, but also the separator to be used when composing 2287 * the aggregate value 2288 */ 2289 typedef struct { 2290 char *envar; 2291 char *value; 2292 char separator; 2293 } pmix_envar_t; 2294 2295 #define PMIX_ENVAR_STATIC_INIT \ 2296 { \ 2297 .envar = NULL, \ 2298 .value = NULL, \ 2299 .separator = '\0' \ 2300 } 2301 2302 2303 /**** PMIX DATA BUFFER ****/ 2304 typedef struct pmix_data_buffer { 2305 /** Start of my memory */ 2306 char *base_ptr; 2307 /** Where the next data will be packed to (within the allocated 2308 memory starting at base_ptr) */ 2309 char *pack_ptr; 2310 /** Where the next data will be unpacked from (within the 2311 allocated memory starting as base_ptr) */ 2312 char *unpack_ptr; 2313 /** Number of bytes allocated (starting at base_ptr) */ 2314 size_t bytes_allocated; 2315 /** Number of bytes used by the buffer (i.e., amount of data -- 2316 including overhead -- packed in the buffer) */ 2317 size_t bytes_used; 2318 } pmix_data_buffer_t; 2319 2320 #define PMIX_DATA_BUFFER_STATIC_INIT \ 2321 { \ 2322 .base_ptr = NULL, \ 2323 .pack_ptr = NULL, \ 2324 .unpack_ptr = NULL, \ 2325 .bytes_allocated = 0, \ 2326 .bytes_used = 0 \ 2327 } 2328 2329 2330 /**** PMIX PROC OBJECT ****/ 2331 typedef struct pmix_proc { 2332 pmix_nspace_t nspace; 2333 pmix_rank_t rank; 2334 } pmix_proc_t; 2335 2336 #define PMIX_PROC_STATIC_INIT \ 2337 { \ 2338 .nspace = {0}, \ 2339 .rank = PMIX_RANK_UNDEF \ 2340 } 2341 2342 2343 /**** PMIX PROC INFO STRUCT ****/ 2344 typedef struct pmix_proc_info { 2345 pmix_proc_t proc; 2346 char *hostname; 2347 char *executable_name; 2348 pid_t pid; 2349 int exit_code; 2350 pmix_proc_state_t state; 2351 } pmix_proc_info_t; 2352 2353 #define PMIX_PROC_INFO_STATIC_INIT \ 2354 { \ 2355 .proc = PMIX_PROC_STATIC_INIT, \ 2356 .hostname = NULL, \ 2357 .executable_name = NULL, \ 2358 .pid = 0, \ 2359 .exit_code = 0, \ 2360 .state = PMIX_PROC_STATE_UNDEF \ 2361 } 2362 2363 2364 2365 /**** PMIX DATA ARRAY STRUCT ****/ 2366 2367 typedef struct pmix_data_array { 2368 pmix_data_type_t type; 2369 size_t size; 2370 void *array; 2371 } pmix_data_array_t; 2372 2373 #define PMIX_DATA_ARRAY_STATIC_INIT \ 2374 { \ 2375 .type = PMIX_UNDEF, \ 2376 .size = 0, \ 2377 .array = NULL \ 2378 } 2379 2380 /* we cannot forward-declare the pmix_regattr_t struct 2381 * as Cython doesn't know what to do with it. Thus, we 2382 * will utilize the void* entry of the pmix_value_t to 2383 * hold the pointer to pmix_regattr_t */ 2384 2385 /**** PMIX VALUE STRUCT ****/ 2386 2387 /* NOTE: operations can supply a collection of values under 2388 * a single key by passing a pmix_value_t containing a 2389 * data array of type PMIX_INFO, with each array element 2390 * containing its own pmix_info_t object */ 2391 2392 typedef struct pmix_value { 2393 pmix_data_type_t type; 2394 union { 2395 bool flag; 2396 uint8_t byte; 2397 char *string; 2398 size_t size; 2399 pid_t pid; 2400 int integer; 2401 int8_t int8; 2402 int16_t int16; 2403 int32_t int32; 2404 int64_t int64; 2405 unsigned int uint; 2406 uint8_t uint8; 2407 uint16_t uint16; 2408 uint32_t uint32; 2409 uint64_t uint64; 2410 float fval; 2411 double dval; 2412 struct timeval tv; 2413 time_t time; 2414 pmix_status_t status; 2415 pmix_rank_t rank; 2416 pmix_nspace_t *nspace; 2417 pmix_proc_t *proc; 2418 pmix_byte_object_t bo; 2419 pmix_persistence_t persist; 2420 pmix_scope_t scope; 2421 pmix_data_range_t range; 2422 pmix_proc_state_t state; 2423 pmix_proc_info_t *pinfo; 2424 pmix_data_array_t *darray; 2425 void *ptr; 2426 pmix_alloc_directive_t adir; 2427 pmix_resource_block_directive_t rbdir; 2428 pmix_envar_t envar; 2429 pmix_coord_t *coord; 2430 pmix_link_state_t linkstate; 2431 pmix_job_state_t jstate; 2432 pmix_topology_t *topo; 2433 pmix_cpuset_t *cpuset; 2434 pmix_locality_t locality; 2435 pmix_geometry_t *geometry; 2436 pmix_device_type_t devtype; 2437 pmix_device_t *device; 2438 pmix_device_distance_t *devdist; 2439 pmix_endpoint_t *endpoint; 2440 pmix_data_buffer_t *dbuf; 2441 pmix_resource_unit_t *resunit; 2442 pmix_node_pid_t *nodepid; 2443 } data; 2444 } pmix_value_t; 2445 2446 #define PMIX_VALUE_STATIC_INIT \ 2447 { \ 2448 .type = PMIX_UNDEF, \ 2449 .data.ptr = NULL \ 2450 } 2451 2452 /**** PMIX INFO STRUCT ****/ 2453 typedef struct pmix_info { 2454 pmix_key_t key; 2455 pmix_info_directives_t flags; // bit-mask of flags 2456 pmix_value_t value; 2457 } pmix_info_t; 2458 2459 #define PMIX_INFO_STATIC_INIT \ 2460 { \ 2461 .key = {0}, \ 2462 .flags = 0, \ 2463 .value = PMIX_VALUE_STATIC_INIT \ 2464 } 2465 2466 2467 typedef enum { 2468 PMIX_BOOL_TRUE, 2469 PMIX_BOOL_FALSE, 2470 PMIX_NON_BOOL 2471 } pmix_boolean_t; 2472 2473 2474 /**** PMIX LOOKUP RETURN STRUCT ****/ 2475 typedef struct pmix_pdata { 2476 pmix_proc_t proc; 2477 pmix_key_t key; 2478 pmix_value_t value; 2479 } pmix_pdata_t; 2480 2481 #define PMIX_LOOKUP_STATIC_INIT \ 2482 { \ 2483 .proc = PMIX_PROC_STATIC_INIT, \ 2484 .key = {0}, \ 2485 .value = PMIX_VALUE_STATIC_INIT \ 2486 } 2487 2488 2489 2490 /**** PMIX APP STRUCT ****/ 2491 typedef struct pmix_app { 2492 char *cmd; 2493 char **argv; 2494 char **env; 2495 char *cwd; 2496 int maxprocs; 2497 pmix_info_t *info; 2498 size_t ninfo; 2499 } pmix_app_t; 2500 2501 #define PMIX_APP_STATIC_INIT \ 2502 { \ 2503 .cmd = NULL, \ 2504 .argv = NULL, \ 2505 .env = NULL, \ 2506 .cwd = NULL, \ 2507 .maxprocs = 0, \ 2508 .info = NULL, \ 2509 .ninfo = 0 \ 2510 } 2511 2512 2513 /**** PMIX QUERY STRUCT ****/ 2514 typedef struct pmix_query { 2515 char **keys; 2516 pmix_info_t *qualifiers; 2517 size_t nqual; 2518 } pmix_query_t; 2519 2520 #define PMIX_QUERY_STATIC_INIT \ 2521 { \ 2522 .keys = NULL, \ 2523 .qualifiers = NULL, \ 2524 .nqual = 0 \ 2525 } 2526 2527 2528 /**** ATTRIBUTE REGISTRATION STRUCT ****/ 2529 typedef struct pmix_regattr_t { 2530 char *name; 2531 pmix_key_t string; 2532 pmix_data_type_t type; 2533 char **description; 2534 } pmix_regattr_t; 2535 2536 #define PMIX_REGATTR_STATIC_INIT \ 2537 { \ 2538 .name = NULL, \ 2539 .string = {0}, \ 2540 .type = PMIX_UNDEF, \ 2541 .description = NULL \ 2542 } 2543 2544 2545 /**** FABRIC STRUCT ****/ 2546 /* Define a pmix_fabric_t struct for 2547 * interacting with fabric-related interfaces */ 2548 typedef struct pmix_fabric_s { 2549 /* user-supplied name for this fabric */ 2550 char *name; 2551 /* a PMIx-supplied index identifying this registration object */ 2552 size_t index; 2553 /* array containing information (provided by the PMIx library) 2554 * about the fabric */ 2555 pmix_info_t *info; 2556 size_t ninfo; 2557 /* object pointer for use by the PMIx library */ 2558 void *module; 2559 } pmix_fabric_t; 2560 2561 #define PMIX_FABRIC_STATIC_INIT \ 2562 { \ 2563 .name = NULL, \ 2564 .index = 0, \ 2565 .info = NULL, \ 2566 .ninfo = 0, \ 2567 .module = NULL \ 2568 } 2569 2570 /* convenience macros to support pmix_fabric_t */ 2571 #define PMIX_FABRIC_CONSTRUCT(x) \ 2572 memset(x, 0, sizeof(pmix_fabric_t)) 2573 2574 typedef enum { 2575 PMIX_FABRIC_REQUEST_INFO, 2576 PMIX_FABRIC_UPDATE_INFO 2577 } pmix_fabric_operation_t; 2578 2579 2580 /**** CALLBACK FUNCTIONS FOR NON-BLOCKING OPERATIONS ****/ 2581 2582 typedef void (*pmix_release_cbfunc_t)(void *cbdata); 2583 2584 /* define a callback function that is solely used by servers, and 2585 * not clients, to return modex data in response to "fence" and "get" 2586 * operations. The returned blob contains the data collected from each 2587 * server participating in the operation. 2588 * 2589 * As the data is "owned" by the host server, provide a secondary 2590 * callback function to notify the host server that we are done 2591 * with the data so it can be released */ 2592 typedef void (*pmix_modex_cbfunc_t)(pmix_status_t status, 2593 const char *data, size_t ndata, 2594 void *cbdata, 2595 pmix_release_cbfunc_t release_fn, 2596 void *release_cbdata); 2597 2598 /* define a callback function for calls to PMIx_Spawn_nb - the function 2599 * will be called upon completion of the spawn command. The status 2600 * will indicate whether or not the spawn succeeded. The nspace 2601 * of the spawned processes will be returned, along with any provided 2602 * callback data. Note that the returned nspace value will be 2603 * released by the library upon return from the callback function, so 2604 * the receiver must copy it if it needs to be retained */ 2605 typedef void (*pmix_spawn_cbfunc_t)(pmix_status_t status, 2606 pmix_nspace_t nspace, void *cbdata); 2607 2608 /* define a callback for common operations that simply return 2609 * a status. Examples include the non-blocking versions of 2610 * Fence, Connect, and Disconnect */ 2611 typedef void (*pmix_op_cbfunc_t)(pmix_status_t status, void *cbdata); 2612 2613 /* define a callback function for calls to PMIx_Lookup_nb - the 2614 * function will be called upon completion of the command with the 2615 * status indicating the success of failure of the request. Any 2616 * retrieved data will be returned in an array of pmix_pdata_t structs. 2617 * The nspace/rank of the process that provided each data element is 2618 * also returned. 2619 * 2620 * Note that these structures will be released upon return from 2621 * the callback function, so the receiver must copy/protect the 2622 * data prior to returning if it needs to be retained */ 2623 2624 typedef void (*pmix_lookup_cbfunc_t)(pmix_status_t status, 2625 pmix_pdata_t data[], size_t ndata, 2626 void *cbdata); 2627 2628 /* define a callback by which an event handler can notify the PMIx library 2629 * that it has completed its response to the notification. The handler 2630 * is _required_ to execute this callback so the library can determine 2631 * if additional handlers need to be called. The handler shall return 2632 * PMIX_SUCCESS if no further action is required. The return status 2633 * of each event handler and any returned pmix_info_t structures 2634 * will be added to the array of pmix_info_t passed to any subsequent 2635 * event handlers to help guide their operation. 2636 * 2637 * If non-NULL, the provided callback function will be called to allow 2638 * the event handler to release the provided info array. 2639 */ 2640 typedef void (*pmix_event_notification_cbfunc_fn_t)(pmix_status_t status, 2641 pmix_info_t *results, size_t nresults, 2642 pmix_op_cbfunc_t cbfunc, void *thiscbdata, 2643 void *notification_cbdata); 2644 2645 /* define a callback function for the event handler. Upon receipt of an 2646 * event notification, PMIx will execute the specified notification 2647 * callback function, providing: 2648 * 2649 * evhdlr_registration_id - the returned registration number of 2650 * the event handler being called 2651 * status - the event that occurred 2652 * source - the nspace and rank of the process that generated 2653 * the event. If the source is the resource manager, 2654 * then the nspace will be empty and the rank will 2655 * be PMIX_RANK_UNDEF 2656 * info - any additional info provided regarding the event. 2657 * ninfo - the number of info objects in the info array 2658 * results - any provided results from event handlers called 2659 * prior to this one. 2660 * nresults - number of info objects in the results array 2661 * cbfunc - the function to be called upon completion of the handler 2662 * cbdata - pointer to be returned in the completion cbfunc 2663 * 2664 * Note that different resource managers may provide differing levels 2665 * of support for event notification to application processes. Thus, the 2666 * info array may be NULL or may contain detailed information of the event. 2667 * It is the responsibility of the application to parse any provided info array 2668 * for defined key-values if it so desires. 2669 * 2670 * Possible uses of the pmix_info_t object include: 2671 * 2672 * - for the RM to alert the process as to planned actions, such as 2673 * to abort the session, in response to the reported event 2674 * 2675 * - provide a timeout for alternative action to occur, such as for 2676 * the application to request an alternate response to the event 2677 * 2678 * For example, the RM might alert the application to the failure of 2679 * a node that resulted in termination of several processes, and indicate 2680 * that the overall session will be aborted unless the application 2681 * requests an alternative behavior in the next 5 seconds. The application 2682 * then has time to respond with a checkpoint request, or a request to 2683 * recover from the failure by obtaining replacement nodes and restarting 2684 * from some earlier checkpoint. 2685 * 2686 * Support for these options is left to the discretion of the host RM. Info 2687 * keys are included in the common definions above, but also may be augmented 2688 * on a per-RM basis. 2689 * 2690 * On the server side, the notification function is used to inform the host 2691 * server of a detected event in the PMIx subsystem and/or client 2692 */ 2693 typedef void (*pmix_notification_fn_t)(size_t evhdlr_registration_id, 2694 pmix_status_t status, 2695 const pmix_proc_t *source, 2696 pmix_info_t info[], size_t ninfo, 2697 pmix_info_t *results, size_t nresults, 2698 pmix_event_notification_cbfunc_fn_t cbfunc, 2699 void *cbdata); 2700 2701 /* define a callback function for calls to register handlers, e.g., event 2702 * notification and IOF requests 2703 * 2704 * status - PMIX_SUCCESS or an appropriate error constant 2705 * 2706 * refid - reference identifier assigned to the handler by PMIx, 2707 * used to deregister the handler 2708 * 2709 * cbdata - object provided to the registration call 2710 */ 2711 typedef void (*pmix_hdlr_reg_cbfunc_t)(pmix_status_t status, 2712 size_t refid, 2713 void *cbdata); 2714 /* retain the deprecated form */ 2715 typedef void (*pmix_evhdlr_reg_cbfunc_t)(pmix_status_t status, 2716 size_t refid, 2717 void *cbdata); 2718 2719 /* define a callback function for calls to PMIx_Get_nb. The status 2720 * indicates if the requested data was found or not - a pointer to the 2721 * pmix_value_t structure containing the found data is returned. The 2722 * pointer will be NULL if the requested data was not found. */ 2723 typedef void (*pmix_value_cbfunc_t)(pmix_status_t status, 2724 pmix_value_t *kv, void *cbdata); 2725 2726 /* define a callback function for calls to PMIx_Query. The status 2727 * indicates if requested data was found or not - an array of 2728 * pmix_info_t will contain the key/value pairs. */ 2729 typedef void (*pmix_info_cbfunc_t)(pmix_status_t status, 2730 pmix_info_t *info, size_t ninfo, 2731 void *cbdata, 2732 pmix_release_cbfunc_t release_fn, 2733 void *release_cbdata); 2734 2735 /* Define a callback function to return a requested security credential. 2736 * Returned values include: 2737 * 2738 * status - PMIX_SUCCESS if a credential could be assigned as requested, or 2739 * else an appropriate error code indicating the problem 2740 * 2741 * credential - pointer to an allocated pmix_byte_object_t containing the 2742 * credential (as a opaque blob) and its size. Ownership of 2743 * the credential is transferred to the receiving function - thus, 2744 * responsibility for releasing the memory lies outside the 2745 * PMIx library. 2746 * 2747 * info - an array of pmix_info_t structures provided by the system to pass 2748 * any additional information about the credential - e.g., the identity 2749 * of the issuing agent. The info array is owned by the PMIx library 2750 * and is not to be released or altered by the receiving party. Note that 2751 * this array is not related to the pmix_info_t structures possibly 2752 * provided in the call to PMIx_Get_credential. 2753 * 2754 * Information provided by the issuing agent can subsequently be used 2755 * by the application for a variety of purposes. Examples include: 2756 * - checking identified authorizations to determine what 2757 * requests/operations are feasible as a means to steering 2758 * workflows 2759 * - compare the credential type to that of the local SMS for 2760 * compatibility 2761 * 2762 * ninfo - number of elements in the info array 2763 * 2764 * cbdata - the caller's provided void* object 2765 * 2766 * NOTE: the credential is opaque and therefore understandable only by 2767 * a service compatible with the issuer. 2768 */ 2769 typedef void (*pmix_credential_cbfunc_t)(pmix_status_t status, 2770 pmix_byte_object_t *credential, 2771 pmix_info_t info[], size_t ninfo, 2772 void *cbdata); 2773 2774 2775 /* Define a validation callback function to indicate if a provided 2776 * credential is valid, and any corresponding information regarding 2777 * authorizations and other security matters 2778 * Returned values include: 2779 * 2780 * status - PMIX_SUCCESS if the provided credential is valid. An appropriate 2781 * error code indicating the issue if the credential is rejected. 2782 * 2783 * info - an array of pmix_info_t structures provided by the system to pass 2784 * any additional information about the authentication - e.g., the 2785 * effective userid and group id of the certificate holder, and any 2786 * related authorizations. The info array is owned by the PMIx library 2787 * and is not to be released or altered by the receiving party. Note that 2788 * this array is not related to the pmix_info_t structures possibly 2789 * provided in the call to PMIx_Validate_credential. 2790 * 2791 * The precise contents of the array will depend on the host SMS and 2792 * its associated security system. At the minimum, it is expected (but 2793 * not required) that the array will contain entries for the PMIX_USERID 2794 * and PMIX_GROUPID of the client described in the credential. 2795 * 2796 * ninfo - number of elements in the info array 2797 * 2798 * cbdata - the caller's provided void* object 2799 */ 2800 typedef void (*pmix_validation_cbfunc_t)(pmix_status_t status, 2801 pmix_info_t info[], size_t ninfo, 2802 void *cbdata); 2803 2804 /* Define a callback function to return device distance arrays 2805 */ 2806 typedef void (*pmix_device_dist_cbfunc_t)(pmix_status_t status, 2807 pmix_device_distance_t *dist, 2808 size_t ndist, 2809 void *cbdata, 2810 pmix_release_cbfunc_t release_fn, 2811 void *release_cbdata); 2812 2813 2814 2815 2816 #include <pmix_deprecated.h> 2817 2818 #if defined(c_plusplus) || defined(__cplusplus) 2819 } 2820 #endif 2821 2822 #endif
| [ Source navigation ] | [ Diff markup ] | [ Identifier search ] | [ general search ] |
|
This page was automatically generated by the 2.3.7 LXR engine. The LXR team |
|