42 #ifdef MPICH_PROFILING 58 #define PF_PACKSIZE 1600 67 static int PF_packsize = 0;
68 static MPI_Status PF_status;
69 LONG PF_maxDollarChunkSize = 0;
71 static int PF_ShortPackInit(
void);
72 static int PF_longPackInit(
void);
84 #define MPI_ERRCODE_CHECK(err) \ 86 int _tmp_err = (err); \ 87 if ( _tmp_err != MPI_SUCCESS ) return _tmp_err != 0 ? _tmp_err : -1; \ 103 static double starttime;
104 if ( i == PF_RESET ) {
105 starttime = MPI_Wtime();
108 return((LONG)( 100. * (MPI_Wtime() - starttime) ) );
126 ret = MPI_Init(argcp,argvp);
127 if ( ret != MPI_SUCCESS )
return(ret);
128 ret = MPI_Comm_rank(PF_COMM,&PF.me);
129 if ( ret != MPI_SUCCESS )
return(ret);
130 ret = MPI_Comm_size(PF_COMM,&PF.numtasks);
131 if ( ret != MPI_SUCCESS )
return(ret);
134 PF_packsize = PF_PACKSIZE/
sizeof(int)*
sizeof(
int);
135 if ( PF_ShortPackInit() )
return -1;
136 if ( PF_longPackInit() )
return -1;
139 int bytes, totalbytes=0;
151 if ( ( ret = MPI_Pack_size(1,PF_INT,PF_COMM,&bytes) )!=MPI_SUCCESS )
158 if ( ( ret = MPI_Pack_size(1,PF_LONG,PF_COMM,&bytes) )!=MPI_SUCCESS )
165 totalbytes = PF_packsize-totalbytes;
172 PF_maxDollarChunkSize=totalbytes/
sizeof(WORD);
177 if ( ( ret = MPI_Pack_size(
178 ++PF_maxDollarChunkSize,PF_WORD,PF_COMM,&bytes) )!=MPI_SUCCESS )
180 }
while ( bytes<totalbytes );
186 if ( ( ret = MPI_Pack_size(
187 --PF_maxDollarChunkSize,PF_WORD,PF_COMM,&bytes) )!=MPI_SUCCESS )
189 }
while ( bytes>totalbytes );
212 return(MPI_Finalize());
233 if ( *src == PF_ANY_SOURCE ) {
234 ret = MPI_Probe(*src,MPI_ANY_TAG,PF_COMM,&PF_status);
238 ret = MPI_Iprobe(*src,MPI_ANY_TAG,PF_COMM,&flag,&PF_status);
240 *src = PF_status.MPI_SOURCE;
241 if ( ret != MPI_SUCCESS ) {
if ( ret > 0 ) ret *= -1;
return(ret); }
242 if ( !flag )
return(0);
243 return(PF_status.MPI_TAG);
265 int size = s->fill[a] - s->buff[a];
270 s->fill[a] = s->buff[a];
271 if ( s->numbufs == 1 ) {
272 r = MPI_Ssend(s->buff[a],size,PF_WORD,MASTER,tag,PF_COMM);
273 if ( r != MPI_SUCCESS ) {
274 fprintf(stderr,
"[%d|%d] PF_ISendSbuf: MPI_Ssend returns: %d \n",
275 PF.me,(
int)AC.CModule,r);
284 if ( PF.sbuf->request[to] != MPI_REQUEST_NULL)
285 r = MPI_Wait(&PF.sbuf->request[to],&PF.sbuf->retstat[to]);
286 if ( r != MPI_SUCCESS )
return(r);
292 r = MPI_Isend(s->buff[a],size,PF_WORD,to,tag,PF_COMM,&s->request[a]);
294 if ( r != MPI_SUCCESS )
return(r);
300 case PF_ENDSORT_MSGTAG:
301 if ( ++finished == PF.numtasks - 1 )
302 r = MPI_Waitall(s->numbufs,s->request,s->status);
303 if ( r != MPI_SUCCESS )
return(r);
305 case PF_BUFFER_MSGTAG:
306 if ( ++s->active >= s->numbufs ) s->active = 0;
307 while ( s->request[s->active] != MPI_REQUEST_NULL ) {
308 r = MPI_Waitsome(s->numbufs,s->request,&size,s->index,s->retstat);
309 if ( r != MPI_SUCCESS )
return(r);
312 case PF_ENDBUFFER_MSGTAG:
313 if ( ++s->active >= s->numbufs ) s->active = 0;
314 r = MPI_Waitall(s->numbufs,s->request,s->status);
315 if ( r != MPI_SUCCESS )
return(r);
341 r = MPI_Recv(b,(
int)*s,PF_WORD,*src,PF_ANY_MSGTAG,PF_COMM,&PF_status);
342 if ( r != MPI_SUCCESS ) {
if ( r > 0 ) r *= -1;
return(r); }
344 r = MPI_Get_count(&PF_status,PF_WORD,&i);
345 if ( r != MPI_SUCCESS ) {
if ( r > 0 ) r *= -1;
return(r); }
348 *src = PF_status.MPI_SOURCE;
349 return(PF_status.MPI_TAG);
369 r->type[bn] = PF_WORD;
371 if ( r->numbufs == 1 ) {
372 r->tag[bn] = MPI_ANY_TAG;
376 ret = MPI_Irecv(r->full[bn],(
int)(r->stop[bn] - r->full[bn]),PF_WORD,from,
377 MPI_ANY_TAG,PF_COMM,&r->request[bn]);
378 if (ret != MPI_SUCCESS) {
if(ret > 0) ret *= -1;
return(ret); }
404 if ( r->numbufs == 1 ) {
405 *size = r->stop[bn] - r->full[bn];
406 ret = MPI_Recv(r->full[bn],(
int)*size,r->type[bn],r->from[bn],r->tag[bn],
407 PF_COMM,&(r->status[bn]));
408 if ( ret != MPI_SUCCESS ) {
if ( ret > 0 ) ret *= -1;
return(ret); }
409 ret = MPI_Get_count(&(r->status[bn]),r->type[bn],&rsize);
410 if ( ret != MPI_SUCCESS ) {
if ( ret > 0 ) ret *= -1;
return(ret); }
411 if ( rsize > *size )
return(-99);
415 while ( r->request[bn] != MPI_REQUEST_NULL ) {
416 ret = MPI_Waitsome(r->numbufs,r->request,&rsize,r->index,r->retstat);
417 if ( ret != MPI_SUCCESS ) {
if ( ret > 0 ) ret *= -1;
return(ret); }
418 while ( --rsize >= 0 ) r->status[r->index[rsize]] = r->retstat[rsize];
420 ret = MPI_Get_count(&(r->status[bn]),r->type[bn],&rsize);
421 if ( ret != MPI_SUCCESS ) {
if ( ret > 0 ) ret *= -1;
return(ret); }
424 return(r->status[bn].MPI_TAG);
442 if ( MPI_Bcast(buffer,count,MPI_BYTE,MASTER,PF_COMM) != MPI_SUCCESS )
465 int ret=MPI_Ssend(buf,(
int)l,MPI_BYTE,dest,tag,PF_COMM);
466 if ( ret != MPI_SUCCESS )
return(-1);
487 int ret=MPI_Recv(buf,(
int)thesize,MPI_BYTE,*src,MPI_ANY_TAG,PF_COMM,&stat);
488 if ( ret != MPI_SUCCESS )
return(-1);
489 if ( MPI_Get_count(&stat,MPI_BYTE,&ret) != MPI_SUCCESS )
return(-1);
491 *src = stat.MPI_SOURCE;
511 int srcval = src != NULL ? *src : PF_ANY_SOURCE;
512 int tagval = tag != NULL ? *tag : PF_ANY_MSGTAG;
513 int ret = MPI_Probe(srcval, tagval, PF_COMM, &stat);
514 if ( ret != MPI_SUCCESS )
return -1;
515 if ( src != NULL ) *src = stat.MPI_SOURCE;
516 if ( tag != NULL ) *tag = stat.MPI_TAG;
517 if ( bytesize != NULL ) {
518 ret = MPI_Get_count(&stat, MPI_BYTE, bytesize);
519 if ( ret != MPI_SUCCESS )
return -1;
533 static UBYTE *PF_packbuf = NULL;
534 static UBYTE *PF_packstop = NULL;
535 static int PF_packpos = 0;
548 static int PF_ShortPackInit(
void)
550 PF_packbuf = (UBYTE *)Malloc1(
sizeof(UBYTE) * PF_packsize,
"PF_ShortPackInit");
551 if ( PF_packbuf == NULL )
return -1;
552 PF_packstop = PF_packbuf + PF_packsize;
566 static inline int PF_InitPackBuf(
void)
604 printf(
"[%d] %s: ",PF.me,s);
605 for(i=0;i<size;i++) printf(
"%d ",PF_packbuf[i]);
608 MesPrint(
"[%d] %s: %a",PF.me,s,size,(WORD *)(PF_packbuf));
626 return PF_InitPackBuf();
642 int PF_Pack(
const void *buffer,
size_t count, MPI_Datatype type)
646 if ( count > INT_MAX )
return -99;
648 err = MPI_Pack_size((
int)count, type, PF_COMM, &bytes);
650 if ( PF_packpos + bytes > PF_packstop - PF_packbuf )
return -99;
652 err = MPI_Pack((
void *)buffer, (
int)count, type, PF_packbuf, PF_packsize, &PF_packpos, PF_COMM);
671 int PF_Unpack(
void *buffer,
size_t count, MPI_Datatype type)
675 if ( count > INT_MAX )
return -99;
677 err = MPI_Unpack(PF_packbuf, PF_packsize, &PF_packpos, buffer, (
int)count, type, PF_COMM);
708 int ret,buflength,bytes,length;
713 if ( ( ret = MPI_Pack_size(1,PF_INT,PF_COMM,&bytes) ) != MPI_SUCCESS )
715 buflength = PF_packsize - bytes;
719 for ( length = 0; length < buflength; length++ ) {
720 if ( str[length] ==
'\0' ) {
728 if ( ( str[0] ==
'\0' )
730 && ( str[2] ==
'\0' )
739 if ( ( ret = MPI_Pack_size(--length,PF_BYTE,PF_COMM,&bytes) )
740 != MPI_SUCCESS )
return(ret);
741 }
while ( bytes > buflength );
748 if ( ( ret = MPI_Pack(&length,1,PF_INT,PF_packbuf,PF_packsize,
749 &PF_packpos,PF_COMM) ) != MPI_SUCCESS )
return(ret);
753 if ( ( ret = MPI_Pack((UBYTE *)str,length,PF_BYTE,PF_packbuf,PF_packsize,
754 &PF_packpos,PF_COMM) ) != MPI_SUCCESS )
return(ret);
780 if( (ret = MPI_Unpack(PF_packbuf,PF_packsize,&PF_packpos,
781 &length,1,PF_INT,PF_COMM))!= MPI_SUCCESS )
786 if ( ( ret = MPI_Unpack(PF_packbuf,PF_packsize,&PF_packpos,
787 str,length,PF_BYTE,PF_COMM) ) != MPI_SUCCESS )
return(ret);
825 err = MPI_Ssend(PF_packbuf, PF_packpos, MPI_PACKED, to, tag, PF_COMM);
853 err = MPI_Recv(PF_packbuf, PF_packsize, MPI_PACKED, src, tag, PF_COMM, &status);
855 if ( psrc ) *psrc = status.MPI_SOURCE;
856 if ( ptag ) *ptag = status.MPI_TAG;
892 #ifdef PF_SHORTBROADCAST 893 int pos = PF_packpos;
895 if ( PF.me != MASTER ) {
896 err = PF_InitPackBuf();
897 if ( err )
return err;
899 #ifdef PF_SHORTBROADCAST 900 err = MPI_Bcast(&pos, 1, MPI_INT, MASTER, PF_COMM);
902 err = MPI_Bcast(PF_packbuf, pos, MPI_PACKED, MASTER, PF_COMM);
904 err = MPI_Bcast(PF_packbuf, PF_packsize, MPI_PACKED, MASTER, PF_COMM);
1024 static UBYTE *PF_longPackBuf = NULL;
1025 static VOID *PF_longPackSmallBuf = NULL;
1026 static int PF_longPackPos = 0;
1027 static int PF_longPackTop = 0;
1031 static int PF_longPackN = 0;
1039 static inline int PF_longMultiNewCell(
void)
1046 if ( PF_longMultiTop->next == NULL )
return(-1);
1050 PF_longMultiTop->next->buffer=(UBYTE*)
1051 Malloc1(
sizeof(UBYTE)*PF_packsize,
"PF_longMultiChunk");
1052 if ( PF_longMultiTop->next->buffer == NULL )
return(-1);
1056 PF_longMultiTop->next->bufpos = -1;
1060 PF_longMultiTop->next->next = NULL;
1071 static inline int PF_longMultiPack2NextCell(
void)
1076 if ( PF_longMultiTop->next == NULL ) {
1080 if ( PF_longMultiNewCell() )
return(-1);
1085 PF_longMultiTop = PF_longMultiTop->next;
1089 if ( PF_longMultiTop->bufpos > -1 )
1090 PF_longMultiTop->buffer = PF_longPackBuf+PF_longMultiTop->bufpos;
1095 PF_longMultiTop->nPacks = 0;
1096 PF_longMultiTop->lastLen = 0;
1097 PF_longMultiTop->packpos = 0;
1106 static inline int PF_longMultiNewChunkAdded(
int n)
1112 int pos = PF_longPackTop;
1120 if ( PF_longMultiLastChunk->next == NULL )
return(-1);
1124 PF_longMultiLastChunk = PF_longMultiLastChunk->next;
1128 PF_longMultiLastChunk->bufpos = pos;
1130 PF_longMultiLastChunk->buffer = NULL;
1131 PF_longMultiLastChunk->packpos = 0;
1132 PF_longMultiLastChunk->nPacks = 0;
1133 PF_longMultiLastChunk->lastLen = 0;
1138 PF_longMultiLastChunk->next = MemCell;
1147 static inline void PF_longCopyChunk(
int *to,
int *from,
int n)
1160 static int PF_longAddChunk(
int n,
int mustRealloc)
1163 if ( ( newbuf = (UBYTE*)Malloc1(
sizeof(UBYTE)*(PF_longPackTop+n*PF_packsize),
1164 "PF_longPackBuf") ) == NULL )
return(-1);
1168 if ( PF_longMultiNewChunkAdded(n) )
return(-1);
1172 if ( mustRealloc ) {
1173 PF_longCopyChunk((
int*)newbuf,(
int*)PF_longPackBuf,PF_longPackTop/
sizeof(
int));
1178 PF_longPackTop += (n*PF_packsize);
1182 M_free(PF_longPackBuf,
"PF_longPackBuf");
1183 PF_longPackBuf = newbuf;
1198 static inline int PF_longMultiHowSplit(
int count, MPI_Datatype type,
int bytes)
1200 int ret, items, totalbytes;
1202 if ( count < 2 )
return(0);
1206 totalbytes = PF_packsize - PF_longMultiTop->packpos;
1210 items = (int)((
double)totalbytes*count/bytes);
1215 if ( ( ret = MPI_Pack_size(++items,type,PF_COMM,&bytes) )
1216 !=MPI_SUCCESS )
return(ret);
1217 }
while ( bytes < totalbytes );
1223 if ( ( ret = MPI_Pack_size(--items,type,PF_COMM,&bytes) )
1224 !=MPI_SUCCESS )
return(ret);
1227 }
while ( bytes > totalbytes );
1235 static int PF_longPackInit(
void)
1238 PF_longPackBuf = (UBYTE*)Malloc1(
sizeof(UBYTE)*PF_packsize,
"PF_longPackBuf");
1239 if ( PF_longPackBuf == NULL )
return(-1);
1243 ret = MPI_Pack_size(1,MPI_INT,PF_COMM,&PF_longPackTop);
1244 if ( ret != MPI_SUCCESS )
return(ret);
1246 PF_longPackSmallBuf =
1247 (VOID*)Malloc1(
sizeof(UBYTE)*PF_longPackTop,
"PF_longPackSmallBuf");
1249 PF_longPackTop = PF_packsize;
1252 if ( PF_longMultiRoot == NULL )
return(-1);
1253 PF_longMultiRoot->bufpos = 0;
1254 PF_longMultiRoot->buffer = NULL;
1255 PF_longMultiRoot->next = NULL;
1256 PF_longMultiLastChunk = PF_longMultiRoot;
1259 PF_longMultiRoot->packpos = 0;
1260 PF_longMultiTop = PF_longMultiRoot;
1270 static inline int PF_longMultiPreparePrefix(
void)
1274 int i = PF_longPackN;
1279 if ( PF_longMultiPack2NextCell() )
return(-1);
1283 thePrefix = PF_longMultiTop;
1287 ret = MPI_Pack(&(PF_longPackN),
1292 &(thePrefix->packpos),
1294 if ( ret != MPI_SUCCESS )
return(ret);
1298 for ( PF_longMultiTop = PF_longMultiRoot; i > 0; i-- ) {
1302 ret = MPI_Pack(&(PF_longMultiTop->nPacks),
1307 &(thePrefix->packpos),
1312 ret |= MPI_Pack(&(PF_longMultiTop->lastLen),
1317 &(thePrefix->packpos),
1322 if ( ret != MPI_SUCCESS )
return(ret);
1326 PF_longMultiTop = PF_longMultiTop->next;
1329 PF_longMultiTop = thePrefix;
1341 static inline int PF_longMultiProcessPrefix(
void)
1349 for ( PF_longMultiTop = PF_longMultiRoot, i = 0; i < PF_longPackN; i++ ) {
1353 if ( PF_longMultiPack2NextCell() )
return(-1);
1357 ret = MPI_Unpack(PF_longMultiRoot->buffer,
1359 &( PF_longMultiRoot->packpos),
1360 &(PF_longMultiTop->nPacks),
1364 if ( ret != MPI_SUCCESS )
return(ret);
1368 ret = MPI_Unpack(PF_longMultiRoot->buffer,
1370 &( PF_longMultiRoot->packpos),
1371 &(PF_longMultiTop->lastLen),
1375 if ( ret != MPI_SUCCESS )
return(ret);
1392 static inline int PF_longSingleReset(
int is_sender)
1397 ret = MPI_Pack(&PF_longPackTop,1,MPI_INT,
1398 PF_longPackBuf,PF_longPackTop,&PF_longPackPos,PF_COMM);
1399 if ( ret != MPI_SUCCESS )
return(ret);
1420 static inline int PF_longMultiReset(
int is_sender)
1422 int ret = 0, theone = 1;
1423 PF_longMultiRoot->packpos = 0;
1425 ret = MPI_Pack(&theone,1,MPI_INT,
1426 PF_longPackBuf,PF_longPackTop,&(PF_longMultiRoot->packpos),PF_COMM);
1432 PF_longMultiRoot->nPacks = 0;
1433 PF_longMultiRoot->lastLen = 0;
1434 PF_longMultiTop = PF_longMultiRoot;
1435 PF_longMultiRoot->buffer = PF_longPackBuf;
1453 return PF_longSingleReset(1);
1473 if ( count > INT_MAX )
return -99;
1474 ret = MPI_Pack_size((
int)count,type,PF_COMM,&bytes);
1475 if ( ret != MPI_SUCCESS )
return(ret);
1477 while ( PF_longPackPos+bytes > PF_longPackTop ) {
1478 if ( PF_longAddChunk(1, 1) )
return(-1);
1484 ret = MPI_Pack((
void *)buffer,(
int)count,type,
1485 PF_longPackBuf,PF_longPackTop,&PF_longPackPos,PF_COMM);
1486 if ( ret != MPI_SUCCESS )
return(ret);
1507 if ( count > INT_MAX )
return -99;
1508 ret = MPI_Unpack(PF_longPackBuf,PF_longPackTop,&PF_longPackPos,
1509 buffer,(
int)count,type,PF_COMM);
1510 if ( ret != MPI_SUCCESS )
return(ret);
1547 if ( PF_longPackN > 1 ) {
1549 int tmp = -PF_longPackTop;
1553 ret = MPI_Pack(&tmp, 1,PF_INT,
1554 PF_longPackSmallBuf,PF_longPackTop,&pos,PF_COMM);
1555 if ( ret != MPI_SUCCESS )
return(ret);
1556 ret = MPI_Ssend(PF_longPackSmallBuf,pos,MPI_PACKED,to,tag,PF_COMM);
1557 if ( ret != MPI_SUCCESS )
return(ret);
1559 ret = MPI_Ssend(PF_longPackBuf,PF_longPackPos,MPI_PACKED,to,tag,PF_COMM);
1560 if ( ret != MPI_SUCCESS )
return(ret);
1585 int ret, missed, oncemore;
1587 PF_longSingleReset(0);
1589 ret = MPI_Recv(PF_longPackBuf,PF_longPackTop,MPI_PACKED,src,tag,
1591 if ( ret != MPI_SUCCESS )
return(ret);
1596 src = status.MPI_SOURCE;
1597 tag = status.MPI_TAG;
1598 if ( psrc ) *psrc = status.MPI_SOURCE;
1599 if ( ptag ) *ptag = status.MPI_TAG;
1604 ret = MPI_Unpack(PF_longPackBuf,PF_longPackTop,&PF_longPackPos,
1605 &missed,1,MPI_INT,PF_COMM);
1606 if ( ret != MPI_SUCCESS )
return(ret);
1620 if ( missed > PF_longPackTop ) {
1625 if ( PF_longAddChunk( (missed-PF_longPackTop)/PF_packsize, !oncemore ) )
1628 }
while ( oncemore );
1645 return PF_longMultiReset(1);
1667 if ( count > INT_MAX )
return -99;
1669 ret = MPI_Pack_size((
int)count,type,PF_COMM,&items);
1670 if ( ret != MPI_SUCCESS )
return(ret);
1672 if ( PF_longMultiTop->packpos + items <= PF_packsize ) {
1673 ret = MPI_Pack((
void *)buffer,(
int)count,type,PF_longMultiTop->buffer,
1674 PF_packsize,&(PF_longMultiTop->packpos),PF_COMM);
1675 if ( ret != MPI_SUCCESS )
return(ret);
1676 PF_longMultiTop->nPacks++;
1686 if ( ( items = PF_longMultiHowSplit((
int)count,type,items) ) < 0 )
return(items);
1689 ret = MPI_Pack((
void *)buffer,items,type,PF_longMultiTop->buffer,
1690 PF_packsize,&(PF_longMultiTop->packpos),PF_COMM);
1691 if ( ret != MPI_SUCCESS )
return(ret);
1692 PF_longMultiTop->nPacks++;
1693 PF_longMultiTop->lastLen = items;
1699 if ( PF_longMultiPack2NextCell() )
return(-1);
1726 if ( count > INT_MAX )
return -99;
1728 if ( PF_longPackN < 2 ) {
1730 PF_longMultiTop->buffer,
1732 &(PF_longMultiTop->packpos),
1734 count,type,PF_COMM);
1735 if ( ret != MPI_SUCCESS )
return(ret);
1741 if ( ( PF_longMultiTop->nPacks > 1 )
1743 ( ( PF_longMultiTop->nPacks == 1 ) && ( PF_longMultiTop->lastLen == 0 ) )
1746 PF_longMultiTop->buffer,
1748 &(PF_longMultiTop->packpos),
1750 count,type,PF_COMM);
1751 if ( ret != MPI_SUCCESS )
return(ret);
1752 (PF_longMultiTop->nPacks)--;
1755 if ( ( PF_longMultiTop->nPacks == 1 ) && ( PF_longMultiTop->lastLen != 0 ) ) {
1760 PF_longMultiTop->buffer,
1762 &(PF_longMultiTop->packpos),
1764 PF_longMultiTop->lastLen,type,PF_COMM);
1765 if ( ret != MPI_SUCCESS )
return(ret);
1769 count -= PF_longMultiTop->lastLen;
1770 if ( count <= 0 )
return(-1);
1774 buffer = (
char *)buffer + PF_longMultiTop->lastLen * eSize;
1775 (PF_longMultiTop->nPacks)--;
1780 if ( ( PF_longMultiTop = PF_longMultiTop->next ) == NULL )
return(-1);
1811 if ( PF.me == MASTER ) {
1816 if ( PF_longPackN > 1 ) {
1817 if ( PF_longMultiPreparePrefix() )
return(-1);
1818 ret = MPI_Bcast((VOID*)PF_longMultiTop->buffer,
1819 PF_packsize,MPI_PACKED,MASTER,PF_COMM);
1820 if ( ret != MPI_SUCCESS )
return(ret);
1828 PF_longMultiTop = PF_longMultiRoot;
1832 for ( i = 0; i < PF_longPackN; i++ ) {
1833 ret = MPI_Bcast((VOID*)PF_longMultiTop->buffer,
1834 PF_packsize,MPI_PACKED,MASTER,PF_COMM);
1835 if ( ret != MPI_SUCCESS )
return(ret);
1836 PF_longMultiTop = PF_longMultiTop->next;
1843 PF_longMultiReset(0);
1848 ret = MPI_Bcast((VOID*)PF_longMultiRoot->buffer,
1849 PF_packsize,MPI_PACKED,MASTER,PF_COMM);
1850 if ( ret != MPI_SUCCESS )
return(ret);
1852 ret = MPI_Unpack((VOID*)PF_longMultiRoot->buffer,
1854 &(PF_longMultiRoot->packpos),
1855 &PF_longPackN,1,MPI_INT,PF_COMM);
1856 if ( ret != MPI_SUCCESS )
return(ret);
1862 if ( PF_longPackN < 2 )
1868 if ( PF_longMultiProcessPrefix() )
return(-1);
1874 for ( PF_longMultiTop = PF_longMultiRoot->next, i = 0; i < PF_longPackN; i++ ) {
1875 ret = MPI_Bcast((VOID*)PF_longMultiTop->buffer,
1876 PF_packsize,MPI_PACKED,MASTER,PF_COMM);
1877 if ( ret != MPI_SUCCESS )
return(ret);
1883 ret = MPI_Unpack((VOID*)PF_longMultiTop->buffer,
1885 &(PF_longMultiTop->packpos),
1886 &tmp,1,MPI_INT,PF_COMM);
1887 if ( ret != MPI_SUCCESS )
return(ret);
1889 PF_longMultiTop = PF_longMultiTop->next;
1895 PF_longMultiTop = PF_longMultiRoot->next;
int PF_LongSingleUnpack(void *buffer, size_t count, MPI_Datatype type)
int PF_Pack(const void *buffer, size_t count, MPI_Datatype type)
int PF_LongSingleReceive(int src, int tag, int *psrc, int *ptag)
int PF_LongMultiPackImpl(const void *buffer, size_t count, size_t eSize, MPI_Datatype type)
int PF_IRecvRbuf(PF_BUFFER *r, int bn, int from)
int PF_Unpack(void *buffer, size_t count, MPI_Datatype type)
int PF_PackString(const UBYTE *str)
int PF_LongMultiBroadcast(void)
int PF_RawProbe(int *src, int *tag, int *bytesize)
int PF_LongMultiUnpackImpl(void *buffer, size_t count, size_t eSize, MPI_Datatype type)
int PF_PrintPackBuf(char *s, int size)
int PF_LibTerminate(int error)
int PF_LibInit(int *argcp, char ***argvp)
int PF_ISendSbuf(int to, int tag)
int PF_PrepareLongMultiPack(void)
int PF_WaitRbuf(PF_BUFFER *r, int bn, LONG *size)
int PF_LongSingleSend(int to, int tag)
int PF_RawSend(int dest, void *buf, LONG l, int tag)
int PF_Bcast(void *buffer, int count)
int PF_LongSinglePack(const void *buffer, size_t count, MPI_Datatype type)
int PF_Send(int to, int tag)
int PF_RecvWbuf(WORD *b, LONG *s, int *src)
int PF_PrepareLongSinglePack(void)
int PF_UnpackString(UBYTE *str)
#define MPI_ERRCODE_CHECK(err)
LONG PF_RawRecv(int *src, void *buf, LONG thesize, int *tag)
int PF_Receive(int src, int tag, int *psrc, int *ptag)