doc: Add serial to list of ci file reserved words
[charm.git] / src / conv-core / conv-onesided.c
1 /*
2  * The emulated version of Get/Put in converse for 
3  * messaging hardware that does not have hardware 
4  * support for one sided communication
5  * Author: Nilesh
6  * Date: 05/17/2006
7  */
8 #include "conv-onesided.h"
9
10 #ifdef __ONESIDED_IMPL
11 #ifdef __ONESIDED_NO_HARDWARE
12
13 #ifndef _CONV_ONESIDED_C_
14 #define _CONV_ONESIDED_C_
15
16 struct CmiCb {
17   CmiRdmaCallbackFn fn;
18   void *param;
19 };
20 typedef struct CmiCb CmiCb;
21
22 /* This is an object which is kindof a handle to a get or put call.
23  * This object is polled in test to verify if the get/put has completed.
24  * The completed bit is always set if the operation is complete
25  */
26 struct CmiRMA {
27   int type;
28   union {
29     int completed;
30     CmiCb *cb;
31   } ready;
32 };
33 typedef struct CmiRMA CmiRMA;
34
35 struct CmiRMAMsg {
36   char core[CmiMsgHeaderSizeBytes];
37   CmiRMA* stat;
38 };
39 typedef struct CmiRMAMsg CmiRMAMsg;
40
41 struct RMAPutMsg {
42   char core[CmiMsgHeaderSizeBytes];
43   void *Saddr;
44   void *Taddr;
45   unsigned int size;
46   unsigned int targetId;
47   unsigned int sourceId;
48   CmiRMA *stat;
49 };
50 typedef struct RMAPutMsg RMAPutMsg;
51
52 int CmiRegisterMemory(void *addr, unsigned int size){
53   //in the emulated version, this is blank
54   return 1;
55 }
56
57 int CmiUnRegisterMemory(void *addr, unsigned int size){
58   //in the emulated version, this is blank
59   return 1;
60 }
61
62 void handlePutSrc(void *msg) {
63   CmiRMA* stat = ((CmiRMAMsg*)msg)->stat;
64   if(stat->type==1) {
65     stat->ready.completed = 1;
66     //the handle is active, and the user will clean it
67   }
68   else {
69     (*(stat->ready.cb->fn))(stat->ready.cb->param);
70     CmiFree(stat->ready.cb);
71     CmiFree(stat); //clean up the internal handle
72   }
73   CmiFree(msg);
74   return;
75 }
76
77 void handlePutDest(void *msg) {
78   RMAPutMsg *context = (RMAPutMsg*)msg;
79   void* putdata = (void*)(((char*)(msg))+sizeof(RMAPutMsg));
80   unsigned int sizeRmaStat = sizeof(CmiRMAMsg);
81   void *msgRmaStat;
82   //copy the message
83   memcpy(context->Taddr,putdata,context->size);
84   //send the ack
85   msgRmaStat = (void*)CmiAlloc(sizeRmaStat);
86   ((CmiRMAMsg*)msgRmaStat)->stat = context->stat;
87   CmiSetHandler(msgRmaStat,putSrcHandler);
88   CmiSyncSendAndFree(context->sourceId,sizeRmaStat,msgRmaStat);
89
90   CmiFree(msg);
91   return;
92 }
93
94 void *CmiPut(unsigned int sourceId, unsigned int targetId, void *Saddr, void *Taddr, unsigned int size) {
95   unsigned int sizeRma = sizeof(RMAPutMsg)+size;
96   void *msgRma = (void*)CmiAlloc(sizeRma);
97   RMAPutMsg *context = (RMAPutMsg*)msgRma;
98
99   context->Saddr = Saddr;
100   context->Taddr = Taddr;
101   context->size = size;
102   context->targetId = targetId;
103   context->sourceId = sourceId;
104   context->stat = (CmiRMA*)CmiAlloc(sizeof(CmiRMA));
105   context->stat->type = 1;
106   context->stat->ready.completed = 0;
107   void* putdata = (void*)(((char*)(msgRma))+sizeof(RMAPutMsg));
108   memcpy(putdata,Saddr,size);
109   void *stat = context->stat;
110
111   CmiSetHandler(msgRma,putDestHandler);
112   CmiSyncSendAndFree(targetId,sizeRma,msgRma);
113
114   return stat;
115 }
116
117 void CmiPutCb(unsigned int sourceId, unsigned int targetId, void *Saddr, void *Taddr, unsigned int size, CmiRdmaCallbackFn fn, void *param) {
118   unsigned int sizeRma = sizeof(RMAPutMsg)+size;
119   void *msgRma = (void*)CmiAlloc(sizeRma);
120   RMAPutMsg *context = (RMAPutMsg*)msgRma;
121
122   context->Saddr = Saddr;
123   context->Taddr = Taddr;
124   context->size = size;
125   context->targetId = targetId;
126   context->sourceId = sourceId;
127   context->stat = (CmiRMA*)CmiAlloc(sizeof(CmiRMA));
128   context->stat->type = 0;
129   context->stat->ready.cb = (CmiCb*)CmiAlloc(sizeof(CmiCb));
130   context->stat->ready.cb->fn = fn;
131   context->stat->ready.cb->param = param;
132   void* putdata = (void*)(((char*)(msgRma))+sizeof(RMAPutMsg));
133   memcpy(putdata,Saddr,size);
134
135   CmiSetHandler(msgRma,putDestHandler);
136   CmiSyncSendAndFree(targetId,sizeRma,msgRma);
137   return;
138 }
139
140 void handleGetSrc(void *msg) {
141   RMAPutMsg *context = (RMAPutMsg*)msg;
142   void* putdata = (void*)(((char*)(msg))+sizeof(RMAPutMsg));
143   //copy the message
144   memcpy(context->Saddr,putdata,context->size);
145   //note the ack
146   if(context->stat->type==1) {
147     context->stat->ready.completed = 1;
148     //the handle will be used still, and the user will clean it
149   }
150   else {
151     (*(context->stat->ready.cb->fn))(context->stat->ready.cb->param);
152     CmiFree(context->stat->ready.cb);
153     CmiFree(context->stat); //clean up the internal handle
154   }
155   CmiFree(msg);
156   return;
157 }
158
159 void handleGetDest(void *msg) {
160   RMAPutMsg *context1 = (RMAPutMsg*)msg;
161   unsigned int sizeRma = sizeof(RMAPutMsg)+context1->size;
162   void *msgRma = (void*)CmiAlloc(sizeRma);
163   RMAPutMsg *context = (RMAPutMsg*)msgRma;
164   memcpy(context,context1,sizeof(RMAPutMsg));
165   void* putdata = (void*)(((char*)(msgRma))+sizeof(RMAPutMsg));
166   memcpy(putdata,context->Taddr,context->size);
167   CmiSetHandler(msgRma,getSrcHandler);
168   CmiSyncSendAndFree(context->sourceId,sizeRma,msgRma);
169   CmiFree(msg);
170   return;
171 }
172
173 void *CmiGet(unsigned int sourceId, unsigned int targetId, void *Saddr, void *Taddr, unsigned int size) {
174   unsigned int sizeRma;
175   char *msgRma;
176   RMAPutMsg *context;
177   sizeRma = sizeof(RMAPutMsg);
178   msgRma = (char*)CmiAlloc(sizeRma*sizeof(char));
179
180   context = (RMAPutMsg*)msgRma;
181   context->Saddr = Saddr;
182   context->Taddr = Taddr;
183   context->size = size;
184   context->targetId = targetId;
185   context->sourceId = sourceId;
186   context->stat = (CmiRMA*)CmiAlloc(sizeof(CmiRMA));
187   context->stat->type = 1;
188   context->stat->ready.completed = 0;
189   void *stat = context->stat;
190
191   CmiSetHandler(msgRma,getDestHandler);
192   CmiSyncSendAndFree(targetId,sizeRma,msgRma);
193   return stat;
194 }
195
196 void CmiGetCb(unsigned int sourceId, unsigned int targetId, void *Saddr, void *Taddr, unsigned int size, CmiRdmaCallbackFn fn, void *param) {
197   unsigned int sizeRma;
198   char *msgRma;
199   RMAPutMsg *context;
200   sizeRma = sizeof(RMAPutMsg);
201   msgRma = (char*)CmiAlloc(sizeRma*sizeof(char));
202
203   context = (RMAPutMsg*)msgRma;
204   context->Saddr = Saddr;
205   context->Taddr = Taddr;
206   context->size = size;
207   context->targetId = targetId;
208   context->sourceId = sourceId;
209   context->stat = (CmiRMA*)CmiAlloc(sizeof(CmiRMA));
210   context->stat->type = 0;
211   context->stat->ready.cb = (CmiCb*)CmiAlloc(sizeof(CmiCb));
212   context->stat->ready.cb->fn = fn;
213   context->stat->ready.cb->param = param;
214
215   CmiSetHandler(msgRma,getDestHandler);
216   CmiSyncSendAndFree(targetId,sizeRma,msgRma);
217   return;
218 }
219
220
221 int CmiWaitTest(void *obj){
222   CmiRMA *stat = (CmiRMA*)obj;
223   return stat->ready.completed;
224 }
225
226 #endif
227 #endif
228 #endif
229