static int pmi_set_proc_attr(const char* attr_name, const void *buffer, size_t size) { int rc; if (NULL == pmi_kvs_name) { if (ORTE_SUCCESS != (rc = setup_pmi())) { ORTE_ERROR_LOG(rc); return rc; } } if (ORTE_SUCCESS != (rc = setup_key(ORTE_PROC_MY_NAME, attr_name))) { ORTE_ERROR_LOG(rc); return rc; } OPAL_OUTPUT_VERBOSE((1, orte_grpcomm_base_output, "%s grpcomm:pmi: set attr %s of size %lu in KVS %s", ORTE_NAME_PRINT(ORTE_PROC_MY_NAME), attr_name, (unsigned long)size, pmi_kvs_name)); if (ORTE_SUCCESS != (rc = pmi_encode(buffer, size))) { ORTE_ERROR_LOG(rc); return rc; } rc = kvs_put(pmi_kvs_key, pmi_attr_val); if (PMI_SUCCESS != rc) { ORTE_PMI_ERROR(rc, "PMI_KVS_Put"); return ORTE_ERROR; } return ORTE_SUCCESS; }
int opal_pmix_base_commit_packed( char* buffer_to_put, int data_to_put, int vallen, int* pack_key, kvs_put_fn fn) { int rc, left; char *pmikey = NULL, *tmp; char tmp_key[32], save; char *encoded_data; int pkey; pkey = *pack_key; if (NULL == (encoded_data = pmi_encode(buffer_to_put, data_to_put))) { OPAL_ERROR_LOG(OPAL_ERR_OUT_OF_RESOURCE); return OPAL_ERR_OUT_OF_RESOURCE; } for (left = strlen (encoded_data), tmp = encoded_data ; left ; ) { size_t value_size = vallen > left ? left : vallen - 1; sprintf (tmp_key, "key%d", *pack_key); if (NULL == (pmikey = setup_key(&OPAL_PROC_MY_NAME, tmp_key, vallen))) { OPAL_ERROR_LOG(OPAL_ERR_BAD_PARAM); rc = OPAL_ERR_BAD_PARAM; break; } /* only write value_size bytes */ save = tmp[value_size]; tmp[value_size] = '\0'; rc = fn(pmikey, tmp); if (OPAL_SUCCESS != rc) { *pack_key = pkey; return rc; } free(pmikey); if (OPAL_SUCCESS != rc) { break; } tmp[value_size] = save; tmp += value_size; left -= value_size; pkey++; rc = OPAL_SUCCESS; } if (encoded_data) { free(encoded_data); } *pack_key = pkey; return OPAL_SUCCESS; }
int hammy_del(ErlNifEnv *env, hammy_db *db, unsigned char *key, int key_size) { ham_key_t k; ham_txn_t *txn; int retval = HAMMY_FALSE; setup_key(&k, key, key_size); ham_txn_begin(&txn, db->databases[0], HAM_TXN_READ_ONLY); if (ham_erase(db->databases[0], txn, &k, 0) == HAM_SUCCESS) { ham_txn_commit(txn, 0); retval = HAMMY_TRUE; } else { ham_txn_abort(txn, 0); } return retval; }
static int pmi_get_proc_attr(const orte_process_name_t name, const char* attr_name, void **buffer, size_t *size) { int rc; /* set default */ *size = 0; *buffer = NULL; if (NULL == pmi_kvs_name) { if (ORTE_SUCCESS != (rc = setup_pmi())) { ORTE_ERROR_LOG(rc); return rc; } } OPAL_OUTPUT_VERBOSE((1, orte_grpcomm_base_output, "%s grpcomm:pmi: get attr %s for proc %s in KVS %s", ORTE_NAME_PRINT(ORTE_PROC_MY_NAME), attr_name, ORTE_NAME_PRINT(&name), pmi_kvs_name)); if (ORTE_SUCCESS != (rc = setup_key(&name, attr_name))) { ORTE_ERROR_LOG(rc); return rc; } rc = kvs_get(pmi_kvs_key, pmi_attr_val, pmi_vallen_max); if (PMI_SUCCESS != rc) { ORTE_PMI_ERROR(rc, "PMI_KVS_Get"); return ORTE_ERROR; } *buffer = pmi_decode(size); if (NULL == *buffer) { return ORTE_ERR_OUT_OF_RESOURCE; } OPAL_OUTPUT_VERBOSE((1, orte_grpcomm_base_output, "%s grpcomm:pmi: got attr %s of size %lu", ORTE_NAME_PRINT(ORTE_PROC_MY_NAME), attr_name, (unsigned long)(*size))); return ORTE_SUCCESS; }
int hammy_put(ErlNifEnv *env, hammy_db *db, unsigned char *key, int key_size, unsigned char *value, int value_size) { ham_key_t k; ham_record_t rec; ham_txn_t *txn; int rc; setup_key(&k, key, key_size); setup_record(&rec, value, value_size); ham_txn_begin(&txn, db->databases[0], 0); rc = ham_insert(db->databases[0], txn, &k, &rec, HAM_OVERWRITE); if (rc == HAM_SUCCESS) { ham_txn_commit(txn, 0); return HAMMY_TRUE; } else { ham_txn_abort(txn, 0); return HAMMY_FALSE; } }
int hammy_get(ErlNifEnv *env, hammy_db *db, unsigned char *key, int key_size, ErlNifBinary *value) { ham_key_t k; ham_record_t rec; ham_txn_t *txn; int rc; int retval = HAMMY_FALSE; setup_key(&k, key, key_size); memset(&rec, 0, sizeof(ham_record_t)); ham_txn_begin(&txn, db->databases[0], HAM_TXN_READ_ONLY); rc = ham_find(db->databases[0], txn, &k, &rec, 0); if (rc == HAM_SUCCESS) { if (enif_alloc_binary_compat(env, rec.size, value)) { memcpy(value->data, rec.data, rec.size); retval = HAMMY_TRUE; } } ham_txn_commit(txn, 0); return retval; }
int opal_pmix_base_get_packed(const opal_process_name_t* proc, char **packed_data, size_t *len, int vallen, kvs_get_fn fn) { char *tmp_encoded = NULL, *pmikey, *pmi_tmp; int remote_key, size; size_t bytes_read; int rc = OPAL_ERR_NOT_FOUND; /* set default */ *packed_data = NULL; *len = 0; pmi_tmp = calloc (vallen, 1); if (NULL == pmi_tmp) { return OPAL_ERR_OUT_OF_RESOURCE; } /* read all of the packed data from this proc */ for (remote_key = 0, bytes_read = 0 ; ; ++remote_key) { char tmp_key[32]; sprintf (tmp_key, "key%d", remote_key); if (NULL == (pmikey = setup_key(proc, tmp_key, vallen))) { rc = OPAL_ERR_OUT_OF_RESOURCE; OPAL_ERROR_LOG(rc); free(pmi_tmp); if (NULL != tmp_encoded) { free(tmp_encoded); } return rc; } OPAL_OUTPUT_VERBOSE((10, opal_pmix_base_framework.framework_output, "GETTING KEY %s", pmikey)); rc = fn(pmikey, pmi_tmp, vallen); free (pmikey); if (OPAL_SUCCESS != rc) { break; } size = strlen (pmi_tmp); if (NULL == tmp_encoded) { tmp_encoded = malloc (size + 1); } else { tmp_encoded = realloc (tmp_encoded, bytes_read + size + 1); } strcpy (tmp_encoded + bytes_read, pmi_tmp); bytes_read += size; /* is the string terminator present? */ if ('-' == tmp_encoded[bytes_read-1]) { break; } } free (pmi_tmp); OPAL_OUTPUT_VERBOSE((10, opal_pmix_base_framework.framework_output, "Read data %s\n", (NULL == tmp_encoded) ? "NULL" : tmp_encoded)); if (NULL != tmp_encoded) { *packed_data = (char *) pmi_decode (tmp_encoded, len); free (tmp_encoded); if (NULL == *packed_data) { return OPAL_ERR_OUT_OF_RESOURCE; } } return rc; }
int opal_pmix_base_partial_commit_packed( char** data, int* data_offset, char** enc_data, int* enc_data_offset, int max_key, int* pack_key, kvs_put_fn fn) { int rc; char *pmikey = NULL, *tmp; char tmp_key[32]; char *encoded_data; int encoded_data_len; int data_len; int pkey; pkey = *pack_key; if (NULL == (tmp = malloc(max_key))) { OPAL_ERROR_LOG(OPAL_ERR_OUT_OF_RESOURCE); return OPAL_ERR_OUT_OF_RESOURCE; } data_len = *data_offset - (*data_offset%3); if (NULL == (encoded_data = pmi_encode(*data, data_len))) { OPAL_ERROR_LOG(OPAL_ERR_OUT_OF_RESOURCE); free(tmp); return OPAL_ERR_OUT_OF_RESOURCE; } if (*data_offset == data_len) { *data = NULL; *data_offset = 0; } else { memmove(*data, *data+data_len, *data_offset - data_len); *data = realloc(*data, *data_offset - data_len); *data_offset -= data_len; } encoded_data_len = (int)strlen(encoded_data); while (encoded_data_len+*enc_data_offset > max_key - 2) { memcpy(tmp, *enc_data, *enc_data_offset); memcpy(tmp+*enc_data_offset, encoded_data, max_key-*enc_data_offset-1); tmp[max_key-1] = 0; sprintf (tmp_key, "key%d", pkey); if (NULL == (pmikey = setup_key(&OPAL_PROC_MY_NAME, tmp_key, max_key))) { OPAL_ERROR_LOG(OPAL_ERR_BAD_PARAM); rc = OPAL_ERR_BAD_PARAM; break; } rc = fn(pmikey, tmp); free(pmikey); if (OPAL_SUCCESS != rc) { *pack_key = pkey; free(tmp); free(encoded_data); return rc; } pkey++; memmove(encoded_data, encoded_data+max_key-1-*enc_data_offset, encoded_data_len - max_key + *enc_data_offset + 2); *enc_data_offset = 0; encoded_data_len = (int)strlen(encoded_data); } free(tmp); if (NULL != *enc_data) { free(*enc_data); } *enc_data = realloc(encoded_data, strlen(encoded_data)+1); *enc_data_offset = strlen(encoded_data); *pack_key = pkey; return OPAL_SUCCESS; }
/*** MODEX SECTION ***/ static int modex(opal_list_t *procs) { int rc, i; size_t len; char *rml_uri, val[64]; orte_vpid_t v; orte_process_name_t name; orte_jmap_t *jmap; orte_nid_t *nid, *loc; orte_pmap_t *pmap; OPAL_OUTPUT_VERBOSE((1, orte_grpcomm_base_output, "%s grpcomm:pmi: modex entered", ORTE_NAME_PRINT(ORTE_PROC_MY_NAME))); if (NULL == pmi_kvs_name) { if (ORTE_SUCCESS != (rc = setup_pmi())) { ORTE_ERROR_LOG(rc); return rc; } } /* provide our hostname so others can know our location */ if (strlen(orte_process_info.nodename) > (size_t)pmi_vallen_max) { ORTE_ERROR_LOG(ORTE_ERR_VALUE_OUT_OF_BOUNDS); return ORTE_ERR_VALUE_OUT_OF_BOUNDS; } if (ORTE_SUCCESS != (rc = setup_key(ORTE_PROC_MY_NAME, "HOSTNAME"))) { ORTE_ERROR_LOG(rc); return rc; } rc = kvs_put(pmi_kvs_key, orte_process_info.nodename); if (PMI_SUCCESS != rc) { ORTE_PMI_ERROR(rc, "PMI_KVS_Put"); return ORTE_ERROR; } /* add our oob endpoint info so that oob communications * can be supported */ rml_uri = orte_rml.get_contact_info(); if (strlen(rml_uri) > (size_t)pmi_vallen_max) { ORTE_ERROR_LOG(ORTE_ERR_VALUE_OUT_OF_BOUNDS); return ORTE_ERROR; } if (ORTE_SUCCESS != (rc = setup_key(ORTE_PROC_MY_NAME, "RMLURI"))) { ORTE_ERROR_LOG(rc); free(rml_uri); return rc; } /* NTH: some characters are not allowed in pmi2 land so we need to encode */ if (ORTE_SUCCESS != (rc = pmi_encode(rml_uri, strlen(rml_uri)))) { ORTE_ERROR_LOG(rc); free(rml_uri); return rc; } /* encoding puts the encoded value in pmi_attr_val */ rc = kvs_put(pmi_kvs_key, pmi_attr_val); if (PMI_SUCCESS != rc) { ORTE_PMI_ERROR(rc, "PMI_KVS_Put"); free(rml_uri); return ORTE_ERROR; } free(rml_uri); /* get the job map for this job */ jmap = (orte_jmap_t*)opal_pointer_array_get_item(&orte_jobmap, 0); /* get my pidmap entry */ pmap = (orte_pmap_t*)opal_pointer_array_get_item(&jmap->pmap, ORTE_PROC_MY_NAME->vpid); /* add our local/node rank info */ if (ORTE_SUCCESS != (rc = setup_key(ORTE_PROC_MY_NAME, "LOCALRANK"))) { ORTE_ERROR_LOG(rc); return rc; } snprintf(val, 64, "%lu", (unsigned long)pmap->local_rank); rc = kvs_put(pmi_kvs_key, val); if (PMI_SUCCESS != rc) { ORTE_PMI_ERROR(rc, "PMI_KVS_Put"); return ORTE_ERROR; } if (ORTE_SUCCESS != (rc = setup_key(ORTE_PROC_MY_NAME, "NODERANK"))) { ORTE_ERROR_LOG(rc); return rc; } snprintf(val, 64, "%lu", (unsigned long)pmap->node_rank); rc = kvs_put(pmi_kvs_key, val); if (PMI_SUCCESS != rc) { ORTE_PMI_ERROR(rc, "PMI_KVS_Put"); return ORTE_ERROR; } /* commit our modex info */ if (PMI_SUCCESS != (rc = kvs_commit())) { ORTE_PMI_ERROR(rc, "PMI_KVS_Commit failed"); return ORTE_ERROR; } /* harvest the oob endpoint info and hostname for all other procs * in our job so oob wireup can be completed and we * can setup their nidmap/pidmap */ name.jobid = ORTE_PROC_MY_NAME->jobid; orte_process_info.num_nodes = 1; /* have to account for mine! */ for (v=0; v < orte_process_info.num_procs; v++) { if (v == ORTE_PROC_MY_NAME->vpid) { continue; } name.vpid = v; if (ORTE_SUCCESS != (rc = setup_key(&name, "RMLURI"))) { ORTE_ERROR_LOG(rc); return rc; } rc = kvs_get(pmi_kvs_key, pmi_attr_val, pmi_vallen_max); if (PMI_SUCCESS != rc) { ORTE_PMI_ERROR(rc, "PMI_KVS_Get"); return ORTE_ERROR; } /* Had to encode to protect against pmi2-prohibited chars */ rml_uri = pmi_decode(&len); if (NULL == rml_uri) { return ORTE_ERROR; } OPAL_OUTPUT_VERBOSE((2, orte_grpcomm_base_output, "%s grpcomm:pmi: proc %s oob endpoint %s", ORTE_NAME_PRINT(ORTE_PROC_MY_NAME), ORTE_NAME_PRINT(&name), rml_uri)); /* set the contact info into the hash table */ if (ORTE_SUCCESS != (rc = orte_rml.set_contact_info(rml_uri))) { free(rml_uri); return rc; } free(rml_uri); if (ORTE_SUCCESS != (rc = setup_key(&name, "HOSTNAME"))) { ORTE_ERROR_LOG(rc); return rc; } rc = kvs_get(pmi_kvs_key, pmi_attr_val, pmi_vallen_max); if (PMI_SUCCESS != rc) { ORTE_PMI_ERROR(rc, "PMI_KVS_Get"); return ORTE_ERROR; } OPAL_OUTPUT_VERBOSE((2, orte_grpcomm_base_output, "%s grpcomm:pmi: proc %s location %s", ORTE_NAME_PRINT(ORTE_PROC_MY_NAME), ORTE_NAME_PRINT(&name), pmi_attr_val)); /* see if this node is already in nidmap */ loc = NULL; for (i=0; i < orte_nidmap.size; i++) { if (NULL == (nid = (orte_nid_t*)opal_pointer_array_get_item(&orte_nidmap, i))) { continue; } if (0 == strcmp(pmi_attr_val, nid->name)) { /* found it */ loc = nid; break; } } if (NULL == loc) { /* new node - save it */ loc = OBJ_NEW(orte_nid_t); loc->name = strdup(pmi_attr_val); loc->index = opal_pointer_array_add(&orte_nidmap, loc); loc->daemon = loc->index; /* keep track */ orte_process_info.num_nodes++; } /* see if this proc is already in the pidmap */ if (NULL == (pmap = (orte_pmap_t*)opal_pointer_array_get_item(&jmap->pmap, v))) { /* nope - add it */ pmap = OBJ_NEW(orte_pmap_t); pmap->node = loc->index; if (ORTE_SUCCESS != (rc = opal_pointer_array_set_item(&jmap->pmap, v, pmap))) { ORTE_ERROR_LOG(rc); return rc; } } /* get the proc's local/node rank info */ if (ORTE_SUCCESS != (rc = setup_key(&name, "LOCALRANK"))) { ORTE_ERROR_LOG(rc); return rc; } rc = kvs_get(pmi_kvs_key, pmi_attr_val, pmi_vallen_max); if (PMI_SUCCESS != rc) { ORTE_PMI_ERROR(rc, "PMI_KVS_Get"); return ORTE_ERROR; } pmap->local_rank = (orte_local_rank_t)strtoul(pmi_attr_val, NULL, 10); if (ORTE_SUCCESS != (rc = setup_key(&name, "NODERANK"))) { ORTE_ERROR_LOG(rc); return rc; } rc = kvs_get(pmi_kvs_key, pmi_attr_val, pmi_vallen_max); if (PMI_SUCCESS != rc) { ORTE_PMI_ERROR(rc, "PMI_KVS_Get"); return ORTE_ERROR; } pmap->node_rank = (orte_node_rank_t)strtoul(pmi_attr_val, NULL, 10); OPAL_OUTPUT_VERBOSE((2, orte_grpcomm_base_output, "%s grpcomm:pmi: proc %s lrank %u nrank %u", ORTE_NAME_PRINT(ORTE_PROC_MY_NAME), ORTE_NAME_PRINT(&name), (unsigned int)pmap->local_rank, (unsigned int)pmap->node_rank)); } OPAL_OUTPUT_VERBOSE((1, orte_grpcomm_base_output, "%s grpcomm:pmi: modex completed", ORTE_NAME_PRINT(ORTE_PROC_MY_NAME))); return rc; }
static int fetch(const opal_identifier_t *uid, const char *key, void **data, opal_data_type_t type) { opal_byte_object_t *boptr; uint16_t ui16; uint32_t ui32; int ival; unsigned int uival; char *pmikey; char tmp_val[1024]; size_t sval; opal_identifier_t proc; /* to protect alignment, copy the data across */ memcpy(&proc, uid, sizeof(opal_identifier_t)); OPAL_OUTPUT_VERBOSE((5, opal_db_base_framework.framework_output, "db:pmi:fetch: searching for key %s[%s] on proc %" PRIu64 "", (NULL == key) ? "NULL" : key, opal_dss.lookup_data_type(type), proc)); /* if the key is NULL, that is an error */ if (NULL == key) { OPAL_ERROR_LOG(OPAL_ERR_BAD_PARAM); return OPAL_ERR_BAD_PARAM; } /* setup the key */ if (NULL == (pmikey = setup_key(proc, key))) { OPAL_ERROR_LOG(OPAL_ERR_BAD_PARAM); return OPAL_ERR_BAD_PARAM; } /* check to see if they are looking for a string */ if (OPAL_STRING == type) { /* might have been passed in multiple sections */ *data = fetch_string(pmikey); free(pmikey); return OPAL_SUCCESS; } /* otherwise, retrieve the pmi keyval */ if (NULL == (pmikey = setup_key(proc, key))) { OPAL_ERROR_LOG(OPAL_ERR_BAD_PARAM); return OPAL_ERR_BAD_PARAM; } if (PMI_SUCCESS != kvs_get(pmikey, tmp_val, pmi_vallen_max)) { OPAL_ERROR_LOG(OPAL_ERR_NOT_FOUND); free(pmikey); return OPAL_ERR_NOT_FOUND; } free(pmikey); /* return the value according to the provided type */ switch (type) { case OPAL_UINT32: ui32 = (uint32_t)strtoul(tmp_val, NULL, 10); memcpy(*data, &ui32, sizeof(uint32_t)); break; case OPAL_UINT16: ui16 = (uint16_t)strtoul(tmp_val, NULL, 10); memcpy(*data, &ui16, sizeof(uint16_t)); break; case OPAL_INT: ival = (int)strtol(tmp_val, NULL, 10); memcpy(*data, &ival, sizeof(int)); break; case OPAL_UINT: uival = (unsigned int)strtoul(tmp_val, NULL, 10); memcpy(*data, &uival, sizeof(unsigned int)); break; case OPAL_BYTE_OBJECT: sval = 0; boptr = (opal_byte_object_t*)malloc(sizeof(opal_byte_object_t)); boptr->bytes = (uint8_t*)pmi_decode(tmp_val, &sval); boptr->size = sval; *data = boptr; break; default: OPAL_ERROR_LOG(OPAL_ERR_NOT_SUPPORTED); return OPAL_ERR_NOT_SUPPORTED; } return OPAL_SUCCESS; }
static int store(const opal_identifier_t *uid, opal_db_locality_t locality, const char *key, const void *data, opal_data_type_t type) { int i, rc; char *pmidata, *str, *localdata; int64_t i64; uint64_t ui64; opal_byte_object_t *bo; char *pmikey, *tmpkey, *tmp, sav; char **strdata=NULL; opal_identifier_t proc; /* to protect alignment, copy the data across */ memcpy(&proc, uid, sizeof(opal_identifier_t)); /* pass internal stores down to someone else */ if (OPAL_DB_INTERNAL == locality) { return OPAL_ERR_TAKE_NEXT_OPTION; } OPAL_OUTPUT_VERBOSE((5, opal_db_base_framework.framework_output, "db:pmi:store: storing key %s[%s] for proc %" PRIu64 "", key, opal_dss.lookup_data_type(type), proc)); if (NULL == (pmikey = setup_key(proc, key))) { OPAL_ERROR_LOG(OPAL_ERR_BAD_PARAM); return OPAL_ERR_BAD_PARAM; } switch (type) { case OPAL_STRING: #if WANT_PMI2_SUPPORT { /* the blasted Cray PMI implementation marked a number of common * ASCII characters as "illegal", so if we are on one of those * machines, then we have to replace those characters with something * else */ size_t n, k; bool subbed; char *ptr; str = (char*)data; /* first, count how many characters need to be replaced - since Cray * is the source of the trouble, we only make this slow for them! */ ptr = str; i=0; for (n=0; n < strlen(illegal); n++) { while (NULL != (tmp = strchr(ptr, illegal[n]))) { i++; ptr = tmp; ptr++; } } /* stretch the string */ ptr = (char*)malloc(sizeof(char) * (1 + strlen(str) + 2*i)); /* now construct it */ k=0; for (n=0; n < strlen(str); n++) { subbed = false; for (i=0; i < (int)strlen(illegal); i++) { if (str[n] == illegal[i]) { /* escape the character */ ptr[k++] = escape_char; ptr[k++] = sub[i]; subbed = true; break; } } if (!subbed) { ptr[k++] = str[n]; } } /* pass the result */ localdata = ptr; } #else localdata = strdup((char*)data); #endif str = localdata; while (pmi_vallen_max < (int)(OPAL_PMI_PAD + strlen(str))) { /* the string is too long, so we need to break it into * multiple sections */ tmp = str + pmi_vallen_max - OPAL_PMI_PAD; sav = *tmp; *tmp = '\0'; opal_argv_append_nosize(&strdata, str); *tmp = sav; str = tmp; } /* put whatever remains on the stack */ opal_argv_append_nosize(&strdata, str); /* cleanup */ free(localdata); /* the first value we put uses the original key, but * the data is prepended with the number of sections * required to hold the entire string */ asprintf(&pmidata, "%d:%s", opal_argv_count(strdata), strdata[0]); OPAL_OUTPUT_VERBOSE((5, opal_db_base_framework.framework_output, "db:pmi:store: storing key %s data %s", pmikey, pmidata)); if (PMI_SUCCESS != (rc = kvs_put(pmikey, pmidata))) { OPAL_PMI_ERROR(rc, "PMI_KVS_Put"); free(pmidata); free(pmikey); opal_argv_free(strdata); return OPAL_ERROR; } free(pmidata); /* for each remaining segment, augment the key with the index */ for (i=1; NULL != strdata[i]; i++) { asprintf(&tmpkey, "%s:%d", pmikey, i); OPAL_OUTPUT_VERBOSE((5, opal_db_base_framework.framework_output, "db:pmi:store: storing key %s data %s", pmikey, strdata[i])); if (PMI_SUCCESS != (rc = kvs_put(tmpkey, strdata[i]))) { OPAL_PMI_ERROR(rc, "PMI_KVS_Put"); free(pmikey); opal_argv_free(strdata); return OPAL_ERROR; } free(tmpkey); } free(pmikey); opal_argv_free(strdata); return OPAL_SUCCESS; case OPAL_INT: i64 = (int64_t)(*((int*)data)); asprintf(&pmidata, "%ld", (long)i64); break; case OPAL_INT32: i64 = (int64_t)(*((int32_t*)data)); asprintf(&pmidata, "%ld", (long)i64); break; case OPAL_INT64: i64 = (int64_t)(*((int*)data)); asprintf(&pmidata, "%ld", (long)i64); break; case OPAL_UINT64: ui64 = *((uint64_t*)data); asprintf(&pmidata, "%lu", (unsigned long)ui64); break; case OPAL_UINT32: ui64 = (uint64_t)(*((uint32_t*)data)); asprintf(&pmidata, "%lu", (unsigned long)ui64); break; case OPAL_UINT16: ui64 = (uint64_t)(*((uint16_t*)data)); asprintf(&pmidata, "%lu", (unsigned long)ui64); break; case OPAL_BYTE_OBJECT: bo = (opal_byte_object_t*)data; pmidata = (char*)malloc(pmi_vallen_max*sizeof(char)); if (OPAL_SUCCESS != (rc = pmi_encode(pmidata, bo->bytes, bo->size))) { OPAL_ERROR_LOG(rc); free(pmidata); return rc; } break; default: OPAL_ERROR_LOG(OPAL_ERR_NOT_SUPPORTED); return OPAL_ERR_NOT_SUPPORTED; } OPAL_OUTPUT_VERBOSE((10, opal_db_base_framework.framework_output, "PUTTING KEY %s DATA %s", pmikey, pmidata)); rc = kvs_put(pmikey, pmidata); if (PMI_SUCCESS != rc) { OPAL_PMI_ERROR(rc, "PMI_KVS_Put"); return OPAL_ERROR; } free(pmidata); free(pmikey); return OPAL_SUCCESS; }