root/opal/mca/pmix/pmix4x/pmix/test/pmi2_client.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. log_fatal
  2. log_error
  3. log_info
  4. random_value
  5. main
  6. test_item1
  7. test_item2
  8. test_item3
  9. test_item4
  10. test_item5
  11. test_item6
  12. test_item7
  13. test_item8
  14. test_item9
  15. test_item10

   1 /*
   2  * Copyright (c) 2013-2017 Intel, Inc.  All rights reserved.
   3  * Copyright (c) 2015      Mellanox Technologies, Inc.
   4  *                         All rights reserved.
   5  * $COPYRIGHT$
   6  *
   7  * Additional copyrights may follow
   8  *
   9  * $HEADER$
  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 /* Target is legacy SLURM pmi2 library implementation */
  23 static int _legacy = 0;
  24 /* Verbose level 0-silent, 1-fatal, 2-error, 3+ debug*/
  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 /* several sequence of fences is a buggy case for pmix v1.0 (see https://github.com/open-mpi/pmix/issues/37) */
 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     /* this test should be always run */
 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     /* Predefined Job attributes */
 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     /* Predefined Node attributes */
 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     /* expected result: return error status */
 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     /* expected result: return error status */
 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 }

/* [<][>][^][v][top][bottom][index][help] */