int MPIDI_Get(void *origin_addr, int origin_count, MPI_Datatype
origin_datatype, int target_rank, MPI_Aint target_disp,
int target_count, MPI_Datatype target_datatype, MPID_Win *win_ptr)
{
int mpi_errno = MPI_SUCCESS;
MPIDI_msg_sz_t data_sz;
int dt_contig, rank, predefined;
MPI_Aint dt_true_lb;
MPIDI_RMA_ops *new_ptr;
MPID_Datatype *dtp;
MPIU_CHKPMEM_DECL(1);
MPIDI_STATE_DECL(MPID_STATE_MPIDI_GET);
MPIDI_RMA_FUNC_ENTER(MPID_STATE_MPIDI_GET);
MPIDI_Datatype_get_info(origin_count, origin_datatype,
dt_contig, data_sz, dtp, dt_true_lb);
if ((data_sz == 0) || (target_rank == MPI_PROC_NULL))
{
goto fn_exit;
}
rank = win_ptr->myrank;
/* If the get is a local operation, do it here */
if (target_rank == rank)
{
mpi_errno = MPIR_Localcopy((char *) win_ptr->base +
win_ptr->disp_unit * target_disp,
target_count, target_datatype,
origin_addr, origin_count,
origin_datatype);
}
else
{
/* queue it up */
MPIU_INSTR_DURATION_START(rmaqueue_alloc);
MPIU_CHKPMEM_MALLOC(new_ptr, MPIDI_RMA_ops *, sizeof(MPIDI_RMA_ops),
mpi_errno, "RMA operation entry");
MPIU_INSTR_DURATION_END(rmaqueue_alloc);
if (win_ptr->rma_ops_list_tail)
win_ptr->rma_ops_list_tail->next = new_ptr;
else
win_ptr->rma_ops_list_head = new_ptr;
win_ptr->rma_ops_list_tail = new_ptr;
/* FIXME: For contig and very short operations, use a streamlined op */
new_ptr->next = NULL;
new_ptr->type = MPIDI_RMA_GET;
new_ptr->origin_addr = origin_addr;
new_ptr->origin_count = origin_count;
new_ptr->origin_datatype = origin_datatype;
new_ptr->target_rank = target_rank;
new_ptr->target_disp = target_disp;
new_ptr->target_count = target_count;
new_ptr->target_datatype = target_datatype;
/* if source or target datatypes are derived, increment their
reference counts */
MPIDI_CH3I_DATATYPE_IS_PREDEFINED(origin_datatype, predefined);
if (!predefined)
{
MPID_Datatype_get_ptr(origin_datatype, dtp);
MPID_Datatype_add_ref(dtp);
}
MPIDI_CH3I_DATATYPE_IS_PREDEFINED(target_datatype, predefined);
if (!predefined)
{
MPID_Datatype_get_ptr(target_datatype, dtp);
MPID_Datatype_add_ref(dtp);
}
}
fn_exit:
MPIDI_RMA_FUNC_EXIT(MPID_STATE_MPIDI_GET);
return mpi_errno;
/* --BEGIN ERROR HANDLING-- */
fn_fail:
MPIU_CHKPMEM_REAP();
goto fn_exit;
/* --END ERROR HANDLING-- */
}
int MPIDI_Win_free(MPID_Win **win_ptr)
{
int mpi_errno=MPI_SUCCESS, total_pt_rma_puts_accs;
int in_use;
MPID_Comm *comm_ptr;
int errflag = FALSE;
MPIDI_STATE_DECL(MPID_STATE_MPIDI_WIN_FREE);
MPIDI_RMA_FUNC_ENTER(MPID_STATE_MPIDI_WIN_FREE);
comm_ptr = (*win_ptr)->comm_ptr;
MPIU_INSTR_DURATION_START(winfree_rs);
mpi_errno = MPIR_Reduce_scatter_block_impl((*win_ptr)->pt_rma_puts_accs,
&total_pt_rma_puts_accs, 1,
MPI_INT, MPI_SUM, comm_ptr, &errflag);
if (mpi_errno) { MPIU_ERR_POP(mpi_errno); }
MPIU_ERR_CHKANDJUMP(errflag, mpi_errno, MPI_ERR_OTHER, "**coll_fail");
MPIU_INSTR_DURATION_END(winfree_rs);
if (total_pt_rma_puts_accs != (*win_ptr)->my_pt_rma_puts_accs)
{
MPID_Progress_state progress_state;
/* poke the progress engine until the two are equal */
MPIU_INSTR_DURATION_START(winfree_complete);
MPID_Progress_start(&progress_state);
while (total_pt_rma_puts_accs != (*win_ptr)->my_pt_rma_puts_accs)
{
mpi_errno = MPID_Progress_wait(&progress_state);
/* --BEGIN ERROR HANDLING-- */
if (mpi_errno != MPI_SUCCESS)
{
MPID_Progress_end(&progress_state);
MPIU_ERR_SETANDJUMP(mpi_errno,MPI_ERR_OTHER,"**winnoprogress");
}
/* --END ERROR HANDLING-- */
}
MPID_Progress_end(&progress_state);
MPIU_INSTR_DURATION_END(winfree_complete);
}
mpi_errno = MPIR_Comm_free_impl(comm_ptr);
if (mpi_errno) MPIU_ERR_POP(mpi_errno);
MPIU_Free((*win_ptr)->base_addrs);
MPIU_Free((*win_ptr)->disp_units);
MPIU_Free((*win_ptr)->all_win_handles);
MPIU_Free((*win_ptr)->pt_rma_puts_accs);
MPIU_Object_release_ref(*win_ptr, &in_use);
/* MPI windows don't have reference count semantics, so this should always be true */
MPIU_Assert(!in_use);
MPIU_Handle_obj_free( &MPID_Win_mem, *win_ptr );
fn_exit:
MPIDI_RMA_FUNC_EXIT(MPID_STATE_MPIDI_WIN_FREE);
return mpi_errno;
fn_fail:
goto fn_exit;
}
int MPIDI_Win_create(void *base, MPI_Aint size, int disp_unit, MPID_Info *info,
MPID_Comm *comm_ptr, MPID_Win **win_ptr )
{
int mpi_errno=MPI_SUCCESS, i, k, comm_size, rank;
MPI_Aint *tmp_buf;
MPID_Comm *win_comm_ptr;
int errflag = FALSE;
MPIU_CHKPMEM_DECL(4);
MPIU_CHKLMEM_DECL(1);
MPIDI_STATE_DECL(MPID_STATE_MPIDI_WIN_CREATE);
MPIDI_RMA_FUNC_ENTER(MPID_STATE_MPIDI_WIN_CREATE);
/* FIXME: There should be no unreferenced args */
MPIU_UNREFERENCED_ARG(info);
if(initRMAoptions) {
int rc;
MPIU_THREADSAFE_INIT_BLOCK_BEGIN(initRMAoptions);
/* Default is to enable the use of the immediate accumulate feature */
if (!MPL_env2bool( "MPICH_RMA_ACC_IMMED", &rc ))
rc = 1;
MPIDI_CH3_RMA_SetAccImmed(rc);
#ifdef USE_MPIU_INSTR
/* Define all instrumentation handle used in the CH3 RMA here*/
MPIU_INSTR_DURATION_INIT(wincreate_allgather,0,"WIN_CREATE:Allgather");
MPIU_INSTR_DURATION_INIT(winfree_rs,0,"WIN_FREE:ReduceScatterBlock");
MPIU_INSTR_DURATION_INIT(winfree_complete,0,"WIN_FREE:Complete");
MPIU_INSTR_DURATION_INIT(rmaqueue_alloc,0,"Allocate RMA Queue element");
MPIDI_CH3_RMA_InitInstr();
#endif
MPIU_THREADSAFE_INIT_CLEAR(initRMAoptions);
MPIU_THREADSAFE_INIT_BLOCK_END(initRMAoptions);
}
comm_size = comm_ptr->local_size;
rank = comm_ptr->rank;
*win_ptr = (MPID_Win *)MPIU_Handle_obj_alloc( &MPID_Win_mem );
MPIU_ERR_CHKANDJUMP1(!(*win_ptr),mpi_errno,MPI_ERR_OTHER,"**nomem",
"**nomem %s","MPID_Win_mem");
MPIU_Object_set_ref(*win_ptr, 1);
(*win_ptr)->fence_cnt = 0;
(*win_ptr)->base = base;
(*win_ptr)->size = size;
(*win_ptr)->disp_unit = disp_unit;
(*win_ptr)->start_group_ptr = NULL;
(*win_ptr)->start_assert = 0;
(*win_ptr)->attributes = NULL;
(*win_ptr)->rma_ops_list_head = NULL;
(*win_ptr)->rma_ops_list_tail = NULL;
(*win_ptr)->lock_granted = 0;
(*win_ptr)->current_lock_type = MPID_LOCK_NONE;
(*win_ptr)->shared_lock_ref_cnt = 0;
(*win_ptr)->lock_queue = NULL;
(*win_ptr)->my_counter = 0;
(*win_ptr)->my_pt_rma_puts_accs = 0;
mpi_errno = MPIR_Comm_dup_impl(comm_ptr, &win_comm_ptr);
if (mpi_errno) MPIU_ERR_POP(mpi_errno);
(*win_ptr)->comm_ptr = win_comm_ptr;
(*win_ptr)->myrank = rank;
MPIU_INSTR_DURATION_START(wincreate_allgather);
/* allocate memory for the base addresses, disp_units, and
completion counters of all processes */
MPIU_CHKPMEM_MALLOC((*win_ptr)->base_addrs, void **,
comm_size*sizeof(void *),
mpi_errno, "(*win_ptr)->base_addrs");
MPIU_CHKPMEM_MALLOC((*win_ptr)->disp_units, int *, comm_size*sizeof(int),
mpi_errno, "(*win_ptr)->disp_units");
MPIU_CHKPMEM_MALLOC((*win_ptr)->all_win_handles, MPI_Win *,
comm_size*sizeof(MPI_Win),
mpi_errno, "(*win_ptr)->all_win_handles");
MPIU_CHKPMEM_MALLOC((*win_ptr)->pt_rma_puts_accs, int *,
comm_size*sizeof(int),
mpi_errno, "(*win_ptr)->pt_rma_puts_accs");
for (i=0; i<comm_size; i++) (*win_ptr)->pt_rma_puts_accs[i] = 0;
/* get the addresses of the windows, window objects, and completion
counters of all processes. allocate temp. buffer for communication */
MPIU_CHKLMEM_MALLOC(tmp_buf, MPI_Aint *, 3*comm_size*sizeof(MPI_Aint),
mpi_errno, "tmp_buf");
/* FIXME: This needs to be fixed for heterogeneous systems */
tmp_buf[3*rank] = MPIU_PtrToAint(base);
tmp_buf[3*rank+1] = (MPI_Aint) disp_unit;
tmp_buf[3*rank+2] = (MPI_Aint) (*win_ptr)->handle;
mpi_errno = MPIR_Allgather_impl(MPI_IN_PLACE, 0, MPI_DATATYPE_NULL,
tmp_buf, 3 * sizeof(MPI_Aint), MPI_BYTE,
comm_ptr, &errflag);
MPIU_INSTR_DURATION_END(wincreate_allgather);
if (mpi_errno) { MPIU_ERR_POP(mpi_errno); }
MPIU_ERR_CHKANDJUMP(errflag, mpi_errno, MPI_ERR_OTHER, "**coll_fail");
k = 0;
for (i=0; i<comm_size; i++)
{
(*win_ptr)->base_addrs[i] = MPIU_AintToPtr(tmp_buf[k++]);
(*win_ptr)->disp_units[i] = (int) tmp_buf[k++];
(*win_ptr)->all_win_handles[i] = (MPI_Win) tmp_buf[k++];
}
fn_exit:
MPIU_CHKLMEM_FREEALL();
MPIDI_RMA_FUNC_EXIT(MPID_STATE_MPIDI_WIN_CREATE);
return mpi_errno;
/* --BEGIN ERROR HANDLING-- */
fn_fail:
MPIU_CHKPMEM_REAP();
goto fn_exit;
/* --END ERROR HANDLING-- */
}
int MPIDI_CH3U_Win_create_gather( void *base, MPI_Aint size, int disp_unit,
MPID_Info *info, MPID_Comm *comm_ptr, MPID_Win **win_ptr )
{
int mpi_errno=MPI_SUCCESS, i, k, comm_size, rank;
MPI_Aint *tmp_buf;
int errflag = FALSE;
MPIU_CHKPMEM_DECL(5);
MPIU_CHKLMEM_DECL(1);
MPIDI_STATE_DECL(MPID_STATE_MPIDI_CH3U_WIN_CREATE_GATHER);
MPIDI_RMA_FUNC_ENTER(MPID_STATE_MPIDI_CH3U_WIN_CREATE_GATHER);
comm_size = (*win_ptr)->comm_ptr->local_size;
rank = (*win_ptr)->comm_ptr->rank;
/* RMA handlers should be set before calling this function */
mpi_errno = (*win_ptr)->RMAFns.Win_set_info(*win_ptr, info);
MPIU_INSTR_DURATION_START(wincreate_allgather);
/* allocate memory for the base addresses, disp_units, and
completion counters of all processes */
MPIU_CHKPMEM_MALLOC((*win_ptr)->base_addrs, void **,
comm_size*sizeof(void *),
mpi_errno, "(*win_ptr)->base_addrs");
MPIU_CHKPMEM_MALLOC((*win_ptr)->sizes, MPI_Aint *, comm_size*sizeof(MPI_Aint),
mpi_errno, "(*win_ptr)->sizes");
MPIU_CHKPMEM_MALLOC((*win_ptr)->disp_units, int *, comm_size*sizeof(int),
mpi_errno, "(*win_ptr)->disp_units");
MPIU_CHKPMEM_MALLOC((*win_ptr)->all_win_handles, MPI_Win *,
comm_size*sizeof(MPI_Win),
mpi_errno, "(*win_ptr)->all_win_handles");
MPIU_CHKPMEM_MALLOC((*win_ptr)->pt_rma_puts_accs, int *,
comm_size*sizeof(int),
mpi_errno, "(*win_ptr)->pt_rma_puts_accs");
for (i=0; i<comm_size; i++) (*win_ptr)->pt_rma_puts_accs[i] = 0;
/* get the addresses of the windows, window objects, and completion
counters of all processes. allocate temp. buffer for communication */
MPIU_CHKLMEM_MALLOC(tmp_buf, MPI_Aint *, 4*comm_size*sizeof(MPI_Aint),
mpi_errno, "tmp_buf");
/* FIXME: This needs to be fixed for heterogeneous systems */
/* FIXME: If we wanted to validate the transfer as within range at the
origin, we'd also need the window size. */
tmp_buf[4*rank] = MPIU_PtrToAint(base);
tmp_buf[4*rank+1] = size;
tmp_buf[4*rank+2] = (MPI_Aint) disp_unit;
tmp_buf[4*rank+3] = (MPI_Aint) (*win_ptr)->handle;
mpi_errno = MPIR_Allgather_impl(MPI_IN_PLACE, 0, MPI_DATATYPE_NULL,
tmp_buf, 4, MPI_AINT,
(*win_ptr)->comm_ptr, &errflag);
MPIU_INSTR_DURATION_END(wincreate_allgather);
if (mpi_errno) { MPIU_ERR_POP(mpi_errno); }
MPIU_ERR_CHKANDJUMP(errflag, mpi_errno, MPI_ERR_OTHER, "**coll_fail");
k = 0;
for (i=0; i<comm_size; i++)
{
(*win_ptr)->base_addrs[i] = MPIU_AintToPtr(tmp_buf[k++]);
(*win_ptr)->sizes[i] = tmp_buf[k++];
(*win_ptr)->disp_units[i] = (int) tmp_buf[k++];
(*win_ptr)->all_win_handles[i] = (MPI_Win) tmp_buf[k++];
}
fn_exit:
MPIU_CHKLMEM_FREEALL();
MPIDI_RMA_FUNC_EXIT(MPID_STATE_MPIDI_CH3U_WIN_CREATE_GATHER);
return mpi_errno;
/* --BEGIN ERROR HANDLING-- */
fn_fail:
MPIU_CHKPMEM_REAP();
goto fn_exit;
/* --END ERROR HANDLING-- */
}