static inline int connection_pop_sendq_req(MPIDI_CH3I_Connection_t * conn)
{
int mpi_errno = MPI_SUCCESS;
MPIDI_CH3I_VC *vcch = &conn->vc->ch;
MPIR_FUNC_VERBOSE_STATE_DECL(MPID_STATE_CONNECTION_POP_SENDQ_REQ);
MPIR_FUNC_VERBOSE_ENTER(MPID_STATE_CONNECTION_POP_SENDQ_REQ);
/* post send of next request on the send queue */
/* FIXME: Is dequeue/get next the operation we really want? */
MPIDI_CH3I_SendQ_dequeue(vcch);
conn->send_active = MPIDI_CH3I_SendQ_head(vcch); /* MT */
if (conn->send_active != NULL)
{
MPL_DBG_MSG_P(MPIDI_CH3_DBG_CONNECT,TYPICAL,"conn=%p: Posting message from connection send queue", conn );
mpi_errno = MPIDI_CH3I_Sock_post_writev(conn->sock, conn->send_active->dev.iov, conn->send_active->dev.iov_count, NULL);
if (mpi_errno != MPI_SUCCESS) {
MPIR_ERR_POP(mpi_errno);
}
}
fn_fail:
MPIR_FUNC_VERBOSE_EXIT(MPID_STATE_CONNECTION_POP_SENDQ_REQ);
return mpi_errno;
}
int MPIDI_CH3_PktHandler_EagerSyncAck( MPIDI_VC_t *vc, MPIDI_CH3_Pkt_t *pkt,
intptr_t *buflen, MPIR_Request **rreqp )
{
MPIDI_CH3_Pkt_eager_sync_ack_t * esa_pkt = &pkt->eager_sync_ack;
MPIR_Request * sreq;
int mpi_errno = MPI_SUCCESS;
MPL_DBG_MSG_P(MPIDI_CH3_DBG_OTHER,VERBOSE,
"received eager sync ack pkt, sreq=0x%08x", esa_pkt->sender_req_id);
MPIR_Request_get_ptr(esa_pkt->sender_req_id, sreq);
/* decrement CC (but don't mark data transfer as complete since the
transfer could still be in progress) */
/* FIXME: This sometimes segfaults */
mpi_errno = MPID_Request_complete(sreq);
if (mpi_errno != MPI_SUCCESS) {
MPIR_ERR_POP(mpi_errno);
}
*buflen = sizeof(MPIDI_CH3_Pkt_t);
*rreqp = NULL;
fn_exit:
return mpi_errno;
fn_fail:
goto fn_exit;
}
static void big_get(void *buf, ptl_size_t left_to_get, MPIDI_VC_t *vc, ptl_match_bits_t match_bits, MPIR_Request *rreq)
{
int ret;
MPID_nem_ptl_vc_area *vc_ptl;
ptl_size_t start, get_sz;
vc_ptl = VC_PTL(vc);
start = (ptl_size_t)buf;
/* we need to handle all events */
REQ_PTL(rreq)->event_handler = handler_recv_big_get;
while (left_to_get > 0) {
/* get up to the maximum allowed by the portals interface */
get_sz = MPL_MIN(MPIDI_nem_ptl_ni_limits.max_msg_size, left_to_get);
ret = MPID_nem_ptl_rptl_get(MPIDI_nem_ptl_global_md, start, get_sz, vc_ptl->id, vc_ptl->ptg, match_bits, 0, rreq);
DBG_MSG_GET("global", get_sz, vc->pg_rank, match_bits);
MPL_DBG_MSG_P(MPIDI_CH3_DBG_CHANNEL, VERBOSE, " buf=%p", (char *)start);
MPIR_Assert(ret == 0);
/* account for what has been sent */
start += get_sz;
left_to_get -= get_sz;
REQ_PTL(rreq)->num_gets++;
}
}
int MPID_Cancel_recv(MPIR_Request * rreq)
{
int netmod_cancelled = TRUE;
int mpi_errno = MPI_SUCCESS;
MPIR_FUNC_VERBOSE_STATE_DECL(MPID_STATE_MPID_CANCEL_RECV);
MPIR_FUNC_VERBOSE_ENTER(MPID_STATE_MPID_CANCEL_RECV);
MPIR_Assert(rreq->kind == MPIR_REQUEST_KIND__RECV);
/* If the netmod has its own cancel_recv function, we need to call
it here. ANYSOURCE cancels (netmod and otherwise) are handled by
MPIDI_CH3U_Recvq_DP below. */
#ifdef ENABLE_COMM_OVERRIDES
if (rreq->dev.match.parts.rank != MPI_ANY_SOURCE)
{
MPIDI_VC_t *vc;
MPIDI_Comm_get_vc_set_active(rreq->comm, rreq->dev.match.parts.rank, &vc);
if (vc->comm_ops && vc->comm_ops->cancel_recv)
netmod_cancelled = !vc->comm_ops->cancel_recv(NULL, rreq);
}
#endif
if (netmod_cancelled && MPIDI_CH3U_Recvq_DP(rreq))
{
MPL_DBG_MSG_P(MPIDI_CH3_DBG_OTHER,VERBOSE,
"request 0x%08x cancelled", rreq->handle);
MPIR_STATUS_SET_CANCEL_BIT(rreq->status, TRUE);
MPIR_STATUS_SET_COUNT(rreq->status, 0);
mpi_errno = MPID_Request_complete(rreq);
if (mpi_errno != MPI_SUCCESS) {
MPIR_ERR_POP(mpi_errno);
}
}
else
{
MPL_DBG_MSG_P(MPIDI_CH3_DBG_OTHER,VERBOSE,
"request 0x%08x already matched, unable to cancel", rreq->handle);
}
fn_exit:
MPIR_FUNC_VERBOSE_EXIT(MPID_STATE_MPID_CANCEL_RECV);
return mpi_errno;
fn_fail:
goto fn_exit;
}
int MPIDI_CH3_VC_Destroy(MPIDI_VC_t *vc )
{
int mpi_errno = MPI_SUCCESS;
MPIR_FUNC_VERBOSE_STATE_DECL(MPID_STATE_MPIDI_CH3_VC_DESTROY);
MPIR_FUNC_VERBOSE_ENTER(MPID_STATE_MPIDI_CH3_VC_DESTROY);
/* no need to destroy vc to self, this corresponds to the optimization above
* in MPIDI_CH3_VC_Init */
if (vc->pg == MPIDI_CH3I_my_pg && vc->pg_rank == MPIDI_CH3I_my_rank) {
MPL_DBG_MSG_P(MPIDI_CH3_DBG_VC, VERBOSE, "skipping self vc=%p", vc);
goto fn_exit;
}
mpi_errno = MPID_nem_vc_destroy(vc);
fn_exit:
MPIR_FUNC_VERBOSE_EXIT(MPID_STATE_MPIDI_CH3_VC_DESTROY);
return mpi_errno;
}
int MPID_nem_ptl_poll(int is_blocking_poll)
{
int mpi_errno = MPI_SUCCESS;
ptl_event_t event;
int ret;
MPIDI_STATE_DECL(MPID_STATE_MPID_NEM_PTL_POLL);
/* MPIDI_FUNC_ENTER(MPID_STATE_MPID_NEM_PTL_POLL); */
while (1) {
int ctl_event = FALSE;
/* Check the rptls EQ first. It should never return an event. */
ret = MPID_nem_ptl_rptl_eqget(MPIDI_nem_ptl_rpt_eq, &event);
MPIU_Assert(ret == PTL_EQ_EMPTY);
/* check EQs for events */
ret = MPID_nem_ptl_rptl_eqget(MPIDI_nem_ptl_eq, &event);
MPIR_ERR_CHKANDJUMP(ret == PTL_EQ_DROPPED, mpi_errno, MPI_ERR_OTHER, "**eqdropped");
if (ret == PTL_EQ_EMPTY) {
ret = MPID_nem_ptl_rptl_eqget(MPIDI_nem_ptl_get_eq, &event);
MPIR_ERR_CHKANDJUMP(ret == PTL_EQ_DROPPED, mpi_errno, MPI_ERR_OTHER, "**eqdropped");
if (ret == PTL_EQ_EMPTY) {
ret = MPID_nem_ptl_rptl_eqget(MPIDI_nem_ptl_control_eq, &event);
MPIR_ERR_CHKANDJUMP(ret == PTL_EQ_DROPPED, mpi_errno, MPI_ERR_OTHER, "**eqdropped");
if (ret == PTL_EQ_EMPTY) {
ret = MPID_nem_ptl_rptl_eqget(MPIDI_nem_ptl_origin_eq, &event);
MPIR_ERR_CHKANDJUMP(ret == PTL_EQ_DROPPED, mpi_errno, MPI_ERR_OTHER, "**eqdropped");
} else {
ctl_event = TRUE;
}
/* all EQs are empty */
if (ret == PTL_EQ_EMPTY)
break;
}
}
MPIR_ERR_CHKANDJUMP1(ret, mpi_errno, MPI_ERR_OTHER, "**ptleqget", "**ptleqget %s", MPID_nem_ptl_strerror(ret));
MPL_DBG_MSG_FMT(MPIDI_CH3_DBG_CHANNEL, VERBOSE, (MPL_DBG_FDEST, "Received event %s pt_idx=%d ni_fail=%s list=%s user_ptr=%p hdr_data=%#lx mlength=%lu rlength=%lu",
MPID_nem_ptl_strevent(&event), event.pt_index, MPID_nem_ptl_strnifail(event.ni_fail_type),
MPID_nem_ptl_strlist(event.ptl_list), event.user_ptr, event.hdr_data, event.mlength, event.rlength));
MPIR_ERR_CHKANDJUMP2(event.ni_fail_type != PTL_NI_OK && event.ni_fail_type != PTL_NI_NO_MATCH, mpi_errno, MPI_ERR_OTHER, "**ptlni_fail", "**ptlni_fail %s %s", MPID_nem_ptl_strevent(&event), MPID_nem_ptl_strnifail(event.ni_fail_type));
/* special case for events on the control portal */
if (ctl_event) {
mpi_errno = MPID_nem_ptl_nm_ctl_event_handler(&event);
if (mpi_errno) MPIR_ERR_POP(mpi_errno);
continue;
}
switch (event.type) {
case PTL_EVENT_PUT:
if (event.ptl_list == PTL_OVERFLOW_LIST)
break;
case PTL_EVENT_PUT_OVERFLOW:
case PTL_EVENT_GET:
case PTL_EVENT_SEND:
case PTL_EVENT_REPLY:
case PTL_EVENT_SEARCH: {
MPID_Request * const req = event.user_ptr;
MPL_DBG_MSG_P(MPIDI_CH3_DBG_CHANNEL, VERBOSE, "req = %p", req);
MPL_DBG_MSG_P(MPIDI_CH3_DBG_CHANNEL, VERBOSE, "REQ_PTL(req)->event_handler = %p", REQ_PTL(req)->event_handler);
if (REQ_PTL(req)->event_handler) {
mpi_errno = REQ_PTL(req)->event_handler(&event);
if (mpi_errno) MPIR_ERR_POP(mpi_errno);
}
break;
}
case PTL_EVENT_AUTO_FREE:
mpi_errno = append_overflow((size_t)event.user_ptr);
if (mpi_errno) MPIR_ERR_POP(mpi_errno);
break;
case PTL_EVENT_AUTO_UNLINK:
overflow_me_handle[(size_t)event.user_ptr] = PTL_INVALID_HANDLE;
break;
case PTL_EVENT_LINK:
/* ignore */
break;
case PTL_EVENT_ACK:
default:
MPL_error_printf("Received unexpected event type: %d %s", event.type, MPID_nem_ptl_strevent(&event));
MPIR_ERR_INTERNALANDJUMP(mpi_errno, "Unexpected event type");
}
}
fn_exit:
/* MPIDI_FUNC_EXIT(MPID_STATE_MPID_NEM_PTL_POLL); */
return mpi_errno;
fn_fail:
goto fn_exit;
}
/*@
MPIDU_Type_vector - create a vector datatype
Input Parameters:
+ count - number of blocks in vector
. blocklength - number of elements in each block
. stride - distance from beginning of one block to the next (see next
parameter for units)
. strideinbytes - if nonzero, then stride is in bytes, otherwise stride
is in terms of extent of oldtype
- oldtype - type (using handle) of datatype on which vector is based
Output Parameters:
. newtype - handle of new vector datatype
Return Value:
0 on success, MPI error code on failure.
@*/
int MPIDU_Type_vector(int count,
int blocklength,
MPI_Aint stride,
int strideinbytes,
MPI_Datatype oldtype,
MPI_Datatype *newtype)
{
int mpi_errno = MPI_SUCCESS;
int is_builtin, old_is_contig;
MPI_Aint el_sz, old_sz;
MPI_Datatype el_type;
MPI_Aint old_lb, old_ub, old_extent, old_true_lb, old_true_ub, eff_stride;
MPIDU_Datatype *new_dtp;
if (count == 0) return MPIDU_Type_zerolen(newtype);
/* allocate new datatype object and handle */
new_dtp = (MPIDU_Datatype *) MPIR_Handle_obj_alloc(&MPIDU_Datatype_mem);
if (!new_dtp) {
/* --BEGIN ERROR HANDLING-- */
mpi_errno = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
"MPIDU_Type_vector", __LINE__,
MPI_ERR_OTHER, "**nomem", 0);
return mpi_errno;
/* --END ERROR HANDLING-- */
}
/* handle is filled in by MPIR_Handle_obj_alloc() */
MPIR_Object_set_ref(new_dtp, 1);
new_dtp->is_permanent = 0;
new_dtp->is_committed = 0;
new_dtp->attributes = NULL;
new_dtp->cache_id = 0;
new_dtp->name[0] = 0;
new_dtp->contents = NULL;
new_dtp->dataloop = NULL;
new_dtp->dataloop_size = -1;
new_dtp->dataloop_depth = -1;
new_dtp->hetero_dloop = NULL;
new_dtp->hetero_dloop_size = -1;
new_dtp->hetero_dloop_depth = -1;
is_builtin = (HANDLE_GET_KIND(oldtype) == HANDLE_KIND_BUILTIN);
if (is_builtin) {
el_sz = (MPI_Aint) MPIDU_Datatype_get_basic_size(oldtype);
el_type = oldtype;
old_lb = 0;
old_true_lb = 0;
old_ub = el_sz;
old_true_ub = el_sz;
old_sz = el_sz;
old_extent = el_sz;
old_is_contig = 1;
new_dtp->size = (MPI_Aint) count *
(MPI_Aint) blocklength * el_sz;
new_dtp->has_sticky_lb = 0;
new_dtp->has_sticky_ub = 0;
new_dtp->alignsize = el_sz; /* ??? */
new_dtp->n_builtin_elements = count * blocklength;
new_dtp->builtin_element_size = el_sz;
new_dtp->basic_type = el_type;
new_dtp->max_contig_blocks = count;
eff_stride = (strideinbytes) ? stride : (stride * el_sz);
}
else /* user-defined base type (oldtype) */ {
MPIDU_Datatype *old_dtp;
MPIDU_Datatype_get_ptr(oldtype, old_dtp);
el_sz = old_dtp->builtin_element_size;
el_type = old_dtp->basic_type;
old_lb = old_dtp->lb;
old_true_lb = old_dtp->true_lb;
old_ub = old_dtp->ub;
old_true_ub = old_dtp->true_ub;
old_sz = old_dtp->size;
old_extent = old_dtp->extent;
old_is_contig = old_dtp->is_contig;
new_dtp->size = count * blocklength * old_dtp->size;
new_dtp->has_sticky_lb = old_dtp->has_sticky_lb;
new_dtp->has_sticky_ub = old_dtp->has_sticky_ub;
new_dtp->alignsize = old_dtp->alignsize;
new_dtp->n_builtin_elements = count * blocklength * old_dtp->n_builtin_elements;
new_dtp->builtin_element_size = el_sz;
new_dtp->basic_type = el_type;
new_dtp->max_contig_blocks = old_dtp->max_contig_blocks * count * blocklength;
eff_stride = (strideinbytes) ? stride : (stride * old_dtp->extent);
}
MPIDU_DATATYPE_VECTOR_LB_UB((MPI_Aint) count,
eff_stride,
(MPI_Aint) blocklength,
old_lb,
old_ub,
old_extent,
new_dtp->lb,
new_dtp->ub);
new_dtp->true_lb = new_dtp->lb + (old_true_lb - old_lb);
new_dtp->true_ub = new_dtp->ub + (old_true_ub - old_ub);
new_dtp->extent = new_dtp->ub - new_dtp->lb;
/* new type is only contig for N types if old one was, and
* size and extent of new type are equivalent, and stride is
* equal to blocklength * size of old type.
*/
if ((MPI_Aint)(new_dtp->size) == new_dtp->extent &&
eff_stride == (MPI_Aint) blocklength * old_sz &&
old_is_contig)
{
new_dtp->is_contig = 1;
new_dtp->max_contig_blocks = 1;
}
else {
new_dtp->is_contig = 0;
}
*newtype = new_dtp->handle;
MPL_DBG_MSG_P(MPIR_DBG_DATATYPE,VERBOSE,"vector type %x created.",
new_dtp->handle);
return mpi_errno;
}
int MPID_Issend(const void * buf, int count, MPI_Datatype datatype, int rank, int tag, MPIR_Comm * comm, int context_offset,
MPIR_Request ** request)
{
intptr_t data_sz;
int dt_contig;
MPI_Aint dt_true_lb;
MPIR_Datatype* dt_ptr;
MPIR_Request * sreq;
MPIDI_VC_t * vc=0;
#if defined(MPID_USE_SEQUENCE_NUMBERS)
MPID_Seqnum_t seqnum;
#endif
int eager_threshold = -1;
int mpi_errno = MPI_SUCCESS;
MPIR_FUNC_VERBOSE_STATE_DECL(MPID_STATE_MPID_ISSEND);
MPIR_FUNC_VERBOSE_ENTER(MPID_STATE_MPID_ISSEND);
MPL_DBG_MSG_FMT(MPIDI_CH3_DBG_OTHER,VERBOSE,(MPL_DBG_FDEST,
"rank=%d, tag=%d, context=%d",
rank, tag, comm->context_id + context_offset));
/* Check to make sure the communicator hasn't already been revoked */
if (comm->revoked &&
MPIR_AGREE_TAG != MPIR_TAG_MASK_ERROR_BITS(tag & ~MPIR_TAG_COLL_BIT) &&
MPIR_SHRINK_TAG != MPIR_TAG_MASK_ERROR_BITS(tag & ~MPIR_TAG_COLL_BIT)) {
MPIR_ERR_SETANDJUMP(mpi_errno,MPIX_ERR_REVOKED,"**revoked");
}
if (rank == comm->rank && comm->comm_kind != MPIR_COMM_KIND__INTERCOMM)
{
mpi_errno = MPIDI_Isend_self(buf, count, datatype, rank, tag, comm, context_offset, MPIDI_REQUEST_TYPE_SSEND, &sreq);
goto fn_exit;
}
if (rank != MPI_PROC_NULL)
{
MPIDI_Comm_get_vc_set_active(comm, rank, &vc);
/* this needs to come before the sreq is created, since the override */
/* function is responsible for creating its own request */
#ifdef ENABLE_COMM_OVERRIDES
if (vc->comm_ops && vc->comm_ops->issend)
{
mpi_errno = vc->comm_ops->issend( vc, buf, count, datatype, rank, tag, comm, context_offset, &sreq);
goto fn_exit;
}
#endif
}
MPIDI_Request_create_sreq(sreq, mpi_errno, goto fn_exit);
MPIDI_Request_set_type(sreq, MPIDI_REQUEST_TYPE_SSEND);
if (rank == MPI_PROC_NULL)
{
MPIR_Object_set_ref(sreq, 1);
MPIR_cc_set(&sreq->cc, 0);
goto fn_exit;
}
MPIDI_Datatype_get_info(count, datatype, dt_contig, data_sz, dt_ptr, dt_true_lb);
if (data_sz == 0)
{
mpi_errno = MPIDI_CH3_EagerSyncZero( &sreq, rank, tag, comm,
context_offset );
goto fn_exit;
}
MPIDI_CH3_GET_EAGER_THRESHOLD(&eager_threshold, comm, vc);
if (data_sz + sizeof(MPIDI_CH3_Pkt_eager_sync_send_t) <= eager_threshold)
{
mpi_errno = MPIDI_CH3_EagerSyncNoncontigSend( &sreq, buf, count,
datatype, data_sz,
dt_contig, dt_true_lb,
rank, tag, comm,
context_offset );
/* If we're not complete and this is a derived datatype
* communication, then add a reference to the datatype */
if (sreq && (HANDLE_GET_KIND(datatype) != HANDLE_KIND_BUILTIN)) {
sreq->dev.datatype_ptr = dt_ptr;
MPIR_Datatype_ptr_add_ref(dt_ptr);
}
}
else
{
/* Note that the sreq was created above */
MPIDI_Request_set_msg_type(sreq, MPIDI_REQUEST_RNDV_MSG);
mpi_errno = vc->rndvSend_fn( &sreq, buf, count, datatype, dt_contig,
data_sz, dt_true_lb, rank, tag, comm,
context_offset );
/* FIXME: fill temporary IOV or pack temporary buffer after send to
hide some latency. This requires synchronization
because the CTS packet could arrive and be processed before the
above iStartmsg completes (depending on the progress
engine, threads, etc.). */
if (sreq && dt_ptr != NULL)
{
sreq->dev.datatype_ptr = dt_ptr;
MPIR_Datatype_ptr_add_ref(dt_ptr);
}
}
fn_exit:
*request = sreq;
MPL_DBG_STMT(MPIDI_CH3_DBG_OTHER,VERBOSE,
{
if (sreq != NULL) {
MPL_DBG_MSG_P(MPIDI_CH3_DBG_OTHER,VERBOSE,
"request allocated, handle=0x%08x", sreq->handle);
}
}
)
/*@
MPIR_Type_contiguous - create a contiguous datatype
Input Parameters:
+ count - number of elements in the contiguous block
- oldtype - type (using handle) of datatype on which vector is based
Output Parameters:
. newtype - handle of new contiguous datatype
Return Value:
MPI_SUCCESS on success, MPI error code on failure.
@*/
int MPIR_Type_contiguous(int count,
MPI_Datatype oldtype,
MPI_Datatype *newtype)
{
int mpi_errno = MPI_SUCCESS;
int is_builtin;
MPI_Aint el_sz;
MPI_Datatype el_type;
MPIR_Datatype *new_dtp;
if (count == 0) return MPII_Type_zerolen(newtype);
/* allocate new datatype object and handle */
new_dtp = (MPIR_Datatype *) MPIR_Handle_obj_alloc(&MPIR_Datatype_mem);
/* --BEGIN ERROR HANDLING-- */
if (!new_dtp)
{
mpi_errno = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE,
"MPIR_Type_contiguous",
__LINE__, MPI_ERR_OTHER,
"**nomem", 0);
return mpi_errno;
}
/* --END ERROR HANDLING-- */
/* handle is filled in by MPIR_Handle_obj_alloc() */
MPIR_Object_set_ref(new_dtp, 1);
new_dtp->is_permanent = 0;
new_dtp->is_committed = 0;
new_dtp->attributes = NULL;
new_dtp->cache_id = 0;
new_dtp->name[0] = 0;
new_dtp->contents = NULL;
new_dtp->dataloop = NULL;
new_dtp->dataloop_size = -1;
new_dtp->dataloop_depth = -1;
new_dtp->hetero_dloop = NULL;
new_dtp->hetero_dloop_size = -1;
new_dtp->hetero_dloop_depth = -1;
is_builtin = (HANDLE_GET_KIND(oldtype) == HANDLE_KIND_BUILTIN);
if (is_builtin)
{
el_sz = MPIR_Datatype_get_basic_size(oldtype);
el_type = oldtype;
new_dtp->size = count * el_sz;
new_dtp->has_sticky_ub = 0;
new_dtp->has_sticky_lb = 0;
new_dtp->true_lb = 0;
new_dtp->lb = 0;
new_dtp->true_ub = count * el_sz;
new_dtp->ub = new_dtp->true_ub;
new_dtp->extent = new_dtp->ub - new_dtp->lb;
new_dtp->alignsize = el_sz;
new_dtp->n_builtin_elements = count;
new_dtp->builtin_element_size = el_sz;
new_dtp->basic_type = el_type;
new_dtp->is_contig = 1;
new_dtp->max_contig_blocks = 1;
}
else
{
/* user-defined base type (oldtype) */
MPIR_Datatype *old_dtp;
MPIR_Datatype_get_ptr(oldtype, old_dtp);
el_sz = old_dtp->builtin_element_size;
el_type = old_dtp->basic_type;
new_dtp->size = count * old_dtp->size;
new_dtp->has_sticky_ub = old_dtp->has_sticky_ub;
new_dtp->has_sticky_lb = old_dtp->has_sticky_lb;
MPII_DATATYPE_CONTIG_LB_UB((MPI_Aint) count,
old_dtp->lb,
old_dtp->ub,
old_dtp->extent,
new_dtp->lb,
new_dtp->ub);
/* easiest to calc true lb/ub relative to lb/ub; doesn't matter
* if there are sticky lb/ubs or not when doing this.
*/
new_dtp->true_lb = new_dtp->lb + (old_dtp->true_lb - old_dtp->lb);
new_dtp->true_ub = new_dtp->ub + (old_dtp->true_ub - old_dtp->ub);
new_dtp->extent = new_dtp->ub - new_dtp->lb;
new_dtp->alignsize = old_dtp->alignsize;
new_dtp->n_builtin_elements = count * old_dtp->n_builtin_elements;
new_dtp->builtin_element_size = old_dtp->builtin_element_size;
new_dtp->basic_type = el_type;
MPIR_Datatype_is_contig(oldtype, &new_dtp->is_contig);
if(new_dtp->is_contig)
new_dtp->max_contig_blocks = 1;
else
new_dtp->max_contig_blocks = count * old_dtp->max_contig_blocks;
}
*newtype = new_dtp->handle;
MPL_DBG_MSG_P(MPIR_DBG_DATATYPE,VERBOSE,"contig type %x created.",
new_dtp->handle);
return mpi_errno;
}
