mpid_segment.c

来自「mpi并行计算的c++代码 可用vc或gcc编译通过 可以用来搭建并行计算试验环」· C语言 代码 · 共 1,316 行 · 第 1/3 页

    dbg_printf("\t[vector unpack: do=%d, dp=%x, bp=%x, sz=%d, blksz=%d, str=%d, blks=%d]\n",
	       rel_off, 
	       (unsigned) bufp,
	       (unsigned) paramp->u.unpack.unpack_buffer,
	       (int) basic_size,
	       (int) blksz,
	       (int) stride,
	       (int) *blocks_p);
#endif

    if (basic_size == 8) {
	MPIDI_COPY_TO_VEC(paramp->u.unpack.unpack_buffer, cbufp, stride, int64_t, blksz, whole_count);
	MPIDI_COPY_TO_VEC(paramp->u.unpack.unpack_buffer, cbufp, 0, int64_t, blocks_left, 1);
    }
    else if (basic_size == 4) {
	MPIDI_COPY_TO_VEC(paramp->u.unpack.unpack_buffer, cbufp, stride, int32_t, blksz, whole_count);
	MPIDI_COPY_TO_VEC(paramp->u.unpack.unpack_buffer, cbufp, 0, int32_t, blocks_left, 1);
    }
    else if (basic_size == 2) {
	MPIDI_COPY_TO_VEC(paramp->u.unpack.unpack_buffer, cbufp, stride, int16_t, blksz, whole_count);
	MPIDI_COPY_TO_VEC(paramp->u.unpack.unpack_buffer, cbufp, 0, int16_t, blocks_left, 1);
    }
    else {
	for (i=0; i < whole_count; i++) {
#ifdef MPID_SU_VERBOSE
	    dbg_printf("\t[vector unpack(1): do=%d, dp=%x, bp=%x, sz=%d, blksz=%d]\n",
		       (int) (cbufp - (char *) bufp), 
		       (unsigned) bufp,
		       (unsigned) paramp->u.unpack.unpack_buffer,
		       basic_size,
		       (int) blksz * basic_size);
#endif
	    memcpy(cbufp, paramp->u.unpack.unpack_buffer, blksz * basic_size);
	    paramp->u.unpack.unpack_buffer += blksz * basic_size;
	    cbufp += stride;
	}
	if (blocks_left) {
#ifdef MPID_SU_VERBOSE
	    dbg_printf("\t[vector unpack(2): do=%d, dp=%x, bp=%x, sz=%d, blksz=%d]\n",
		       (int) (cbufp - (char *) bufp), 
		       (unsigned) bufp,
		       (unsigned) paramp->u.unpack.unpack_buffer,
		       basic_size,
		       (int) blocks_left * basic_size);
#endif
	    memcpy(cbufp, paramp->u.unpack.unpack_buffer, blocks_left * basic_size);
	    paramp->u.unpack.unpack_buffer += blocks_left * basic_size;
	}
    }
    MPIDI_FUNC_EXIT(MPID_STATE_MPID_SEGMENT_VECTOR_UNPACK_TO_BUF);
    return 0;
}

#undef FUNCNAME
#define FUNCNAME MPID_Segment_blkidx_unpack_to_buf
#undef FCNAME
#define FCNAME MPIDI_QUOTE(FUNCNAME)
/* MPID_Segment_blkidx_unpack_to_buf
 */
static int MPID_Segment_blkidx_unpack_to_buf(DLOOP_Offset *blocks_p,
					     int count,
					     int blocklen,
					     DLOOP_Offset *offsetarray,
					     DLOOP_Type el_type,
					     DLOOP_Offset rel_off,
					     void *bufp,
					     void *v_paramp)
{
    int curblock = 0, el_size;
    DLOOP_Offset blocks_left = *blocks_p;
    char *cbufp = (char *) bufp + rel_off;
    struct MPID_Segment_piece_params *paramp = v_paramp;
    MPIDI_STATE_DECL(MPID_STATE_MPID_SEGMENT_BLKIDX_UNPACK_TO_BUF);

    MPIDI_FUNC_ENTER(MPID_STATE_MPID_SEGMENT_BLKIDX_UNPACK_TO_BUF);

    MPIU_UNREFERENCED_ARG(count);

    el_size = MPID_Datatype_get_basic_size(el_type);

    while (blocks_left) {
	cbufp = (char *) bufp + rel_off + offsetarray[curblock];

	if (blocklen > blocks_left) blocklen = blocks_left;

	if (el_size == 8) {
	    /* note: macro updates pack buffer location */
	    MPIDI_COPY_TO_VEC(paramp->u.unpack.unpack_buffer,
			      cbufp, 0, int64_t, blocklen, 1);
	}
	else if (el_size == 4) {
	    MPIDI_COPY_TO_VEC(paramp->u.unpack.unpack_buffer,
			      cbufp, 0, int32_t, blocklen, 1);
	}
	else if (el_size == 2) {
	    MPIDI_COPY_TO_VEC(paramp->u.unpack.unpack_buffer,
			      cbufp, 0, int16_t, blocklen, 1);
	}
	else {
	    DLOOP_Offset size = blocklen * el_size;
	    memcpy(cbufp, paramp->u.unpack.unpack_buffer, size);
	    paramp->u.unpack.unpack_buffer += size;
	}
	blocks_left -= blocklen;
	curblock++;
    }
    MPIDI_FUNC_EXIT(MPID_STATE_MPID_SEGMENT_BLKIDX_UNPACK_TO_BUF);
    return 0;
}

#undef FUNCNAME
#define FUNCNAME MPID_Segment_index_unpack_to_buf
#undef FCNAME
#define FCNAME MPIDI_QUOTE(FUNCNAME)
/* MPID_Segment_index_unpack_to_buf
 */
static int MPID_Segment_index_unpack_to_buf(DLOOP_Offset *blocks_p,
					    int count,
					    int *blockarray,
					    DLOOP_Offset *offsetarray,
					    DLOOP_Type el_type,
					    DLOOP_Offset rel_off,
					    void *bufp,
					    void *v_paramp)
{
    int curblock = 0, el_size;
    DLOOP_Offset cur_block_sz, blocks_left = *blocks_p;
    char *cbufp = (char *) bufp + rel_off;
    struct MPID_Segment_piece_params *paramp = v_paramp;
    MPIDI_STATE_DECL(MPID_STATE_MPID_SEGMENT_INDEX_UNPACK_TO_BUF);

    MPIDI_FUNC_ENTER(MPID_STATE_MPID_SEGMENT_INDEX_UNPACK_TO_BUF);

    MPIU_UNREFERENCED_ARG(count);

    el_size = MPID_Datatype_get_basic_size(el_type);

    while (blocks_left) {
	cur_block_sz = blockarray[curblock];
	cbufp = (char *) bufp + rel_off + offsetarray[curblock];

	if (cur_block_sz > blocks_left) cur_block_sz = blocks_left;

	if (el_size == 8) {
	    /* note: macro updates pack buffer location */
	    MPIDI_COPY_TO_VEC(paramp->u.unpack.unpack_buffer, cbufp, 0, int64_t, cur_block_sz, 1);
	}
	else if (el_size == 4) {
	    MPIDI_COPY_TO_VEC(paramp->u.unpack.unpack_buffer, cbufp, 0, int32_t, cur_block_sz, 1);
	}
	else if (el_size == 2) {
	    MPIDI_COPY_TO_VEC(paramp->u.unpack.unpack_buffer, cbufp, 0, int16_t, cur_block_sz, 1);
	}
	else {
	    DLOOP_Offset size = cur_block_sz * el_size;
	    memcpy(cbufp, paramp->u.unpack.unpack_buffer, size);
	    paramp->u.unpack.unpack_buffer += size;
	}
	blocks_left -= cur_block_sz;
	curblock++;
    }
    MPIDI_FUNC_EXIT(MPID_STATE_MPID_SEGMENT_INDEX_UNPACK_TO_BUF);
    return 0;
}

/********** FUNCTIONS FOR PACKING INTO A BUFFER **********/

#undef FUNCNAME
#define FUNCNAME MPID_Segment_contig_pack_to_buf
#undef FCNAME
#define FCNAME MPIDI_QUOTE(FUNCNAME)
/* MPID_Segment_contig_pack_to_buf
 */
static int MPID_Segment_contig_pack_to_buf(DLOOP_Offset *blocks_p,
                                           DLOOP_Type el_type,
					   DLOOP_Offset rel_off,
					   void *bufp,
					   void *v_paramp)
{
    int el_size;
    DLOOP_Offset size;
    struct MPID_Segment_piece_params *paramp = v_paramp;
    MPIDI_STATE_DECL(MPID_STATE_MPID_SEGMENT_CONTIG_PACK_TO_BUF);

    MPIDI_FUNC_ENTER(MPID_STATE_MPID_SEGMENT_CONTIG_PACK_TO_BUF);

    el_size =MPID_Datatype_get_basic_size(el_type);
    size = *blocks_p * (DLOOP_Offset) el_size;

    /*
     * h  = handle value
     * do = datatype buffer offset
     * dp = datatype buffer pointer
     * bp = pack buffer pointer (current location, incremented as we go)
     * sz = size of datatype (guess we could get this from handle value if
     *      we wanted...)
     */
#ifdef MPID_SP_VERBOSE
    dbg_printf("\t[contig pack: do=%d, dp=%x, bp=%x, sz=%d, blksz=%d]\n",
	       rel_off, 
	       (unsigned) bufp,
	       (unsigned) paramp->u.pack.pack_buffer,
	       el_size,
	       (int) *blocks_p);
#endif

    /* TODO: DEAL WITH CASE WHERE ALL DATA DOESN'T FIT! */

    memcpy(paramp->u.pack.pack_buffer, (char *) bufp + rel_off, size);
    paramp->u.pack.pack_buffer += size;

    MPIDI_FUNC_EXIT(MPID_STATE_MPID_SEGMENT_CONTIG_PACK_TO_BUF);
    return 0;
}

#undef FUNCNAME
#define FUNCNAME MPID_Segment_vector_pack_to_buf
#undef FCNAME
#define FCNAME MPIDI_QUOTE(FUNCNAME)
/* MPID_Segment_vector_pack_to_buf
 *
 * Note: this is only called when the starting position is at the beginning
 * of a whole block in a vector type.
 */
static int MPID_Segment_vector_pack_to_buf(DLOOP_Offset *blocks_p,
					   int count,
					   int blksz,
					   DLOOP_Offset stride,
					   DLOOP_Type el_type,
					   DLOOP_Offset rel_off, /* offset into buffer */
					   void *bufp, /* start of buffer */
					   void *v_paramp)
{
    int i, basic_size;
    DLOOP_Offset blocks_left, whole_count;
    char *cbufp = (char *) bufp + rel_off;
    struct MPID_Segment_piece_params *paramp = v_paramp;
    MPIDI_STATE_DECL(MPID_STATE_MPID_SEGMENT_VECTOR_PACK_TO_BUF);

    MPIDI_FUNC_ENTER(MPID_STATE_MPID_SEGMENT_VECTOR_PACK_TO_BUF);

    MPIU_UNREFERENCED_ARG(count);

    basic_size = MPID_Datatype_get_basic_size(el_type);

    whole_count = (blksz > 0) ? (*blocks_p / blksz) : 0;
    blocks_left = (blksz > 0) ? (*blocks_p % blksz) : 0;

#ifdef MPID_SP_VERBOSE
    dbg_printf("\t[vector pack: do=%d, dp=%x, bp=%x, sz=%d, blksz=%d, str=%d, blks=%d]\n",
	       rel_off, 
	       (unsigned) bufp,
	       (unsigned) paramp->u.pack.pack_buffer,
	       (int) basic_size,
	       (int) blksz,
	       (int) stride,
	       (int) *blocks_p);
#endif

    if (basic_size == 8) {
	MPIDI_COPY_FROM_VEC(cbufp, paramp->u.pack.pack_buffer, stride, int64_t, blksz, whole_count);
	MPIDI_COPY_FROM_VEC(cbufp, paramp->u.pack.pack_buffer, 0, int64_t, blocks_left, 1);
    }
    else if (basic_size == 4) {
	MPIDI_COPY_FROM_VEC(cbufp, paramp->u.pack.pack_buffer, stride, int32_t, blksz, whole_count);
	MPIDI_COPY_FROM_VEC(cbufp, paramp->u.pack.pack_buffer, 0, int32_t, blocks_left, 1);
    }
    else if (basic_size == 2) {
	MPIDI_COPY_FROM_VEC(cbufp, paramp->u.pack.pack_buffer, stride, int16_t, blksz, whole_count);
	MPIDI_COPY_FROM_VEC(cbufp, paramp->u.pack.pack_buffer, 0, int16_t, blocks_left, 1);
    }
    else {
	for (i=0; i < whole_count; i++) {
#ifdef MPID_SP_VERBOSE
	    dbg_printf("\t[vector pack(1): do=%d, dp=%x, bp=%x, sz=%d, blksz=%d]\n",
		       (int) (cbufp - (char *) bufp), 
		       (unsigned) bufp,
		       (unsigned) paramp->u.pack.pack_buffer,
		       basic_size,
		       (int) blksz * basic_size);
#endif
	    memcpy(paramp->u.pack.pack_buffer, cbufp, blksz * basic_size);
	    paramp->u.pack.pack_buffer += blksz * basic_size;
	    cbufp += stride;
	}
	if (blocks_left) {
#ifdef MPID_SP_VERBOSE
	    dbg_printf("\t[vector pack(2): do=%d, dp=%x, bp=%x, sz=%d, blksz=%d]\n",
		       (int) (cbufp - (char *) bufp), 
		       (unsigned) bufp,
		       (unsigned) paramp->u.pack.pack_buffer,
		       basic_size,
		       (int) blocks_left * basic_size);
#endif
	    memcpy(paramp->u.pack.pack_buffer, cbufp, blocks_left * basic_size);
	    paramp->u.pack.pack_buffer += blocks_left * basic_size;
	}
    }
    MPIDI_FUNC_EXIT(MPID_STATE_MPID_SEGMENT_VECTOR_PACK_TO_BUF);
    return 0;
}

#undef FUNCNAME
#define FUNCNAME MPID_Segment_index_pack_to_buf
#undef FCNAME
#define FCNAME MPIDI_QUOTE(FUNCNAME)
/* MPID_Segment_index_pack_to_buf
 */
static int MPID_Segment_index_pack_to_buf(DLOOP_Offset *blocks_p,
					  int count,
					  int *blockarray,
					  DLOOP_Offset *offsetarray,
                                          DLOOP_Type el_type,
					  DLOOP_Offset rel_off,
					  void *bufp,
					  void *v_paramp)
{
    int curblock = 0, el_size;
    DLOOP_Offset cur_block_sz, blocks_left = *blocks_p;
    char *cbufp;
    struct MPID_Segment_piece_params *paramp = v_paramp;
    MPIDI_STATE_DECL(MPID_STATE_MPID_SEGMENT_INDEX_PACK_TO_BUF);

    MPIDI_FUNC_ENTER(MPID_STATE_MPID_SEGMENT_INDEX_PACK_TO_BUF);

    MPIU_UNREFERENCED_ARG(count);

    el_size = MPID_Datatype_get_basic_size(el_type);

#ifdef MPID_SP_VERBOSE
    dbg_printf("\t[index pack: do=%d, dp=%x, bp=%x, sz=%d (%s), cnt=%d, blks=%d]\n",
	       rel_off, 
	       (unsigned) bufp,
	       (unsigned) paramp->u.pack.pack_buffer,
	       (int) el_size,
	       MPIDU_Datatype_builtin_to_string(el_type),
	       (int) count,
	       (int) *blocks_p);
#endif

    while (blocks_left) {
	MPIU_Assert(curblock < count);
	cur_block_sz = blockarray[curblock];
	cbufp = (char *) bufp + rel_off + offsetarray[curblock];

	if (cur_block_sz > blocks_left) cur_block_sz = blocks_left;

#ifdef MPID_SP_VERBOSE
	    dbg_printf("\t[index pack(1): do=%d, dp=%x, bp=%x, sz=%d, blksz=%d]\n",
		       (int) (cbufp - (char *) bufp), 
		       (unsigned) bufp,
		       (unsigned) paramp->u.pack.pack_buffer,
		       el_size,
		       (int) cur_block_sz * el_size);
#endif
	if (el_size == 8) {
	    /* note: macro updates pack buffer location */
	    MPIDI_COPY_FROM_VEC(cbufp, paramp->u.pack.pack_buffer, 0, int64_t, cur_block_sz, 1);
	}
	else if (el_size == 4) {
	    MPIDI_COPY_FROM_VEC(cbufp, paramp->u.pack.pack_buffer, 0, int32_t, cur_block_sz, 1);
	}
	else if (el_size == 2) {
	    MPIDI_COPY_FROM_VEC(cbufp, paramp->u.pack.pack_buffer, 0, int16_t, cur_block_sz, 1);
	}
	else {
	    DLOOP_Offset size = cur_block_sz * el_size;

	    memcpy(paramp->u.pack.pack_buffer, cbufp, size);
	    paramp->u.pack.pack_buffer += size;
	}
	blocks_left -= cur_block_sz;
	curblock++;
    }
    MPIDI_FUNC_EXIT(MPID_STATE_MPID_SEGMENT_INDEX_PACK_TO_BUF);
    return 0;
}


#undef FUNCNAME
#define FUNCNAME MPID_Segment_blkidx_pack_to_buf
#undef FCNAME
#define FCNAME MPIDI_QUOTE(FUNCNAME)
/* MPID_Segment_blkidx_pack_to_buf
 */
static int MPID_Segment_blkidx_pack_to_buf(DLOOP_Offset *blocks_p,
					   int count,
					   int blocklen,
					   DLOOP_Offset *offsetarray,
					   DLOOP_Type el_type,
					   DLOOP_Offset rel_off,
					   void *bufp,
					   void *v_paramp)
{
    int curblock = 0, el_size;
    DLOOP_Offset blocks_left = *blocks_p;
    char *cbufp;
    struct MPID_Segment_piece_params *paramp = v_paramp;
    MPIDI_STATE_DECL(MPID_STATE_MPID_SEGMENT_BLKIDX_PACK_TO_BUF);

    MPIDI_FUNC_ENTER(MPID_STATE_MPID_SEGMENT_BLKIDX_PACK_TO_BUF);

    MPIU_UNREFERENCED_ARG(count);

    el_size = MPID_Datatype_get_basic_size(el_type);

    while (blocks_left) {
	MPIU_Assert(curblock < count);
	cbufp = (char *) bufp + rel_off + offsetarray[curblock];

	if (blocklen > blocks_left) blocklen = blocks_left;

	if (el_size == 8) {
	    /* note: macro updates pack buffer location */
	    MPIDI_COPY_FROM_VEC(cbufp, paramp->u.pack.pack_buffer,
				0, int64_t, blocklen, 1);
	}
	else if (el_size == 4) {
	    MPIDI_COPY_FROM_VEC(cbufp, paramp->u.pack.pack_buffer,
				0, int32_t, blocklen, 1);
	}
	else if (el_size == 2) {
	    MPIDI_COPY_FROM_VEC(cbufp, paramp->u.pack.pack_buffer,
				0, int16_t, blocklen, 1);
	}
	else {
	    DLOOP_Offset size = blocklen * el_size;

	    memcpy(paramp->u.pack.pack_buffer, cbufp, size);
	    paramp->u.pack.pack_buffer += size;
	}
	blocks_left -= blocklen;
	curblock++;
    }
    MPIDI_FUNC_EXIT(MPID_STATE_MPID_SEGMENT_BLKIDX_PACK_TO_BUF);
    return 0;
}