int MPI_File_close(MPI_File *fh) { int rc; if (MPI_PARAM_CHECK) { OMPI_ERR_INIT_FINALIZE(FUNC_NAME); /* Note that MPI-2:9.7 (p265) says that errors in MPI_FILE_CLOSE should invoke the default error handler on MPI_FILE_NULL */ if (NULL == fh || ompi_file_invalid(*fh)) { return OMPI_ERRHANDLER_INVOKE(MPI_FILE_NULL, MPI_ERR_FILE, FUNC_NAME); } } OPAL_CR_ENTER_LIBRARY(); /* Release the MPI_File; the destructor releases the component, zeroes out fiels, etc. */ rc = ompi_file_close(fh); OMPI_ERRHANDLER_RETURN(rc, *fh, rc, FUNC_NAME); }
int MPI_Win_get_info(MPI_Win win, MPI_Info *info_used) { int ret; OPAL_CR_NOOP_PROGRESS(); 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_used) { return OMPI_ERRHANDLER_INVOKE(win, MPI_ERR_ARG, FUNC_NAME); } } if (NULL == win->super.s_info) { /* * Setup any defaults if MPI_Win_set_info was never called */ opal_infosubscribe_change_info(win, &MPI_INFO_NULL->super); } (*info_used) = OBJ_NEW(ompi_info_t); if (NULL == (*info_used)) { return OMPI_ERRHANDLER_INVOKE(win, MPI_ERR_NO_MEM, FUNC_NAME); } ret = opal_info_dup(&win->super.s_info, &(*info_used)->super); OMPI_ERRHANDLER_RETURN(ret, win, ret, FUNC_NAME); }
int MPI_Comm_set_name(MPI_Comm comm, char *name) { int rc; 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); } if ( NULL == name ) { return OMPI_ERRHANDLER_INVOKE ( comm, MPI_ERR_ARG, FUNC_NAME); } } rc = ompi_comm_set_name (comm, name ); /* -- Tracing information for new communicator name -- */ #if 0 /* Force TotalView DLL to take note of this name setting */ ++ompi_tv_comm_sequence_number; #endif #if OMPI_PROFILING_DEFINES #include "ompi/mpi/c/profile/defines.h" #endif OMPI_ERRHANDLER_RETURN(rc, comm, rc, FUNC_NAME); }
int MPI_Win_get_name(MPI_Win win, char *win_name, int *resultlen) { 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); } else if (NULL == win_name || NULL == resultlen) { return OMPI_ERRHANDLER_INVOKE(win, MPI_ERR_ARG, FUNC_NAME); } } OPAL_CR_ENTER_LIBRARY(); /* Note that MPI-2.1 requires: - terminating the string with a \0 - name[*resultlen] == '\0' - and therefore (*resultlen) cannot be > (MPI_MAX_OBJECT_NAME-1) The Fortran API version will pad to the right if necessary. Note that win->name is guaranteed to be \0-terminated and able to completely fit into MPI_MAX_OBJECT_NAME bytes (i.e., name+\0). ompi_win_get_name() does the Right things. */ ret = ompi_win_get_name(win, win_name, resultlen); OMPI_ERRHANDLER_RETURN(ret, win, ret, FUNC_NAME); }
int MPI_Keyval_create(MPI_Copy_function *copy_attr_fn, MPI_Delete_function *delete_attr_fn, int *keyval, void *extra_state) { int ret; ompi_attribute_fn_ptr_union_t copy_fn; ompi_attribute_fn_ptr_union_t del_fn; if (MPI_PARAM_CHECK) { OMPI_ERR_INIT_FINALIZE(FUNC_NAME); if (NULL == keyval) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_KEYVAL, FUNC_NAME); } else if ((NULL == copy_attr_fn) || (NULL == delete_attr_fn)) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG, FUNC_NAME); } } OPAL_CR_ENTER_LIBRARY(); copy_fn.attr_communicator_copy_fn = (MPI_Comm_internal_copy_attr_function*)copy_attr_fn; del_fn.attr_communicator_delete_fn = delete_attr_fn; ret = ompi_attr_create_keyval(COMM_ATTR, copy_fn, del_fn, keyval, extra_state, 0, NULL); OMPI_ERRHANDLER_RETURN(ret, MPI_COMM_WORLD, MPI_ERR_OTHER, FUNC_NAME); }
int MPI_Group_translate_ranks(MPI_Group group1, int n_ranks, int *ranks1, MPI_Group group2, int *ranks2) { int err; /* check for errors */ if( MPI_PARAM_CHECK ) { OMPI_ERR_INIT_FINALIZE(FUNC_NAME); if ((MPI_GROUP_NULL == group1) || (MPI_GROUP_NULL == group2) || (NULL == group1) || (NULL == group2)) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_GROUP, FUNC_NAME); } if (n_ranks < 0) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_GROUP, FUNC_NAME); } if (n_ranks > 0 && ((NULL == ranks1) || (NULL == ranks2 ))) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_GROUP, FUNC_NAME); } } if (0 == n_ranks) { return MPI_SUCCESS; } OPAL_CR_ENTER_LIBRARY(); err = ompi_group_translate_ranks ( group1, n_ranks, ranks1, group2, ranks2 ); OMPI_ERRHANDLER_RETURN(err, MPI_COMM_WORLD, err, FUNC_NAME ); }
int MPI_Comm_create_errhandler(MPI_Comm_errhandler_function *function, MPI_Errhandler *errhandler) { int err = MPI_SUCCESS; /* Error checking */ if (MPI_PARAM_CHECK) { OMPI_ERR_INIT_FINALIZE(FUNC_NAME); if (NULL == function || NULL == errhandler) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG, FUNC_NAME); } } OPAL_CR_ENTER_LIBRARY(); /* Create and cache the errhandler. Sets a refcount of 1. */ *errhandler = ompi_errhandler_create(OMPI_ERRHANDLER_TYPE_COMM, (ompi_errhandler_generic_handler_fn_t*) function, OMPI_ERRHANDLER_LANG_C); if (NULL == *errhandler) { err = MPI_ERR_INTERN; } OMPI_ERRHANDLER_RETURN(err, MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME); }
int MPI_Type_create_keyval(MPI_Type_copy_attr_function *type_copy_attr_fn, MPI_Type_delete_attr_function *type_delete_attr_fn, int *type_keyval, void *extra_state) { int ret; ompi_attribute_fn_ptr_union_t copy_fn; ompi_attribute_fn_ptr_union_t del_fn; if (MPI_PARAM_CHECK) { OMPI_ERR_INIT_FINALIZE(FUNC_NAME); if ((NULL == type_copy_attr_fn) || (NULL == type_delete_attr_fn) || (NULL == type_keyval)) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG, FUNC_NAME); } } OPAL_CR_ENTER_LIBRARY(); copy_fn.attr_datatype_copy_fn = (MPI_Type_internal_copy_attr_function*)type_copy_attr_fn; del_fn.attr_datatype_delete_fn = type_delete_attr_fn; ret = ompi_attr_create_keyval(TYPE_ATTR, copy_fn, del_fn, type_keyval, extra_state, 0, NULL); OMPI_ERRHANDLER_RETURN(ret, MPI_COMM_WORLD, ret, FUNC_NAME); }
int MPI_File_set_info(MPI_File fh, MPI_Info info) { int rc; if (MPI_PARAM_CHECK) { rc = MPI_SUCCESS; OMPI_ERR_INIT_FINALIZE(FUNC_NAME); if (ompi_file_invalid(fh)) { fh = MPI_FILE_NULL; rc = MPI_ERR_FILE; } OMPI_ERRHANDLER_CHECK(rc, fh, rc, FUNC_NAME); } /* Call the back-end io component function */ switch (fh->f_io_version) { case MCA_IO_BASE_V_2_0_0: rc = fh->f_io_selected_module.v2_0_0. io_module_file_set_info(fh, info); break; default: rc = MPI_ERR_INTERN; break; } /* All done */ OMPI_ERRHANDLER_RETURN(rc, fh, rc, FUNC_NAME); }
/** * 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_Compare_and_swap(const void *origin_addr, const void *compare_addr, void *result_addr, MPI_Datatype datatype, int target_rank, MPI_Aint target_disp, MPI_Win win) { int rc; if (MPI_PARAM_CHECK) { rc = OMPI_SUCCESS; OMPI_ERR_INIT_FINALIZE(FUNC_NAME); if (ompi_win_invalid(win)) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_WIN, FUNC_NAME); } else if (ompi_win_peer_invalid(win, target_rank) && (MPI_PROC_NULL != target_rank)) { rc = MPI_ERR_RANK; } else if ( MPI_WIN_FLAVOR_DYNAMIC != win->w_flavor && target_disp < 0 ) { rc = MPI_ERR_DISP; } else { OMPI_CHECK_DATATYPE_FOR_ONE_SIDED(rc, datatype, 1); } OMPI_ERRHANDLER_CHECK(rc, win, rc, FUNC_NAME); } if (MPI_PROC_NULL == target_rank) return MPI_SUCCESS; OPAL_CR_ENTER_LIBRARY(); rc = win->w_osc_module->osc_compare_and_swap(origin_addr, compare_addr, result_addr, datatype, target_rank, target_disp, win); OMPI_ERRHANDLER_RETURN(rc, win, rc, 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_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); }
/** * 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_File_get_atomicity(MPI_File fh, int *flag) { int rc; if (MPI_PARAM_CHECK) { rc = MPI_SUCCESS; OMPI_ERR_INIT_FINALIZE(FUNC_NAME); if (ompi_file_invalid(fh)) { rc = MPI_ERR_FILE; fh = MPI_FILE_NULL; } else if (NULL == flag) { rc = MPI_ERR_ARG; } OMPI_ERRHANDLER_CHECK(rc, fh, rc, FUNC_NAME); } OPAL_CR_ENTER_LIBRARY(); /* Call the back-end io component function */ switch (fh->f_io_version) { case MCA_IO_BASE_V_2_0_0: rc = fh->f_io_selected_module.v2_0_0. io_module_file_get_atomicity(fh, flag); break; default: rc = MPI_ERR_INTERN; break; } /* All done */ OMPI_ERRHANDLER_RETURN(rc, fh, rc, FUNC_NAME); }
int MPI_File_read_ordered_end(MPI_File fh, void *buf, MPI_Status *status) { int rc; if (MPI_PARAM_CHECK) { rc = MPI_SUCCESS; OMPI_ERR_INIT_FINALIZE(FUNC_NAME); if (ompi_file_invalid(fh)) { fh = MPI_FILE_NULL; rc = MPI_ERR_FILE; } OMPI_ERRHANDLER_CHECK(rc, fh, rc, FUNC_NAME); } OPAL_CR_ENTER_LIBRARY(); /* Call the back-end io component function */ switch (fh->f_io_version) { case MCA_IO_BASE_V_2_0_0: rc = fh->f_io_selected_module.v2_0_0. io_module_file_read_ordered_end(fh, buf, status); break; default: rc = MPI_ERR_INTERN; break; } /* All done */ OMPI_ERRHANDLER_RETURN(rc, fh, rc, FUNC_NAME); }
int MPI_File_get_byte_offset(MPI_File fh, MPI_Offset offset, MPI_Offset *disp) { int rc; if (MPI_PARAM_CHECK) { rc = MPI_SUCCESS; OMPI_ERR_INIT_FINALIZE(FUNC_NAME); if (ompi_file_invalid(fh)) { rc = MPI_ERR_FILE; fh = MPI_FILE_NULL; } else if (NULL == disp) { rc = MPI_ERR_ARG; } OMPI_ERRHANDLER_CHECK(rc, fh, rc, FUNC_NAME); } /* Call the back-end io component function */ switch (fh->f_io_version) { case MCA_IO_BASE_V_2_0_0: rc = fh->f_io_selected_module.v2_0_0. io_module_file_get_byte_offset(fh, offset, disp); break; default: rc = MPI_ERR_INTERN; break; } /* All done */ OMPI_ERRHANDLER_RETURN(rc, fh, rc, FUNC_NAME); }
int MPI_Win_lock(int lock_type, int rank, int assert, MPI_Win win) { int rc; 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); } else if (lock_type != MPI_LOCK_EXCLUSIVE && lock_type != MPI_LOCK_SHARED) { return OMPI_ERRHANDLER_INVOKE(win, MPI_ERR_LOCKTYPE, FUNC_NAME); } else if (ompi_win_peer_invalid(win, rank)) { return OMPI_ERRHANDLER_INVOKE(win, MPI_ERR_RANK, FUNC_NAME); } else if (0 != (assert & ~(MPI_MODE_NOCHECK))) { return OMPI_ERRHANDLER_INVOKE(win, MPI_ERR_ASSERT, FUNC_NAME); } else if (! ompi_win_allow_locks(win)) { return OMPI_ERRHANDLER_INVOKE(win, MPI_ERR_RMA_SYNC, FUNC_NAME); } } /* NTH: do not bother keeping track of locking MPI_PROC_NULL. */ if (MPI_PROC_NULL == rank) return MPI_SUCCESS; rc = win->w_osc_module->osc_lock(lock_type, rank, assert, win); OMPI_ERRHANDLER_RETURN(rc, win, rc, FUNC_NAME); }
int MPI_Rsend(void *buf, int count, MPI_Datatype type, int dest, int tag, MPI_Comm comm) { int rc = MPI_SUCCESS; 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 (count < 0) { rc = MPI_ERR_COUNT; } else if (type == MPI_DATATYPE_NULL) { rc = MPI_ERR_TYPE; } else if (tag < 0 || tag > mca_pml.pml_max_tag) { rc = MPI_ERR_TAG; } else if (ompi_comm_peer_invalid(comm, dest) && (MPI_PROC_NULL != dest)) { rc = MPI_ERR_RANK; } else { OMPI_CHECK_DATATYPE_FOR_SEND(rc, type, count); OMPI_CHECK_USER_BUFFER(rc, buf, type, count); } OMPI_ERRHANDLER_CHECK(rc, comm, rc, FUNC_NAME); } if (MPI_PROC_NULL == dest) { return MPI_SUCCESS; } rc = MCA_PML_CALL(send(buf, count, type, dest, tag, MCA_PML_BASE_SEND_READY, comm)); OMPI_ERRHANDLER_RETURN(rc, comm, rc, FUNC_NAME); }
int MPI_Type_contiguous(int count, MPI_Datatype oldtype, MPI_Datatype *newtype) { int rc; if( MPI_PARAM_CHECK ) { OMPI_ERR_INIT_FINALIZE(FUNC_NAME); if (MPI_DATATYPE_NULL == oldtype || NULL == newtype || NULL == newtype) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_TYPE, FUNC_NAME); } else if( count < 0 ) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_COUNT, FUNC_NAME); } } rc = ompi_ddt_create_contiguous( count, oldtype, newtype ); OMPI_ERRHANDLER_CHECK(rc, MPI_COMM_WORLD, rc, FUNC_NAME ); /* data description */ { int* a_i[1]; a_i[0] = &count; ompi_ddt_set_args( *newtype, 1, a_i, 0, NULL, 1, &oldtype, MPI_COMBINER_CONTIGUOUS ); } OMPI_ERRHANDLER_RETURN(rc, MPI_COMM_WORLD, rc, FUNC_NAME ); }
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); }
int OMPI_CR_self_register_continue_callback(OMPI_CR_self_continue_fn function) { int rc; if ( MPI_PARAM_CHECK ) { OMPI_ERR_INIT_FINALIZE(FUNC_NAME); } OPAL_CR_ENTER_LIBRARY(); rc = opal_crs_base_self_register_continue_callback(function); OMPI_ERRHANDLER_RETURN(rc, MPI_COMM_WORLD, rc, FUNC_NAME); }
int MPI_Keyval_free(int *keyval) { int ret; /* Check for valid key pointer */ if (MPI_PARAM_CHECK) { if (NULL == keyval) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_KEYVAL, FUNC_NAME); } } ret = ompi_attr_free_keyval(COMM_ATTR, keyval, 0); OMPI_ERRHANDLER_RETURN(ret, MPI_COMM_WORLD, MPI_ERR_OTHER, FUNC_NAME); }
int MPI_Type_vector(int count, int blocklength, int stride, MPI_Datatype oldtype, MPI_Datatype *newtype) { int rc; if( MPI_PARAM_CHECK ) { OMPI_ERR_INIT_FINALIZE(FUNC_NAME); if (NULL == oldtype || MPI_DATATYPE_NULL == oldtype || NULL == newtype) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_TYPE, FUNC_NAME ); } else if( count < 0 ) { OMPI_ERRHANDLER_RETURN( MPI_ERR_COUNT, MPI_COMM_WORLD, MPI_ERR_COUNT, FUNC_NAME ); } else if( blocklength < 0) { OMPI_ERRHANDLER_RETURN( MPI_ERR_ARG, MPI_COMM_WORLD, MPI_ERR_ARG, FUNC_NAME ); } } rc = ompi_ddt_create_vector ( count, blocklength, stride, oldtype, newtype ); OMPI_ERRHANDLER_CHECK(rc, MPI_COMM_WORLD, rc, FUNC_NAME ); { int* a_i[3]; a_i[0] = &count; a_i[1] = &blocklength; a_i[2] = &stride; ompi_ddt_set_args( *newtype, 3, a_i, 0, NULL, 1, &oldtype, MPI_COMBINER_VECTOR ); } return MPI_SUCCESS; }
int MPI_Win_complete(MPI_Win win) { int rc; 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); } } rc = win->w_osc_module->osc_complete(win); OMPI_ERRHANDLER_RETURN(rc, win, rc, FUNC_NAME); }
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); }
int OMPI_CR_INC_register_callback(OMPI_CR_INC_callback_event_t event, OMPI_CR_INC_callback_function function, OMPI_CR_INC_callback_function *prev_function) { int rc; if ( MPI_PARAM_CHECK ) { OMPI_ERR_INIT_FINALIZE(FUNC_NAME); } OPAL_CR_ENTER_LIBRARY(); rc = opal_cr_user_inc_register_callback(event, function, prev_function); OMPI_ERRHANDLER_RETURN(rc, MPI_COMM_WORLD, rc, FUNC_NAME); }
int MPI_Grequest_complete(MPI_Request request) { int rc = MPI_SUCCESS; if (MPI_PARAM_CHECK) { OMPI_ERR_INIT_FINALIZE(FUNC_NAME); if (request == MPI_REQUEST_NULL) { rc = MPI_ERR_REQUEST; } else if (OMPI_REQUEST_GEN != request->req_type) { rc = MPI_ERR_REQUEST; } OMPI_ERRHANDLER_CHECK(rc, MPI_COMM_WORLD, rc, FUNC_NAME); } rc = ompi_grequest_complete(request); OMPI_ERRHANDLER_RETURN(rc, MPI_COMM_WORLD, MPI_ERR_INTERN, FUNC_NAME); }
int MPI_Win_set_attr(MPI_Win win, int win_keyval, void *attribute_val) { 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); } } ret = ompi_attr_set_c(WIN_ATTR, win, &win->w_keyhash, win_keyval, attribute_val, false, true); OMPI_ERRHANDLER_RETURN(ret, win, MPI_ERR_OTHER, FUNC_NAME); }
int MPI_Register_datarep(char *datarep, MPI_Datarep_conversion_function *read_conversion_fn, MPI_Datarep_conversion_function *write_conversion_fn, MPI_Datarep_extent_function *dtype_file_extent_fn, void *extra_state) { int rc; if (MPI_PARAM_CHECK) { rc = MPI_SUCCESS; OMPI_ERR_INIT_FINALIZE(FUNC_NAME); if (NULL == datarep) { rc = MPI_ERR_ARG; } OMPI_ERRHANDLER_CHECK(rc, MPI_FILE_NULL, rc, FUNC_NAME); } /* 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); } } OPAL_CR_ENTER_LIBRARY(); /* Call the back-end io component function */ rc = mca_io_base_register_datarep(datarep, read_conversion_fn, write_conversion_fn, dtype_file_extent_fn, extra_state); /* All done */ OMPI_ERRHANDLER_RETURN(rc, MPI_FILE_NULL, rc, FUNC_NAME); }