More unused variable cleanup
[charm.git] / src / conv-com / petable.C
1 /*****************************************************************************
2  * $Source$
3  * $Author$
4  * $Date$
5  * $Revision$
6  *****************************************************************************/
7
8 /**
9    @addtogroup ConvComlib
10    @{
11    @file 
12    @brief Tables of messages for PEs 
13 */
14
15 #include <string.h>
16 #include <stdlib.h>
17 //#include <converse.h>
18 //#include "convcomlib.h"
19 #include "petable.h"
20 //#include "converse.h"
21
22 #define BIGBUFFERSIZE 65536
23 #define PTPREALLOC    100
24
25 struct AllToAllHdr {
26   char dummy[CmiReservedHeaderSize];
27   int refno;
28   comID id;
29   int size;
30   int ufield;
31   int nmsgs;
32 };
33
34
35 /**************************************************************
36  * Preallocated memory=P*MSGQLEN ptr + 2P ints + 1000 ptrs
37  **************************************************************/
38 PeTable :: PeTable(int n) {
39   NumPes=n;
40   magic=0;
41   PeList = (PTinfo ***)CmiAlloc(sizeof(PTinfo *)*NumPes);
42   //  ComlibPrintf("Pelist[%d][%d]\n", NumPes, MSGQLEN);
43   msgnum=new int[NumPes];
44   MaxSize=new int[NumPes];
45   for (int i=0;i<NumPes;i++) {
46     msgnum[i]=0;
47     MaxSize[i]=MSGQLEN;
48     PeList[i]=(PTinfo **)CmiAlloc(sizeof(PTinfo *)*MSGQLEN);
49     for (int j=0;j<MSGQLEN;j++) PeList[i][j]=0;
50   }
51
52   //ptrlist=(PTinfo **)CmiAlloc(1000*sizeof(PTinfo *));
53   //  FreeList= new GList;
54   //CombBuffer=(char *)CmiAlloc(BIGBUFFERSIZE);
55
56   PTFreeList=NULL;
57   PTFreeChunks=NULL;
58 }
59
60 PeTable :: ~PeTable() {
61   int i;
62   for (i=0;i<NumPes;i++) CmiFree(PeList[i]);
63   CmiFree(PeList);
64   delete msgnum;
65   delete MaxSize;
66   GarbageCollect();
67   //CmiFree(ptrlist);
68   PTinfo *tmp;
69   while (PTFreeChunks) {
70     tmp=PTFreeChunks;
71     PTFreeChunks=PTNEXTCHUNK(tmp);
72     CmiFree(tmp);
73   }
74   // delete FreeList;
75
76 }
77
78 void PeTable:: Purge() {
79   for (int i=0; i<NumPes;i++) {
80     if (msgnum[i]) {
81       // ComlibPrintf("%d Warning: %d Undelivered Messages for %d\n", CkMyPe(), msgnum[i], i);
82       //msgnum[i]=0;
83     }
84   }
85   GarbageCollect();
86   //  ComlibPrintf("combcount = %d\n", combcount);
87   //combcount = 0;
88 }
89
90 void PeTable :: ExtractAndDeliverLocalMsgs(int index, Strategy *myStrat) {
91   int j;
92   msgstruct m;
93
94   ComlibPrintf("%d:Delivering %d local messages\n", CkMyPe(), msgnum[index]);
95   for (j=msgnum[index]-1;(j>=0);j--) {
96
97     m.msgsize=PeList[index][j]->msgsize;
98     m.msg=PeList[index][j]->msg;
99
100     if (--(PeList[index][j]->refCount) <=0) {
101       //CmiSyncSendAndFree(CkMyPe()/*index*/, m.msgsize, (char*)m.msg);
102       myStrat->deliver((char*)m.msg, m.msgsize);
103       PTFREE(PeList[index][j]);
104     }
105     else {
106       char *dupmsg = (char*)CmiAlloc(m.msgsize);
107       memcpy(dupmsg, m.msg, m.msgsize);
108       myStrat->deliver(dupmsg, m.msgsize);
109       //CmiSyncSend(CkMyPe()/*index*/, m.msgsize, (char*)m.msg);
110     }
111     PeList[index][j]=NULL;
112   }
113   msgnum[index]=j+1;
114
115   return;
116 }
117
118
119 #undef PACK
120 #undef PACKMSG
121 //#define PACKINT(data) {((int*)t)[0] = data; t+=sizeof(int);}
122 #define PACK(type,data) {junk=(char *)&(data); memcpy(t, junk, sizeof(type)); t+=sizeof(type);}
123 #define PACKMSG(data, size) { memcpy(p+msg_offset, (data), size); msg_offset += size; }
124
125 /*
126   Protocol:
127   |     AllToAllHdr      |npe|ChunkHdr1|msg1|ChunkHdr2|msg2|...
128   |ref|comid|ufield|nmsgs|
129 */
130 char * PeTable ::ExtractAndPack(comID id, int ufield, int npe, 
131                                 int *pelist, int *length) {
132   char *junk;
133   int nummsgs, offset, num_distinctmsgs;
134         
135   int tot_msgsize=TotalMsgSize(npe, pelist, &nummsgs, &num_distinctmsgs);
136
137   ComlibPrintf("%d In ExtractAndPack %d, %d\n", CmiMyPe(), npe, nummsgs); 
138
139   if (tot_msgsize ==0) {
140     *length=0;
141         
142     ComlibPrintf("Returning NULL\n");
143     return(NULL);
144   }
145     
146   int msg_offset = sizeof(struct AllToAllHdr) + (npe + nummsgs + 1) * sizeof(int);
147   //int msg_offset = CmiReservedHeaderSize + sizeof(comID) 
148   //    + (npe + 4 + nummsgs) * sizeof(int);  
149
150   msg_offset = ALIGN8(msg_offset);
151     
152   *length = tot_msgsize;
153   *length += msg_offset;
154   char *p;
155   p=(char *)CmiAlloc(*length);
156
157   char *t = p + CmiReservedHeaderSize;
158   int i, j;
159   if (!p) CmiAbort("Big time problem\n");
160   magic++;
161
162   int refno = id.refno;    
163
164   PACK(int, refno);
165   PACK(comID, id);
166   PACK(int, *length);
167   PACK(int, ufield);
168   PACK(int, nummsgs);
169   PACK(int, npe);
170     
171   int lesspe=0;
172   int npacked = 0;
173   for (i=0;i<npe;i++) {
174     int index=pelist[i];
175
176     if (msgnum[index]<=0) {
177       lesspe++;
178             
179       ComlibPrintf("[%d] msgnum[index]<=0 !!!!!\n", CkMyPe());
180       continue;
181     }
182         
183     ComlibPrintf("%d Packing pelist[%d]\n", CkMyPe(), index);
184     register int newval=-1*pelist[i];
185     PACK(int, newval); 
186
187     for (j=0;j<msgnum[index];j++) {
188       if (PeList[index][j]->magic == magic) {
189         offset=(PeList[index][j]->offset);
190       }
191       else {
192         npacked ++;
193                 
194         //offset=msg_offset;
195         offset=npacked;
196         PeList[index][j]->magic=magic;
197         PeList[index][j]->offset=offset;
198         PTinfo *tempmsg=PeList[index][j];
199                 
200         CmiChunkHeader hdr;
201         hdr.size = tempmsg->msgsize;
202         hdr.ref = -1;
203         PACKMSG(&hdr, sizeof(CmiChunkHeader));
204         PACKMSG(tempmsg->msg, tempmsg->msgsize);
205
206         msg_offset = ALIGN8(msg_offset);
207       }
208             
209       //ComlibPrintf("%d Packing msg_offset=%d\n", CkMyPe(), offset);
210       PACK(int, offset); 
211
212       if (--(PeList[index][j]->refCount) <=0) {
213         CmiFree(PeList[index][j]->msg);
214                 
215         PTFREE(PeList[index][j]);
216       }
217       PeList[index][j]=NULL;
218     }
219     msgnum[index]=0;
220   }
221   //offset=-1;
222   //PACK(int, offset);
223
224   /*    
225         if (lesspe) {
226         t=p+CmiReservedHeaderSize+2*sizeof(int) + sizeof(comID);
227         npe=npe-lesspe;
228         PACK(int, npe);
229         }
230   */
231
232   return(p);
233
234
235 /*Used for all to all multicast operations.  Assumes that each message
236   is destined to all the processors, to speed up all to all
237   substantially --Sameer 09/03/03 
238   
239   Protocol:
240   |     AllToAllHdr      |ChunkHdr1|msg1|ChunkHdr2|msg2|...
241   |ref|comid|ufield|nmsgs|
242 */
243
244 char * PeTable ::ExtractAndPackAll(comID id, int ufield, int *length) {
245   int nmsgs = 0;
246   int i, j;
247   int index = 0;
248
249   ComlibPrintf("[%d] In Extract And Pack All\n", CkMyPe());
250
251   //Increment magic to detect duplicate messages
252   magic++;
253
254   register int total_msg_size = 0;
255
256   //first compute size
257   for (i=0;i<NumPes;i++) {
258     index = i;
259     for (j=msgnum[index]-1; (j>=0); j--) {
260       if (PeList[index][j]->magic != magic) {                
261         total_msg_size += ALIGN8(PeList[index][j]->msgsize);
262         total_msg_size += 2 * sizeof(int);
263         PeList[index][j]->magic=magic;
264
265         nmsgs ++;
266       }            
267     }
268   }
269     
270   total_msg_size += ALIGN8(sizeof(AllToAllHdr));
271
272   ComlibPrintf("[%d] Message Size %d, nmsgs %d **%d**\n", CkMyPe(), total_msg_size, nmsgs, sizeof(AllToAllHdr));
273     
274   //poiter to the combined message, UGLY NAME
275   char *p = (char *) CmiAlloc(total_msg_size * sizeof(char));    
276
277   ComlibPrintf("After cmialloc\n");
278
279   //buffer to copy stuff into
280   char *t = p; 
281   char *junk = NULL;
282     
283   int refno = 0;
284
285   AllToAllHdr ahdr;
286   ahdr.refno = refno;
287   ahdr.id = id;
288   ahdr.size = *length;
289   ahdr.ufield = ufield;
290   ahdr.nmsgs = nmsgs;
291
292   /*
293     PACKINT(refno);    
294     PACK(comID, id);
295       
296     PACKINT(ufield);
297     PACKINT(nmsgs);
298     //    PACKINT(dummy); //Aligning to 8 bytes
299     */
300
301   PACK(AllToAllHdr, ahdr);   
302
303   int msg_offset = ALIGN8(sizeof(AllToAllHdr));
304     
305   //Increment magic again for creating the message
306   magic++;
307   for (i=0;i<NumPes;i++) {
308     index=i;
309     int ref = 0;
310     int size;
311
312     for (j=msgnum[index]-1; (j>=0); j--) {
313       //Check if it is a duplicate
314       if (PeList[index][j]->magic != magic) {                
315         size = PeList[index][j]->msgsize;
316         PACKMSG(&size, sizeof(int));
317         PACKMSG(&ref, sizeof(int));
318         PeList[index][j]->magic=magic;
319         PACKMSG(PeList[index][j]->msg, size);
320
321         msg_offset = ALIGN8(msg_offset);
322       }
323
324       //Free it when all the processors have gotten rid of it
325       if (--(PeList[index][j]->refCount) <=0) {
326         ComlibPrintf("before cmifree \n");
327         CmiFree(PeList[index][j]->msg);   
328         ComlibPrintf("after cmifree \n");
329
330         PTFREE(PeList[index][j]);
331       }
332       //Assign the current processors message pointer to NULL
333       PeList[index][j] = NULL;
334     }
335     msgnum[index] = 0;
336   }
337     
338   *length = total_msg_size;
339   return p;
340 }
341
342 #undef UNPACK
343 #define UNPACK(type,data) {junk=(char *)&(data); memcpy(junk, t, sizeof(type));t+=sizeof(type);}
344 #undef UNPACKMSG
345 #define UNPACKMSG(dest,src, size) { memcpy(dest, src, size); offset += size;}
346
347 int PeTable :: UnpackAndInsert(void *in) {
348   char *junk;
349   char *t =(char *)in + CmiReservedHeaderSize;
350   int i, ufield, npe, pe, nummsgs, ptrlistindex=0;
351   char *msgend, *msgcur;
352   comID id;
353   int refno = 0;
354   int msgsize;
355
356   register int offset;
357
358   UNPACK(int, refno);
359   ComlibPrintf("%d UnPackAndInsert\n", CkMyPe());
360   UNPACK(comID, id);
361   UNPACK(int, msgsize);
362   UNPACK(int, ufield);
363   UNPACK(int, nummsgs);
364   UNPACK(int, npe);
365
366   // unpack all messages into an array
367   msgend = (char*)in + msgsize;
368   msgcur = (char*)in + ALIGN8(sizeof(struct AllToAllHdr) + (npe+nummsgs+1)*sizeof(int));
369   while (msgcur < msgend) {
370     CmiChunkHeader *ch = (CmiChunkHeader *)msgcur;
371
372     PTinfo *temp;
373     PTALLOC(temp);
374     temp->msgsize=ch->size;
375     temp->msg=(void*)&ch[1];
376     temp->refCount=0;
377     temp->magic=0;
378     temp->offset=0;
379
380     ptrvec.insert(++ptrlistindex, temp);
381
382     // fix the ref field of the message
383     ch->ref = (int)((char*)in - (char*)temp->msg);
384     msgcur += ALIGN8(ch->size) + sizeof(CmiChunkHeader);
385   }
386
387   pe = -1;
388   //for (i=0;i<npe;i++) {
389   for (i=0; i<nummsgs; ++i) {
390     //UNPACK(int, pe);
391     //pe *= -1;
392
393     UNPACK(int, offset);
394     if (offset <= 0) {
395       pe = -1 * offset;
396       --i;
397       continue;
398     }
399
400     if (msgnum[pe] >= MaxSize[pe]) {
401       REALLOC(PeList[pe], MaxSize[pe]);
402       MaxSize[pe] *= 2;
403     }
404     PeList[pe][msgnum[pe]] = ptrvec[offset];
405     (ptrvec[offset])->refCount++;
406     msgnum[pe]++;
407
408     /*
409       while (offset > 0) {
410       int tempmsgsize;
411       UNPACKMSG(&(tempmsgsize), (char *)in+offset, sizeof(int));
412       int ptr;
413       UNPACKMSG(&ptr, (char *)in+offset, sizeof(int));
414
415       if (ptr >=0 )  {
416       if (msgnum[pe] >= MaxSize[pe]) {
417       REALLOC(PeList[pe], MaxSize[pe]);
418       MaxSize[pe] *= 2;
419       }
420       PeList[pe][msgnum[pe]]=ptrvec[ptr];
421       (ptrvec[ptr])->refCount++;
422       msgnum[pe]++;
423
424       UNPACK(int, offset);
425       continue;
426       }
427             
428       PTinfo *temp;
429       PTALLOC(temp);
430       temp->msgsize=tempmsgsize;
431       temp->refCount=1;
432       temp->magic=0;
433       temp->offset=0;
434
435       ptrvec.insert(ptrlistindex, temp);
436       memcpy((char *)in+offset-sizeof(int), &ptrlistindex, sizeof(int));
437
438       ptrlistindex++;
439       temp->msg=(void *)((char *)in+offset);
440       if (msgnum[pe] >= MaxSize[pe]) {
441
442       REALLOC(PeList[pe], MaxSize[pe]);
443       MaxSize[pe] *= 2;
444       }
445       PeList[pe][msgnum[pe]]=temp;
446       msgnum[pe]++;
447       UNPACK(int, offset);
448       //}
449       //t -=sizeof(int);
450       }
451       *(int *)((char *)in -sizeof(int))=ptrlistindex; 
452       */
453   }
454
455   REFFIELD(in) = ptrlistindex;
456   if (ptrlistindex==0) {
457     REFFIELD(in) = 1;
458     CmiFree(in);
459   }
460
461   /*  
462       for (i=0;i<ptrlistindex;i++) {
463       char * actualmsg=(char *)(ptrvec[i]->msg);
464       int *rc=(int *)(actualmsg-sizeof(int));
465       *rc=(int)((char *)in-actualmsg);
466       //ComlibPrintf("I am inserting %d\n", *rc);
467       }
468   */
469
470   ptrvec.removeAll();
471   
472   return(ufield);
473 }
474
475 /* Unpack and insert an all to all message, the router provides the
476    list of processors to insert into.
477    Same protocol as mentioned earlier.
478 */
479
480 int PeTable :: UnpackAndInsertAll(void *in, int npes, int *pelist) {
481   char *junk;
482   char *t =(char *)in /*+CmiReservedHeaderSize*/;
483   int i,  
484     ufield,   // user field or ths stage of the iteration 
485     nmsgs,    // number of messages in combo message
486     refno,    // reference number
487     dummy;    // alignment dummy
488   
489   comID id;
490
491   /*
492     UNPACK(int, refno);      
493     UNPACK(comID, id);
494     
495     UNPACK(int, ufield);
496     UNPACK(int, nmsgs);
497     //UNPACK(int, dummy);
498     int header_size = sizeof(comID) + CmiReservedHeaderSize + 3 *sizeof(int);
499     if(header_size % 8 != 0)
500     t+= 8 - header_size % 8;
501   */
502
503   AllToAllHdr ahdr;
504   UNPACK(AllToAllHdr, ahdr);
505
506   if((sizeof(AllToAllHdr) & 7) != 0)
507     t += 8 - (sizeof(AllToAllHdr) & 7);
508
509   refno = ahdr.refno;
510   id = ahdr.id;
511   nmsgs = ahdr.nmsgs;
512   ufield = ahdr.ufield;
513
514   ComlibPrintf("[%d] unpack and insert all %d, %d\n", CkMyPe(), ufield, nmsgs);
515   
516   //Inserting a memory foot print may, change later
517   CmiChunkHeader *chdr= (CmiChunkHeader*)((char*)in - sizeof(CmiChunkHeader));
518
519   int *ref;
520   int size;
521   char *msg;
522   for(int count = 0; count < nmsgs; count++){
523
524     t += sizeof(CmiChunkHeader);
525     msg = t;
526
527     // Get the size of the message, and set the ref field correctly for CmiFree
528     size = SIZEFIELD(msg);
529     REFFIELD(msg) = (int)((char *)in - (char *)msg);
530
531     t += ALIGN8(size);
532
533     // Do CmiReference(msg), this is done bypassing converse!
534     chdr->ref++;
535
536     /*
537       UNPACK(int, size);
538       ref = (int *)t;
539       t += sizeof(int);
540     
541       *ref = (int)((char *)(&chdr->ref) - (char *)ref);
542       chdr->ref ++;
543
544       ComlibPrintf("ref = %d, global_ref = %d\n", *ref, chdr->ref);
545     
546       msg = t;
547       t += ALIGN8(size);
548     */
549     InsertMsgs(npes, pelist, size, msg);
550   }  
551
552   CmiFree(in);
553   return ufield;
554 }
555
556 /*
557  * Added by Filippo, 2005/04/18 to allow a zero-copy sending, through the
558  * CmiVectorSend functions.
559  */
560 PTvectorlist PeTable :: ExtractAndVectorize(comID id, int ufield, int npe, int *pelist) {
561   char *junk;
562   int nummsgs = 0;
563   int offset;
564   int i, j;
565
566   for (i=0; i<npe; ++i) nummsgs += msgnum[pelist[i]];
567
568   ComlibPrintf("%d In ExtractAndVectorize %d, %d\n", CmiMyPe(), npe, nummsgs); 
569
570   if (nummsgs ==0) {
571     ComlibPrintf("Returning NULL\n");
572     return(NULL);
573   }
574     
575   int headersize = sizeof(struct AllToAllHdr) + (npe + nummsgs + 1) * sizeof(int);
576   //int msg_offset = CmiReservedHeaderSize + sizeof(comID) 
577   //    + (npe + 4 + nummsgs) * sizeof(int);  
578
579   char *p;
580   p=(char *)CmiAlloc(headersize);
581
582   char *t = p + CmiReservedHeaderSize;
583   if (!p) CmiAbort("Big time problem\n");
584   magic++;
585
586   int refno = id.refno;    
587
588   // SHOULD PACK THE SIZE, which is not available: fix elan and undo this cvs update
589   PACK(int, refno);
590   PACK(comID, id);
591   PACK(int, ufield);
592   PACK(int, nummsgs);
593   PACK(int, npe);
594     
595   int lesspe=0;
596   int npacked = 0;
597   for (i=0;i<npe;i++) {
598     int index=pelist[i];
599
600     if (msgnum[index]<=0) {
601       lesspe++;
602             
603       ComlibPrintf("[%d] msgnum[index]<=0 !!!!!\n", CkMyPe());
604       continue;
605     }
606         
607     ComlibPrintf("%d Packing pelist[%d]\n", CkMyPe(), index);
608     register int newval=-1*pelist[i];
609     PACK(int, newval); 
610
611     for (j=0;j<msgnum[index];j++) {
612       if (PeList[index][j]->magic == magic) {
613         offset=(PeList[index][j]->offset);
614       }
615       else {
616         npacked ++;
617                 
618         //offset=msg_offset;
619         offset=npacked;
620         PeList[index][j]->magic=magic;
621         PeList[index][j]->offset=offset;
622         PTinfo *tempmsg=PeList[index][j];
623
624         ptrvec.insert(npacked, tempmsg);
625       }
626       
627       //ComlibPrintf("%d Packing msg_offset=%d\n", CkMyPe(), offset);
628       PACK(int, offset); 
629
630       --(PeList[index][j]->refCount);
631       /*
632         if (--(PeList[index][j]->refCount) <=0) {
633         CmiFree(PeList[index][j]->msg);
634                 
635         PTFREE(PeList[index][j]);
636         }
637       */
638       PeList[index][j]=NULL;
639     }
640     msgnum[index]=0;
641   }
642   //offset=-1;
643   //PACK(int, offset);
644
645   // See petable.h for a description of this structure
646   PTvectorlist result = (PTvectorlist)CmiAlloc(sizeof(struct ptvectorlist) +
647                                                (npacked+1)*2*sizeof(char*) +
648                                                2*sizeof(CmiChunkHeader));
649   result->count = npacked + 1;
650   result->sizes = (int*)((char*)result + sizeof(struct ptvectorlist) + sizeof(CmiChunkHeader));
651   result->msgs  = (char**)((char*)result->sizes + (npacked+1)*sizeof(int) + sizeof(CmiChunkHeader));
652
653   SIZEFIELD(result->sizes) = (npacked+1)*sizeof(int);
654   REFFIELD(result->sizes) = - (int)(sizeof(struct ptvectorlist) + sizeof(CmiChunkHeader));
655   SIZEFIELD(result->msgs) = (npacked+1)*sizeof(int);
656   REFFIELD(result->msgs) = - (sizeof(struct ptvectorlist) + (npacked+1)*sizeof(int) + 2*sizeof(CmiChunkHeader));
657   CmiReference(result);
658
659   result->sizes[0] = headersize;
660   result->msgs[0] = p;
661   PTinfo *temp;
662   for (i=1; i<=npacked; ++i) {
663     temp = ptrvec[i];
664     result->sizes[i] = temp->msgsize;
665     result->msgs[i] = (char*)temp->msg;
666     // if there is still reference we CmiReference the message so it does not get deleted
667     // otherwise we free also the PTinfo struct use to hold it
668     if (temp->refCount > 0) CmiReference(result->msgs[i]);
669     else PTFREE(temp);
670   }
671
672   ptrvec.removeAll();
673
674   /*    
675         if (lesspe) {
676         t=p+CmiReservedHeaderSize+2*sizeof(int) + sizeof(comID);
677         npe=npe-lesspe;
678         PACK(int, npe);
679         }
680   */
681
682   //return(p);
683
684   return result;
685 }
686
687 /*
688  * Added by Filippo, 2005/04/18 to allow a zero-copy sending, through the
689  * CmiVectorSend functions.
690  */
691 PTvectorlist PeTable :: ExtractAndVectorizeAll(comID id, int ufield) {
692   int nmsgs = 0, i, j;
693   int index = 0;
694
695   ComlibPrintf("[%d] In Extract And Vectorize All\n", CkMyPe());
696
697   //Increment magic to detect duplicate messages
698   magic++;
699
700   //register int total_msg_size = 0;
701
702   //first compute size
703   for (i=0;i<NumPes;i++) {
704     index = i;
705     for (j=msgnum[index]-1; (j>=0); j--) {
706       if (PeList[index][j]->magic != magic) {                
707         //total_msg_size += ALIGN8(PeList[index][j]->msgsize);
708         //total_msg_size += 2 * sizeof(int);
709         PeList[index][j]->magic=magic;
710         ptrvec.insert(nmsgs, PeList[index][j]);
711         PeList[index][j] = NULL;
712         nmsgs ++;
713       }
714       --(PeList[index][j]->refCount);
715     }
716   }
717
718   //total_msg_size += ALIGN8(sizeof(AllToAllHdr));
719
720   ComlibPrintf("[%d] nmsgs %d **%d**\n", CkMyPe(), nmsgs, sizeof(AllToAllHdr));
721     
722   //poiter to the message header
723   AllToAllHdr *ahdr = (AllToAllHdr *) CmiAlloc(sizeof(struct AllToAllHdr));
724
725   ComlibPrintf("After cmialloc\n");
726
727   /*
728   //buffer to copy stuff into
729   char *t = p; 
730   char *junk = NULL;
731     
732   int dummy = 0;
733   */
734
735   int refno = 0;
736
737   ahdr->refno = refno;
738   ahdr->id = id;
739   ahdr->ufield = ufield;
740   ahdr->nmsgs = nmsgs;
741
742   /*
743     PACKINT(refno);    
744     PACK(comID, id);
745       
746     PACKINT(ufield);
747     PACKINT(nmsgs);
748     //    PACKINT(dummy); //Aligning to 8 bytes
749     */
750
751   // See petable.h for a description of this structure
752   PTvectorlist result = (PTvectorlist)CmiAlloc(sizeof(struct ptvectorlist) +
753                                                (nmsgs+1)*2*sizeof(char*) +
754                                                2*sizeof(CmiChunkHeader));
755   result->count = nmsgs + 1;
756   result->sizes = (int*)((char*)result + sizeof(struct ptvectorlist) + sizeof(CmiChunkHeader));
757   result->msgs  = (char**)((char*)result->sizes + (nmsgs+1)*sizeof(int) + sizeof(CmiChunkHeader));
758
759   SIZEFIELD(result->sizes) = (nmsgs+1)*sizeof(int);
760   REFFIELD(result->sizes) = - (int)(sizeof(struct ptvectorlist) + sizeof(CmiChunkHeader));
761   SIZEFIELD(result->msgs) = (nmsgs+1)*sizeof(int);
762   REFFIELD(result->msgs) = - (sizeof(struct ptvectorlist) + (nmsgs+1)*sizeof(int) + 2*sizeof(CmiChunkHeader));
763   CmiReference(result);
764
765   result->sizes[0] = sizeof(ahdr);
766   result->msgs[0] = (char*)ahdr;
767   PTinfo *temp;
768   for (i=1; i<nmsgs; ++i) {
769     temp = ptrvec[i];
770     result->sizes[i] = temp->msgsize;
771     result->msgs[i] = (char*)temp->msg;
772     // if there is still reference we CmiReference the message so it does not get deleted
773     // otherwise we free also the PTinfo struct use to hold it
774     if (temp->refCount > 0) CmiReference(result->msgs[i]);
775     else PTFREE(temp);
776   }
777
778   ptrvec.removeAll();
779
780   return result;
781
782   /*
783   PACK(AllToAllHdr, ahdr);   
784
785   int msg_offset = ALIGN8(sizeof(AllToAllHdr));
786     
787   //Increment magic again for creating the message
788   magic++;
789   for (i=0;i<NumPes;i++) {
790     index=i;
791     int ref = 0;
792     int size;
793
794     for (j=msgnum[index]-1; (j>=0); j--) {
795       //Check if it is a duplicate
796       if (PeList[index][j]->magic != magic) {                
797         size = PeList[index][j]->msgsize;
798         PACKMSG(&size, sizeof(int));
799         PACKMSG(&ref, sizeof(int));
800         PeList[index][j]->magic=magic;
801         PACKMSG(PeList[index][j]->msg, size);
802
803         msg_offset = ALIGN8(msg_offset);
804       }
805
806       //Free it when all the processors have gotten rid of it
807       if (--(PeList[index][j]->refCount) <=0) {
808         ComlibPrintf("before cmifree \n");
809         CmiFree(PeList[index][j]->msg);   
810         ComlibPrintf("after cmifree \n");
811
812         PTFREE(PeList[index][j]);
813       }
814       //Assign the current processors message pointer to NULL
815       PeList[index][j] = NULL;
816     }
817     msgnum[index] = 0;
818   }
819     
820   *length = total_msg_size;
821   return p;
822   */
823 }
824
825 void PeTable :: GarbageCollect() {
826 }
827
828 /*@}*/