This source file includes following definitions.
- pmix_gds_base_get_available_modules
- pmix_gds_base_assign_module
- pmix_gds_base_setup_fork
- pmix_gds_base_store_modex
- pmix_gds_base_modex_pack_kval
- pmix_gds_base_modex_unpack_kval
   1 
   2 
   3 
   4 
   5 
   6 
   7 
   8 
   9 
  10 
  11 
  12 
  13 
  14 
  15 
  16 
  17 #include <src/include/pmix_config.h>
  18 
  19 #include <pmix_common.h>
  20 #include "src/include/pmix_globals.h"
  21 
  22 #include "src/class/pmix_list.h"
  23 #include "src/util/argv.h"
  24 #include "src/util/error.h"
  25 
  26 #include "src/mca/gds/base/base.h"
  27 #include "src/server/pmix_server_ops.h"
  28 
  29 
  30 char* pmix_gds_base_get_available_modules(void)
  31 {
  32     if (!pmix_gds_globals.initialized) {
  33         return NULL;
  34     }
  35 
  36     return strdup(pmix_gds_globals.all_mods);
  37 }
  38 
  39 
  40 pmix_gds_base_module_t* pmix_gds_base_assign_module(pmix_info_t *info, size_t ninfo)
  41 {
  42     pmix_gds_base_active_module_t *active;
  43     pmix_gds_base_module_t *mod = NULL;
  44     int pri, priority = -1;
  45 
  46     if (!pmix_gds_globals.initialized) {
  47         return NULL;
  48     }
  49 
  50     PMIX_LIST_FOREACH(active, &pmix_gds_globals.actives, pmix_gds_base_active_module_t) {
  51         if (NULL == active->module->assign_module) {
  52             continue;
  53         }
  54         if (PMIX_SUCCESS == active->module->assign_module(info, ninfo, &pri)) {
  55             if (pri < 0) {
  56                 
  57                 pri = active->pri;
  58             }
  59             if (priority < pri) {
  60                 mod = active->module;
  61                 priority = pri;
  62             }
  63         }
  64     }
  65 
  66     return mod;
  67 }
  68 
  69 pmix_status_t pmix_gds_base_setup_fork(const pmix_proc_t *proc,
  70                                        char ***env)
  71 {
  72     pmix_gds_base_active_module_t *active;
  73     pmix_status_t rc;
  74 
  75     if (!pmix_gds_globals.initialized) {
  76         return PMIX_ERR_INIT;
  77     }
  78 
  79     PMIX_LIST_FOREACH(active, &pmix_gds_globals.actives, pmix_gds_base_active_module_t) {
  80         if (NULL == active->module->setup_fork) {
  81             continue;
  82         }
  83         if (PMIX_SUCCESS != (rc = active->module->setup_fork(proc, env))) {
  84             return rc;
  85         }
  86     }
  87 
  88     return PMIX_SUCCESS;
  89 }
  90 
  91 pmix_status_t pmix_gds_base_store_modex(struct pmix_namespace_t *nspace,
  92                                         pmix_buffer_t * buff,
  93                                         pmix_gds_base_ctx_t ctx,
  94                                         pmix_gds_base_store_modex_cb_fn_t cb_fn,
  95                                         void *cbdata)
  96 {
  97     pmix_status_t rc = PMIX_SUCCESS;
  98     pmix_buffer_t bkt;
  99     pmix_byte_object_t bo, bo2;
 100     int32_t cnt = 1;
 101     pmix_collect_t ctype;
 102     pmix_server_trkr_t *trk = (pmix_server_trkr_t*)cbdata;
 103     pmix_proc_t proc;
 104     pmix_buffer_t pbkt;
 105     pmix_rank_t rel_rank;
 106     pmix_nspace_caddy_t *nm;
 107     bool found;
 108     char  **kmap = NULL;
 109     uint32_t kmap_size;
 110     pmix_gds_modex_key_fmt_t kmap_type;
 111     pmix_gds_modex_blob_info_t blob_info_byte = 0;
 112 
 113     
 114 
 115     cnt = 1;
 116     PMIX_BFROPS_UNPACK(rc, pmix_globals.mypeer,
 117             buff, &bo, &cnt, PMIX_BYTE_OBJECT);
 118 
 119     
 120     if ((PMIX_COLLECT_YES == trk->collect_type) &&
 121             (PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER == rc)) {
 122         goto exit;
 123     }
 124 
 125     while (PMIX_SUCCESS == rc) {
 126         PMIX_CONSTRUCT(&bkt, pmix_buffer_t);
 127         PMIX_LOAD_BUFFER(pmix_globals.mypeer, &bkt, bo.bytes, bo.size);
 128         
 129         cnt = 1;
 130         PMIX_BFROPS_UNPACK(rc, pmix_globals.mypeer,
 131                 &bkt, &blob_info_byte, &cnt, PMIX_BYTE);
 132         if (PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER == rc) {
 133             
 134             PMIX_DESTRUCT(&bkt);
 135             break;
 136         }
 137         if (PMIX_SUCCESS != rc) {
 138             
 139             PMIX_ERROR_LOG(rc);
 140             PMIX_DESTRUCT(&bkt);
 141             goto exit;
 142         }
 143         
 144 
 145         ctype = PMIX_GDS_COLLECT_IS_SET(blob_info_byte) ?
 146                     PMIX_COLLECT_YES : PMIX_COLLECT_NO;
 147         if (trk->collect_type != ctype) {
 148             rc = PMIX_ERR_INVALID_ARG;
 149             PMIX_ERROR_LOG(rc);
 150             goto exit;
 151         }
 152 
 153         
 154         kmap_type = PMIX_GDS_KEYMAP_IS_SET(blob_info_byte) ?
 155                     PMIX_MODEX_KEY_KEYMAP_FMT : PMIX_MODEX_KEY_NATIVE_FMT;
 156         if (PMIX_MODEX_KEY_KEYMAP_FMT == kmap_type) {
 157             
 158             cnt = 1;
 159             PMIX_BFROPS_UNPACK(rc, pmix_globals.mypeer,
 160                                &bkt, &kmap_size, &cnt, PMIX_UINT32);
 161             if (PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER == rc) {
 162                 rc = PMIX_SUCCESS;
 163                 PMIX_DESTRUCT(&bkt);
 164                 break;
 165             } else if (PMIX_SUCCESS != rc) {
 166                 PMIX_ERROR_LOG(rc);
 167                 PMIX_DESTRUCT(&bkt);
 168                 break;
 169             }
 170 
 171             
 172 
 173             kmap = (char**)(calloc(kmap_size + 1, sizeof(char*)));
 174             if (NULL == kmap) {
 175                 rc = PMIX_ERR_OUT_OF_RESOURCE;
 176                 PMIX_ERROR_LOG(rc);
 177                 goto exit;
 178             }
 179             cnt = kmap_size;
 180             PMIX_BFROPS_UNPACK(rc, pmix_globals.mypeer, &bkt,
 181                                kmap, &cnt, PMIX_STRING);
 182             if (PMIX_SUCCESS != rc) {
 183                 PMIX_ERROR_LOG(rc);
 184                 PMIX_DESTRUCT(&bkt);
 185                 goto exit;
 186             }
 187             if (pmix_argv_count(kmap) != (int)kmap_size) {
 188                 rc = PMIX_ERR_UNPACK_FAILURE;
 189                 PMIX_ERROR_LOG(rc);
 190                 PMIX_DESTRUCT(&bkt);
 191                 goto exit;
 192             }
 193         }
 194         
 195         cnt = 1;
 196         PMIX_BFROPS_UNPACK(rc, pmix_globals.mypeer,
 197                 &bkt, &bo2, &cnt, PMIX_BYTE_OBJECT);
 198         while (PMIX_SUCCESS == rc) {
 199             
 200 
 201 
 202 
 203 
 204 
 205 
 206             
 207             PMIX_CONSTRUCT(&pbkt, pmix_buffer_t);
 208             PMIX_LOAD_BUFFER(pmix_globals.mypeer, &pbkt, bo2.bytes, bo2.size);
 209             
 210             cnt = 1;
 211             PMIX_BFROPS_UNPACK(rc, pmix_globals.mypeer, &pbkt, &rel_rank, &cnt,
 212                                PMIX_PROC_RANK);
 213             if (PMIX_SUCCESS != rc) {
 214                 PMIX_ERROR_LOG(rc);
 215                 pbkt.base_ptr = NULL;
 216                 PMIX_DESTRUCT(&pbkt);
 217                 break;
 218             }
 219             found = false;
 220             
 221             if (pmix_list_get_size(&trk->nslist) == 1) {
 222                 found = true;
 223                 nm = (pmix_nspace_caddy_t*)pmix_list_get_first(&trk->nslist);
 224             } else {
 225                 PMIX_LIST_FOREACH(nm, &trk->nslist, pmix_nspace_caddy_t) {
 226                     if (rel_rank < nm->ns->nprocs) {
 227                         found = true;
 228                         break;
 229                     }
 230                     rel_rank -= nm->ns->nprocs;
 231                 }
 232             }
 233             if (false == found) {
 234                 rc = PMIX_ERR_NOT_FOUND;
 235                 PMIX_ERROR_LOG(rc);
 236                 pbkt.base_ptr = NULL;
 237                 PMIX_DESTRUCT(&pbkt);
 238                 break;
 239             }
 240             PMIX_PROC_LOAD(&proc, nm->ns->nspace, rel_rank);
 241 
 242             
 243 
 244             rc = cb_fn(ctx, &proc, kmap_type, kmap, &pbkt);
 245             if (PMIX_SUCCESS != rc) {
 246                 PMIX_ERROR_LOG(rc);
 247                 pbkt.base_ptr = NULL;
 248                 PMIX_DESTRUCT(&pbkt);
 249                 break;
 250             }
 251             pbkt.base_ptr = NULL;
 252             PMIX_DESTRUCT(&pbkt);
 253             PMIX_BYTE_OBJECT_DESTRUCT(&bo2);
 254             
 255             cnt = 1;
 256             PMIX_BFROPS_UNPACK(rc, pmix_globals.mypeer,
 257                     &bkt, &bo2, &cnt, PMIX_BYTE_OBJECT);
 258         }
 259         PMIX_DESTRUCT(&bkt);
 260 
 261         if (PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER == rc) {
 262             rc = PMIX_SUCCESS;
 263         } else if (PMIX_SUCCESS != rc) {
 264             PMIX_ERROR_LOG(rc);
 265             goto exit;
 266         }
 267         
 268         cnt = 1;
 269         PMIX_BFROPS_UNPACK(rc, pmix_globals.mypeer,
 270                 buff, &bo, &cnt, PMIX_BYTE_OBJECT);
 271     }
 272 
 273     if (PMIX_ERR_UNPACK_READ_PAST_END_OF_BUFFER == rc) {
 274         rc = PMIX_SUCCESS;
 275     } else if (PMIX_SUCCESS != rc) {
 276         PMIX_ERROR_LOG(rc);
 277     }
 278 exit:
 279     pmix_argv_free(kmap);
 280     return rc;
 281 }
 282 
 283 
 284 
 285 
 286 
 287 
 288 
 289 
 290 
 291 
 292 
 293 
 294 
 295 
 296 pmix_status_t pmix_gds_base_modex_pack_kval(pmix_gds_modex_key_fmt_t key_fmt,
 297                                             pmix_buffer_t *buf, char ***kmap,
 298                                             pmix_kval_t *kv)
 299 {
 300     uint32_t key_idx;
 301     pmix_status_t rc = PMIX_SUCCESS;
 302 
 303     if (PMIX_MODEX_KEY_KEYMAP_FMT == key_fmt) {
 304         rc = pmix_argv_append_unique_idx((int*)&key_idx, kmap, kv->key);
 305         if (PMIX_SUCCESS != rc) {
 306             PMIX_ERROR_LOG(rc);
 307             return rc;
 308         }
 309         
 310         PMIX_BFROPS_PACK(rc, pmix_globals.mypeer, buf, &key_idx, 1, PMIX_UINT32);
 311         if (PMIX_SUCCESS != rc) {
 312             PMIX_ERROR_LOG(rc);
 313             return rc;
 314         }
 315         
 316         PMIX_BFROPS_PACK(rc, pmix_globals.mypeer, buf, kv->value, 1, PMIX_VALUE);
 317         if (PMIX_SUCCESS != rc) {
 318             PMIX_ERROR_LOG(rc);
 319             return rc;
 320         }
 321     } else if (PMIX_MODEX_KEY_NATIVE_FMT == key_fmt) {
 322         PMIX_BFROPS_PACK(rc, pmix_globals.mypeer, buf, kv, 1, PMIX_KVAL);
 323         if (PMIX_SUCCESS != rc) {
 324             PMIX_ERROR_LOG(rc);
 325             return rc;
 326         }
 327     } else {
 328         rc = PMIX_ERR_BAD_PARAM;
 329         PMIX_ERROR_LOG(rc);
 330         return rc;
 331     }
 332 
 333     return PMIX_SUCCESS;
 334 }
 335 
 336 
 337 
 338 
 339 
 340 
 341 
 342 
 343 
 344 
 345 
 346 pmix_status_t pmix_gds_base_modex_unpack_kval(pmix_gds_modex_key_fmt_t key_fmt,
 347                                               pmix_buffer_t *buf, char **kmap,
 348                                               pmix_kval_t *kv)
 349 {
 350     int32_t cnt;
 351     uint32_t key_idx;
 352     pmix_status_t rc = PMIX_SUCCESS;
 353 
 354     if (PMIX_MODEX_KEY_KEYMAP_FMT == key_fmt) {
 355         cnt = 1;
 356         PMIX_BFROPS_UNPACK(rc, pmix_globals.mypeer, buf, &key_idx, &cnt, PMIX_UINT32);
 357         if (PMIX_SUCCESS != rc) {
 358             return rc;
 359         }
 360         
 361         if (NULL == kmap[key_idx]) {
 362             rc = PMIX_ERR_BAD_PARAM;
 363             PMIX_ERROR_LOG(rc);
 364             return rc;
 365         }
 366         kv->key = strdup(kmap[key_idx]);
 367         cnt = 1;
 368         PMIX_VALUE_CREATE(kv->value, 1);
 369         PMIX_BFROPS_UNPACK(rc, pmix_globals.mypeer, buf, kv->value, &cnt, PMIX_VALUE);
 370         if (PMIX_SUCCESS != rc) {
 371             free(kv->key);
 372             PMIX_VALUE_RELEASE(kv->value);
 373             PMIX_ERROR_LOG(rc);
 374             return rc;
 375         }
 376     } else if (PMIX_MODEX_KEY_NATIVE_FMT == key_fmt) {
 377         cnt = 1;
 378         PMIX_BFROPS_UNPACK(rc, pmix_globals.mypeer, buf, kv, &cnt, PMIX_KVAL);
 379         if (PMIX_SUCCESS != rc) {
 380             return rc;
 381         }
 382     } else {
 383         rc = PMIX_ERR_BAD_PARAM;
 384         PMIX_ERROR_LOG(rc);
 385         return rc;
 386     }
 387 
 388     return PMIX_SUCCESS;
 389 }