ch3_rma_ops.c

mpi并行计算的c++代码 可用vc或gcc编译通过 可以用来搭建并行计算试验环境

    for (i=0; i<comm_size; i++) {
        if ((i != rank) && ((*win_ptr)->shm_structs[i].size != 0)) {
            mpi_errno = MPIDI_CH3I_SHM_Release_mem( &((*win_ptr)->shm_structs[i]) );
	    if (mpi_errno) { MPIU_ERR_POP(mpi_errno); }
        }
    }

    if (rank != 0) {
        mpi_errno = MPIDI_CH3I_SHM_Release_mem( (*win_ptr)->locks );
    }
    else {
        locks_base_addr = (*win_ptr)->locks->addr;
        for (i=0; i<comm_size; i++) 
            MPIDU_Process_lock_free(&locks_base_addr[i]);
        
        mpi_errno = MPIDI_CH3I_SHM_Unlink_and_detach_mem( (*win_ptr)->locks );
    }
    if (mpi_errno) { MPIU_ERR_POP(mpi_errno); }

    for (i=0; i<comm_size; i++) {
        if (i != rank) {
            mpi_errno = MPIDI_CH3I_SHM_Release_mem( &((*win_ptr)->pscw_shm_structs[i]) );
        }
        else {
            mpi_errno = 
                MPIDI_CH3I_SHM_Unlink_and_detach_mem( &((*win_ptr)->pscw_shm_structs[i]) );
        }
	if (mpi_errno) { MPIU_ERR_POP(mpi_errno); }
    }

    MPIU_Free((*win_ptr)->locks);
    MPIU_Free((*win_ptr)->shm_structs);
    MPIU_Free((*win_ptr)->offsets);
    MPIU_Free((*win_ptr)->pscw_shm_structs);

    /* check whether refcount needs to be decremented here as in group_free */
    MPIU_Handle_obj_free( &MPID_Win_mem, *win_ptr );

 fn_exit:    
    MPIDI_FUNC_EXIT(MPID_STATE_MPIDI_CH3_WIN_FREE);
    return mpi_errno;
    /* --BEGIN ERROR HANDLING-- */
 fn_fail:
    goto fn_exit;
    /* --END ERROR HANDLING-- */
}



/*
 * MPIDI_CH3_Put()
 */
#undef FUNCNAME
#define FUNCNAME MPIDI_CH3_Put
#undef FCNAME
#define FCNAME MPIDI_QUOTE(FUNCNAME)
int MPIDI_CH3_Put(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;
    void *target_addr;
    MPIDI_STATE_DECL(MPID_STATE_MPIDI_CH3_PUT);

    MPIDI_FUNC_ENTER(MPID_STATE_MPIDI_CH3_PUT);

    target_addr = (char *) win_ptr->shm_structs[target_rank].addr + 
                  (long) win_ptr->offsets[target_rank] +
                  win_ptr->disp_units[target_rank] * target_disp;

    mpi_errno = MPIR_Localcopy (origin_addr, origin_count, origin_datatype, 
                                target_addr, target_count, target_datatype);
    /* --BEGIN ERROR HANDLING-- */
    if (mpi_errno)
    {
        mpi_errno = MPIR_Err_create_code(mpi_errno, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, MPI_ERR_OTHER, "**fail", 0);
    }
    /* --END ERROR HANDLING-- */

    MPIDI_FUNC_EXIT(MPID_STATE_MPIDI_CH3_PUT);
    return mpi_errno;
}




/*
 * MPIDI_CH3_Get()
 */
#undef FUNCNAME
#define FUNCNAME MPIDI_CH3_Get
#undef FCNAME
#define FCNAME MPIDI_QUOTE(FUNCNAME)
int MPIDI_CH3_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;
    void *target_addr;
    MPIDI_STATE_DECL(MPID_STATE_MPIDI_CH3_GET);

    MPIDI_FUNC_ENTER(MPID_STATE_MPIDI_CH3_GET);

    target_addr = (char *) win_ptr->shm_structs[target_rank].addr + 
                  (long) win_ptr->offsets[target_rank] +
                  win_ptr->disp_units[target_rank] * target_disp;

    mpi_errno = MPIR_Localcopy (target_addr, target_count, target_datatype,
                                origin_addr, origin_count, origin_datatype);
    /* --BEGIN ERROR HANDLING-- */
    if (mpi_errno)
    {
        mpi_errno = MPIR_Err_create_code(mpi_errno, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, MPI_ERR_OTHER, "**fail", 0);
    }
    /* --END ERROR HANDLING-- */


    MPIDI_FUNC_EXIT(MPID_STATE_MPIDI_CH3_GET);
    return mpi_errno;
}




/*
 * MPIDI_CH3_Accumulate()
 */
#undef FUNCNAME
#define FUNCNAME MPIDI_CH3_Accumulate
#undef FCNAME
#define FCNAME MPIDI_QUOTE(FUNCNAME)
int MPIDI_CH3_Accumulate(void *origin_addr, int origin_count, MPI_Datatype
                    origin_datatype, int target_rank, MPI_Aint target_disp,
                    int target_count, MPI_Datatype target_datatype, MPI_Op op,
                    MPID_Win *win_ptr)
{
    int mpi_errno = MPI_SUCCESS;
    void *target_addr, *source_addr, *tmp_buf=NULL;
    MPI_Aint true_lb, true_extent, extent;
    MPI_User_function *uop;
    MPIDU_Process_lock_t *locks_base_addr;
    MPIU_CHKLMEM_DECL(2);
    MPIDI_STATE_DECL(MPID_STATE_MPIDI_CH3_ACCUMULATE);

    MPIDI_FUNC_ENTER(MPID_STATE_MPIDI_CH3_ACCUMULATE);

    target_addr = (char *) win_ptr->shm_structs[target_rank].addr + 
                  (long) win_ptr->offsets[target_rank] +
                  win_ptr->disp_units[target_rank] * target_disp;
    source_addr = origin_addr;

    locks_base_addr = win_ptr->locks->addr;

    if (op == MPI_REPLACE) {
        /* simply do a memcpy */

        /* all accumulate operations need to be done atomically. If the process does 
           not already have an exclusive lock, acquire it */

        if (win_ptr->pt_rma_excl_lock == 0)
            MPIDU_Process_lock( &locks_base_addr[target_rank] );

        mpi_errno = MPIR_Localcopy (origin_addr, origin_count, origin_datatype, 
                                    target_addr, target_count, target_datatype);

        if (win_ptr->pt_rma_excl_lock == 0)
            MPIDU_Process_unlock( &locks_base_addr[target_rank] );

	if (mpi_errno) { MPIU_ERR_POP(mpi_errno); }
    }

    else {

	MPIU_ERR_CHKANDJUMP1((HANDLE_GET_KIND(op) != HANDLE_KIND_BUILTIN), mpi_errno, MPI_ERR_OP, "**opnotpredefined",
			     "**opnotpredefined %d", op );

	/* get the function by indexing into the op table */
	uop = MPIR_Op_table[op%16 - 1];
    
        if ((HANDLE_GET_KIND(target_datatype) == HANDLE_KIND_BUILTIN) &&
            (HANDLE_GET_KIND(origin_datatype) == HANDLE_KIND_BUILTIN)) {
                /* basic datatype on origin and target */
            if (win_ptr->pt_rma_excl_lock == 0)
                MPIDU_Process_lock( &locks_base_addr[target_rank] );

            (*uop)(origin_addr, target_addr, &origin_count, &origin_datatype);

            if (win_ptr->pt_rma_excl_lock == 0)
                MPIDU_Process_unlock( &locks_base_addr[target_rank] );
        }
        else {

	    if (origin_datatype != target_datatype) {
            /* allocate a tmp buffer of extent equal to extent of target buf */

		MPIR_Nest_incr();
		mpi_errno = NMPI_Type_get_true_extent(target_datatype, 
						      &true_lb, &true_extent);
		MPIR_Nest_decr();
		if (mpi_errno) { MPIU_ERR_POP(mpi_errno); }

		MPID_Datatype_get_extent_macro(target_datatype, extent); 

		MPIU_CHKLMEM_MALLOC(tmp_buf, void *, target_count * (MPIR_MAX(extent,true_extent)), 
				    mpi_errno, "temporary buffer");

		/* adjust for potential negative lower bound in datatype */
		tmp_buf = (void *)((char*)tmp_buf - true_lb);

		/*  copy origin buffer into tmp_buf with same datatype as target. */
		mpi_errno = MPIR_Localcopy (origin_addr, origin_count, origin_datatype, 
					    tmp_buf, target_count, target_datatype);
		if (mpi_errno) { MPIU_ERR_POP(mpi_errno); }

		source_addr = tmp_buf;
	    }
            
            if (HANDLE_GET_KIND(target_datatype) == HANDLE_KIND_BUILTIN) {
                /* basic datatype on target. call uop. */
                if (win_ptr->pt_rma_excl_lock == 0)
                    MPIDU_Process_lock( &locks_base_addr[target_rank] );

                (*uop)(source_addr, target_addr, &target_count, &target_datatype);

                if (win_ptr->pt_rma_excl_lock == 0)
                    MPIDU_Process_unlock( &locks_base_addr[target_rank] );
            }
            else
            {
                /* derived datatype on target */
                MPID_Segment *segp;
                DLOOP_VECTOR *dloop_vec;
                MPI_Aint first, last;
                int vec_len, i, type_size, count;
                MPI_Datatype type;
                MPID_Datatype *dtp;
                
                segp = MPID_Segment_alloc();
		MPIU_ERR_CHKANDJUMP((!segp), mpi_errno, MPI_ERR_OTHER, "**nomem"); 

                MPID_Segment_init(NULL, target_count, target_datatype, segp, 0);
                first = 0;
                last  = SEGMENT_IGNORE_LAST;
                
                MPID_Datatype_get_ptr(target_datatype, dtp);
                vec_len = dtp->n_contig_blocks * target_count + 1; 
                /* +1 needed because Rob says so */
		MPIU_CHKLMEM_MALLOC(dloop_vec, DLOOP_VECTOR *, vec_len * sizeof(DLOOP_VECTOR), mpi_errno, "dloop vector");
                
                MPID_Segment_pack_vector(segp, first, &last, dloop_vec, &vec_len);
                
                type = dtp->eltype;
                type_size = MPID_Datatype_get_basic_size(type);

                if (win_ptr->pt_rma_excl_lock == 0)
                    MPIDU_Process_lock( &locks_base_addr[target_rank] );
                for (i=0; i<vec_len; i++)
                {
                    count = (dloop_vec[i].DLOOP_VECTOR_LEN)/type_size;
                    (*uop)((char *)source_addr + MPIU_PtrToAint( dloop_vec[i].DLOOP_VECTOR_BUF ),
                           (char *)target_addr + MPIU_PtrToAint( dloop_vec[i].DLOOP_VECTOR_BUF ),
                           &count, &type);
                }
                if (win_ptr->pt_rma_excl_lock == 0)
                    MPIDU_Process_unlock( &locks_base_addr[target_rank] );
                
                MPID_Segment_free(segp);
            }
	}
    }

 fn_exit:
    MPIU_CHKLMEM_FREEALL();
    MPIDI_FUNC_EXIT(MPID_STATE_MPIDI_CH3_ACCUMULATE);
    return mpi_errno;
    /* --BEGIN ERROR HANDLING-- */
 fn_fail:
    goto fn_exit;
    /* --END ERROR HANDLING-- */
}