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;
}
