/* * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana * University Research and Technology * Corporation. All rights reserved. * Copyright (c) 2004-2008 The University of Tennessee and The University * of Tennessee Research Foundation. All rights * reserved. * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart, * University of Stuttgart. All rights reserved. * Copyright (c) 2004-2005 The Regents of the University of California. * All rights reserved. * $COPYRIGHT$ * * Additional copyrights may follow * * $HEADER$ */ #include "orte_config.h" #include "orte/constants.h" #include #include "opal/util/output.h" #include "opal/util/argv.h" #include "orte/mca/errmgr/errmgr.h" #include "orte/util/name_fns.h" #include "orte/runtime/orte_globals.h" #include "orte/mca/ras/base/ras_private.h" static void orte_ras_base_proc_construct(orte_ras_proc_t* proc) { proc->node_name = NULL; proc->cpu_list = NULL; proc->rank = ORTE_VPID_MAX; } static void orte_ras_base_proc_destruct(orte_ras_proc_t* proc) { if (NULL != proc->node_name) { free(proc->node_name); } if (NULL != proc->cpu_list) { free(proc->cpu_list); } } OBJ_CLASS_INSTANCE( orte_ras_proc_t, opal_list_item_t, orte_ras_base_proc_construct, orte_ras_base_proc_destruct); /* * Add the specified node definitions to the global data store * NOTE: this removes all items from the list! */ int orte_ras_base_node_insert(opal_list_t* nodes, orte_job_t *jdata) { opal_list_item_t* item; orte_std_cntr_t num_nodes; int rc; orte_node_t *node, *hnp_node; /* get the number of nodes */ num_nodes = (orte_std_cntr_t)opal_list_get_size(nodes); if (0 == num_nodes) { return ORTE_SUCCESS; /* nothing to do */ } OPAL_OUTPUT_VERBOSE((5, orte_ras_base.ras_output, "%s ras:base:node_insert inserting %ld nodes", ORTE_NAME_PRINT(ORTE_PROC_MY_NAME), (long)num_nodes)); /* set the size of the global array - this helps minimize time * spent doing realloc's */ if (ORTE_SUCCESS != (rc = opal_pointer_array_set_size(orte_node_pool, num_nodes))) { ORTE_ERROR_LOG(rc); return rc; } /* get the hnp node's info */ hnp_node = (orte_node_t*)(orte_node_pool->addr[0]); /* cycle through the list */ while (NULL != (item = opal_list_remove_first(nodes))) { node = (orte_node_t*)item; /* the HNP had to already enter its node on the array - that entry is in the * first position since it is the first one entered. We need to check to see * if this node is the same as the HNP's node so we don't double-enter it */ if (0 == strcmp(node->name, hnp_node->name)) { OPAL_OUTPUT_VERBOSE((5, orte_ras_base.ras_output, "%s ras:base:node_insert updating HNP info to %ld slots", ORTE_NAME_PRINT(ORTE_PROC_MY_NAME), (long)node->slots)); /* adjust the total slots in the job */ jdata->total_slots_alloc -= hnp_node->slots; /* copy the allocation data to that node's info */ hnp_node->slots = node->slots; hnp_node->slots_alloc = node->slots_alloc; hnp_node->slots_max = node->slots_max; hnp_node->launch_id = node->launch_id; /* set the node to available for use */ hnp_node->allocate = true; /* update the total slots in the job */ jdata->total_slots_alloc += hnp_node->slots; /* don't keep duplicate copy */ OBJ_RELEASE(node); } else { /* insert the object onto the orte_nodes global array */ OPAL_OUTPUT_VERBOSE((5, orte_ras_base.ras_output, "%s ras:base:node_insert node %s", ORTE_NAME_PRINT(ORTE_PROC_MY_NAME), (NULL == node->name) ? "NULL" : node->name)); /* set node to available for use */ node->allocate = true; node->index = opal_pointer_array_add(orte_node_pool, (void*)node); if (ORTE_SUCCESS > (rc = node->index)) { ORTE_ERROR_LOG(rc); return rc; } /* update the total slots in the job */ jdata->total_slots_alloc += node->slots; } } return ORTE_SUCCESS; } /* SAVE DEFUNCT CODE IN CASE WE NEED TO REVIVE IT LATER */ #if 0 int orte_ras_base_proc_insert(opal_list_t* procs, orte_jobid_t jobid) { opal_list_item_t* item; orte_gpr_value_t **values; orte_process_name_t proc_name; int rc; orte_std_cntr_t num_values, i, j; char *keys[] = { ORTE_NODE_NAME_KEY, ORTE_PROC_RANK_KEY, ORTE_PROC_CPU_LIST_KEY, }; opal_data_type_t types[] = { OPAL_STRING, ORTE_STD_CNTR, OPAL_STRING, }; orte_ras_proc_t* proc; num_values = (orte_std_cntr_t)opal_list_get_size(procs); if (0 >= num_values) { ORTE_ERROR_LOG(ORTE_ERR_BAD_PARAM); return ORTE_ERR_BAD_PARAM; } values = (orte_gpr_value_t**)malloc(num_values * sizeof(orte_gpr_value_t*)); if (NULL == values) { ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE); return ORTE_ERR_OUT_OF_RESOURCE; } /** preallocate the appropriate number of containers on the segment */ rc = orte_gpr.preallocate_segment(ORTE_PROC_SEGMENT, num_values); if(ORTE_SUCCESS != rc) { ORTE_ERROR_LOG(rc); return rc; } for (i=0; i < num_values; i++) { if (ORTE_SUCCESS != (rc = orte_gpr.create_value(&(values[i]), ORTE_GPR_OVERWRITE | ORTE_GPR_TOKENS_AND, ORTE_PROC_SEGMENT, 3, 0))) { ORTE_ERROR_LOG(rc); for (j=0; j < i; j++) { OBJ_RELEASE(values[j]); } free(values); return rc; } } proc_name.jobid = jobid; for(i=0, item = opal_list_get_first(procs); i < num_values && item != opal_list_get_end(procs); i++, item = opal_list_get_next(item)) { proc = (orte_ras_proc_t*)item; j = 0; if (ORTE_SUCCESS != (rc = orte_gpr.create_keyval(&(values[i]->keyvals[j]), keys[j], types[j], proc->node_name))) { ORTE_ERROR_LOG(rc); goto cleanup; } ++j; if (ORTE_SUCCESS != (rc = orte_gpr.create_keyval(&(values[i]->keyvals[j]), keys[j], types[j], &(proc->rank)))) { ORTE_ERROR_LOG(rc); goto cleanup; } ++j; if (ORTE_SUCCESS != (rc = orte_gpr.create_keyval(&(values[i]->keyvals[j]), keys[j], types[j], proc->cpu_list))) { ORTE_ERROR_LOG(rc); goto cleanup; } ++j; /* setup index/keys for this node */ proc_name.vpid = (orte_vpid_t)i; rc = orte_schema.get_proc_tokens(&(values[i]->tokens), &(values[i]->num_tokens), &proc_name); if (ORTE_SUCCESS != rc) { ORTE_ERROR_LOG(rc); goto cleanup; } } /* try the insert */ if (ORTE_SUCCESS != (rc = orte_gpr.put(num_values, values))) { ORTE_ERROR_LOG(rc); } cleanup: for (j=0; j < num_values; j++) { OBJ_RELEASE(values[j]); } if (NULL != values) free(values); return rc; } int orte_ras_base_proc_query_alloc(opal_list_t* procs) { char* keys[] = { ORTE_NODE_NAME_KEY, ORTE_PROC_RANK_KEY, ORTE_PROC_CPU_LIST_KEY, NULL }; orte_std_cntr_t i, cnt; orte_gpr_value_t** values; orte_std_cntr_t *sptr; int rc; /* query selected node entries */ rc = orte_gpr.get( ORTE_GPR_KEYS_OR|ORTE_GPR_TOKENS_OR, ORTE_PROC_SEGMENT, NULL, keys, &cnt, &values); if(ORTE_SUCCESS != rc) { ORTE_ERROR_LOG(rc); return rc; } /* parse the response */ for(i=0; icnt; k++) { orte_gpr_keyval_t* keyval = value->keyvals[k]; if(strcmp(keyval->key, ORTE_NODE_NAME_KEY) == 0) { /* we use the dss.copy function here instead of strdup because that function * automatically protects us against a NULL (or zero-length) string */ if (ORTE_SUCCESS != (rc = opal_dss.copy((void**)&(proc->node_name), keyval->value->data, OPAL_STRING))) { ORTE_ERROR_LOG(rc); continue; } continue; } if(strcmp(keyval->key, ORTE_PROC_CPU_LIST_KEY) == 0) { /* we use the dss.copy function here instead of strdup because that function * automatically protects us against a NULL (or zero-length) string */ if (ORTE_SUCCESS != (rc = opal_dss.copy((void**)&(proc->cpu_list), keyval->value->data, OPAL_STRING))) { ORTE_ERROR_LOG(rc); continue; } continue; } if(strcmp(keyval->key, ORTE_PROC_RANK_KEY) == 0) { if (ORTE_SUCCESS != (rc = opal_dss.get((void**)&sptr, keyval->value, ORTE_STD_CNTR))) { ORTE_ERROR_LOG(rc); continue; } proc->rank = *sptr; continue; } } opal_list_append(procs, &proc->super); OBJ_RELEASE(value); } if (NULL != values) free(values); return ORTE_SUCCESS; } /* * Query the registry for all available nodes */ int orte_ras_base_node_query(opal_list_t* nodes) { char* keys[] = { ORTE_NODE_NAME_KEY, ORTE_NODE_LAUNCH_ID_KEY, ORTE_NODE_ARCH_KEY, ORTE_NODE_STATE_KEY, ORTE_NODE_SLOTS_KEY, ORTE_NODE_SLOTS_IN_USE_KEY, ORTE_NODE_SLOTS_ALLOC_KEY, ORTE_NODE_SLOTS_MAX_KEY, ORTE_NODE_USERNAME_KEY, NULL }; orte_std_cntr_t i, cnt, *sptr; orte_node_state_t *nsptr; int32_t *i32; orte_gpr_value_t** values; int rc; /* query all node entries */ rc = orte_gpr.get( ORTE_GPR_KEYS_OR|ORTE_GPR_TOKENS_OR, ORTE_NODE_SEGMENT, NULL, keys, &cnt, &values); if(ORTE_SUCCESS != rc) { ORTE_ERROR_LOG(rc); return rc; } /* parse the response */ for(i=0; icnt; k++) { orte_gpr_keyval_t* keyval = value->keyvals[k]; if(strcmp(keyval->key, ORTE_NODE_NAME_KEY) == 0) { /* we use the dss.copy function here instead of strdup because that function * automatically protects us against a NULL (or zero-length) string */ if (ORTE_SUCCESS != (rc = opal_dss.copy((void**)&(node->node_name), keyval->value->data, OPAL_STRING))) { ORTE_ERROR_LOG(rc); continue; } continue; } if(strcmp(keyval->key, ORTE_NODE_LAUNCH_ID_KEY) == 0) { if (ORTE_SUCCESS != (rc = opal_dss.get((void**)&i32, keyval->value, OPAL_INT32))) { ORTE_ERROR_LOG(rc); continue; } node->launch_id = *i32; continue; } if(strcmp(keyval->key, ORTE_NODE_ARCH_KEY) == 0) { /* we use the dss.copy function here instead of strdup because that function * automatically protects us against a NULL (or zero-length) string */ if (ORTE_SUCCESS != (rc = opal_dss.copy((void**)&(node->node_arch), keyval->value->data, OPAL_STRING))) { ORTE_ERROR_LOG(rc); continue; } continue; } if(strcmp(keyval->key, ORTE_NODE_STATE_KEY) == 0) { if (ORTE_SUCCESS != (rc = opal_dss.get((void**)&nsptr, keyval->value, ORTE_NODE_STATE))) { ORTE_ERROR_LOG(rc); continue; } node->node_state = *nsptr; continue; } if(strcmp(keyval->key, ORTE_NODE_SLOTS_KEY) == 0) { if (ORTE_SUCCESS != (rc = opal_dss.get((void**)&sptr, keyval->value, ORTE_STD_CNTR))) { ORTE_ERROR_LOG(rc); continue; } node->node_slots = *sptr; continue; } if(strcmp(keyval->key, ORTE_NODE_SLOTS_IN_USE_KEY) == 0) { if (ORTE_SUCCESS != (rc = opal_dss.get((void**)&sptr, keyval->value, ORTE_STD_CNTR))) { ORTE_ERROR_LOG(rc); continue; } node->node_slots_inuse = *sptr; continue; } if(strncmp(keyval->key, ORTE_NODE_SLOTS_ALLOC_KEY, strlen(ORTE_NODE_SLOTS_ALLOC_KEY)) == 0) { if (ORTE_SUCCESS != (rc = opal_dss.get((void**)&sptr, keyval->value, ORTE_STD_CNTR))) { ORTE_ERROR_LOG(rc); continue; } node->node_slots_alloc += *sptr; continue; } if(strcmp(keyval->key, ORTE_NODE_SLOTS_MAX_KEY) == 0) { if (ORTE_SUCCESS != (rc = opal_dss.get((void**)&sptr, keyval->value, ORTE_STD_CNTR))) { ORTE_ERROR_LOG(rc); continue; } node->node_slots_max = *sptr; continue; } if(strcmp(keyval->key, ORTE_NODE_USERNAME_KEY) == 0) { /* we use the dss.copy function here instead of strdup because that function * automatically protects us against a NULL (or zero-length) string */ if (ORTE_SUCCESS != (rc = opal_dss.copy((void**)&(node->node_username), keyval->value->data, OPAL_STRING))) { ORTE_ERROR_LOG(rc); continue; } continue; } } opal_list_append(nodes, &node->super); OBJ_RELEASE(value); } if (NULL != values) free(values); return ORTE_SUCCESS; } int orte_ras_base_node_segment_empty(bool *empty) { int ret; opal_list_t nodes; opal_list_item_t *item; /* See what's already on the node segment */ OBJ_CONSTRUCT(&nodes, opal_list_t); if (ORTE_SUCCESS != (ret = orte_ras_base_node_query(&nodes))) { ORTE_ERROR_LOG(ret); OBJ_DESTRUCT(&nodes); return ret; } *empty = opal_list_is_empty(&nodes); /* Free the list */ while (NULL != (item = opal_list_remove_first(&nodes))) { OBJ_RELEASE(item); } OBJ_DESTRUCT(&nodes); /* All done */ return ORTE_SUCCESS; } /* * Assign the allocated slots on the specified nodes to the * indicated jobid. */ int orte_ras_base_node_assign(opal_list_t* nodes, orte_jobid_t jobid) { opal_list_item_t* item; orte_gpr_value_t **values; int rc; orte_std_cntr_t num_values, i, j, total_slots; orte_ras_node_t* node; char* jobid_str, *key=NULL; num_values = (orte_std_cntr_t)opal_list_get_size(nodes); if (0 >= num_values) { ORTE_ERROR_LOG(ORTE_ERR_BAD_PARAM); return ORTE_ERR_BAD_PARAM; } values = (orte_gpr_value_t**)malloc(num_values * sizeof(orte_gpr_value_t*)); if (NULL == values) { ORTE_ERROR_LOG(ORTE_ERR_OUT_OF_RESOURCE); return ORTE_ERR_OUT_OF_RESOURCE; } for (i=0; i < num_values; i++) { if (ORTE_SUCCESS != (rc = orte_gpr.create_value(&(values[i]), ORTE_GPR_OVERWRITE | ORTE_GPR_TOKENS_AND, ORTE_NODE_SEGMENT, 1, 0))) { ORTE_ERROR_LOG(rc); for (j=0; j < i; j++) { OBJ_RELEASE(values[j]); } if (NULL != values) free(values); return rc; } } /* setup the allocation key */ if (ORTE_SUCCESS != (rc = orte_ns.convert_jobid_to_string(&jobid_str, jobid))) { ORTE_ERROR_LOG(rc); goto cleanup; } asprintf(&key, "%s-%s", ORTE_NODE_SLOTS_ALLOC_KEY, jobid_str); free(jobid_str); /* initialize the total slots */ total_slots = 0; for(i=0, item = opal_list_get_first(nodes); i < num_values && item != opal_list_get_end(nodes); i++, item = opal_list_get_next(item)) { node = (orte_ras_node_t*)item; if(node->node_slots_alloc == 0) continue; /* setup index/keys for this node */ rc = orte_schema.get_node_tokens(&(values[i]->tokens), &(values[i]->num_tokens), node->node_name); if (ORTE_SUCCESS != rc) { ORTE_ERROR_LOG(rc); free(jobid_str); goto cleanup; } /* setup node key/value pairs */ if (ORTE_SUCCESS != (rc = orte_gpr.create_keyval(&(values[i]->keyvals[0]), key, ORTE_STD_CNTR, &(node->node_slots_alloc)))) { ORTE_ERROR_LOG(rc); free(key); goto cleanup; } /* add the slots to our total */ total_slots += node->node_slots; } /* do the insert */ if (ORTE_SUCCESS != (rc = orte_gpr.put(num_values, values))) { ORTE_ERROR_LOG(rc); goto cleanup; } /* store the total number of slots */ if (ORTE_SUCCESS != (rc = orte_rmgr.set_universe_size(jobid, total_slots))) { ORTE_ERROR_LOG(rc); } cleanup: for (j=0; j < num_values; j++) { OBJ_RELEASE(values[j]); } if (NULL != values) free(values); if (NULL != key) free(key); return rc; } /* * Query the registry for all nodes allocated to a specified job */ int orte_ras_base_node_query_alloc(opal_list_t* nodes, orte_jobid_t jobid) { char* keys[] = { ORTE_NODE_NAME_KEY, ORTE_NODE_LAUNCH_ID_KEY, ORTE_NODE_ARCH_KEY, ORTE_NODE_STATE_KEY, ORTE_NODE_SLOTS_KEY, ORTE_NODE_SLOTS_IN_USE_KEY, ORTE_NODE_SLOTS_ALLOC_KEY, ORTE_NODE_SLOTS_MAX_KEY, ORTE_NODE_USERNAME_KEY, NULL }; orte_std_cntr_t i, cnt, keys_len; orte_gpr_value_t** values; char* jobid_str; orte_std_cntr_t *sptr; orte_node_state_t *nsptr; int32_t *i32; int rc, alloc_key_posn=5; if(ORTE_SUCCESS != (rc = orte_ns.convert_jobid_to_string(&jobid_str, jobid))) { ORTE_ERROR_LOG(rc); return rc; } asprintf(&keys[alloc_key_posn], "%s-%s", ORTE_NODE_SLOTS_ALLOC_KEY, jobid_str); keys_len = (orte_std_cntr_t)strlen(keys[alloc_key_posn]); free(jobid_str); /* query selected node entries */ rc = orte_gpr.get( ORTE_GPR_KEYS_OR|ORTE_GPR_TOKENS_OR, ORTE_NODE_SEGMENT, NULL, keys, &cnt, &values); if(ORTE_SUCCESS != rc) { ORTE_ERROR_LOG(rc); return rc; } /* parse the response */ for(i=0; icnt; k++) { orte_gpr_keyval_t* keyval = value->keyvals[k]; if(0 == strcmp(keyval->key, keys[alloc_key_posn])) { found = true; break; } } if (!found) continue; node = OBJ_NEW(orte_ras_node_t); for(k=0; k < value->cnt; k++) { orte_gpr_keyval_t* keyval = value->keyvals[k]; if(strcmp(keyval->key, ORTE_NODE_NAME_KEY) == 0) { /* we use the dss.copy function here instead of strdup because that function * automatically protects us against a NULL (or zero-length) string */ if (ORTE_SUCCESS != (rc = opal_dss.copy((void**)&(node->node_name), keyval->value->data, OPAL_STRING))) { ORTE_ERROR_LOG(rc); continue; } continue; } if(strcmp(keyval->key, ORTE_NODE_LAUNCH_ID_KEY) == 0) { if (ORTE_SUCCESS != (rc = opal_dss.get((void**)&i32, keyval->value, OPAL_INT32))) { ORTE_ERROR_LOG(rc); continue; } node->launch_id = *i32; continue; } if(strcmp(keyval->key, ORTE_NODE_ARCH_KEY) == 0) { /* we use the dss.copy function here instead of strdup because that function * automatically protects us against a NULL (or zero-length) string */ if (ORTE_SUCCESS != (rc = opal_dss.copy((void**)&(node->node_arch), keyval->value->data, OPAL_STRING))) { ORTE_ERROR_LOG(rc); continue; } continue; } if(strcmp(keyval->key, ORTE_NODE_STATE_KEY) == 0) { if (ORTE_SUCCESS != (rc = opal_dss.get((void**)&nsptr, keyval->value, ORTE_NODE_STATE))) { ORTE_ERROR_LOG(rc); continue; } node->node_state = *nsptr; continue; } if(strcmp(keyval->key, ORTE_NODE_SLOTS_KEY) == 0) { if (ORTE_SUCCESS != (rc = opal_dss.get((void**)&sptr, keyval->value, ORTE_STD_CNTR))) { ORTE_ERROR_LOG(rc); continue; } node->node_slots = *sptr; continue; } if(strcmp(keyval->key, ORTE_NODE_SLOTS_IN_USE_KEY) == 0) { if (ORTE_SUCCESS != (rc = opal_dss.get((void**)&sptr, keyval->value, ORTE_STD_CNTR))) { ORTE_ERROR_LOG(rc); continue; } node->node_slots_inuse = *sptr; continue; } if(strncmp(keyval->key, keys[alloc_key_posn], keys_len) == 0) { if (ORTE_SUCCESS != (rc = opal_dss.get((void**)&sptr, keyval->value, ORTE_STD_CNTR))) { ORTE_ERROR_LOG(rc); continue; } node->node_slots_alloc += *sptr; continue; } if(strcmp(keyval->key, ORTE_NODE_SLOTS_MAX_KEY) == 0) { if (ORTE_SUCCESS != (rc = opal_dss.get((void**)&sptr, keyval->value, ORTE_STD_CNTR))) { ORTE_ERROR_LOG(rc); continue; } node->node_slots_max = *sptr; continue; } if(strcmp(keyval->key, ORTE_NODE_USERNAME_KEY) == 0) { /* we use the dss.copy function here instead of strdup because that function * automatically protects us against a NULL (or zero-length) string */ if (ORTE_SUCCESS != (rc = opal_dss.copy((void**)&(node->node_username), keyval->value->data, OPAL_STRING))) { ORTE_ERROR_LOG(rc); continue; } continue; } } /* check to see if any slots were reserved on this node for us * The "get" command will return data from ALL nodes on the node * segment. We ONLY want to include here nodes that are assigned * to the specified job - i.e., nodes that have a node_slots_alloc_key * for this jobid. If that is the case, then the node_slots_alloc will be * set to a value greater than 0 */ if (0 < node->node_slots_alloc) { opal_list_append(nodes, &node->super); } else { /* no slots were allocated to us on this node */ OBJ_RELEASE(node); } OBJ_RELEASE(value); } free (keys[alloc_key_posn]); if (NULL != values) free(values); return ORTE_SUCCESS; } /* * Query the registry for a specific node */ orte_ras_node_t* orte_ras_base_node_lookup(const char* node_name) { char* keys[] = { ORTE_NODE_NAME_KEY, ORTE_NODE_LAUNCH_ID_KEY, ORTE_NODE_ARCH_KEY, ORTE_NODE_STATE_KEY, ORTE_NODE_SLOTS_KEY, ORTE_NODE_SLOTS_IN_USE_KEY, ORTE_NODE_SLOTS_ALLOC_KEY, ORTE_NODE_SLOTS_MAX_KEY, ORTE_NODE_USERNAME_KEY, NULL }; orte_ras_node_t* node = NULL; orte_std_cntr_t i, cnt, num_tokens; orte_std_cntr_t *sptr; orte_node_state_t *nsptr; int32_t *i32; orte_gpr_value_t** values; char** tokens = NULL; int rc; rc = orte_schema.get_node_tokens(&tokens, &num_tokens, (char*)node_name); if(ORTE_SUCCESS != rc) { ORTE_ERROR_LOG(rc); return NULL; } /* query specific entry */ rc = orte_gpr.get( ORTE_GPR_KEYS_OR|ORTE_GPR_TOKENS_OR, ORTE_NODE_SEGMENT, tokens, keys, &cnt, &values); if(ORTE_SUCCESS != rc) { ORTE_ERROR_LOG(rc); return NULL; } /* parse the response */ for(i=0; icnt; k++) { orte_gpr_keyval_t* keyval = value->keyvals[k]; if(strcmp(keyval->key, ORTE_NODE_NAME_KEY) == 0) { /* we use the dss.copy function here instead of strdup because that function * automatically protects us against a NULL (or zero-length) string */ if (ORTE_SUCCESS != (rc = opal_dss.copy((void**)&(node->node_name), keyval->value->data, OPAL_STRING))) { ORTE_ERROR_LOG(rc); continue; } continue; } if(strcmp(keyval->key, ORTE_NODE_LAUNCH_ID_KEY) == 0) { if (ORTE_SUCCESS != (rc = opal_dss.get((void**)&i32, keyval->value, OPAL_INT32))) { ORTE_ERROR_LOG(rc); continue; } node->launch_id = *i32; continue; } if(strcmp(keyval->key, ORTE_NODE_ARCH_KEY) == 0) { /* we use the dss.copy function here instead of strdup because that function * automatically protects us against a NULL (or zero-length) string */ if (ORTE_SUCCESS != (rc = opal_dss.copy((void**)&(node->node_arch), keyval->value->data, OPAL_STRING))) { ORTE_ERROR_LOG(rc); continue; } continue; } if(strcmp(keyval->key, ORTE_NODE_STATE_KEY) == 0) { if (ORTE_SUCCESS != (rc = opal_dss.get((void**)&nsptr, keyval->value, ORTE_NODE_STATE))) { ORTE_ERROR_LOG(rc); continue; } node->node_state = *nsptr; continue; } if(strcmp(keyval->key, ORTE_NODE_SLOTS_KEY) == 0) { if (ORTE_SUCCESS != (rc = opal_dss.get((void**)&sptr, keyval->value, ORTE_STD_CNTR))) { ORTE_ERROR_LOG(rc); continue; } node->node_slots = *sptr; continue; } if(strcmp(keyval->key, ORTE_NODE_SLOTS_IN_USE_KEY) == 0) { if (ORTE_SUCCESS != (rc = opal_dss.get((void**)&sptr, keyval->value, ORTE_STD_CNTR))) { ORTE_ERROR_LOG(rc); continue; } node->node_slots_inuse = *sptr; continue; } if(strncmp(keyval->key, ORTE_NODE_SLOTS_ALLOC_KEY, strlen(ORTE_NODE_SLOTS_ALLOC_KEY)) == 0) { if (ORTE_SUCCESS != (rc = opal_dss.get((void**)&sptr, keyval->value, ORTE_STD_CNTR))) { ORTE_ERROR_LOG(rc); continue; } node->node_slots_alloc += *sptr; continue; } if(strcmp(keyval->key, ORTE_NODE_SLOTS_MAX_KEY) == 0) { if (ORTE_SUCCESS != (rc = opal_dss.get((void**)&sptr, keyval->value, ORTE_STD_CNTR))) { ORTE_ERROR_LOG(rc); continue; } node->node_slots_max = *sptr; continue; } if(strcmp(keyval->key, ORTE_NODE_USERNAME_KEY) == 0) { /* we use the dss.copy function here instead of strdup because that function * automatically protects us against a NULL (or zero-length) string */ if (ORTE_SUCCESS != (rc = opal_dss.copy((void**)&(node->node_username), keyval->value->data, OPAL_STRING))) { ORTE_ERROR_LOG(rc); continue; } continue; } } OBJ_RELEASE(values[i]); break; } for(i=1; i= num_values) { ORTE_ERROR_LOG(ORTE_ERR_BAD_PARAM); return ORTE_ERR_BAD_PARAM; } for(item = opal_list_get_first(nodes); item != opal_list_get_end(nodes); item = opal_list_get_next(item)) { node = (orte_ras_node_t*)item; /* setup index/keys for this node */ rc = orte_schema.get_node_tokens(&tokens, &num_tokens, node->node_name); if (ORTE_SUCCESS != rc) { ORTE_ERROR_LOG(rc); return rc; } rc = orte_gpr.delete_entries( ORTE_GPR_TOKENS_AND, ORTE_NODE_SEGMENT, tokens, NULL); if(ORTE_SUCCESS != rc) { ORTE_ERROR_LOG(rc); return rc; } for (i=0; i < num_tokens; i++) { free(tokens[i]); tokens[i] = NULL; } if (NULL != tokens) free(tokens); } return ORTE_SUCCESS; } #endif