a little cleanup and conformation of usage of CmiChunkHeader. It will prevent in
[charm.git] / src / conv-com / petable.h
1 /*****************************************************************************
2  * $Source$
3  * $Author$
4  * $Date$
5  * $Revision$
6  *****************************************************************************/
7
8 #ifndef PETABLE_H
9 #define PETABLE_H
10
11 #ifndef NULL
12 #define NULL 0
13 #endif
14
15 #define MSGQLEN 32
16
17 typedef struct ptinfo {
18   int refCount;
19   int magic;
20   int offset;
21   /*int freelistindex;*/
22   int msgsize;
23   void *msg;
24   struct ptinfo * next;
25 } PTinfo;
26
27 typedef struct ptvectorlist {
28   int count;
29   int *sizes;
30   char *msgs;
31 }* PTvectorlist;
32
33 /*
34 typedef struct {
35   int refCount;
36   int flag;
37   void * ptr;
38 } InNode;
39
40 class GList {
41  private:
42         InNode *InList;
43         int InListIndex;
44  public:
45         GList();
46         ~GList();
47         int AddWholeMsg(void *);
48         void setRefcount(int, int);
49         void DeleteWholeMsg(int);
50         void DeleteWholeMsg(int, int);
51         void GarbageCollect();
52         void Add(void *);
53         void Delete();
54 };
55 */
56
57 #define ALIGN8(x)       (int)((~7)&((x)+7))
58
59 /* Reduce the no. of mallocs by allocating from
60  * a free list. By allocating 21 at a time, it allocates
61  * 512 contiguous bytes. */
62 #define PTALLOC(ktmp) {\
63   if (PTFreeList) {\
64         ktmp=PTFreeList;\
65         PTFreeList=ktmp->next;\
66   }\
67   else {\
68         ktmp=(PTinfo *)CmiAlloc(21*sizeof(PTinfo)+sizeof(PTinfo *));\
69         for (int ii=1; ii<20; ++ii) {\
70           ktmp[ii].next = &(ktmp[ii+1]);\
71         }\
72         ktmp[20].next = NULL;\
73         PTFreeList=&(ktmp[1]);\
74         *((PTinfo**)(&ktmp[21]))=PTFreeChunks;\
75         PTFreeChunks=ktmp;\
76   }\
77 }
78
79 #define PTFREE(ktmp) {\
80   ktmp->next=PTFreeList;\
81   PTFreeList=ktmp;\
82 }
83
84 #define PTNEXTCHUNK(ktmp)  (*((PTinfo**)(&ktmp[21])));
85
86 #define REALLOC(ktmp, ksize) {\
87    PTinfo **junkptr=(PTinfo **)CmiAlloc(2*ksize*sizeof(void *));\
88    for (int ki=0; ki<ksize;ki++) junkptr[ki]=ktmp[ki];\
89    CmiFree(ktmp);\
90    ktmp=junkptr;\
91 }
92
93 class PeTable {
94   private:
95     PTinfo ***PeList;
96     CkVec<PTinfo *> ptrvec;
97
98     PTinfo *PTFreeList;
99     PTinfo *PTFreeChunks;
100     //  char * CombBuffer;
101     int *msgnum, *MaxSize;
102     int NumPes;
103     int magic;
104     //GList *FreeList;
105
106     inline int TotalMsgSize(int npe, int *pelist, int *nm, int *nd) {
107         register int totsize=0;
108         magic++;
109         *nm=0;
110         *nd=0;        
111         
112         for (int i=0;i<npe;i++) {            
113             int index = pelist[i];            
114             *nm += msgnum[index];
115             
116             ComlibPrintf("%d: NUM MSGS %d, %d\n", CkMyPe(), index, 
117                          msgnum[index]);
118             
119             for (int j=0;j<msgnum[index];j++) {
120                 if (PeList[index][j]->magic != magic) {                    
121                     int tmp_size = PeList[index][j]->msgsize;
122                     tmp_size = ALIGN8(tmp_size);                
123                     totsize += tmp_size;                
124                     totsize += sizeof(int)+sizeof(int);                    
125                     PeList[index][j]->magic=magic;
126                     (*nd)++;
127                 }
128             }
129         }
130         return(totsize);
131     }
132
133  public:
134     
135     PeTable(int n);
136     ~PeTable();
137     
138     inline void InsertMsgs(int npe, int *pelist, int size, void *msg) {
139         PTinfo *tmp;
140         PTALLOC(tmp);
141         tmp->refCount=0;
142         tmp->magic=0;
143         tmp->offset=0;
144         /*tmp->freelistindex=-1;*/
145         tmp->msgsize=size;
146         tmp->msg=msg;
147         
148         for (int j=0;j<npe;j++) {
149             tmp->refCount++;
150             int index=pelist[j];
151             
152             ComlibPrintf("[%d] Inserting %d %d %d\n", CkMyPe(), 
153                          msgnum[index], index, size);
154             
155             if (msgnum[index] >= MaxSize[index]) {
156                 REALLOC(PeList[index], MaxSize[index]);
157                 MaxSize[index] *= 2;
158             }
159             PeList[index][msgnum[index]]=tmp;
160             msgnum[index]++;
161         }
162     }
163
164     inline void InsertMsgs(int npe, int *pelist, int nmsgs, void **msglist){
165         msgstruct **m=(msgstruct **)msglist;
166         for (int i=0;i<nmsgs;i++)
167             InsertMsgs(npe, pelist, m[i]->msgsize, m[i]->msg);
168     }
169         
170     void ExtractAndDeliverLocalMsgs(int pe);
171     
172     int UnpackAndInsert(void *in);
173     int UnpackAndInsertAll(void *in, int npes, int *pelist);
174     
175     char * ExtractAndPack(comID, int, int, int *pelist, int *length); 
176     char * ExtractAndPackAll(comID id, int ufield, int *length);
177     
178     struct ptvectorlist * ExtractAndVectorize(comID, int, int, int *pelist); 
179     struct ptvectorlist * ExtractAndVectorizeAll(comID id, int ufield);
180     
181     void GarbageCollect();
182     void Purge();
183 };
184
185 #endif