src/arch/ofi/runtime-pmi2.c

   1 /*
   2  * Copyright (c) 2017, Intel Corporation. All rights reserved.
   3  * See LICENSE in this directory.
   4  *
   5  * Runtime functions used by OFI LRTS machine layer to exchange
   6  * addresses during the initialization.
   7  *
   8  * This example uses the PMI2 API as described in pmi2.h.
   9  */
  10 #include <stdlib.h>
  11 #include <string.h>
  12
  13 #include <pmi2.h>
  14
  15 #include "runtime.h"
  16
  17 /* For encode/decode functions */
  18 #include "runtime-codec.h"
  19
  20 static int initialized;
  21 static int max_keylen = PMI2_MAX_KEYLEN;
  22 static int max_valuelen = PMI2_MAX_VALLEN;
  23 static char *kvsname;
  24 static char *key;
  25 static char *value;
  26
  27 int runtime_init(int *rank, int *jobsize)
  28 {
  29     int ret;
  30     int spawned;
  31     int appnum;
  32     int max_kvsnamelen = PMI2_MAX_VALLEN;
  33
  34     ret = PMI2_Init(&spawned, jobsize, rank, &appnum);
  35     if (PMI2_SUCCESS != ret) {
  36         return 1;
  37     }
  38
  39     kvsname = calloc(max_kvsnamelen, sizeof(char));
  40     if (!kvsname) {
  41         return 2;
  42     }
  43
  44     ret = PMI2_Job_GetId(kvsname, max_kvsnamelen);
  45     if (PMI2_SUCCESS != ret) {
  46         return 3;
  47     }
  48
  49     key = calloc(max_keylen, sizeof(char));
  50     if (!key) {
  51         free(kvsname);
  52         return 4;
  53     }
  54
  55     value = calloc(max_valuelen, sizeof(char));
  56     if (!value) {
  57         free(key);
  58         free(kvsname);
  59         return 5;
  60     }
  61
  62     initialized = 1;
  63     return 0;
  64 }
  65
  66 int runtime_fini()
  67 {
  68     int ret;
  69
  70     if (initialized) {
  71         ret = PMI2_Finalize();
  72         if (PMI2_SUCCESS != ret) {
  73             return 1;
  74         }
  75     }
  76
  77     if (value) {
  78         free(value);
  79         value = NULL;
  80     }
  81     if (key) {
  82         free(key);
  83         key = NULL;
  84     }
  85     if (kvsname) {
  86         free(kvsname);
  87         kvsname = NULL;
  88     }
  89
  90     initialized = 0;
  91     return 0;
  92 }
  93
  94 int runtime_get_max_keylen(int *len)
  95 {
  96     if (!initialized) {
  97         return 1;
  98     }
  99     *len = max_keylen;
 100     return 0;
 101 }
 102
 103 int runtime_kvs_put(const char *k, const void *v, int vlen)
 104 {
 105     int ret;
 106     int keylen;
 107
 108     if (!initialized) {
 109         return 1;
 110     }
 111
 112     keylen = strlen(k);
 113     if (keylen > max_keylen) {
 114         return 2;
 115     }
 116
 117     if (vlen > max_valuelen) {
 118         return 3;
 119     }
 120
 121     ret = encode(v, vlen, value, max_valuelen);
 122     if (ret) {
 123         return 4;
 124     }
 125
 126     ret = PMI2_KVS_Put(k, value);
 127     if (ret) {
 128         return 5;
 129     }
 130
 131     return 0;
 132 }
 133
 134 int runtime_kvs_get(const char *k, void *v, int vlen)
 135 {
 136     int ret;
 137     int len;
 138
 139     if (!initialized) {
 140         return 1;
 141     }
 142
 143     ret = PMI2_KVS_Get(kvsname, PMI2_ID_NULL, k, value, max_valuelen, &len);
 144     if (ret) {
 145         return 2;
 146     }
 147
 148     ret = decode(value, v, vlen);
 149     if (ret) {
 150         return 3;
 151     }
 152
 153     return 0;
 154 }
 155
 156 int runtime_barrier()
 157 {
 158     int ret;
 159
 160     if (!initialized) {
 161         return 1;
 162     }
 163
 164     ret = PMI2_KVS_Fence();
 165     if (ret) {
 166         return 2;
 167     }
 168     return 0;
 169 }