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