int mca_pml_base_bsend_request_alloc(ompi_request_t* request) { mca_pml_base_send_request_t* sendreq = (mca_pml_base_send_request_t*)request; assert( sendreq->req_bytes_packed > 0 ); /* has a buffer been provided */ OPAL_THREAD_LOCK(&mca_pml_bsend_mutex); if(NULL == mca_pml_bsend_addr) { sendreq->req_addr = NULL; OPAL_THREAD_UNLOCK(&mca_pml_bsend_mutex); return OMPI_ERR_BUFFER; } /* allocate a buffer to hold packed message */ sendreq->req_addr = mca_pml_bsend_allocator->alc_alloc( mca_pml_bsend_allocator, sendreq->req_bytes_packed, 0, NULL); if(NULL == sendreq->req_addr) { /* release resources when request is freed */ sendreq->req_base.req_pml_complete = true; OPAL_THREAD_UNLOCK(&mca_pml_bsend_mutex); /* progress communications, with the hope that more resources * will be freed */ opal_progress(); return OMPI_ERR_BUFFER; } /* increment count of pending requests */ mca_pml_bsend_count++; OPAL_THREAD_UNLOCK(&mca_pml_bsend_mutex); return OMPI_SUCCESS; }
static inline int mca_spml_ikrit_get_shm(void *src_addr, size_t size, void *dst_addr, int src) { int ptl_id; void *rva; ptl_id = get_ptl_id(src); /** * Get the address to the remote rkey. **/ if (ptl_id != MXM_PTL_SHM) return OSHMEM_ERROR; if (NULL != mca_spml_ikrit_get_mkey(src, src_addr, MXM_PTL_SHM, &rva)) return OSHMEM_ERROR; SPML_VERBOSE_FASTPATH(100, "shm get: pe:%d src=%p -> dst: %p sz=%d. src_rva=%p", src, src_addr, dst_addr, (int)size, (void *)rva); memcpy(dst_addr, (void *) (unsigned long) rva, size); opal_progress(); return OSHMEM_SUCCESS; }
/* gvm * A collective operation calls this routine to release the payload buffer. * All processes in the shared memory sub-group of a bcol should call the non-blocking * barrier on the last payload buffer of a memory bank. On the completion * of the non-blocking barrier, the ML callback is called which is responsible * for recycling the memory bank. */ mca_bcol_basesmuma_module_t *sm_bcol_module int bcol_basesmuma_free_payload_buff( struct mca_bcol_base_memory_block_desc_t *block, sm_buffer_mgmt *ctl_mgmt, uint64_t buff_id) { /* local variables */ int ret = OMPI_SUCCESS; memory_bank = BANK_FROM_BUFFER_IDX(buff_id); ctl_mgmt->ctl_buffs_mgmt[memory_bank].n_buffs_freed++; OPAL_THREAD_ADD32(&(ctl_mgmt->ctl_buffs_mgmt[memory_bank].n_buffs_freed),1); if (ctl_mgmt->ctl_buffs_mgmt[memory_bank].n_buffs_freed == block->size_buffers_bank){ /* start non-blocking barrier */ bcol_basesmuma_rd_nb_barrier_init_admin( &(ctl_mgmt->ctl_buffs_mgmt[memory_bank].nb_barrier_desc)); if (NB_BARRIER_DONE != ctl_mgmt->ctl_buffs_mgmt[memory_bank]. nb_barrier_desc.collective_phase){ /* progress the barrier */ opal_progress(); } else{ /* free the buffer - i.e. initiate callback to ml level */ block->ml_release_cb(block,memory_bank); } } return ret; }
void* mca_pml_base_bsend_request_alloc_buf( size_t length ) { void* buf = NULL; /* has a buffer been provided */ OPAL_THREAD_LOCK(&mca_pml_bsend_mutex); if(NULL == mca_pml_bsend_addr) { OPAL_THREAD_UNLOCK(&mca_pml_bsend_mutex); return NULL; } /* allocate a buffer to hold packed message */ buf = mca_pml_bsend_allocator->alc_alloc( mca_pml_bsend_allocator, length, 0, NULL); if(NULL == buf) { /* release resources when request is freed */ OPAL_THREAD_UNLOCK(&mca_pml_bsend_mutex); /* progress communications, with the hope that more resources * will be freed */ opal_progress(); return NULL; } /* increment count of pending requests */ mca_pml_bsend_count++; OPAL_THREAD_UNLOCK(&mca_pml_bsend_mutex); return buf; }
/* * With support for nonblocking collectives, we don't have an upper * limit on the number of outstanding collectives per communicator. * Also, since we want to avoid communication to figure out which * buffers other ranks in the group will use, we will rely on the * fact that collective operations are called in the same order * in each process, to assign a unique ID to each collective operation. * We use this to create a static mapping from the index to the buffer * that will be used. Also, because there is no limit to the number of * outstanding collective operations, we use a generation index for each * memory bank, so the collective will use the buffer only when the * correct generation of the bank is ready for use. */ int bcol_basesmuma_get_buff_index( sm_buffer_mgmt *buff_block, uint64_t buff_id ) { /* local variables */ int memory_bank; uint64_t generation; int index=-1; /* get the bank index that will be used */ memory_bank=buff_id& buff_block->mask; memory_bank = memory_bank SHIFT_DOWN buff_block->log2_num_buffs_per_mem_bank; /* get the generation of the bank this maps to */ generation = buff_id SHIFT_DOWN (buff_block->log2_number_of_buffs); /* check to see if the bank is available */ if( generation == buff_block->ctl_buffs_mgmt[memory_bank]. bank_gen_counter ) { /* get the buffer index that will be returned */ index=buff_id & buff_block->mask; /* no in-use counter increment, as the mapping is static, and * all we need to know if the number of collectives that complete */ } else { /* progress communications so that resources can be freed up */ opal_progress(); } /* return */ return index; }
int orte_sstore_central_local_register(orte_sstore_base_handle_t handle) { int ret, exit_status = ORTE_SUCCESS; orte_sstore_central_local_snapshot_info_t *handle_info = NULL; OPAL_OUTPUT_VERBOSE((10, mca_sstore_central_component.super.output_handle, "sstore:central:(local): register()")); /* * Create a handle */ if( NULL == (handle_info = find_handle_info(handle)) ) { handle_info = create_new_handle_info(handle); } /* * Get basic information from Global SStore */ if( ORTE_SUCCESS != (ret = pull_handle_info(handle_info)) ) { ORTE_ERROR_LOG(ret); exit_status = ret; goto cleanup; } /* * Wait here until the pull request has been satisfied */ while(SSTORE_LOCAL_READY != handle_info->status && SSTORE_LOCAL_ERROR != handle_info->status ) { opal_progress(); } cleanup: return exit_status; }
static int wait_all_apps_updated(orte_sstore_central_local_snapshot_info_t *handle_info) { orte_sstore_central_local_app_snapshot_info_t *app_info = NULL; opal_list_item_t *item = NULL; bool is_done = true; do { is_done = true; for(item = opal_list_get_first(handle_info->app_info_handle); item != opal_list_get_end(handle_info->app_info_handle); item = opal_list_get_next(item) ) { app_info = (orte_sstore_central_local_app_snapshot_info_t*)item; if( NULL == app_info->crs_comp && !app_info->ckpt_skipped ) { is_done = false; break; } } if( !is_done ) { OPAL_OUTPUT_VERBOSE((10, mca_sstore_central_component.super.output_handle, "sstore:central:(local): Waiting for appliccation %s", ORTE_NAME_PRINT(&(app_info->name)) )); opal_progress(); } } while(!is_done); return ORTE_SUCCESS; }
int mca_spml_ikrit_fence(void) { mxm_peer_t *peer; opal_list_item_t *item; SPML_VERBOSE(20, "Into fence with %d active puts on %d pes", mca_spml_ikrit.n_active_puts, (int)opal_list_get_size(&mca_spml_ikrit.active_peers)); /* puts(unless are send sync) are completed by remote side lazily. That is either when remote decides to * ack window which can take hundreds of ms. So speed things up by doing fence */ while (NULL != (item = opal_list_remove_first(&mca_spml_ikrit.active_peers))) { peer = spml_ikrit_container_of(item, mxm_peer_t, link); peer->n_active_puts = 0; peer->need_fence = 0; mca_spml_ikrit_mxm_fence(peer - mca_spml_ikrit.mxm_peers); } while (0 < mca_spml_ikrit.n_mxm_fences || 0 < mca_spml_ikrit.n_active_gets) { opal_progress(); } SPML_VERBOSE(20, "fence completed"); return OSHMEM_SUCCESS; }
int mca_pml_ob1_iprobe(int src, int tag, struct ompi_communicator_t *comm, int *matched, ompi_status_public_t * status) { int rc = OMPI_SUCCESS; mca_pml_ob1_recv_request_t recvreq; OBJ_CONSTRUCT( &recvreq, mca_pml_ob1_recv_request_t ); recvreq.req_recv.req_base.req_ompi.req_type = OMPI_REQUEST_PML; recvreq.req_recv.req_base.req_type = MCA_PML_REQUEST_IPROBE; MCA_PML_OB1_RECV_REQUEST_INIT(&recvreq, NULL, 0, &ompi_mpi_char.dt, src, tag, comm, true); MCA_PML_OB1_RECV_REQUEST_START(&recvreq); if( recvreq.req_recv.req_base.req_ompi.req_complete == true ) { if( NULL != status ) { *status = recvreq.req_recv.req_base.req_ompi.req_status; } rc = recvreq.req_recv.req_base.req_ompi.req_status.MPI_ERROR; *matched = 1; } else { *matched = 0; opal_progress(); } MCA_PML_BASE_RECV_REQUEST_FINI( &recvreq.req_recv ); return rc; }
int mca_spml_yoda_wait_gets(void) { while (0 < mca_spml_yoda.n_active_gets) { opal_progress(); } return OSHMEM_SUCCESS; }
static inline void mca_spml_irkit_req_wait(mxm_req_base_t *req) { do { /* do at least one progress since * with some TLs (self, shm) request * can be completed immediately */ opal_progress(); } while (!mxm_req_test(req)); }
static int mca_coll_ml_barrier_launch(mca_coll_ml_module_t *ml_module, ompi_request_t **req) { int rc; ompi_free_list_item_t *item; mca_coll_ml_collective_operation_progress_t *coll_op; ml_payload_buffer_desc_t *src_buffer_desc = NULL; /* allocate an ml buffer for signaling purposes */ src_buffer_desc = mca_coll_ml_alloc_buffer(ml_module); while (NULL == src_buffer_desc) { opal_progress(); src_buffer_desc = mca_coll_ml_alloc_buffer(ml_module); } /* Blocking call on fragment allocation (Maybe we want to make it non blocking ?) */ OMPI_FREE_LIST_WAIT(&(ml_module->coll_ml_collective_descriptors), item, rc); coll_op = (mca_coll_ml_collective_operation_progress_t *) item; assert(NULL != coll_op); ML_VERBOSE(10, ("Get coll request %p", coll_op)); MCA_COLL_ML_OP_BASIC_SETUP(coll_op, 0, 0, NULL, NULL, ml_module->coll_ml_barrier_function); coll_op->fragment_data.buffer_desc = src_buffer_desc; coll_op->dag_description.num_tasks_completed = 0; coll_op->variable_fn_params.buffer_index = src_buffer_desc->buffer_index; coll_op->variable_fn_params.sequence_num = OPAL_THREAD_ADD64(&(ml_module->collective_sequence_num), 1); /* Pointer to a coll finalize function */ coll_op->process_fn = NULL; (*req) = &coll_op->full_message.super; OMPI_REQUEST_INIT((*req), false); (*req)->req_status._cancelled = 0; (*req)->req_state = OMPI_REQUEST_ACTIVE; (*req)->req_status.MPI_ERROR = OMPI_SUCCESS; /* Set order info if there is a bcol needs ordering */ MCA_COLL_ML_SET_ORDER_INFO(coll_op, 1); return mca_coll_ml_generic_collectives_launcher(coll_op, mca_coll_ml_barrier_task_setup); }
static void* shmem_opal_thread(void* argc) { /* * WHAT: sleep() invocation * WHY: there occures a segfault sometimes and sleep() * reduces it's possibility */ sleep(1); while(oshmem_shmem_initialized) opal_progress(); return NULL; }
static inline int start_exclusive(ompi_osc_sm_module_t *module, int target) { uint32_t me = lk_fetch_add32(module, target, offsetof(ompi_osc_sm_lock_t, counter), 1); while (me != lk_fetch32(module, target, offsetof(ompi_osc_sm_lock_t, write))) { opal_progress(); } return OMPI_SUCCESS; }
int mca_bcol_iboffload_new_style_fanin_first_call( mca_bcol_iboffload_module_t *iboffload, struct mca_bcol_iboffload_collreq_t *coll_request) { int i = 0, leader_rank = 0, /* We always suppose - the lowest index is a leader */ my_rank = iboffload->ibnet->super.my_index, sbgp_size = iboffload->ibnet->super.group_size; mca_bcol_iboffload_endpoint_t *ep = NULL; mca_sbgp_ibnet_proc_t *my_ibnet_proc = iboffload->endpoints[my_rank]->ibnet_proc; assert(NULL != my_ibnet_proc); if (MCA_SBGP_IBNET_NODE_LEADER == my_ibnet_proc->duty) { iboffload->fanin_algth = mca_bcol_iboffload_fanin_leader_progress; iboffload->alg_task_consump[FANIN_ALG] += sbgp_size; for (i = leader_rank + 1; i < sbgp_size; ++i) { ep = iboffload->endpoints[i]; while (OMPI_SUCCESS != check_endpoint_state(ep, NULL, NULL)) { opal_progress(); } } } else { iboffload->fanin_algth = mca_bcol_iboffload_fanin_proxy_progress; iboffload->alg_task_consump[FANIN_ALG] += 1; ep = iboffload->endpoints[leader_rank]; while(OMPI_SUCCESS != check_endpoint_state(ep, NULL, NULL)) { opal_progress(); } } return iboffload->fanin_algth(iboffload, coll_request); }
int ompi_osc_sm_start(struct ompi_group_t *group, int assert, struct ompi_win_t *win) { ompi_osc_sm_module_t *module = (ompi_osc_sm_module_t*) win->w_osc_module; int my_rank = ompi_comm_rank (module->comm); void *_tmp_ptr = NULL; OBJ_RETAIN(group); if (!OPAL_ATOMIC_COMPARE_EXCHANGE_STRONG_PTR(&module->start_group, (void *) &_tmp_ptr, group)) { OBJ_RELEASE(group); return OMPI_ERR_RMA_SYNC; } if (0 == (assert & MPI_MODE_NOCHECK)) { int size; int *ranks = ompi_osc_sm_group_ranks (module->comm->c_local_group, group); if (NULL == ranks) { return OMPI_ERR_OUT_OF_RESOURCE; } size = ompi_group_size(module->start_group); for (int i = 0 ; i < size ; ++i) { int rank_byte = ranks[i] >> OSC_SM_POST_BITS; osc_sm_post_type_t rank_bit = ((osc_sm_post_type_t) 1) << (ranks[i] & 0x3f); /* wait for rank to post */ while (!(module->posts[my_rank][rank_byte] & rank_bit)) { opal_progress(); opal_atomic_mb(); } opal_atomic_rmb (); #if OPAL_HAVE_ATOMIC_MATH_64 (void) opal_atomic_fetch_xor_64 ((volatile int64_t *) module->posts[my_rank] + rank_byte, rank_bit); #else (void) opal_atomic_fetch_xor_32 ((volatile int32_t *) module->posts[my_rank] + rank_byte, rank_bit); #endif } free (ranks); }
static inline int start_shared(ompi_osc_sm_module_t *module, int target) { uint32_t me = lk_fetch_add32(module, target, offsetof(ompi_osc_sm_lock_t, counter), 1); while (me != lk_fetch32(module, target, offsetof(ompi_osc_sm_lock_t, read))) { opal_progress(); } lk_add32(module, target, offsetof(ompi_osc_sm_lock_t, read), 1); return OMPI_SUCCESS; }
int mca_pml_ob1_improbe(int src, int tag, struct ompi_communicator_t *comm, int *matched, struct ompi_message_t **message, ompi_status_public_t * status) { int rc = OMPI_SUCCESS; mca_pml_ob1_recv_request_t *recvreq; MCA_PML_OB1_RECV_REQUEST_ALLOC(recvreq, rc); if (NULL == recvreq) return rc; recvreq->req_recv.req_base.req_type = MCA_PML_REQUEST_IMPROBE; /* initialize the request enough to probe and get the status */ MCA_PML_OB1_RECV_REQUEST_INIT(recvreq, NULL, 0, &ompi_mpi_char.dt, src, tag, comm, false); MCA_PML_OB1_RECV_REQUEST_START(recvreq); if( recvreq->req_recv.req_base.req_ompi.req_complete == true ) { if( NULL != status ) { *status = recvreq->req_recv.req_base.req_ompi.req_status; } *matched = 1; *message = ompi_message_alloc(); (*message)->comm = comm; (*message)->req_ptr = recvreq; (*message)->peer = recvreq->req_recv.req_base.req_ompi.req_status.MPI_SOURCE; (*message)->count = recvreq->req_recv.req_base.req_ompi.req_status._ucount; rc = OMPI_SUCCESS; } else { *matched = 0; /* we only free if we didn't match, because we're going to translate the request into a receive request later on if it was matched */ ompi_request_free((ompi_request_t**)&recvreq); opal_progress(); } return rc; }
void orte_trigger_event(orte_trigger_event_t *trig) { int data=1; OPAL_OUTPUT_VERBOSE((1, orte_debug_output, "%s calling %s trigger", ORTE_NAME_PRINT(ORTE_PROC_MY_NAME), trig->name)); if (opal_atomic_trylock(&trig->lock)) { /* returns 1 if already locked */ return; } send(trig->channel, (const char*)&data, sizeof(int), 0); closesocket(trig->channel); opal_progress(); }
static int setup_mpool_base_resources(mca_btl_sm_component_t *comp_ptr, mca_mpool_base_resources_t *out_res) { int rc = OPAL_SUCCESS; int fd = -1; ssize_t bread = 0; /* Wait for the file to be created */ while (0 != access(comp_ptr->sm_rndv_file_name, R_OK)) { opal_progress(); } if (-1 == (fd = open(comp_ptr->sm_mpool_rndv_file_name, O_RDONLY))) { int err = errno; opal_show_help("help-mpi-btl-sm.txt", "sys call fail", true, "open(2)", strerror(err), err); rc = OPAL_ERR_IN_ERRNO; goto out; } if ((ssize_t)sizeof(opal_shmem_ds_t) != (bread = read(fd, &out_res->bs_meta_buf, sizeof(opal_shmem_ds_t)))) { opal_output(0, "setup_mpool_base_resources: " "Read inconsistency -- read: %lu, but expected: %lu!\n", (unsigned long)bread, (unsigned long)sizeof(opal_shmem_ds_t)); rc = OPAL_ERROR; goto out; } if ((ssize_t)sizeof(out_res->size) != (bread = read(fd, &out_res->size, sizeof(size_t)))) { opal_output(0, "setup_mpool_base_resources: " "Read inconsistency -- read: %lu, but expected: %lu!\n", (unsigned long)bread, (unsigned long)sizeof(opal_shmem_ds_t)); rc = OPAL_ERROR; goto out; } out: if (-1 != fd) { (void)close(fd); } return rc; }
int orte_errmgr_base_restart_job(orte_jobid_t jobid, char * global_handle, int seq_num) { int ret, exit_status = ORTE_SUCCESS; orte_process_name_t loc_proc; orte_job_t *jdata; orte_sstore_base_handle_t prev_sstore_handle = ORTE_SSTORE_HANDLE_INVALID; /* JJH First determine if we can recover this way */ /* * Find the corresponding sstore handle */ prev_sstore_handle = orte_sstore_handle_last_stable; if( ORTE_SUCCESS != (ret = orte_sstore.request_restart_handle(&orte_sstore_handle_last_stable, NULL, global_handle, seq_num, NULL)) ) { ORTE_ERROR_LOG(ret); goto cleanup; } /* get the job object */ if (NULL == (jdata = orte_get_job_data_object(jobid))) { exit_status = ORTE_ERR_NOT_FOUND; ORTE_ERROR_LOG(exit_status); goto cleanup; } /* * Start the recovery */ orte_snapc_base_has_recovered = false; loc_proc.jobid = jobid; loc_proc.vpid = 0; ORTE_ACTIVATE_PROC_STATE(&loc_proc, ORTE_PROC_STATE_KILLED_BY_CMD); ORTE_ACTIVATE_JOB_STATE(jdata, ORTE_JOB_CONTROL_RESTART); while( !orte_snapc_base_has_recovered ) { opal_progress(); } orte_sstore_handle_last_stable = prev_sstore_handle; cleanup: return exit_status; }
int ompi_osc_sm_start(struct ompi_group_t *group, int assert, struct ompi_win_t *win) { ompi_osc_sm_module_t *module = (ompi_osc_sm_module_t*) win->w_osc_module; int my_rank = ompi_comm_rank (module->comm); OBJ_RETAIN(group); if (!OPAL_ATOMIC_CMPSET_PTR(&module->start_group, NULL, group)) { OBJ_RELEASE(group); return OMPI_ERR_RMA_SYNC; } if (0 == (assert & MPI_MODE_NOCHECK)) { int size; int *ranks = ompi_osc_sm_group_ranks (module->comm->c_local_group, group); if (NULL == ranks) { return OMPI_ERR_OUT_OF_RESOURCE; } size = ompi_group_size(module->start_group); for (int i = 0 ; i < size ; ++i) { int rank_byte = ranks[i] >> 6; uint64_t old, rank_bit = ((uint64_t) 1) << (ranks[i] & 0x3f); /* wait for rank to post */ while (!(module->posts[my_rank][rank_byte] & rank_bit)) { opal_progress(); opal_atomic_mb(); } opal_atomic_rmb (); do { old = module->posts[my_rank][rank_byte]; } while (!opal_atomic_cmpset_64 ((int64_t *) module->posts[my_rank] + rank_byte, old, old ^ rank_bit)); } free (ranks); }
void orte_trigger_event(orte_trigger_event_t *trig) { int data=1; OPAL_OUTPUT_VERBOSE((1, orte_debug_output, "%s calling %s trigger", ORTE_NAME_PRINT(ORTE_PROC_MY_NAME), trig->name)); /* if we already fired it, don't do it again - this automatically * records that we did fire it */ if (opal_atomic_trylock(&trig->lock)) { /* returns 1 if already locked */ return; } write(trig->channel, &data, sizeof(int)); close(trig->channel); opal_progress(); }
int mca_pml_ucx_probe(int src, int tag, struct ompi_communicator_t* comm, ompi_status_public_t* mpi_status) { ucp_tag_t ucp_tag, ucp_tag_mask; ucp_tag_recv_info_t info; ucp_tag_message_h ucp_msg; PML_UCX_TRACE_PROBE("probe", src, tag, comm); PML_UCX_MAKE_RECV_TAG(ucp_tag, ucp_tag_mask, tag, src, comm); for (;;) { ucp_msg = ucp_tag_probe_nb(ompi_pml_ucx.ucp_worker, ucp_tag, ucp_tag_mask, 0, &info); if (ucp_msg != NULL) { mca_pml_ucx_set_recv_status_safe(mpi_status, UCS_OK, &info); return OMPI_SUCCESS; } opal_progress(); } }
static void mca_spml_ucx_waitall(void **reqs, size_t *count_p) { ucs_status_t status; size_t i; SPML_VERBOSE(10, "waiting for %d disconnect requests", *count_p); for (i = 0; i < *count_p; ++i) { do { opal_progress(); status = ucp_request_test(reqs[i], NULL); } while (status == UCS_INPROGRESS); if (status != UCS_OK) { SPML_ERROR("disconnect request failed: %s", ucs_status_string(status)); } ucp_request_release(reqs[i]); reqs[i] = NULL; } *count_p = 0; }
int mca_spml_ikrit_get(void *src_addr, size_t size, void *dst_addr, int src) { mxm_send_req_t sreq; if (0 >= size) { return OSHMEM_SUCCESS; } if (OSHMEM_SUCCESS == mca_spml_ikrit_get_shm(src_addr, size, dst_addr, src)) return OSHMEM_SUCCESS; if (OSHMEM_SUCCESS != mca_spml_ikrit_get_helper(&sreq, src_addr, size, dst_addr, src)) { oshmem_shmem_abort(-1); return OSHMEM_ERROR; } #if MXM_API < MXM_VERSION(2,0) sreq.base.flags = MXM_REQ_FLAG_BLOCKING; #else sreq.flags = MXM_REQ_SEND_FLAG_BLOCKING; #endif sreq.base.completed_cb = NULL; mxm_req_send(&sreq); opal_progress(); mca_spml_irkit_req_wait(&sreq.base); if (MXM_OK != sreq.base.error) { SPML_ERROR("get request failed: %s - aborting", mxm_error_string(sreq.base.error)); oshmem_shmem_abort(-1); return OSHMEM_ERROR; } return OSHMEM_SUCCESS; }
static int plm_tm_connect(void) { int ret; struct tm_roots tm_root; int count; /* try a couple times to connect - might get busy signals every now and then */ for (count = 0 ; count < 10; ++count) { ret = tm_init(NULL, &tm_root); if (TM_SUCCESS == ret) { return ORTE_SUCCESS; } #if ORTE_ENABLE_PROGRESS_THREADS { /* provide a very short quiet period so we * don't hammer the cpu while we wait */ struct timespec tp = {0, 100}; nanosleep(&tp, NULL); #if HAVE_SCHED_YIELD sched_yield(); #endif } #else { int progress; for (progress = 0 ; progress < 10 ; ++progress) { opal_progress(); #if HAVE_SCHED_YIELD sched_yield(); #endif } } #endif } return ORTE_ERR_RESOURCE_BUSY; }
int mca_pml_yalla_probe(int src, int tag, struct ompi_communicator_t* comm, ompi_status_public_t* status) { mxm_recv_req_t rreq; mxm_error_t error; PML_YALLA_INIT_MXM_PROBE_REQ(&rreq, src, tag, comm); for (;;) { error = mxm_req_probe(&rreq); switch (error) { case MXM_OK: PML_YALLA_SET_RECV_STATUS(&rreq, rreq.completion.sender_len, status); return OMPI_SUCCESS; case MXM_ERR_NO_MESSAGE: break; default: return OMPI_ERROR; } opal_progress(); } }
static inline int mca_spml_ikrit_get_shm(void *src_addr, size_t size, void *dst_addr, int src) { int ptl_id; void *rva; sshmem_mkey_t *r_mkey; ptl_id = get_ptl_id(src); /** * Get the address to the remote rkey. **/ if (ptl_id != MXM_PTL_SHM) return OSHMEM_ERROR; r_mkey = mca_memheap.memheap_get_cached_mkey(src, src_addr, ptl_id, &rva); if (!r_mkey) { SPML_ERROR("pe=%d: %p is not address of shared variable", src, src_addr); oshmem_shmem_abort(-1); return OSHMEM_ERROR; } if (!mca_memheap_base_can_local_copy(r_mkey, src_addr)) return OSHMEM_ERROR; SPML_VERBOSE(100, "shm get: pe:%d src=%p -> dst: %p sz=%d. src_rva=%p, %s", src, src_addr, dst_addr, (int)size, (void *)rva, mca_spml_base_mkey2str(r_mkey)); memcpy(dst_addr, (void *) (unsigned long) rva, size); opal_progress(); return OSHMEM_SUCCESS; }
/* Non blocking test for the request status. Upon completion, the request will * not be freed (unlike the test function). A subsequent call to test, wait * or free should be executed on the request. */ int MPI_Request_get_status(MPI_Request request, int *flag, MPI_Status *status) { if( MPI_PARAM_CHECK ) { OMPI_ERR_INIT_FINALIZE(FUNC_NAME); if( (NULL == flag) || (NULL == status) ) { return OMPI_ERRHANDLER_INVOKE(MPI_COMM_WORLD, MPI_ERR_ARG, FUNC_NAME); } } opal_atomic_mb(); if( (request == MPI_REQUEST_NULL) || (request->req_state == OMPI_REQUEST_INACTIVE) ) { *flag = true; if( MPI_STATUS_IGNORE != status ) { *status = ompi_status_empty; } return MPI_SUCCESS; } if( request->req_complete ) { *flag = true; /* If this is a generalized request, we *always* have to call the query function to get the status (MPI-2:8.2), even if the user passed STATUS_IGNORE. */ if (OMPI_REQUEST_GEN == request->req_type) { ompi_grequest_invoke_query(request, &request->req_status); } if (MPI_STATUS_IGNORE != status) { *status = request->req_status; } return MPI_SUCCESS; } *flag = false; #if OMPI_ENABLE_PROGRESS_THREADS == 0 opal_progress(); #endif return MPI_SUCCESS; }