/* MPID_Leaf_contig_count_block * * Note: because bufp is just an offset, we can ignore it in our * calculations of # of contig regions. */ static int DLOOP_Leaf_contig_count_block(DLOOP_Offset *blocks_p, DLOOP_Type el_type, DLOOP_Offset rel_off, DLOOP_Buffer bufp ATTRIBUTE((unused)), void *v_paramp) { DLOOP_Offset size, el_size; struct PREPEND_PREFIX(contig_blocks_params) *paramp = v_paramp; DLOOP_Assert(*blocks_p > 0); DLOOP_Handle_get_size_macro(el_type, el_size); size = *blocks_p * el_size; #ifdef MPID_SP_VERBOSE MPIU_dbg_printf("contig count block: count = %d, buf+off = %d, lastloc = " DLOOP_OFFSET_FMT_DEC_SPEC "\n", (int) paramp->count, (int) ((char *) bufp + rel_off), paramp->last_loc); #endif if (paramp->count > 0 && rel_off == paramp->last_loc) { /* this region is adjacent to the last */ paramp->last_loc += size; } else { /* new region */ paramp->last_loc = rel_off + size; paramp->count++; } return 0; }
/* DLOOP_Leaf_vector_mpi_flatten * * Input Parameters: * blocks_p - [inout] pointer to a count of blocks (total, for all noncontiguous pieces) * count - # of noncontiguous regions * blksz - size of each noncontiguous region * stride - distance in bytes from start of one region to start of next * el_type - elemental type (e.g. MPI_INT) * ... * * Note: this is only called when the starting position is at the beginning * of a whole block in a vector type. * * TODO: MAKE THIS CODE SMARTER, USING THE SAME GENERAL APPROACH AS IN THE * COUNT BLOCK CODE ABOVE. */ static int DLOOP_Leaf_vector_mpi_flatten(DLOOP_Offset *blocks_p, DLOOP_Count count, DLOOP_Count 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; DLOOP_Size size, blocks_left; DLOOP_Offset el_size; struct PREPEND_PREFIX(mpi_flatten_params) *paramp = v_paramp; DLOOP_Handle_get_size_macro(el_type, el_size); blocks_left = *blocks_p; for (i=0; i < count && blocks_left > 0; i++) { int last_idx; char *last_end = NULL; if (blocks_left > blksz) { size = blksz * el_size; blocks_left -= blksz; } else { /* last pass */ size = blocks_left * el_size; blocks_left = 0; } last_idx = paramp->index - 1; if (last_idx >= 0) { /* Since disps can be negative, we cannot use * DLOOP_Ensure_Offset_fits_in_pointer to verify that disps + * blklens fits in a pointer. Nor can we use * DLOOP_OFFSET_CAST_TO_VOID_PTR to cast the sum to a pointer. * Just let it truncate, if the sizeof a pointer is less * than the sizeof an MPI_Aint. */ last_end = (char *) DLOOP_OFFSET_CAST_TO_VOID_PTR (paramp->disps[last_idx] + (MPI_Aint)(paramp->blklens[last_idx])); } /* Since bufp can be a displacement and can be negative, we cannot use * DLOOP_Ensure_Offset_fits_in_pointer to ensure the sum fits in a pointer. * Just let it truncate. */ if ((last_idx == paramp->length-1) && (last_end != ((char *) bufp + rel_off))) { /* we have used up all our entries, and this one doesn't fit on * the end of the last one. */ *blocks_p -= (blocks_left + (size / el_size)); #ifdef MPID_SP_VERBOSE MPIU_dbg_printf("\t[vector to vec exiting (1): next ind = %d, " DLOOP_OFFSET_FMT_DEC_SPEC " blocks processed.\n", paramp->u.pack_vector.index, *blocks_p); #endif return 1; } else if (last_idx >= 0 && (last_end == ((char *) bufp + rel_off))) { /* add this size to the last vector rather than using up new one */ paramp->blklens[last_idx] += size; } else { /* Since bufp can be a displacement and can be negative, we cannot use * DLOOP_VOID_PTR_CAST_TO_OFFSET to cast the sum to a pointer. Just let it * sign extend. */ paramp->disps[last_idx+1] = DLOOP_PTR_DISP_CAST_TO_OFFSET bufp + rel_off; paramp->blklens[last_idx+1] = size; paramp->index++; } rel_off += stride; } #ifdef MPID_SP_VERBOSE MPIU_dbg_printf("\t[vector to vec exiting (2): next ind = %d, " DLOOP_OFFSET_FMT_DEC_SPEC " blocks processed.\n", paramp->u.pack_vector.index, *blocks_p); #endif /* if we get here then we processed ALL the blocks; don't need to update * blocks_p */ DLOOP_Assert(blocks_left == 0); return 0; }