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 }