467c58c9c844e218abc3435b128078e7759c2156
[charm.git] / src / ck-core / msgalloc.C
1 /*****************************************************************************
2  * $Source$
3  * $Author$
4  * $Date$
5  * $Revision$
6  *****************************************************************************/
7
8 #include "ck.h"
9 #include "queueing.h"
10
11 extern "C"
12 void *CkAllocSysMsg(void)
13 {
14   return CkpvAccess(_msgPool)->get();
15 }
16
17 extern "C"
18 void CkFreeSysMsg(void *m)
19 {
20   CkpvAccess(_msgPool)->put(m);
21 }
22
23 extern "C"
24 void* CkAllocMsg(int msgIdx, int msgBytes, int prioBits)
25 {
26   register envelope* env;
27   env = _allocEnv(ForChareMsg, msgBytes, prioBits);
28   setMemoryTypeMessage(env);
29
30   env->setQueueing(_defaultQueueing);
31   env->setMsgIdx(msgIdx);
32   return EnvToUsr(env);
33 }
34
35 extern "C"
36 void* CkAllocBuffer(void *msg, int bufsize)
37 {
38   bufsize = CkMsgAlignLength(bufsize);
39   register envelope *env = UsrToEnv(msg);
40   register envelope *packbuf;
41   packbuf = _allocEnv(env->getMsgtype(), bufsize, 
42                       env->getPriobits());
43   
44   register int size = packbuf->getTotalsize();
45   CmiMemcpy(packbuf, env, sizeof(envelope));
46   packbuf->setTotalsize(size);
47   packbuf->setPacked(!env->isPacked());
48   CmiMemcpy(packbuf->getPrioPtr(), env->getPrioPtr(), packbuf->getPrioBytes());
49   return EnvToUsr(packbuf);;
50 }
51
52 extern "C"
53 void  CkFreeMsg(void *msg)
54 {
55   if (msg!=NULL) {
56       CmiFree(UsrToEnv(msg));
57   }
58 }
59
60
61 extern "C"
62 void* CkCopyMsg(void **pMsg)
63 {// cannot simply memcpy, because srcMsg could be varsize msg
64   register void *srcMsg = *pMsg;
65   register envelope *env = UsrToEnv(srcMsg);
66   register unsigned char msgidx = env->getMsgIdx();
67   if(!env->isPacked() && _msgTable[msgidx]->pack) {
68     srcMsg = _msgTable[msgidx]->pack(srcMsg);
69     UsrToEnv(srcMsg)->setPacked(1);
70   }
71   register int size = UsrToEnv(srcMsg)->getTotalsize();
72   register envelope *newenv = (envelope *) CmiAlloc(size);
73   CmiMemcpy(newenv, UsrToEnv(srcMsg), size);
74   if(UsrToEnv(srcMsg)->isPacked() && _msgTable[msgidx]->unpack) {
75     srcMsg = _msgTable[msgidx]->unpack(srcMsg);
76     UsrToEnv(srcMsg)->setPacked(0);
77   }
78   *pMsg = srcMsg;
79   if(newenv->isPacked() && _msgTable[msgidx]->unpack) {
80     srcMsg = _msgTable[msgidx]->unpack(EnvToUsr(newenv));
81     UsrToEnv(srcMsg)->setPacked(0);
82   } else srcMsg = EnvToUsr(newenv);
83
84   setMemoryTypeMessage(newenv);
85   return srcMsg;
86 }
87
88 extern "C"
89 void  CkSetQueueing(void *msg, int strategy)
90 {
91   UsrToEnv(msg)->setQueueing((unsigned char) strategy);
92 }
93
94
95 extern "C"
96 void* CkPriorityPtr(void *msg)
97 {
98   return UsrToEnv(msg)->getPrioPtr();
99 }
100
101 CkMarshallMsg *CkAllocateMarshallMsgNoninline(int size,const CkEntryOptions *opts)
102 {
103         //Allocate the message
104         CkMarshallMsg *m=new (size,opts->getPriorityBits())CkMarshallMsg;
105         //Copy the user's priority data into the message
106         envelope *env=UsrToEnv(m);
107         setMemoryTypeMessage(env);
108         CmiMemcpy(env->getPrioPtr(),opts->getPriorityPtr(),env->getPrioBytes());
109         //Set the message's queueing type
110         env->setQueueing((unsigned char)opts->getQueueing());
111         return m;
112 }
113