src/conv-ldb/cldb.bluegene.c

   1 /****
   2   converse ldb for Blue Gene, this is the first version, full of hack and
   3   need more work.
   4 ***/
   5
   6 #include "converse.h"
   7 #include "blue.h"
   8 #include "cldb.h"
   9 #include "queueing.h"
  10 #include <stdlib.h>
  11
  12 #define  DEBUGF(x)   /*CmiPrintf x;*/
  13
  14 #if CMK_BIGSIM_CHARM
  15
  16 extern int CldPresentPE(int pe);
  17
  18 void LoadNotifyFn(int l)
  19 {
  20 }
  21
  22 char *CldGetStrategy(void)
  23 {
  24   return "rand";
  25 }
  26
  27 void CldBalanceHandler(void *msg)
  28 {
  29   CldRestoreHandler((char *)msg);
  30   CldPutToken((char *)msg);
  31 }
  32
  33 void CldHandler(char *msg)
  34 {
  35   int len, queueing, priobits;
  36   unsigned int *prioptr;
  37   CldInfoFn ifn; CldPackFn pfn;
  38
  39   CldRestoreHandler(msg);
  40   ifn = (CldInfoFn)CmiHandlerToFunction(CmiGetInfo(msg));
  41   ifn(msg, &pfn, &len, &queueing, &priobits, &prioptr);
  42   CsdEnqueueGeneral(msg, queueing, priobits, prioptr);
  43 }
  44
  45 #if CMK_BIGSIM_NODE
  46 static int BgMyPe() { return BgMyNode(); }
  47 static int BgNumPes() { int x,y,z; BgGetSize(&x, &y, &z); return (x*y*z); }
  48 #   define BGSENDPE(pe, msg, len)  {    \
  49       int x,y,z;        \
  50       BgGetXYZ(pe, &x, &y, &z); \
  51       DEBUGF(("send to: (%d %d %d, %d) handle:%d\n", x,y,z,t, CmiGetHandler(msg)));  \
  52       BgSendPacket(x,y,z, ANYTHREAD, CmiGetHandler(msg), LARGE_WORK, \
  53                    len, (char *)msg);   \
  54       }
  55 #   define BGBDCASTALL(len, msg)        \
  56       BgBroadcastAllPacket(CmiGetHandler(msg), LARGE_WORK, len, msg);
  57 #   define BGBDCAST(len, msg)   \
  58       BgBroadcastPacketExcept(BgMyNode(), ANYTHREAD, CmiGetHandler(msg), \
  59                               LARGE_WORK, len, msg);
  60
  61 #elif CMK_BIGSIM_THREAD
  62 static int BgMyPe() { return BgGetGlobalWorkerThreadID(); }
  63 static int BgNumPes() { return BgNumNodes()*BgGetNumWorkThread(); }
  64 #   define BGSENDPE(pe, msg, len)  {    \
  65       int x,y,z,t;      \
  66       t = (pe)%BgGetNumWorkThread();    \
  67       pe = (pe)/BgGetNumWorkThread();   \
  68       BgGetXYZ(pe, &x, &y, &z); \
  69       DEBUGF(("send to: (%d %d %d, %d) handle:%d\n", x,y,z,t, CmiGetHandler(msg)));  \
  70       BgSendPacket(x,y,z, t, CmiGetHandler(msg), LARGE_WORK, len, (char *)msg); \
  71       }
  72 #   define BGBDCASTALL(len, msg)        \
  73       BgThreadBroadcastAllPacket(CmiGetHandler(msg), LARGE_WORK, len, msg);
  74 #   define BGBDCAST(len, msg)   \
  75       BgThreadBroadcastPacketExcept(BgMyNode(), BgGetThreadID(), \
  76                                     CmiGetHandler(msg), LARGE_WORK, len, msg);
  77 #   define BGSENDNODE(node, msg, len)  {        \
  78       int x,y,z;        \
  79       BgGetXYZ(node, &x, &y, &z);       \
  80       DEBUGF(("send to: (%d %d %d) handle:%d\n", x,y,z, CmiGetHandler(msg)));  \
  81       BgSendPacket(x,y,z, ANYTHREAD, CmiGetHandler(msg), LARGE_WORK, len, (char *)msg); \
  82       }
  83 #   define BGNODEBDCASTALL(len, msg)    \
  84       BgBroadcastAllPacket(CmiGetHandler(msg), LARGE_WORK, len, msg);
  85 #   define BGNODEBDCAST(len, msg)       \
  86       BgBroadcastPacketExcept(BgMyNode(), ANYTHREAD,\
  87                                     CmiGetHandler(msg), LARGE_WORK, len, msg);
  88 #endif
  89
  90 void CldEnqueueGroup(CmiGroup grp, void *msg, int infofn)
  91 {
  92   CmiAbort("CldEnqueueGroup not supported!");
  93 }
  94
  95 void CldEnqueueMulti(int npes, int *pes, void *msg, int infofn)
  96 {
  97   int len, queueing, priobits,i; unsigned int *prioptr;
  98   CldInfoFn ifn = (CldInfoFn)CmiHandlerToFunction(infofn);
  99   CldPackFn pfn;
 100   ifn(msg, &pfn, &len, &queueing, &priobits, &prioptr);
 101   if (pfn) {
 102     pfn(&msg);
 103     ifn(msg, &pfn, &len, &queueing, &priobits, &prioptr);
 104   }
 105 /*
 106   CldSwitchHandler((char *)msg, CpvAccess(CldHandlerIndex));
 107   CmiSetInfo(msg,infofn);
 108 */
 109   BgSyncListSend(npes, pes, CmiGetHandler(msg), LARGE_WORK, len, msg);
 110 }
 111
 112 void CldEnqueue(int pe, void *msg, int infofn)
 113 {
 114   int len, queueing, priobits; unsigned int *prioptr;
 115   CldInfoFn ifn = (CldInfoFn)CmiHandlerToFunction(infofn);
 116   CldPackFn pfn;
 117
 118   DEBUGF(("[%d>] CldEnqueue pe: %d infofn:%d\n", BgMyNode(), pe, infofn));
 119   if (pe == CLD_ANYWHERE) {
 120     pe = (((CrnRand()+BgMyPe())&0x7FFFFFFF)%BgNumPes());
 121 /*
 122     while (!CldPresentPE(pe))
 123       pe = (((CrnRand()+BgMyPe())&0x7FFFFFFF)%BgNumPes());
 124 */
 125     if (pe != BgMyPe())
 126       CpvAccess(CldRelocatedMessages)++;
 127     if (pe == BgMyPe()) {
 128       ifn(msg, &pfn, &len, &queueing, &priobits, &prioptr);
 129       CmiSetInfo(msg,infofn);
 130       DEBUGF(("CldEnqueue CLD_ANYWHERE (pe == BgMyPe)\n"));
 131 /*
 132       CldPutToken((char *)msg);
 133 */
 134       BGSENDPE(pe, msg, len);
 135     }
 136     else {
 137       ifn(msg, &pfn, &len, &queueing, &priobits, &prioptr);
 138       if (pfn) {
 139         pfn(&msg);
 140         ifn(msg, &pfn, &len, &queueing, &priobits, &prioptr);
 141       }
 142       DEBUGF(("CldEnqueue at 2 pe=%d\n", pe));
 143 /*
 144       CldSwitchHandler((char *)msg, CpvAccess(CldBalanceHandlerIndex));
 145       CmiSetInfo(msg,infofn);
 146       CmiSyncSendAndFree(pe, len, (char *)msg);
 147 */
 148       BGSENDPE(pe, msg, len);
 149     }
 150   }
 151   else if ((pe == BgMyPe()) || (BgNumPes() == 1)) {
 152     DEBUGF(("CldEnqueue pe == CmiMyPe()\n"));
 153     ifn(msg, &pfn, &len, &queueing, &priobits, &prioptr);
 154     CmiSetInfo(msg,infofn);
 155 /*
 156     CsdEnqueueGeneral(msg, CQS_QUEUEING_LIFO, priobits, prioptr);
 157 */
 158     pe = BgMyPe();
 159     BGSENDPE(pe, msg, len);
 160   }
 161   else {
 162     ifn(msg, &pfn, &len, &queueing, &priobits, &prioptr);
 163     if (pfn) {
 164       pfn(&msg);
 165       ifn(msg, &pfn, &len, &queueing, &priobits, &prioptr);
 166     }
 167 /*
 168     CldSwitchHandler((char *)msg, CpvAccess(CldHandlerIndex));
 169 */
 170     CmiSetInfo(msg,infofn);
 171     DEBUGF(("CldEnqueue pe=%d\n", pe));
 172     if (pe==CLD_BROADCAST) {
 173 CmiPrintf("CldEnqueue pe=%d\n", pe); CmiAbort("");
 174 /*
 175       CmiSyncBroadcastAndFree(len, (char *)msg);
 176 */
 177       BGBDCAST(len, (char *)msg);
 178     }
 179     else if (pe==CLD_BROADCAST_ALL) {
 180 /*
 181       CmiSyncBroadcastAllAndFree(len, (char *)msg);
 182 */
 183       BGBDCASTALL(len, (char *)msg);
 184     }
 185     else {
 186 /*
 187       CmiSyncSendAndFree(pe, len, (char *)msg);
 188 */
 189       BGSENDPE(pe, msg, len);
 190     }
 191   }
 192 }
 193
 194 void CldNodeEnqueue(int node, void *msg, int infofn)
 195 {
 196   int len, queueing, priobits; unsigned int *prioptr;
 197   CldInfoFn ifn = (CldInfoFn)CmiHandlerToFunction(infofn);
 198   CldPackFn pfn;
 199   if (node == CLD_ANYWHERE) {
 200     /* node = (((rand()+CmiMyNode())&0x7FFFFFFF)%CmiNumNodes()); */
 201     node = (((CrnRand()+BgMyNode())&0x7FFFFFFF)%BgNumNodes());
 202     if (node != BgMyNode())
 203       CpvAccess(CldRelocatedMessages)++;
 204   }
 205   if (node == BgMyNode()) {
 206     ifn(msg, &pfn, &len, &queueing, &priobits, &prioptr);
 207 /*
 208     CsdNodeEnqueueGeneral(msg, queueing, priobits, prioptr);
 209 */
 210     BGSENDNODE(node, msg, len);
 211   }
 212   else {
 213     ifn(msg, &pfn, &len, &queueing, &priobits, &prioptr);
 214     if (pfn) {
 215       pfn(&msg);
 216       ifn(msg, &pfn, &len, &queueing, &priobits, &prioptr);
 217     }
 218 /*
 219     CldSwitchHandler((char *)msg, CpvAccess(CldHandlerIndex));
 220 */
 221     CmiSetInfo(msg,infofn);
 222     if (node==CLD_BROADCAST) {
 223 /*      CmiSyncNodeBroadcastAndFree(len, (char *)msg);  */
 224       BGNODEBDCAST(len, (char *)msg);
 225     }
 226     else if (node==CLD_BROADCAST_ALL){
 227 /*      CmiSyncNodeBroadcastAllAndFree(len,(char *)msg); */
 228       BGNODEBDCASTALL(len, (char *)msg);
 229     }
 230     else {
 231 /*      CmiSyncNodeSendAndFree(node, len, (char *)msg);  */
 232       BGSENDNODE(node, msg, len);
 233     }
 234   }
 235 }
 236
 237 void CldModuleInit(char **argv)
 238 {
 239   CpvInitialize(int, CldHandlerIndex);
 240   CpvInitialize(int, CldBalanceHandlerIndex);
 241   CpvAccess(CldHandlerIndex) = CmiRegisterHandler((CmiHandler)CldHandler);
 242   CpvAccess(CldBalanceHandlerIndex) = CmiRegisterHandler(CldBalanceHandler);
 243   CpvInitialize(int, CldRelocatedMessages);
 244   CpvInitialize(int, CldLoadBalanceMessages);
 245   CpvInitialize(int, CldMessageChunks);
 246   CpvAccess(CldRelocatedMessages) = CpvAccess(CldLoadBalanceMessages) =
 247     CpvAccess(CldMessageChunks) = 0;
 248   CldModuleGeneralInit(argv);
 249 }
 250
 251 void CldCallback(){}
 252
 253 #endif