/** * Delete a (key,value) pair from "info" * * @param info MPI_Info handle on which we need to operate * @param key The key portion of the (key,value) pair that * needs to be deleted * * @retval MPI_SUCCESS If the (key,val) pair was deleted * @retval MPI_ERR_INFO * @retval MPI_ERR_INFO_KEYY */ int MPI_Info_delete(MPI_Info info, const char *key) { int key_length; int err; /** * This function merely deletes the (key,val) pair in info */ if (MPI_PARAM_CHECK) { OMPI_ERR_INIT_FINALIZE(FUNC_NAME); if (NULL == info || MPI_INFO_NULL == info || ompi_info_is_freed(info)) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INFO, FUNC_NAME); } key_length = (key) ? (int)strlen (key) : 0; if ((NULL == key) || (0 == key_length) || (MPI_MAX_INFO_KEY <= key_length)) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INFO_KEY, FUNC_NAME); } } err = ompi_info_delete (info, key); OMPI_ERRHANDLER_RETURN(err, MPI_COMM_WORLD, err, FUNC_NAME); }
int MPI_File_set_info(MPI_File fh, MPI_Info info) { int ret; OPAL_CR_NOOP_PROGRESS(); if (MPI_PARAM_CHECK) { OMPI_ERR_INIT_FINALIZE(FUNC_NAME); if (ompi_file_invalid(fh)) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_FILE, FUNC_NAME); } if (NULL == info || MPI_INFO_NULL == info || ompi_info_is_freed(info)) { return OMPI_ERRHANDLER_INVOKE(fh, MPI_ERR_INFO, FUNC_NAME); } } OPAL_CR_ENTER_LIBRARY(); ret = opal_infosubscribe_change_info(fh, &info->super); OMPI_ERRHANDLER_RETURN(ret, fh, ret, FUNC_NAME); }
int MPI_Publish_name(char *service_name, MPI_Info info, char *port_name) { int rc; if ( MPI_PARAM_CHECK ) { OMPI_ERR_INIT_FINALIZE(FUNC_NAME); if ( NULL == port_name || 0 == strlen(port_name) ) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG, FUNC_NAME); } if ( NULL == service_name || 0 == strlen(service_name) ) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG, FUNC_NAME); } if (NULL == info || ompi_info_is_freed(info)) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INFO, FUNC_NAME); } } /* * No predefined info-objects for this function in MPI-2, * therefore, we do not parse the info-object at the moment. */ rc = ompi_comm_namepublish (service_name, port_name); if ( OMPI_SUCCESS != rc ) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME); } return MPI_SUCCESS; }
/** * MPI_Info_get_valuelen - Get the length of a value for a given key in an 'M * * @param info - info object (handle) * @param key - null-terminated character string of the index key * @param valuelen - length of the value associated with 'key' (integer) * @param flag - true (1) if 'key' defined on 'info', false (0) if not * (logical) * * @retval MPI_SUCCESS * @retval MPI_ERR_ARG * @retval MPI_ERR_INFO * @retval MPI_ERR_INFO_KEY * * The length returned in C and C++ does not include the end-of-string * character. If the 'key' is not found on 'info', 'valuelen' is left * alone. */ int MPI_Info_get_valuelen(MPI_Info info, const char *key, int *valuelen, int *flag) { int key_length; int err; /* * Simple function. All we need to do is search for the value * having the "key" associated with it and return the length */ if (MPI_PARAM_CHECK) { OMPI_ERR_INIT_FINALIZE(FUNC_NAME); if (NULL == info || MPI_INFO_NULL == info || ompi_info_is_freed(info)) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INFO, FUNC_NAME); } key_length = (key) ? (int)strlen (key) : 0; if ((NULL == key) || (0 == key_length) || (MPI_MAX_INFO_KEY <= key_length)) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INFO_KEY, FUNC_NAME); } if (NULL == flag || NULL == valuelen) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG, FUNC_NAME); } } OPAL_CR_ENTER_LIBRARY(); err = ompi_info_get_valuelen (info, key, valuelen, flag); OMPI_ERRHANDLER_RETURN(err, MPI_COMM_WORLD, err, FUNC_NAME); }
int MPI_Open_port(MPI_Info info, char *port_name) { int rc; if ( MPI_PARAM_CHECK ) { OMPI_ERR_INIT_FINALIZE(FUNC_NAME); if ( NULL == port_name ) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG, FUNC_NAME); } if (NULL == info || ompi_info_is_freed(info)) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INFO, FUNC_NAME); } } if ( MPI_INFO_NULL != info ) { /* in theory, they user might tell us here how to establish the address. Since our communication is relying on OOB, we probably won't use the info-object. Potential values defined in MPI-2: - "ip_port" : value contains IP port number - "ip_address" : value contains IP address */ } OPAL_CR_ENTER_LIBRARY(); rc = ompi_dpm_open_port(port_name); OMPI_ERRHANDLER_RETURN(rc, MPI_COMM_WORLD, rc, FUNC_NAME); }
int MPI_Alloc_mem(MPI_Aint size, MPI_Info info, void *baseptr) { if (MPI_PARAM_CHECK) { OMPI_ERR_INIT_FINALIZE(FUNC_NAME); if (size < 0 || NULL == baseptr) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG, FUNC_NAME); } else if (NULL == info || ompi_info_is_freed(info)) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INFO, FUNC_NAME); } } /* Per these threads: http://www.open-mpi.org/community/lists/devel/2007/07/1977.php http://www.open-mpi.org/community/lists/devel/2007/07/1979.php If you call MPI_ALLOC_MEM with a size of 0, you get NULL back .*/ if (0 == size) { *((void **) baseptr) = NULL; return MPI_SUCCESS; } *((void **) baseptr) = mca_mpool_base_alloc((size_t) size, (struct opal_info_t*)info); if (NULL == *((void **) baseptr)) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_NO_MEM, FUNC_NAME); } /* All done */ return MPI_SUCCESS; }
int MPI_File_open(MPI_Comm comm, char *filename, int amode, MPI_Info info, MPI_File *fh) { int rc; if (MPI_PARAM_CHECK) { OMPI_ERR_INIT_FINALIZE(FUNC_NAME); if (NULL == info || ompi_info_is_freed(info)) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INFO, FUNC_NAME); } else if (ompi_comm_invalid(comm)) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_COMM, FUNC_NAME); } if (OMPI_COMM_IS_INTER(comm)) { return OMPI_ERRHANDLER_INVOKE (comm, MPI_ERR_COMM, FUNC_NAME); } } /* Note that MPI-2:9.7 (p265 in the ps; p261 in the pdf) says that errors in MPI_FILE_OPEN (before the file handle is created) should invoke the default error handler on MPI_FILE_NULL. Hence, if we get a file handle out of ompi_file_open(), invoke the error handler on that. If not, invoke the error handler on MPI_FILE_NULL. */ /* The io framework is only initialized lazily. If it hasn't already been initialized, do so now (note that MPI_FILE_OPEN and MPI_FILE_DELETE are the only two places that it will be initialized). */ if (!(mca_io_base_components_opened_valid || mca_io_base_components_available_valid)) { if (OMPI_SUCCESS != (rc = mca_io_base_open())) { return OMPI_ERRHANDLER_INVOKE(MPI_FILE_NULL, rc, FUNC_NAME); } if (OMPI_SUCCESS != (rc = mca_io_base_find_available(OMPI_ENABLE_PROGRESS_THREADS, OMPI_ENABLE_MPI_THREADS))) { return OMPI_ERRHANDLER_INVOKE(MPI_FILE_NULL, rc, FUNC_NAME); } } /* Create an empty MPI_File handle */ *fh = MPI_FILE_NULL; rc = ompi_file_open(comm, filename, amode, info, fh); /* Creating the file handle also selects a component to use, creates a module, and calls file_open() on the module. So we're good to go. */ OMPI_ERRHANDLER_RETURN(rc, *fh, rc, FUNC_NAME); }
MPI_Fint MPI_Info_c2f(MPI_Info info) { OPAL_CR_NOOP_PROGRESS(); if (MPI_PARAM_CHECK) { OMPI_ERR_INIT_FINALIZE(FUNC_NAME); if (NULL == info || ompi_info_is_freed(info)) { return OMPI_INT_2_FINT(-1); } } return OMPI_INT_2_FINT(info->i_f_to_c_index); }
int MPI_File_delete(char *filename, MPI_Info info) { int rc; if (MPI_PARAM_CHECK) { rc = MPI_SUCCESS; OMPI_ERR_INIT_FINALIZE(FUNC_NAME); if (NULL == info || ompi_info_is_freed(info)) { rc = MPI_ERR_INFO; } else if (NULL == filename) { rc = MPI_ERR_ARG; } OMPI_ERRHANDLER_CHECK(rc, MPI_FILE_NULL, rc, FUNC_NAME); } /* Note that MPI-2:9.7 (p265 in the ps; 261 in the pdf) says that errors in MPI_FILE_OPEN (before the file handle is created) should invoke the default error handler on MPI_FILE_NULL. Hence, if we get a file handle out of ompi_file_open(), invoke the error handler on that. If not, invoke the error handler on MPI_FILE_NULL. */ /* The io framework is only initialized lazily. If it hasn't already been initialized, do so now (note that MPI_FILE_OPEN and MPI_FILE_DELETE are the only two places that it will be initialized). */ if (!(mca_io_base_components_opened_valid || mca_io_base_components_available_valid)) { if (OMPI_SUCCESS != (rc = mca_io_base_open())) { return OMPI_ERRHANDLER_INVOKE(MPI_FILE_NULL, rc, FUNC_NAME); } if (OMPI_SUCCESS != (rc = mca_io_base_find_available(OPAL_ENABLE_PROGRESS_THREADS, OMPI_ENABLE_THREAD_MULTIPLE))) { return OMPI_ERRHANDLER_INVOKE(MPI_FILE_NULL, rc, FUNC_NAME); } } OPAL_CR_ENTER_LIBRARY(); /* Since there is no MPI_File handle associated with this function, the MCA has to do a selection and perform the action */ rc = mca_io_base_delete(filename, info); OMPI_ERRHANDLER_RETURN(rc, MPI_FILE_NULL, rc, FUNC_NAME); }
/** * MPI_Info_set - Set a (key, value) pair in an 'MPI_Info' object * * @param key null-terminated character string of the index key * @param value null-terminated character string of the value * @param info info object (handle) * * @retval MPI_SUCCESS * @retval MPI_ERR_ARG * @retval MPI_ERR_INFO_KEY * @retval MPI_ERR_INFO_VAL * @retval MPI_ERR_INFO_NOKEY * @retval MPI_ERR_NO_MEM * * MPI_Info_set adds the (key,value) pair to info, and overrides * the value if for the same key a previsou value was set. key and * value must be NULL terminated strings in C. In Fortan, leading * and trailing spaces in key and value are stripped. If either * key or value is greater than the allowed maxima, MPI_ERR_INFO_KEY * and MPI_ERR_INFO_VALUE are raised */ int MPI_Info_set(MPI_Info info, const char *key, const char *value) { int err; int key_length; int value_length; /* * Error conditions are * - info is NULL * - No storage space available for the new value * - Key length exceeded MPI_MAX_KEY_VAL * - value length exceeded MPI_MAX_KEY_VAL */ if (MPI_PARAM_CHECK) { OMPI_ERR_INIT_FINALIZE(FUNC_NAME); if (NULL == info || MPI_INFO_NULL == info || ompi_info_is_freed(info)) { return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_INFO, FUNC_NAME); } key_length = (key) ? (int)strlen (key) : 0; if ((NULL == key) || (0 == key_length) || (MPI_MAX_INFO_KEY <= key_length)) { return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_INFO_KEY, FUNC_NAME); } value_length = (value) ? (int)strlen (value) : 0; if ((NULL == value) || (0 == value_length) || (MPI_MAX_INFO_VAL <= value_length)) { return OMPI_ERRHANDLER_INVOKE (MPI_COMM_WORLD, MPI_ERR_INFO_VALUE, FUNC_NAME); } } OPAL_CR_ENTER_LIBRARY(); /* * If all is right with the arguments, then call the back-end * allocator. */ err = ompi_info_set (info, key, value); OMPI_ERRHANDLER_RETURN(err, MPI_COMM_WORLD, err, FUNC_NAME); }
int MPI_Comm_set_info(MPI_Comm comm, MPI_Info info) { if (MPI_PARAM_CHECK) { OMPI_ERR_INIT_FINALIZE(FUNC_NAME); if (NULL == info || MPI_INFO_NULL == info || ompi_info_is_freed(info)) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INFO, FUNC_NAME); } if (ompi_comm_invalid(comm)) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_COMM, FUNC_NAME); } } /* At the moment, we do not support any communicator hints. So... do nothing */ return MPI_SUCCESS; }
int MPI_Lookup_name(const char *service_name, MPI_Info info, char *port_name) { char *tmp; if ( MPI_PARAM_CHECK ) { OMPI_ERR_INIT_FINALIZE(FUNC_NAME); if ( NULL == port_name ) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG, FUNC_NAME); } if ( NULL == service_name ) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG, FUNC_NAME); } if (NULL == info || ompi_info_is_freed(info)) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INFO, FUNC_NAME); } } OPAL_CR_ENTER_LIBRARY(); /* * No predefined info-objects for this function in MPI-2, * therefore, we do not parse the info-object at the moment. */ /* * if multiple entries found, this implementation uses * at the moment the first entry. */ tmp = (char *) ompi_pubsub.lookup(service_name, info); if ( NULL == tmp ) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_NAME, FUNC_NAME); } strncpy ( port_name, tmp, MPI_MAX_PORT_NAME ); OPAL_CR_EXIT_LIBRARY(); return MPI_SUCCESS; }
int MPI_Win_set_info(MPI_Win win, MPI_Info info) { int ret; if (MPI_PARAM_CHECK) { OMPI_ERR_INIT_FINALIZE(FUNC_NAME); if (ompi_win_invalid(win)) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_WIN, FUNC_NAME); } if (NULL == info || MPI_INFO_NULL == info || ompi_info_is_freed(info)) { return OMPI_ERRHANDLER_INVOKE(win, MPI_ERR_INFO, FUNC_NAME); } } ret = win->w_osc_module->osc_set_info(win, info); OMPI_ERRHANDLER_RETURN(ret, win, ret, FUNC_NAME); }
int MPI_Win_create(void *base, MPI_Aint size, int disp_unit, MPI_Info info, MPI_Comm comm, MPI_Win *win) { int ret = MPI_SUCCESS; /* argument checking */ if (MPI_PARAM_CHECK) { OMPI_ERR_INIT_FINALIZE(FUNC_NAME); if (ompi_comm_invalid (comm)) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_COMM, FUNC_NAME); } else if (NULL == info || ompi_info_is_freed(info)) { return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_INFO, FUNC_NAME); } else if (NULL == win) { return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_WIN, FUNC_NAME); } else if ( size < 0 ) { return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_SIZE, FUNC_NAME); } else if ( disp_unit <= 0 ) { return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_DISP, FUNC_NAME); } } /* communicator must be an intracommunicator */ if (OMPI_COMM_IS_INTER(comm)) { return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_COMM, FUNC_NAME); } /* create window and return */ ret = ompi_win_create(base, (size_t)size, disp_unit, comm, info, win); if (OMPI_SUCCESS != ret) { *win = MPI_WIN_NULL; return OMPI_ERRHANDLER_INVOKE(comm, MPI_ERR_WIN, FUNC_NAME); } return MPI_SUCCESS; }
int MPI_File_delete(const char *filename, MPI_Info info) { int rc; if (MPI_PARAM_CHECK) { rc = MPI_SUCCESS; OMPI_ERR_INIT_FINALIZE(FUNC_NAME); if (NULL == info || ompi_info_is_freed(info)) { rc = MPI_ERR_INFO; } else if (NULL == filename) { rc = MPI_ERR_ARG; } OMPI_ERRHANDLER_CHECK(rc, MPI_FILE_NULL, rc, FUNC_NAME); } /* Note that MPI-2:9.7 (p265 in the ps; 261 in the pdf) says that errors in MPI_FILE_OPEN (before the file handle is created) should invoke the default error handler on MPI_FILE_NULL. Hence, if we get a file handle out of ompi_file_open(), invoke the error handler on that. If not, invoke the error handler on MPI_FILE_NULL. */ /* The io framework is only initialized lazily. If it hasn't already been initialized, do so now (note that MPI_FILE_OPEN and MPI_FILE_DELETE are the only two places that it will be initialized). We might want to add a check to see if the framework is open instead of just incrementing the open count. */ if (OMPI_SUCCESS != (rc = mca_base_framework_open(&ompi_io_base_framework, 0))) { return OMPI_ERRHANDLER_INVOKE(MPI_FILE_NULL, rc, FUNC_NAME); } OPAL_CR_ENTER_LIBRARY(); /* Since there is no MPI_File handle associated with this function, the MCA has to do a selection and perform the action */ rc = mca_io_base_delete(filename, info); OMPI_ERRHANDLER_RETURN(rc, MPI_FILE_NULL, rc, FUNC_NAME); }
int MPI_Unpublish_name(const char *service_name, MPI_Info info, const char *port_name) { int rc; char range[OPAL_MAX_INFO_VAL]; int flag=0; opal_list_t pinfo; opal_value_t *rng; char **keys = NULL; if ( MPI_PARAM_CHECK ) { OMPI_ERR_INIT_FINALIZE(FUNC_NAME); if ( NULL == port_name ) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG, FUNC_NAME); } if ( NULL == service_name ) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG, FUNC_NAME); } if (NULL == info || ompi_info_is_freed(info)) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INFO, FUNC_NAME); } } OPAL_CR_ENTER_LIBRARY(); OBJ_CONSTRUCT(&pinfo, opal_list_t); /* OMPI supports info keys to pass the range to * be searched for the given key */ if (MPI_INFO_NULL != info) { ompi_info_get (info, "range", sizeof(range) - 1, range, &flag); if (flag) { if (0 == strcmp(range, "nspace")) { rng = OBJ_NEW(opal_value_t); rng->key = strdup(OPAL_PMIX_RANGE); rng->type = OPAL_INT; rng->data.integer = OPAL_PMIX_NAMESPACE; // share only with procs in same nspace opal_list_append(&pinfo, &rng->super); } else if (0 == strcmp(range, "session")) { rng = OBJ_NEW(opal_value_t); rng->key = strdup(OPAL_PMIX_RANGE); rng->type = OPAL_INT; rng->data.integer = OPAL_PMIX_SESSION; // share only with procs in same session opal_list_append(&pinfo, &rng->super); } else { /* unrecognized scope */ OPAL_LIST_DESTRUCT(&pinfo); return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG, FUNC_NAME); } } } /* unpublish the service_name */ opal_argv_append_nosize(&keys, service_name); rc = opal_pmix.unpublish(keys, &pinfo); opal_argv_free(keys); OPAL_LIST_DESTRUCT(&pinfo); if ( OPAL_SUCCESS != rc ) { if (OPAL_ERR_NOT_FOUND == rc) { /* service couldn't be found */ OPAL_CR_EXIT_LIBRARY(); return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_SERVICE, FUNC_NAME); } if (OPAL_ERR_PERM == rc) { /* this process didn't own the specified service */ OPAL_CR_EXIT_LIBRARY(); return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ACCESS, FUNC_NAME); } /* none of the MPI-specific errors occurred - must be some * kind of internal error */ OPAL_CR_EXIT_LIBRARY(); return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME); } OPAL_CR_EXIT_LIBRARY(); return MPI_SUCCESS; }
int MPI_Lookup_name(const char *service_name, MPI_Info info, char *port_name) { char range[OPAL_MAX_INFO_VAL]; int flag=0, ret; opal_value_t *rng; opal_list_t results, pinfo; opal_pmix_pdata_t *pdat; if ( MPI_PARAM_CHECK ) { OMPI_ERR_INIT_FINALIZE(FUNC_NAME); if ( NULL == port_name ) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG, FUNC_NAME); } if ( NULL == service_name ) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG, FUNC_NAME); } if (NULL == info || ompi_info_is_freed(info)) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_INFO, FUNC_NAME); } } OPAL_CR_ENTER_LIBRARY(); OBJ_CONSTRUCT(&pinfo, opal_list_t); /* OMPI supports info keys to pass the range to * be searched for the given key */ if (MPI_INFO_NULL != info) { ompi_info_get (info, "range", sizeof(range) - 1, range, &flag); if (flag) { if (0 == strcmp(range, "nspace")) { rng = OBJ_NEW(opal_value_t); rng->key = strdup(OPAL_PMIX_RANGE); rng->type = OPAL_INT; rng->data.integer = OPAL_PMIX_NAMESPACE; // share only with procs in same nspace opal_list_append(&pinfo, &rng->super); } else if (0 == strcmp(range, "session")) { rng = OBJ_NEW(opal_value_t); rng->key = strdup(OPAL_PMIX_RANGE); rng->type = OPAL_INT; rng->data.integer = OPAL_PMIX_SESSION; // share only with procs in same session opal_list_append(&pinfo, &rng->super); } else { /* unrecognized scope */ OPAL_LIST_DESTRUCT(&pinfo); return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG, FUNC_NAME); } } } /* collect the findings */ OBJ_CONSTRUCT(&results, opal_list_t); pdat = OBJ_NEW(opal_pmix_pdata_t); pdat->value.key = strdup(service_name); opal_list_append(&results, &pdat->super); ret = opal_pmix.lookup(&results, &pinfo); OPAL_LIST_DESTRUCT(&pinfo); if (OPAL_SUCCESS != ret || OPAL_STRING != pdat->value.type || NULL == pdat->value.data.string) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_NAME, FUNC_NAME); } strncpy ( port_name, pdat->value.data.string, MPI_MAX_PORT_NAME ); OPAL_LIST_DESTRUCT(&results); OPAL_CR_EXIT_LIBRARY(); return MPI_SUCCESS; }