mca/gds/gds.h

0001 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
0002 /*
0003  * Copyright (c) 2016-2020 Mellanox Technologies, Inc.
0004  *                         All rights reserved.
0005  * Copyright (c) 2016-2020 Intel, Inc.  All rights reserved.
0006  * Copyright (c) 2018      IBM Corporation.  All rights reserved.
0007  * Copyright (c) 2021-2025 Nanook Consulting  All rights reserved.
0008  * Copyright (c) 2022      Triad National Security, LLC. All rights reserved.
0009  * $COPYRIGHT$
0010  *
0011  * Additional copyrights may follow
0012  *
0013  * $HEADER$
0014  */
0015
0016 #ifndef PMIX_GDS_H
0017 #define PMIX_GDS_H
0018
0019 #include "src/include/pmix_config.h"
0020
0021 #include "pmix_common.h"
0022 #include "src/mca/base/pmix_mca_base_framework.h"
0023 #include "src/mca/base/pmix_mca_base_var.h"
0024 #include "src/mca/bfrops/bfrops_types.h"
0025 #include "src/mca/mca.h"
0026
0027 /* The client dictates the GDS module that will be used to interact
0028  * with the server - this module is stored in pmix_globals.mypeer->compat.gds
0029  * Because that is a long address to keep typing out, convenience macros
0030  * are provided for when that module is to be used in an operation.
0031  *
0032  * However, an application can open any number of GDS modules for
0033  * purposes other than exchanging info with the server. For example,
0034  * an application may wish to utilize a DHT module for its own
0035  * peer-to-peer data sharing. Thus, the public and private interfaces
0036  * are deliberately designed to be generic. The macros should make
0037  * things easier for the typical internal operations
0038  *
0039  * NOTE: ALTHOUGH SOME GDS COMPONENTS MAY UTILIZE THEIR OWN INTERNAL
0040  * PROGRESS THREADS, THE GDS IS NOT GUARANTEED TO BE THREAD-SAFE.
0041  * GDS FUNCTIONS SHOULD THEREFORE ALWAYS BE CALLED IN A THREAD-SAFE
0042  * CONDITION - E.G., FROM WITHIN AN EVENT
0043  */
0044
0045 BEGIN_C_DECLS
0046 /* forward declaration */
0047 struct pmix_peer_t;
0048 struct pmix_namespace_t;
0049
0050 /* backdoor to base verbosity */
0051 PMIX_EXPORT extern int pmix_gds_base_output;
0052
0053 /**
0054  * Initialize the module. Returns an error if the module cannot
0055  * run, success if it can.
0056  */
0057 typedef pmix_status_t (*pmix_gds_base_module_init_fn_t)(pmix_info_t info[], size_t ninfo);
0058
0059 /**
0060  * Finalize the module. Tear down any allocated storage, disconnect
0061  * from any system support.
0062  */
0063 typedef void (*pmix_gds_base_module_fini_fn_t)(void);
0064
0065 /**
0066  * Assign a module per the requested directives. Modules should
0067  * review the provided directives to determine if they can support
0068  * the request. Modules are "scanned" in component priority order
0069  * and given an opportunity to respond. If a module offers itself,
0070  * it will provide a priority (which can be based on the directives
0071  * and therefore different from the component priority). The highest
0072  * returned priority received from a responder will be selected
0073  * and a pointer to its module returned */
0074 typedef pmix_status_t (*pmix_gds_base_assign_module_fn_t)(pmix_info_t *info, size_t ninfo,
0075                                                           int *priority);
0076
0077 #define PMIX_GDS_CHECK_COMPONENT(p, s) (0 == strcmp((p)->nptr->compat.gds->name, (s)))
0078 #define PMIX_GDS_CHECK_PEER_COMPONENT(p1, p2) \
0079     (0 == strcmp((p1)->nptr->compat.gds->name, (p2)->nptr->compat.gds->name))
0080
0081 /* SERVER FN: assemble the keys buffer for server answer */
0082 typedef pmix_status_t (*pmix_gds_base_module_assemb_kvs_req_fn_t)(const pmix_proc_t *proc,
0083                                                                   pmix_list_t *kvs,
0084                                                                   pmix_buffer_t *buf, void *cbdata);
0085
0086 /* define a macro for server keys answer based on peer */
0087 #define PMIX_GDS_ASSEMB_KVS_REQ(s, p, r, k, b, c)                              \
0088     do {                                                                       \
0089         pmix_gds_base_module_t *_g = (p)->nptr->compat.gds;                    \
0090         (s) = PMIX_SUCCESS;                                                    \
0091         if (NULL == _g->assemb_kvs_req) {                                      \
0092             if (0 == strcmp(_g->name, "hash")) {                               \
0093                 (s) = PMIX_ERR_NOT_SUPPORTED;                                  \
0094             } else {                                                           \
0095                 _g = pmix_globals.mypeer->nptr->compat.gds;                    \
0096             }                                                                  \
0097         }                                                                      \
0098         if (NULL != _g->assemb_kvs_req) {                                      \
0099             pmix_output_verbose(1, pmix_gds_base_output,                       \
0100                                 "[%s:%d] GDS ASSEMBLE REQ WITH %s",            \
0101                                 __FILE__, __LINE__, _g->name);                 \
0102             (s) = _g->assemb_kvs_req(r, k, b, (void *) c);                     \
0103         }                                                                      \
0104     } while (0)
0105
0106 /* CLIENT FN: unpack buffer and key processing */
0107 typedef pmix_status_t (*pmix_gds_base_module_accept_kvs_resp_fn_t)(pmix_buffer_t *buf);
0108
0109 /* define a macro for client key processing from a server response based on peer */
0110 #define PMIX_GDS_ACCEPT_KVS_RESP(s, p, b)                                      \
0111     do {                                                                       \
0112         pmix_gds_base_module_t *_g = (p)->nptr->compat.gds;                    \
0113         (s) = PMIX_SUCCESS;                                                    \
0114         if (NULL == _g->accept_kvs_resp) {                                     \
0115             if (0 == strcmp(_g->name, "hash")) {                               \
0116                 (s) = PMIX_ERR_NOT_SUPPORTED;                                  \
0117             } else {                                                           \
0118                 _g = pmix_globals.mypeer->nptr->compat.gds;                    \
0119             }                                                                  \
0120         }                                                                      \
0121         if (NULL != _g->accept_kvs_resp) {                                     \
0122             pmix_output_verbose(1, pmix_gds_base_output,                       \
0123                                 "[%s:%d] GDS ACCEPT RESP WITH %s",             \
0124                                 __FILE__, __LINE__, _g->name);                 \
0125             (s) = _g->accept_kvs_resp(b);                                      \
0126         }                                                                      \
0127     } while (0)
0128
0129 /* SERVER FN: cache job-level info in the server's GDS until client
0130  * procs connect and we discover which GDS module to use for them.
0131  * Note that this is essentially the same function as store_job_info,
0132  * only we don't have packed data on the server side, and don't want
0133  * to incur the overhead of packing it just to unpack it in the function.
0134  */
0135 typedef pmix_status_t (*pmix_gds_base_module_cache_job_info_fn_t)(struct pmix_namespace_t *ns,
0136                                                                   pmix_info_t info[], size_t ninfo);
0137
0138 /* define a convenience macro for caching job info */
0139 #define PMIX_GDS_CACHE_JOB_INFO(s, p, n, i, ni)                                            \
0140     do {                                                                                   \
0141         pmix_gds_base_module_t *_g = (p)->nptr->compat.gds;                                \
0142         pmix_output_verbose(1, pmix_gds_base_output, "[%s:%d] GDS CACHE JOB INFO WITH %s", \
0143                             __FILE__, __LINE__, _g->name);                                 \
0144         (s) = _g->cache_job_info((struct pmix_namespace_t *) (n), (i), (ni));              \
0145     } while (0)
0146
0147 /* register job-level info - this is provided as a special function
0148  * to allow for optimization. Called solely by the server. We cannot
0149  * prepare the job-level info provided at PMIx_Register_nspace, because
0150  * we don't know the GDS component to use for that application until
0151  * a local client contacts us. Thus, the module is required to process
0152  * the job-level info cached in the pmix_namespace_t for this job and
0153  * do whatever is necessary to support the client, packing any required
0154  * return message into the provided buffer.
0155  *
0156  * This function will be called once for each local client of
0157  * a given nspace. PMIx assumes that all peers of a given nspace
0158  * will use the same GDS module. Thus, the module is free to perform
0159  * any relevant optimizations (e.g., packing the data only once and
0160  * then releasing the cached buffer once all local clients have
0161  * been serviced, or storing it once in shared memory and simply
0162  * returning the shared memory rendezvous information for subsequent
0163  * calls).
0164  *
0165  * Info provided in the reply buffer will be given to the "store_job_info"
0166  * API of the GDS module on the client. Since this should match the
0167  * module used by the server, each module has full knowledge and control
0168  * over what is in the reply buffer.
0169  *
0170  * The pmix_peer_t of the requesting client is provided here so that
0171  * the module can access the job-level info cached on the corresponding
0172  * pmix_namespace_t pointed to by the pmix_peer_t
0173  */
0174 typedef pmix_status_t (*pmix_gds_base_module_register_job_info_fn_t)(struct pmix_peer_t *pr,
0175                                                                      pmix_buffer_t *reply);
0176
0177 /* define a convenience macro for registering job info for
0178  * a given peer */
0179 #define PMIX_GDS_REGISTER_JOB_INFO(s, p, b)                                                        \
0180     do {                                                                                           \
0181         pmix_gds_base_module_t *_g = (p)->nptr->compat.gds;                                        \
0182         pmix_output_verbose(1, pmix_gds_base_output, "[%s:%d] GDS REG JOB INFO WITH %s", __FILE__, \
0183                             __LINE__, _g->name);                                                   \
0184         (s) = _g->register_job_info((struct pmix_peer_t *) (p), b);                                \
0185     } while (0)
0186
0187 /* update job-level info - this is provided as a special function
0188  * to allow for optimization. Called solely by the client. The buffer
0189  * provided to this API is the same one given to the server by the
0190  * corresponding "register_job_info" function
0191  */
0192 typedef pmix_status_t (*pmix_gds_base_module_store_job_info_fn_t)(const char *nspace,
0193                                                                   pmix_buffer_t *buf);
0194
0195 /* define a convenience macro for storing job info based on peer */
0196 #define PMIX_GDS_STORE_JOB_INFO(s, p, n, b)                                                \
0197     do {                                                                                   \
0198         pmix_gds_base_module_t *_g = (p)->nptr->compat.gds;                                \
0199         pmix_output_verbose(1, pmix_gds_base_output, "[%s:%d] GDS STORE JOB INFO WITH %s", \
0200                             __FILE__, __LINE__, _g->name);                                 \
0201         (s) = _g->store_job_info(n, b);                                                    \
0202     } while (0)
0203
0204 /**
0205  * store key/value pair - these will either be values committed by the peer
0206  * and transmitted to the server, or values stored locally by the peer.
0207  * The format of the data depends on the GDS module. Note that data stored
0208  * with PMIX_INTERNAL scope should be stored solely within the process and
0209  * is never shared.
0210  *
0211  * @param peer   pointer to pmix_peer_t object of the peer that
0212  *               provided the data
0213  *
0214  * @param proc   the proc that the data describes
0215  *
0216  * @param scope  scope of the data
0217  *
0218  * @param kv     key/value pair.
0219  *
0220  * @return PMIX_SUCCESS on success.
0221  */
0222 typedef pmix_status_t (*pmix_gds_base_module_store_fn_t)(const pmix_proc_t *proc,
0223                                                          pmix_scope_t scope, pmix_kval_t *kv);
0224
0225 /* define a convenience macro for storing key-val pairs based on peer */
0226 #define PMIX_GDS_STORE_KV(s, p, pc, sc, k)                                     \
0227     do {                                                                       \
0228         pmix_gds_base_module_t *_g = (p)->nptr->compat.gds;                    \
0229         (s) = PMIX_SUCCESS;                                                    \
0230         if (NULL == _g->store) {                                               \
0231             if (0 == strcmp(_g->name, "hash")) {                               \
0232                 (s) = PMIX_ERR_NOT_SUPPORTED;                                  \
0233             } else {                                                           \
0234                 _g = pmix_globals.mypeer->nptr->compat.gds;                    \
0235             }                                                                  \
0236         }                                                                      \
0237         if (NULL != _g->store) {                                               \
0238             pmix_output_verbose(1, pmix_gds_base_output,                       \
0239                                 "[%s:%d] GDS STORE KV WITH %s",                \
0240                                 __FILE__, __LINE__, _g->name);                 \
0241             (s) = _g->store(pc, sc, k);                                        \
0242         }                                                                      \
0243     } while (0)
0244
0245 /**
0246  * unpack and store a data "blob" from a peer so that the individual
0247  * elements can later be retrieved. This is an optimization path to
0248  * avoid repeatedly storing pmix_kval_t's for multiple local procs
0249  * from the same nspace.
0250  *
0251  * buff - packed modex data collected across the operation
0252  *
0253  * cbdata - pointer to modex callback data
0254  *
0255  */
0256 typedef pmix_status_t (*pmix_gds_base_module_store_modex_fn_t)(pmix_buffer_t *buff, void *cbdata);
0257
0258 /**
0259  * define a convenience macro for storing modex byte objects
0260  *
0261  * r - return status code
0262  *
0263  * b - pointer to pmix_buffer_t containing the data
0264  *
0265  * t - pointer to the modex server tracker
0266  */
0267 #define PMIX_GDS_STORE_MODEX(r, b, t)                                       \
0268     do {                                                                    \
0269         pmix_gds_base_module_t *_g = pmix_globals.mypeer->nptr->compat.gds; \
0270         pmix_output_verbose(1, pmix_gds_base_output,                        \
0271                             "[%s:%d] GDS STORE MODEX WITH %s", __FILE__,    \
0272                             __LINE__, _g->name);                            \
0273         (r) = _g->store_modex(b, t);                                        \
0274     } while (0)
0275
0276 typedef pmix_status_t (*pmix_gds_base_module_mark_modex_complete_fn_t)(struct pmix_peer_t *peer,
0277                                                                        pmix_list_t *nslist,
0278                                                                        pmix_buffer_t *buff);
0279 #define PMIX_GDS_MARK_MODEX_COMPLETE(r, p, l, b)                            \
0280     do {                                                                    \
0281         pmix_gds_base_module_t *_g = pmix_globals.mypeer->nptr->compat.gds; \
0282         pmix_output_verbose(1, pmix_gds_base_output,                        \
0283                             "[%s:%d] GDS MARK MODEX COMPLETE WITH %s",      \
0284                             __FILE__, __LINE__, _g->name);                  \
0285         (r) = _g->mark_modex_complete(p, l, b);                             \
0286     } while (0)
0287
0288 typedef pmix_status_t (*pmix_gds_base_module_recv_modex_complete_fn_t)(pmix_buffer_t *buff);
0289 #define PMIX_GDS_RECV_MODEX_COMPLETE(r, p, b)                               \
0290     do {                                                                    \
0291         pmix_gds_base_module_t *_g = pmix_globals.mypeer->nptr->compat.gds; \
0292         pmix_output_verbose(1, pmix_gds_base_output,                        \
0293                             "[%s:%d] GDS RECV MODEX COMPLETE WITH %s",      \
0294                             __FILE__, __LINE__, _g->name);                  \
0295         (r) = _g->recv_modex_complete(b);                                   \
0296     } while (0)
0297
0298 /**
0299  * fetch value corresponding to provided key from within the defined
0300  * scope. A NULL key returns all values committed by the given peer
0301  * for that scope.
0302  *
0303  * @param peer    peer object of the proc requesting the info - needed
0304  *                because the server can request info on behalf of another
0305  *                process, and the fetch response has to be formatted
0306  *                to match the _requesting_ process
0307  *
0308  * @param proc    namespace and rank whose info is being requested
0309  *
0310  * @param key     key.
0311  *
0312  * @param scope   scope of the data to be considered
0313  *
0314  * @param copy    true if the caller _requires_ a copy of the data. This
0315  *                is used when the requestor is off-node. If
0316  *                set to false, then the GDS component can provide
0317  *                either a copy of the data, or shmem contact info
0318  *                to the location of the data
0319  *
0320  * @param info    array of pmix_info_t the caller provided as
0321  *                qualifiers to guide the request
0322  *
0323  * @param ninfo   number of elements in the info array
0324  *
0325  * @param kvs     pointer to a list that will be populated with the
0326  *                returned pmix_kval_t data
0327  *
0328  * @return       PMIX_SUCCESS on success.
0329  *
0330  * Note: all available job-level data for a given nspace can be fetched
0331  * by passing a proc with rank=PMIX_RANK_WILDCARD and a NULL key. Similarly,
0332  * passing a NULL key for a non-wildcard rank will return all data "put"
0333  * by that rank. Scope is ignored for job-level data requests.
0334  *
0335  * When a specific rank if provided with a NULL key, then data for only
0336  * that rank is returned. If the scope is PMIX_LOCAL, then the returned
0337  * data shall include only data that was specifically "put" to local scope,
0338  * plus any data that was put to PMIX_GLOBAL scope. Similarly, a scope of
0339  * PMIX_REMOTE will return data that was "put" to remote scope, plus
0340  * any data that was put to PMIX_GLOBAL scope. A scope of PMIX_GLOBAL
0341  * will return LOCAL, REMOTE, and GLOBAL data.
0342  *
0343  * Data stored with PMIX_INTERNAL scope can be retrieved with that scope.
0344  */
0345 typedef pmix_status_t (*pmix_gds_base_module_fetch_fn_t)(struct pmix_peer_t *peer,
0346                                                          const pmix_proc_t *proc,
0347                                                          pmix_scope_t scope, bool copy,
0348                                                          const char *key, pmix_info_t info[],
0349                                                          size_t ninfo, pmix_list_t *kvs);
0350
0351 /* define a convenience macro for fetch key-val pairs based on peer,
0352  * passing a pmix_cb_t containing all the required info */
0353 #define PMIX_GDS_FETCH_KV(s, p, c)                                                             \
0354     do {                                                                                       \
0355         pmix_gds_base_module_t *_g = (p)->nptr->compat.gds;                                    \
0356         pmix_output_verbose(1, pmix_gds_base_output,                                           \
0357                             "[%s:%d] GDS FETCH KV WITH %s",                                    \
0358                             __FILE__,  __LINE__, _g->name);                                    \
0359         (s) = _g->fetch((p), (c)->proc, (c)->scope, (c)->copy, (c)->key,                       \
0360                         (c)->info, (c)->ninfo, &(c)->kvs);                                     \
0361     } while (0)
0362
0363 /**
0364  * Add any envars to a peer's environment that the module needs
0365  * to communicate. The API stub will rotate across all active modules, giving
0366  * each a chance to contribute
0367  *
0368  * @return PMIX_SUCCESS on success.
0369  */
0370 typedef pmix_status_t (*pmix_gds_base_module_setup_fork_fn_t)(const pmix_proc_t *proc, char ***env);
0371
0372 /**
0373  * Define a new nspace in the GDS
0374  *
0375  * @param nspace   namespace string
0376  *
0377  * @return PMIX_SUCCESS on success.
0378  */
0379 typedef pmix_status_t (*pmix_gds_base_module_add_nspace_fn_t)(const char *nspace,
0380                                                               uint32_t nlocalprocs,
0381                                                               pmix_info_t info[], size_t ninfo);
0382
0383 /* define a convenience macro for add_nspace based on peer */
0384 #define PMIX_GDS_ADD_NSPACE(s, n, ls, i, ni)                                                \
0385     do {                                                                                    \
0386         pmix_gds_base_active_module_t *_g;                                                  \
0387         pmix_status_t _s = PMIX_SUCCESS;                                                    \
0388         (s) = PMIX_SUCCESS;                                                                 \
0389         pmix_output_verbose(1, pmix_gds_base_output, "[%s:%d] GDS ADD NSPACE %s", __FILE__, \
0390                             __LINE__, (n));                                                 \
0391         PMIX_LIST_FOREACH (_g, &pmix_gds_globals.actives, pmix_gds_base_active_module_t) {  \
0392             if (NULL != _g->module->add_nspace) {                                           \
0393                 _s = _g->module->add_nspace(n, ls, i, ni);                                  \
0394             }                                                                               \
0395             if (PMIX_SUCCESS != _s) {                                                       \
0396                 (s) = PMIX_ERROR;                                                           \
0397             }                                                                               \
0398         }                                                                                   \
0399     } while (0)
0400
0401 /**
0402  * Delete nspace and its associated data
0403  *
0404  * @param nspace   namespace string
0405  *
0406  * @return PMIX_SUCCESS on success.
0407  */
0408 typedef pmix_status_t (*pmix_gds_base_module_del_nspace_fn_t)(const char *nspace);
0409
0410 /* define a convenience macro for del_nspace based on peer */
0411 #define PMIX_GDS_DEL_NSPACE(s, n)                                                           \
0412     do {                                                                                    \
0413         pmix_gds_base_active_module_t *_g;                                                  \
0414         pmix_status_t _s = PMIX_SUCCESS;                                                    \
0415         (s) = PMIX_SUCCESS;                                                                 \
0416         pmix_output_verbose(1, pmix_gds_base_output, "[%s:%d] GDS DEL NSPACE %s", __FILE__, \
0417                             __LINE__, (n));                                                 \
0418         PMIX_LIST_FOREACH (_g, &pmix_gds_globals.actives, pmix_gds_base_active_module_t) {  \
0419             if (NULL != _g->module->del_nspace) {                                           \
0420                 _s = _g->module->del_nspace(n);                                             \
0421             }                                                                               \
0422             if (PMIX_SUCCESS != _s) {                                                       \
0423                 (s) = PMIX_ERROR;                                                           \
0424             }                                                                               \
0425         }                                                                                   \
0426     } while (0)
0427
0428 /* define a convenience macro for is_tsafe for fetch operation */
0429 #define PMIX_GDS_FETCH_IS_TSAFE(s, p)                       \
0430     do {                                                    \
0431         pmix_gds_base_module_t *_g = (p)->nptr->compat.gds; \
0432         pmix_output_verbose(1, pmix_gds_base_output,        \
0433                 "[%s:%d] GDS FETCH IS THREAD SAFE WITH %s", \
0434                             __FILE__, __LINE__, _g->name);  \
0435         if (true == _g->is_tsafe) {                         \
0436             (s) = PMIX_SUCCESS;                             \
0437         } else {                                            \
0438             (s) = PMIX_ERR_NOT_SUPPORTED;                   \
0439         }                                                   \
0440     } while(0)
0441
0442 typedef pmix_status_t (*pmix_gds_base_module_fetch_array_fn_t)(struct pmix_peer_t *pr,
0443                                                                pmix_buffer_t *reply);
0444 /* define a convenience macro for fetching array info for
0445  * a given peer */
0446 #define PMIX_GDS_FETCH_INFO_ARRAYS(s, p, b)                                 \
0447     do {                                                                    \
0448         pmix_gds_base_module_t *_g = pmix_globals.mypeer->nptr->compat.gds; \
0449         pmix_output_verbose(1, pmix_gds_base_output,                        \
0450                             "[%s:%d] GDS FETCH ARRAYS WITH %s",             \
0451                             __FILE__, __LINE__, _g->name);                  \
0452         (s) = _g->fetch_arrays((struct pmix_peer_t*)(p), b);                \
0453     } while(0)
0454
0455
0456 /* structure for gds modules */
0457 typedef struct {
0458     const char *name;
0459     const bool is_tsafe;
0460     pmix_gds_base_module_init_fn_t                  init;
0461     pmix_gds_base_module_fini_fn_t                  finalize;
0462     pmix_gds_base_assign_module_fn_t                assign_module;
0463     pmix_gds_base_module_cache_job_info_fn_t        cache_job_info;
0464     pmix_gds_base_module_register_job_info_fn_t     register_job_info;
0465     pmix_gds_base_module_store_job_info_fn_t        store_job_info;
0466     pmix_gds_base_module_store_fn_t                 store;
0467     pmix_gds_base_module_store_modex_fn_t           store_modex;
0468     pmix_gds_base_module_fetch_fn_t                 fetch;
0469     pmix_gds_base_module_setup_fork_fn_t            setup_fork;
0470     pmix_gds_base_module_add_nspace_fn_t            add_nspace;
0471     pmix_gds_base_module_del_nspace_fn_t            del_nspace;
0472     pmix_gds_base_module_assemb_kvs_req_fn_t        assemb_kvs_req;
0473     pmix_gds_base_module_accept_kvs_resp_fn_t       accept_kvs_resp;
0474     pmix_gds_base_module_fetch_array_fn_t           fetch_arrays;
0475     pmix_gds_base_module_mark_modex_complete_fn_t   mark_modex_complete;
0476     pmix_gds_base_module_recv_modex_complete_fn_t   recv_modex_complete;
0477 } pmix_gds_base_module_t;
0478
0479 /* NOTE: there is no public GDS interface structure - all access is
0480  * done directly to/from an assigned module */
0481
0482 /* define the component structure */
0483 typedef pmix_mca_base_component_t pmix_gds_base_component_t;
0484
0485 /*
0486  * Macro for use in components that are of type gds
0487  */
0488 #define PMIX_GDS_BASE_VERSION_1_0_0 PMIX_MCA_BASE_VERSION_1_0_0("gds", 1, 0, 0)
0489
0490 END_C_DECLS
0491
0492 #endif