int MPI_Ssend_init(MPE_CONST void *buf, int count, MPI_Datatype datatype,
int dest, int tag, MPI_Comm comm, MPI_Request *request)
{
int returnVal;
request_list *newrq;
int typesize3;
/* fprintf( stderr, "MPI_Ssend_init call on %d\n", procid_1 ); */
returnVal = PMPI_Ssend_init( buf, count, datatype, dest, tag, comm, request );
if (dest != MPI_PROC_NULL) {
rq_alloc( requests_avail_1, newrq );
if (newrq) {
PMPI_Type_size( datatype, &typesize3 );
newrq->request = *request;
newrq->status = RQ_SEND;
newrq->size = count * typesize3;
newrq->tag = tag;
newrq->otherParty = dest;
newrq->next = 0;
rq_add( requests_head_1, requests_tail_1, newrq );
}
}
return returnVal;
}
int MPI_Sendrecv(const void *sendbuf, int sendcount, MPI_Datatype sendtype,
int dest, int sendtag, void *recvbuf, int recvcount,
MPI_Datatype recvtype, int source, int recvtag,
MPI_Comm comm, MPI_Status *status)
{
char sendtypename[MPI_MAX_OBJECT_NAME], recvtypename[MPI_MAX_OBJECT_NAME];
char commname[MPI_MAX_OBJECT_NAME];
int len;
int rank;
int size;
PMPI_Comm_rank(MPI_COMM_WORLD, &rank);
PMPI_Type_get_name(sendtype, sendtypename, &len);
PMPI_Type_get_name(sendtype, recvtypename, &len);
PMPI_Comm_get_name(comm, commname, &len);
PMPI_Type_size(recvtype, &size);
fprintf(stderr, "MPI_SENDRECV[%d]: sendbuf %0" PRIxPTR " sendcount %d sendtype %s dest %d sendtag %d\n\t"
"recvbuf %0" PRIxPTR " recvcount %d recvtype %s source %d recvtag %d comm %s\n",
rank, (uintptr_t) sendbuf, sendcount, sendtypename, dest, sendtag,
(uintptr_t) recvbuf, recvcount, recvtypename, source, recvtag, commname);
fflush(stderr);
memset(recvbuf, 0, recvcount*size);
return PMPI_Sendrecv(sendbuf, sendcount, sendtype, dest, sendtag,
recvbuf, recvcount, recvtype, source, recvtag,
comm, status);
}
int main( int argc, char* argv[] )
{
int i, j;
int myrank, nprocs;
char *sbuf, *rbuf;
int dsize;
MPI_Init( &argc, &argv );
MPI_Comm_rank( MPI_COMM_WORLD, &myrank );
MPI_Comm_size( MPI_COMM_WORLD, &nprocs );
PMPI_Type_size(DATATYPE, &dsize);
sbuf=(char*)malloc(COUNT*dsize);
rbuf=(char*)malloc(COUNT*dsize*nprocs);
for( i=0; i<REPEAT; i++ )
{
MPI_Allgather( sbuf, COUNT, DATATYPE,
rbuf, COUNT, DATATYPE,
MPI_COMM_WORLD );
}
fprintf(stdout, "DONE (rank %d)!\n", myrank);
MPI_Finalize();
}
void vt_check_request(uint64_t* time, struct VTRequest* req, MPI_Status *status)
{
if (!req ||
((req->flags & ERF_IS_PERSISTENT) && !(req->flags & ERF_IS_ACTIVE)))
return;
/* if receive request, write receive trace record */
if ((req->flags & ERF_RECV) &&
(status->MPI_SOURCE != MPI_PROC_NULL) &&
(status->MPI_SOURCE != MPI_ANY_SOURCE))
{
int count, sz;
PMPI_Type_size(req->datatype, &sz);
PMPI_Get_count(status, req->datatype, &count);
vt_mpi_recv(time, VT_RANK_TO_PE(status->MPI_SOURCE, req->comm),
VT_COMM_ID(req->comm), status->MPI_TAG, count * sz);
}
if (req->flags & ERF_IS_PERSISTENT)
{
/* if persistent request, set to inactive,
and, if requested delete request */
req->flags &= ~ERF_IS_ACTIVE;
if (req->flags & ERF_DEALLOCATE) vt_request_free(req);
}
else
{
/* if non-persistent request, delete always request */
vt_request_free(req);
}
}
void vt_check_request(uint64_t* time, struct VTRequest* req, MPI_Status *status,
uint8_t record_event)
{
if (!req ||
((req->flags & ERF_IS_PERSISTENT) && !(req->flags & ERF_IS_ACTIVE)))
return;
/* if receive request, write receive trace record */
if (record_event &&
(req->flags & ERF_RECV) &&
(status->MPI_SOURCE != MPI_PROC_NULL) &&
(status->MPI_SOURCE != MPI_ANY_SOURCE))
{
VT_MPI_INT count, sz;
PMPI_Type_size(req->datatype, &sz);
PMPI_Get_count(status, req->datatype, &count);
vt_mpi_recv(VT_CURRENT_THREAD, time,
VT_RANK_TO_PE(status->MPI_SOURCE, req->comm),
VT_COMM_ID(req->comm), status->MPI_TAG, count * sz);
}
if (record_event && (req->flags & ERF_IO))
{
VT_MPI_INT count, sz;
PMPI_Type_size(req->datatype, &sz);
PMPI_Get_count(status, req->datatype, &count);
if (count == MPI_UNDEFINED)
count = 0;
vt_ioend(VT_CURRENT_THREAD, time, req->fileid, req->matchingid, req->handleid, req->fileop,
(uint64_t)count*(uint64_t)sz);
}
if (req->flags & ERF_IS_PERSISTENT)
{
/* if persistent request, set to inactive,
and, if requested delete request */
req->flags &= ~ERF_IS_ACTIVE;
if (req->flags & ERF_DEALLOCATE) vt_request_free(req);
}
else
{
/* if non-persistent request, delete always request */
vt_request_free(req);
}
}
int MPI_Get_C_Wrapper (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_Win win)
{
int ierror;
int origin_datatype_size, target_datatype_size;
ierror = PMPI_Type_size(origin_datatype, &origin_datatype_size);
MPI_CHECK(ierror, PMPI_Type_size);
ierror = PMPI_Type_size(target_datatype, &target_datatype_size);
MPI_CHECK(ierror, PMPI_Type_size);
TRACE_MPIEVENT(LAST_READ_TIME, MPI_GET_EV, EVT_BEGIN, target_rank, origin_datatype_size * origin_count, EMPTY, target_disp * target_datatype_size, origin_addr);
ierror = PMPI_Get (origin_addr, origin_count, origin_datatype, target_rank,
target_disp, target_count, target_datatype, win);
TRACE_MPIEVENT(TIME, MPI_GET_EV, EVT_END, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY);
updateStats_OTHER(global_mpi_stats);
return ierror;
}
int MPI_Get_accumulate_C_Wrapper (void *origin_addr, int origin_count, MPI_Datatype origin_datatype, void *result_addr, int result_count, MPI_Datatype result_datatype, int target_rank,
MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Op op,
MPI_Win win)
{
int ierror;
int origin_datatype_size, result_datatype_size, target_datatype_size;
ierror = PMPI_Type_size(origin_datatype, &origin_datatype_size);
MPI_CHECK(ierror, PMPI_Type_size);
ierror = PMPI_Type_size(result_datatype, &result_datatype_size);
MPI_CHECK(ierror, PMPI_Type_size);
ierror = PMPI_Type_size(target_datatype, &target_datatype_size);
MPI_CHECK(ierror, PMPI_Type_size);
TRACE_MPIEVENT(LAST_READ_TIME, MPI_GET_ACCUMULATE_EV, EVT_BEGIN, target_rank, ((origin_datatype_size * origin_count) + (target_datatype_size * target_count)), EMPTY, target_datatype_size * target_disp, origin_addr);
ierror = PMPI_Get_accumulate (origin_addr, origin_count, origin_datatype, result_addr, result_count, result_datatype, target_rank, target_disp, target_count, target_datatype, op, win);
TRACE_MPIEVENT(TIME, MPI_GET_ACCUMULATE_EV, EVT_END, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY);
updateStats_OTHER(global_mpi_stats);
return ierror;
}
int MPI_Compare_and_swap_C_Wrapper (void *origin_addr, void *compare_addr,
void *result_addr, MPI_Datatype datatype, int target_rank,
MPI_Aint target_disp, MPI_Win win)
{
int ierror;
int datatype_size;
ierror = PMPI_Type_size(datatype, &datatype_size);
MPI_CHECK(ierror, PMPI_Type_size);
TRACE_MPIEVENT (LAST_READ_TIME, MPI_COMPARE_AND_SWAP_EV, EVT_BEGIN, target_rank,
(datatype_size * target_disp), EMPTY, EMPTY, origin_addr);
ierror = PMPI_Compare_and_swap (origin_addr, compare_addr, result_addr,
datatype, target_rank, target_disp, win);
TRACE_MPIEVENT (TIME, MPI_COMPARE_AND_SWAP_EV, EVT_END, EMPTY, EMPTY,
EMPTY, EMPTY, EMPTY);
updateStats_OTHER(global_mpi_stats);
return ierror;
}
int main( int argc, char* argv[] )
{
int i;
int myrank, nprocs;
char *buf;
int dsize;
MPI_Init( &argc, &argv );
MPI_Comm_rank( MPI_COMM_WORLD, &myrank );
MPI_Comm_size( MPI_COMM_WORLD, &nprocs );
PMPI_Type_size(DATATYPE, &dsize);
buf=(char*)malloc(SIZE*dsize);
while(1) /* forever */
{
MPI_Bcast( buf, SIZE, DATATYPE, ROOT, MPI_COMM_WORLD );
}
MPI_Finalize();
}
int E_count2byte ( MPI_Datatype datatype, int count ) {
int nb = 0;
PMPI_Type_size(datatype, &nb);
nb *= count;
return nb;
}
int MPI_Type_size(MPI_Datatype datatype, int *size)
{
return PMPI_Type_size(datatype, size);
}
