This source file includes following definitions.
- log_fatal
- log_error
- log_info
- random_value
- main
- test_item1
- test_item2
- test_item3
- test_item4
- test_item5
- test_item6
- test_item7
- test_item8
- test_item9
- test_item10
1
2
3
4
5
6
7
8
9
10
11
12
13 #define _GNU_SOURCE
14 #include <stdio.h>
15 #include <stdlib.h>
16 #include <string.h>
17 #include <time.h>
18 #include <stdarg.h>
19
20 #include "pmi2.h"
21
22
23 static int _legacy = 0;
24
25 static int _verbose = 1;
26
27 static void log_fatal(const char *format, ...)
28 {
29 va_list arglist;
30 char *output = NULL;
31
32 va_start(arglist, format);
33 if (_verbose > 0) {
34 if (0 > vasprintf(&output, format, arglist) ||
35 NULL == output) {
36 va_end(arglist);
37 return;
38 }
39 fprintf(stderr, "FATAL: %s", output);
40 free(output);
41 }
42 va_end(arglist);
43 }
44
45 static void log_error(const char *format, ...)
46 {
47 va_list arglist;
48 char *output = NULL;
49
50 va_start(arglist, format);
51 if (_verbose > 0) {
52 if (0 > vasprintf(&output, format, arglist) ||
53 NULL == output) {
54 va_end(arglist);
55 return;
56 }
57 fprintf(stderr, "ERROR: %s", output);
58 free(output);
59 }
60 va_end(arglist);
61 }
62
63 static void log_info(const char *format, ...)
64 {
65 va_list arglist;
66 char *output = NULL;
67
68 va_start(arglist, format);
69 if (_verbose > 0) {
70 if (0 > vasprintf(&output, format, arglist) ||
71 NULL == output) {
72 va_end(arglist);
73 return;
74 }
75 fprintf(stderr, "INFO: %s", output);
76 free(output);
77 }
78 va_end(arglist);
79 }
80
81 #define log_assert(e, msg) \
82 do { \
83 if (!(e)) { \
84 log_fatal("%s at %s:%d\n", msg, __func__, __LINE__); \
85 rc = -1; \
86 } \
87 } while (0)
88
89 static inline long random_value(long min_value, long max_value)
90 {
91 return ((min_value >= max_value) ? min_value : min_value + (rand() % (max_value - min_value + 1)));
92 }
93
94 static int test_item1(void);
95 static int test_item2(void);
96 static int test_item3(void);
97 static int test_item4(void);
98 static int test_item5(void);
99 static int test_item6(void);
100 static int test_item7(void);
101 static int test_item8(void);
102 static int test_item9(void);
103
104 static int test_item10(void);
105
106 static int spawned, size, rank, appnum;
107 static char jobid[100];
108
109
110 int main(int argc, char **argv)
111 {
112 int ret = 0;
113 int rc;
114 char *str = NULL;
115 int ti = (argc > 1 ? atoi(argv[1]) : 0);
116
117 srand(time(NULL));
118 str = getenv("VERBOSE");
119 _verbose = (str ? atoi(str) : _verbose);
120
121 spawned = random_value(10, 20);
122 size = random_value(10, 20);
123 rank = random_value(10, 20);
124 appnum = random_value(10, 20);
125 if (PMI2_SUCCESS != (rc = PMI2_Init(&spawned, &size, &rank, &appnum))) {
126 log_fatal("PMI2_Init failed: %d\n", rc);
127 return rc;
128 }
129
130 str = getenv("PMIX_NAMESPACE");
131 _legacy = (str ? 0 : 1);
132
133
134 if (1) {
135 rc = test_item1();
136 ret += (rc ? 1 : 0);
137 log_info("TI1 : %s\n", (rc ? "FAIL" : "PASS"));
138 }
139
140 if (!ti || 2 == ti) {
141 rc = test_item2();
142 ret += (rc ? 1 : 0);
143 log_info("TI2 : %s\n", (rc ? "FAIL" : "PASS"));
144 }
145
146 if (!ti || 3 == ti) {
147 rc = test_item3();
148 ret += (rc ? 1 : 0);
149 log_info("TI3 : %s\n", (rc ? "FAIL" : "PASS"));
150 }
151
152 if (!ti || 4 == ti) {
153 rc = test_item4();
154 ret += (rc ? 1 : 0);
155 log_info("TI4 : %s\n", (rc ? "FAIL" : "PASS"));
156 }
157
158 if (!ti || 5 == ti) {
159 rc = test_item5();
160 ret += (rc ? 1 : 0);
161 log_info("TI5 : %s\n", (rc ? "FAIL" : "PASS"));
162 }
163
164 if (!ti || 6 == ti) {
165 rc = test_item6();
166 ret += (rc ? 1 : 0);
167 log_info("TI6 : %s\n", (rc ? "FAIL" : "PASS"));
168 }
169
170 if (!ti || 7 == ti) {
171 rc = test_item7();
172 ret += (rc ? 1 : 0);
173 log_info("TI7 : %s\n", (rc ? "FAIL" : "PASS"));
174 }
175
176 if (!ti || 8 == ti) {
177 rc = test_item8();
178 ret += (rc ? 1 : 0);
179 log_info("TI8 : %s\n", (rc ? "FAIL" : "PASS"));
180 }
181
182 if (!ti || 9 == ti) {
183 rc = test_item9();
184 ret += (rc ? 1 : 0);
185 log_info("TI9 : %s\n", (rc ? "FAIL" : "PASS"));
186 }
187
188 if (!ti || 10 == ti) {
189 rc = test_item10();
190 ret += (rc ? 1 : 0);
191 log_info("TI10 : %s\n", (rc ? "FAIL" : "PASS"));
192 }
193
194 if (PMI2_SUCCESS != (rc = PMI2_Finalize())) {
195 log_fatal("PMI2_Finalize failed: %d\n", rc);
196 return rc;
197 }
198
199 return ret;
200 }
201
202 static int test_item1(void)
203 {
204 int rc = 0;
205
206 log_info("spawned=%d size=%d rank=%d appnum=%d\n", spawned, size, rank, appnum);
207
208 log_assert(spawned == 0 || spawned == 1, "");
209 log_assert(size >= 0, "");
210 log_assert(rank >= 0, "");
211 log_assert(rank < size, "");
212
213 sprintf(jobid, "%s", __func__);
214 if (PMI2_SUCCESS != (rc = PMI2_Job_GetId(jobid, sizeof(jobid)))) {
215 log_fatal("PMI2_Job_GetId failed: %d\n", rc);
216 return rc;
217 }
218
219 log_info("jobid=%s\n", jobid);
220 log_assert(memcmp(jobid, __func__, sizeof(__func__)), "");
221
222 return rc;
223 }
224
225 static int test_item2(void)
226 {
227 int rc = 0;
228 int val = 0;
229
230 log_assert(PMI2_Initialized(), "");
231
232 val = random_value(10, 100);
233 if (PMI2_SUCCESS != (rc = PMI2_Job_GetRank(&val))) {
234 log_fatal("PMI2_Job_GetRank failed: %d\n", rc);
235 return rc;
236 }
237 log_assert(rank == val, "");
238
239 val = -1;
240 if (PMI2_SUCCESS != (rc = PMI2_Info_GetSize(&val))) {
241 log_fatal("PMI2_Info_GetSize failed: %d\n", rc);
242 return rc;
243 }
244 log_assert(0 < val, "");
245
246 return rc;
247 }
248
249 static int test_item3(void)
250 {
251 int rc = 0;
252 char val[PMI2_MAX_VALLEN];
253 int found = 0;
254
255 const char *tkeys[] = {
256 "universeSize",
257 "hasNameServ",
258 "physTopology",
259 "physTopologyLevels",
260 "cartDims",
261 "isHeterogeneous",
262 NULL
263 };
264 const char **ptr = tkeys;
265
266 if (!_legacy) {
267 log_error("%s\n", "PMIx and SLURM/PMI2 does not set Job Attributes (Do not mark test as failed)");
268 return rc;
269 }
270
271 while (*ptr) {
272 if (PMI2_SUCCESS != (rc = PMI2_Info_GetJobAttr(*ptr, val, sizeof(val), &found))) {
273 log_fatal("PMI2_Info_GetJobAttr: [%s] %d\n", *ptr, rc);
274 return rc;
275 }
276 log_info("key=%s value=%s found=%d\n", *ptr, (found ? val : "N/A"), found);
277 if (!_legacy && !found) {
278 log_error("PMIx does not set: %s (Do not mark test as failed)\n", *ptr);
279 }
280 ptr++;
281 }
282
283 return rc;
284 }
285
286 static int test_item4(void)
287 {
288 int rc = 0;
289 char val[PMI2_MAX_VALLEN];
290 int found = 0;
291
292 const char *tkeys[] = {
293 "memPoolType",
294 "memSYSVid",
295 "memAnonMMAPfd",
296 "memNTName",
297 NULL
298 };
299 const char **ptr = tkeys;
300
301 if (!_legacy) {
302 log_error("%s\n", "PMIx and SLURM/PMI2 does not set Node Attributes (Do not mark test as failed)");
303 return rc;
304 }
305
306 while (*ptr) {
307 if (PMI2_SUCCESS != (rc = PMI2_Info_GetNodeAttr(*ptr, val, sizeof(val), &found, 1))) {
308 log_fatal("PMI2_Info_GetNodeAttr: [%s] %d\n", *ptr, rc);
309 return rc;
310 }
311 log_info("key=%s value=%s found=%d\n", *ptr, (found ? val : "N/A"), found);
312 if (!_legacy && !found) {
313 log_error("PMIx does not set: %s (Do not mark test as failed)\n", *ptr);
314 }
315 ptr++;
316 }
317
318 return rc;
319 }
320
321 static int test_item5(void)
322 {
323 int rc = 0;
324 char val[PMI2_MAX_VALLEN];
325 int found = 0;
326 const char *tkey = "sharedFilename";
327 const char *tval = "pmix-pmi2-check";
328
329 if (PMI2_SUCCESS != (rc = PMI2_Info_PutNodeAttr(tkey, tval))) {
330 log_fatal("PMI2_Info_PutNodeAttr %d\n", rc);
331 return rc;
332 }
333
334 if (PMI2_SUCCESS != (rc = PMI2_Info_GetNodeAttr(tkey, val, sizeof(val), &found, 1))) {
335 log_fatal("PMI2_Info_GetNodeAttr %d\n", rc);
336 return rc;
337 }
338
339 log_info("tkey=%s tval=%s val=%s found=%d\n", tkey, tval, val, found);
340
341 log_assert(found, "PMI2_Info_GetNodeAttr does not find expected key");
342 log_assert(strlen(tval) == strlen(val), "value does not meet expectation");
343 log_assert(!strcmp(tval, val), "value does not meet expectation");
344
345 return rc;
346 }
347
348 static int test_item6(void)
349 {
350 int rc = 0;
351 char val[PMI2_MAX_VALLEN];
352 int len;
353 const char *tkey = __func__;
354 const char *tval = __FILE__;
355
356 if (PMI2_SUCCESS != (rc = PMI2_KVS_Put(tkey, tval))) {
357 log_fatal("PMI2_KVS_Put %d\n", rc);
358 return rc;
359 }
360
361
362 rc = PMI2_KVS_Get(NULL, PMI2_ID_NULL, tkey, val, sizeof(val), &len);
363 if (PMI2_SUCCESS == rc) {
364 log_info("tkey=%s tval=%s val=%s len=%d\n", tkey, tval, val, len);
365 log_error("%s\n", "PMI2_KVS_Get should not find data w/o commit");
366 return 1;
367 }
368
369 return 0;
370 }
371
372 static int test_item7(void)
373 {
374 int rc = 0;
375 char val[PMI2_MAX_VALLEN];
376 int len;
377 char tkey[PMI2_MAX_VALLEN];
378 char tval[PMI2_MAX_VALLEN];
379
380 sprintf(tkey, "KEY-%d", rank);
381 sprintf(tval, "VALUE-%d", rank);
382 if (PMI2_SUCCESS != (rc = PMI2_KVS_Put(tkey, tval))) {
383 log_fatal("PMI2_KVS_Put %d\n", rc);
384 return rc;
385 }
386
387 if (PMI2_SUCCESS != (rc = PMI2_KVS_Fence())) {
388 log_fatal("PMI2_KVS_Fence %d\n", rc);
389 return rc;
390 }
391
392
393 rc = PMI2_KVS_Get(jobid, rank, tkey, val, sizeof(val), &len);
394 if (PMI2_SUCCESS != rc) {
395 log_fatal("PMI2_KVS_Get [%s=?] %d\n", tkey, rc);
396 return rc;
397 }
398
399 log_info("tkey=%s tval=%s val=%s len=%d\n", tkey, tval, val, len);
400
401 log_assert((int)strlen(tval) == len, "value does not meet expectation");
402 log_assert(!strcmp(tval, val), "value does not meet expectation");
403
404 return 0;
405 }
406
407 static int test_item8(void)
408 {
409 int rc = 0;
410 int len;
411 char tkey[PMI2_MAX_VALLEN];
412 char tval[PMI2_MAX_VALLEN];
413 char val[PMI2_MAX_VALLEN];
414 int i = 0;
415
416 for (i = 0; i < size; i++) {
417 sprintf(tkey, "KEY-%d", i);
418 sprintf(tval, "VALUE-%d", i);
419 if (i == rank) {
420 if (PMI2_SUCCESS != (rc = PMI2_KVS_Put(tkey, tval))) {
421 log_fatal("PMI2_KVS_Put [%s=%s] %d\n", tkey, tval, rc);
422 return rc;
423 }
424 }
425 }
426
427 if (PMI2_SUCCESS != (rc = PMI2_KVS_Fence())) {
428 log_fatal("PMI2_KVS_Fence %d\n", rc);
429 return rc;
430 }
431
432 for (i = 0; i < size; i++) {
433 sprintf(tkey, "KEY-%d", i);
434 sprintf(tval, "VALUE-%d", i);
435 if (PMI2_SUCCESS != (rc = PMI2_KVS_Get(jobid, i, tkey, val, sizeof(val), &len))) {
436 log_fatal("PMI2_KVS_Get [%s=?] %d\n", tkey, rc);
437 return rc;
438 }
439
440 log_info("tkey=%s tval=%s val=%s len=%d\n", tkey, tval, val, len);
441
442 log_assert((int)strlen(tval) == len, "value does not meet expectation");
443 log_assert(!strcmp(tval, val), "value does not meet expectation");
444 }
445
446 return rc;
447 }
448
449 static int test_item9(void)
450 {
451 int rc = 0;
452 int len;
453 char tkey[PMI2_MAX_VALLEN];
454 char tval[PMI2_MAX_VALLEN];
455 char val[PMI2_MAX_VALLEN];
456 int i = 0;
457
458 for (i = 0; i < size; i++) {
459 sprintf(tkey, "KEY-%d", i);
460 sprintf(tval, "VALUE-%d", i);
461 if (i == rank) {
462 log_info("Rank %d executing Put of key %s\n", rank, tkey);
463 if (PMI2_SUCCESS != (rc = PMI2_KVS_Put(tkey, tval))) {
464 log_fatal("PMI2_KVS_Put [%s=%s] %d\n", tkey, tval, rc);
465 return rc;
466 }
467 }
468 }
469
470 log_info("Rank %d executing Fence\n", rank);
471 if (PMI2_SUCCESS != (rc = PMI2_KVS_Fence())) {
472 log_fatal("PMI2_KVS_Fence %d\n", rc);
473 return rc;
474 }
475
476 for (i = 0; i < size; i++) {
477 sprintf(tkey, "KEY-%d", i);
478 sprintf(tval, "VALUE-%d", i);
479 log_info("Rank %d executing Get of key %s\n", rank, tkey);
480 if (PMI2_SUCCESS != (rc = PMI2_KVS_Get(jobid, PMI2_ID_NULL, tkey, val, sizeof(val), &len))) {
481 log_fatal("PMI2_KVS_Get [%s=?] %d\n", tkey, rc);
482 return rc;
483 }
484
485 log_info("tkey=%s tval=%s val=%s len=%d\n", tkey, tval, val, len);
486
487 log_assert((int)strlen(tval) == len, "value does not meet expectation");
488 log_assert(!strcmp(tval, val), "value does not meet expectation");
489 }
490
491 return rc;
492 }
493
494 static int test_item10(void)
495 {
496 int rc = 0;
497 int i, j, r;
498 char symb, symb_start = 'a';
499 int fence_cnt;
500 int fence_num = 5;
501 int keys_per_fence = 50;
502 int val_size = random_value(10, PMI2_MAX_VALLEN / 10);
503 int keys_total = 0;
504
505 fence_cnt = 0;
506 while (fence_cnt < fence_num) {
507 log_info("fence_cnt=%d of fence_num=%d keys_per_fence=%d keys_total=%d val_size=%d\n",
508 fence_cnt, fence_num, keys_per_fence, keys_total, val_size);
509 symb = symb_start;
510 for (i = 0; i < keys_per_fence; i++) {
511 char key[PMI2_MAX_KEYLEN];
512 char val[PMI2_MAX_VALLEN] = "";
513 sprintf(key, "RANK%d-key-%d", rank, i + keys_total);
514 for (j = 0; j < val_size; j++) {
515 val[j] = symb;
516 }
517 symb++;
518 if (symb > 'z') {
519 symb = 'a';
520 }
521 if (PMI2_SUCCESS != (rc = PMI2_KVS_Put(key, val))) {
522 log_fatal("%d : PMI2_KVS_Put [%s=%s] %d\n", rank, key, val, rc);
523 return rc;
524 }
525 log_info("%d : PMI2_KVS_Put [%s=%s] %d\n", rank, key, val, rc);
526 }
527 symb_start = symb;
528 keys_total += keys_per_fence;
529
530 if (PMI2_SUCCESS != (rc = PMI2_KVS_Fence())) {
531 log_fatal("%d : PMI2_KVS_Fence %d\n", rank, rc);
532 return rc;
533 }
534
535 for (r = 0; r < size; r++) {
536 int len;
537 symb = 'a';
538 for (i = 0; i < keys_total; i++) {
539 char key[PMI2_MAX_KEYLEN];
540 char val[PMI2_MAX_VALLEN] = "";
541 sprintf(key, "RANK%d-key-%d", r, i);
542
543 if (PMI2_SUCCESS != (rc = PMI2_KVS_Get(jobid, r, key, val, sizeof(val), &len))) {
544 log_fatal("%d : PMI2_KVS_Get [%s=?] %d\n", rank, key, rc);
545 return rc;
546 }
547
548 log_info("%d : PMI2_KVS_Get from %d [%s=%s] %d\n", r, rank, key, val, rc);
549
550 if (len != val_size) {
551 log_fatal("%d: failure on rank %d, key #%d: len mismatch:"
552 " %d instead of %d\n", rank, r, i, len, val_size);
553 }
554
555 for (j = 0; j < val_size; j++) {
556 if (val[j] != symb) {
557 log_fatal("%d: failure on rank %d, key #%d: value mismatch"
558 " at symb %d: \'%c\' instead of \'%c\'\n", rank,
559 r, i, j, val[j], symb);
560 }
561 }
562 symb++;
563 if (symb > 'z') {
564 symb = 'a';
565 }
566 }
567 }
568 fence_cnt++;
569 }
570
571 return rc;
572 }