src/conv-core/cpm.c

   1 #include <stdlib.h>
   2 #include <string.h>
   3 #include "queueing.h"
   4 #include <converse.h>
   5
   6 static void CpmLSend(int pe, int len, void *msg)
   7 {
   8   if (pe==CpmALL) CmiSyncBroadcastAllAndFree(len, msg);
   9   else if (pe==CpmOTHERS) CmiSyncBroadcastAndFree(len, msg);
  10   else CmiSyncSendAndFree(pe,len,msg);
  11 }
  12
  13 /******************************************************************************
  14  *
  15  * Control for simple-send
  16  *
  17  *****************************************************************************/
  18
  19 typedef struct CpmDestinationSend_s
  20 {
  21   void *(*sendfn)(struct CpmDestinationSend_s *, int, void *);
  22   int envsize;
  23   int pe;
  24 }
  25 *CpmDestinationSend;
  26
  27 typedef struct CpmDestinationSend_s DestinationSend;
  28
  29 void *CpmSend1(CpmDestinationSend ctrl, int len, void *msg)
  30 {
  31   CpmLSend(ctrl->pe, len, msg);
  32   return (void *) 0;
  33 }
  34
  35 CpvStaticDeclare(DestinationSend, ctrlSend);
  36
  37 CpmDestination CpmSend(int pe)
  38 {
  39   CpvAccess(ctrlSend).envsize = 0;
  40   CpvAccess(ctrlSend).sendfn = CpmSend1;
  41   CpvAccess(ctrlSend).pe = pe;
  42   return (CpmDestination)&CpvAccess(ctrlSend);
  43 }
  44
  45 /******************************************************************************
  46  *
  47  * Control for CpmEnqueue
  48  *
  49  *****************************************************************************/
  50
  51 typedef struct CpmDestinationEnq_s
  52 {
  53   void *(*sendfn)(struct CpmDestinationEnq_s *, int, void *);
  54   int envsize;
  55   int pe, qs, priobits;
  56   unsigned int *prioptr;
  57 }
  58 *CpmDestinationEnq;
  59
  60 typedef struct CpmDestinationEnq_s DestinationEnq;
  61
  62 CpvStaticDeclare(DestinationEnq, ctrlEnq);
  63
  64 CpvDeclare(int, CpmEnqueue2_Index);
  65
  66 void CpmEnqueue2(void *msg)
  67 {
  68   int *env;
  69   env = (int *)CpmEnv(msg);
  70   CmiSetHandler(msg, env[0]);
  71   CsdEnqueueGeneral(msg, env[1], env[2], (unsigned int *)(env+3));
  72 }
  73
  74 void *CpmEnqueue1(CpmDestinationEnq ctrl, int len, void *msg)
  75 {
  76   int *env = (int *)CpmEnv(msg);
  77   int intbits = sizeof(int)*8;
  78   int priobits = ctrl->priobits;
  79   int prioints = (priobits+intbits-1) / intbits;
  80   env[0] = CmiGetHandler(msg);
  81   env[1] = ctrl->qs;
  82   env[2] = ctrl->priobits;
  83   memcpy(env+3, ctrl->prioptr, prioints*sizeof(int));
  84   CmiSetHandler(msg, CpvAccess(CpmEnqueue2_Index));
  85   CpmLSend(ctrl->pe, len, msg);
  86   return (void *) 0;
  87 }
  88
  89 CpmDestination CpmEnqueue(int pe, int qs, int priobits,unsigned int *prioptr)
  90 {
  91   int intbits = sizeof(int)*8;
  92   int prioints = (priobits+intbits-1) / intbits;
  93   CpvAccess(ctrlEnq).envsize = (3+prioints)*sizeof(int);
  94   CpvAccess(ctrlEnq).sendfn  = CpmEnqueue1;
  95   CpvAccess(ctrlEnq).pe = pe; CpvAccess(ctrlEnq).qs = qs;
  96   CpvAccess(ctrlEnq).priobits = priobits; CpvAccess(ctrlEnq).prioptr = prioptr;
  97   return (CpmDestination)&CpvAccess(ctrlEnq);
  98 }
  99
 100 CpvStaticDeclare(unsigned int, fiprio);
 101
 102 CpmDestination CpmEnqueueIFIFO(int pe, int prio)
 103 {
 104   CpvAccess(fiprio) = prio;
 105   return CpmEnqueue(pe, CQS_QUEUEING_IFIFO, sizeof(int)*8, &CpvAccess(fiprio));
 106 }
 107
 108 CpvStaticDeclare(unsigned int, liprio);
 109
 110 CpmDestination CpmEnqueueILIFO(int pe, int prio)
 111 {
 112   CpvAccess(liprio) = prio;
 113   return CpmEnqueue(pe, CQS_QUEUEING_ILIFO, sizeof(int)*8, &CpvAccess(liprio));
 114 }
 115
 116 CpmDestination CpmEnqueueBFIFO(int pe, int priobits,unsigned int *prioptr)
 117 {
 118   return CpmEnqueue(pe, CQS_QUEUEING_BFIFO, priobits, prioptr);
 119 }
 120
 121 CpmDestination CpmEnqueueBLIFO(int pe, int priobits,unsigned int *prioptr)
 122 {
 123   return CpmEnqueue(pe, CQS_QUEUEING_BLIFO, priobits, prioptr);
 124 }
 125
 126 CpmDestination CpmEnqueueLFIFO(int pe, int priobits,unsigned int *prioptr)
 127 {
 128   return CpmEnqueue(pe, CQS_QUEUEING_LFIFO, priobits, prioptr);
 129 }
 130
 131 CpmDestination CpmEnqueueLLIFO(int pe, int priobits,unsigned int *prioptr)
 132 {
 133   return CpmEnqueue(pe, CQS_QUEUEING_LLIFO, priobits, prioptr);
 134 }
 135
 136 /******************************************************************************
 137  *
 138  * Control for Enqueue-FIFO
 139  *
 140  *****************************************************************************/
 141
 142 CpvDeclare(int, CpmEnqueueFIFO2_Index);
 143
 144 void CpmEnqueueFIFO2(void *msg)
 145 {
 146   int *env;
 147   env = (int *)CpmEnv(msg);
 148   CmiSetHandler(msg, env[0]);
 149   CsdEnqueueFifo(msg);
 150 }
 151
 152 void *CpmEnqueueFIFO1(CpmDestinationSend ctrl, int len, void *msg)
 153 {
 154   int *env = (int *)CpmEnv(msg);
 155   env[0] = CmiGetHandler(msg);
 156   CmiSetHandler(msg, CpvAccess(CpmEnqueueFIFO2_Index));
 157   CpmLSend(ctrl->pe, len, msg);
 158   return (void *) 0;
 159 }
 160
 161 CpvStaticDeclare(DestinationSend, ctrlFIFO);
 162
 163 CpmDestination CpmEnqueueFIFO(int pe)
 164 {
 165   CpvAccess(ctrlFIFO).envsize = sizeof(int);
 166   CpvAccess(ctrlFIFO).sendfn  = CpmEnqueueFIFO1;
 167   CpvAccess(ctrlFIFO).pe = pe;
 168   return (CpmDestination)&CpvAccess(ctrlFIFO);
 169 }
 170
 171 /******************************************************************************
 172  *
 173  * Control for Enqueue-LIFO
 174  *
 175  *****************************************************************************/
 176
 177 CpvDeclare(int, CpmEnqueueLIFO2_Index);
 178
 179 void CpmEnqueueLIFO2(void *msg)
 180 {
 181   int *env;
 182   env = (int *)CpmEnv(msg);
 183   CmiSetHandler(msg, env[0]);
 184   CsdEnqueueLifo(msg);
 185 }
 186
 187 void *CpmEnqueueLIFO1(CpmDestinationSend ctrl, int len, void *msg)
 188 {
 189   int *env = (int *)CpmEnv(msg);
 190   env[0] = CmiGetHandler(msg);
 191   CmiSetHandler(msg, CpvAccess(CpmEnqueueLIFO2_Index));
 192   CpmLSend(ctrl->pe, len, msg);
 193   return (void *) 0;
 194 }
 195
 196 CpvStaticDeclare(DestinationSend, ctrlLIFO);
 197
 198 CpmDestination CpmEnqueueLIFO(int pe)
 199 {
 200   CpvAccess(ctrlLIFO).envsize = sizeof(int);
 201   CpvAccess(ctrlLIFO).sendfn  = CpmEnqueueLIFO1;
 202   CpvAccess(ctrlLIFO).pe = pe;
 203   return (CpmDestination)&CpvAccess(ctrlLIFO);
 204 }
 205
 206 /******************************************************************************
 207  *
 208  * Control for thread-creation
 209  *
 210  *****************************************************************************/
 211
 212 CpvDeclare(int, CpmThread2_Index);
 213
 214 void CpmThread3(void *msg)
 215 {
 216   int *env = (int *)CpmEnv(msg);
 217   CmiHandlerInfo *h=&CmiHandlerToInfo(env[0]);
 218   (h->hdlr)(msg,h->userPtr);
 219   CthFree(CthSelf()); CthSuspend();
 220 }
 221
 222 void CpmThread2(void *msg)
 223 {
 224   CthThread t;
 225   t = CthCreate(CpmThread3, msg, 0);
 226   CthSetStrategyDefault(t); CthAwaken(t);
 227 }
 228
 229 void *CpmThread1(CpmDestinationSend ctrl, int len, void *msg)
 230 {
 231   int *env = (int *)CpmEnv(msg);
 232   env[0] = CmiGetHandler(msg);
 233   CmiSetHandler(msg, CpvAccess(CpmThread2_Index));
 234   CpmLSend(ctrl->pe, len, msg);
 235   return (void *) 0;
 236 }
 237
 238 CpvStaticDeclare(DestinationSend, ctrlThread);
 239
 240 CpmDestination CpmMakeThread(int pe)
 241 {
 242   CpvAccess(ctrlThread).envsize = sizeof(int);
 243   CpvAccess(ctrlThread).sendfn = CpmThread1;
 244   CpvAccess(ctrlThread).pe = pe;
 245   return (CpmDestination)&CpvAccess(ctrlThread);
 246 }
 247
 248 /******************************************************************************
 249  *
 250  * Control for thread-creation with size parameter
 251  *
 252  *****************************************************************************/
 253
 254 CpvDeclare(int, CpmThreadSize2_Index);
 255
 256 typedef struct CpmDestinationThreadSize_s
 257 {
 258   void *(*sendfn)(struct CpmDestinationThreadSize_s *, int, void *);
 259   int envsize;
 260   int pe;
 261   int size;
 262 }
 263 *CpmDestinationThreadSize;
 264
 265 typedef struct CpmDestinationThreadSize_s DestinationThreadSize;
 266
 267 void CpmThreadSize2(void *msg)
 268 {
 269   int *env = (int *)CpmEnv(msg);
 270   CthThread t;
 271   t = CthCreate(CpmThread3, msg, env[1]);
 272   CthSetStrategyDefault(t); CthAwaken(t);
 273 }
 274
 275 void *CpmThreadSize1(CpmDestinationThreadSize ctrl, int len, void *msg)
 276 {
 277   int *env = (int *)CpmEnv(msg);
 278   env[0] = CmiGetHandler(msg);
 279   env[1] = ctrl->size;
 280   CmiSetHandler(msg, CpvAccess(CpmThreadSize2_Index));
 281   CpmLSend(ctrl->pe, len, msg);
 282   return (void *) 0;
 283 }
 284
 285 CpvStaticDeclare(DestinationThreadSize, ctrlThreadSize);
 286
 287 CpmDestination CpmMakeThreadSize(int pe, int size)
 288 {
 289   CpvAccess(ctrlThreadSize).envsize = 2*sizeof(int);
 290   CpvAccess(ctrlThreadSize).sendfn = CpmThreadSize1;
 291   CpvAccess(ctrlThreadSize).pe = pe;
 292   CpvAccess(ctrlThreadSize).size = size;
 293   return (CpmDestination)&CpvAccess(ctrlThreadSize);
 294 }
 295
 296 /******************************************************************************
 297  *
 298  * Cpm initialization
 299  *
 300  *****************************************************************************/
 301
 302 void CpmModuleInit(void)
 303 {
 304   CpvInitialize(int, CpmThread2_Index);
 305   CpvAccess(CpmThread2_Index) = CmiRegisterHandler(CpmThread2);
 306   CpvInitialize(int, CpmThreadSize2_Index);
 307   CpvAccess(CpmThreadSize2_Index) = CmiRegisterHandler(CpmThreadSize2);
 308   CpvInitialize(int, CpmEnqueueFIFO2_Index);
 309   CpvAccess(CpmEnqueueFIFO2_Index) = CmiRegisterHandler(CpmEnqueueFIFO2);
 310   CpvInitialize(int, CpmEnqueueLIFO2_Index);
 311   CpvAccess(CpmEnqueueLIFO2_Index) = CmiRegisterHandler(CpmEnqueueLIFO2);
 312   CpvInitialize(int, CpmEnqueue2_Index);
 313   CpvAccess(CpmEnqueue2_Index) = CmiRegisterHandler(CpmEnqueue2);
 314   CpvInitialize(DestinationSend, ctrlSend);
 315   CpvInitialize(DestinationEnq, ctrlEnq);
 316   CpvInitialize(DestinationSend, ctrlFIFO);
 317   CpvInitialize(DestinationSend, ctrlLIFO);
 318   CpvInitialize(DestinationSend, ctrlThread);
 319   CpvInitialize(DestinationThreadSize, ctrlThreadSize);
 320   CpvInitialize(unsigned int, fiprio);
 321   CpvInitialize(unsigned int, liprio);
 322 }
 323