src/arch/sim/machine.C

   1 #include <stdio.h>
   2 #include <math.h>
   3 #include "machine.h"
   4 #include "converse.h"
   5
   6 #if CMK_TIMER_SIM_USE_TIMES
   7 #include <sys/times.h>
   8 #include <sys/unistd.h>
   9 #endif
  10 #if CMK_TIMER_SIM_USE_GETRUSAGE
  11 #include <sys/time.h>
  12 #include <sys/resource.h>
  13 #endif
  14
  15
  16 CMI_EXTERNC
  17 void CthInit(char **);
  18 CMI_EXTERNC
  19 void ConverseCommonInit(char **);
  20 CMI_EXTERNC
  21 void ConverseCommonExit(void);
  22
  23 static void **McQueue;
  24
  25 int _Cmi_mype;
  26 int _Cmi_numpes;
  27
  28
  29 CsvDeclare(int, CsdStopCount);
  30 CpvDeclare(void*, CmiLocalQueue);
  31 CpvExtern(int, CcdNumChecks);
  32 CpvExtern(int, disable_sys_msgs);
  33
  34 double CmiTimer(void);
  35
  36 static void CsiTimerInit(void);
  37 static double CsiTimer(void);
  38
  39
  40 void CmiDeliversInit(void)
  41 {
  42 }
  43
  44
  45 int CsdScheduler(int maxmsgs)
  46 {
  47   CmiError("Cannot call scheduling functions in SIM versions.\n");
  48   exit(0);
  49 }
  50
  51 int CmiDeliverMsgs(int maxmsgs)
  52 {
  53   CmiError("Cannot call scheduling functions in SIM versions.\n");
  54   exit(1);
  55 }
  56
  57 void CmiDeliverSpecificMsg(int handler)
  58 {
  59   CmiError("Cannot call scheduling functions in SIM versions.\n");
  60   exit(1);
  61 }
  62
  63 CmiUniContextSwitch(int i)
  64 {
  65   _Cmi_mype = i;
  66 }
  67
  68 void CmiNotifyIdle(void)
  69 {
  70 #if CMK_WHEN_PROCESSOR_IDLE_USLEEP
  71   struct timeval tv;
  72   tv.tv_sec=0; tv.tv_usec=5000;
  73   select(0,0,0,0,&tv);
  74 #endif
  75 }
  76
  77 static void CmiNotifyIdleCcd(void *ignored1, double ignored2)
  78 {
  79     CmiNotifyIdle();
  80 }
  81
  82 /***********************************************************************
  83  *
  84  * Abort function:
  85  *
  86  ************************************************************************/
  87
  88 void CmiAbort(const char *message)
  89 {
  90   CmiError(message);
  91   exit(1);
  92   CMI_NORETURN_FUNCTION_END
  93 }
  94
  95 void ConverseExit(int exitcode)
  96 {
  97   exit(exitcode);
  98 }
  99
 100 /********************* MESSAGE SEND FUNCTIONS ******************/
 101
 102 void CmiSyncSendFn(int destPE, int size, char *msg)
 103 {
 104     char *buf;
 105
 106     buf =  (char *) CmiAlloc(size);
 107     memcpy(buf,msg,size);
 108     sim_send_message(_Cmi_mype,buf,size,FALSE,destPE);
 109 }
 110
 111
 112
 113
 114 CmiCommHandle CmiAsyncSendFn(int destPE, int size, char *msg)
 115 {
 116      CmiSyncSendFn(destPE, size, msg);
 117      return 0;
 118 }
 119
 120
 121
 122 void CmiFreeSendFn(int destPE, int size, char *msg)
 123 {
 124      sim_send_message(_Cmi_mype,msg,size,FALSE,destPE);
 125 }
 126
 127
 128
 129 int CmiAsyncMsgSent(CmiCommHandle c)
 130 {
 131     return 1;
 132 }
 133
 134
 135 void CmiReleaseCommHandle(CmiCommHandle c)
 136 {
 137 }
 138
 139
 140 void CmiNodeBarrier(void)
 141 {
 142 }
 143
 144 void CmiNodeAllBarrier(void)
 145 {
 146 }
 147
 148 /********************* MESSAGE RECEIVE FUNCTIONS ******************/
 149
 150 void *CmiGetNonLocal(void){return NULL;}
 151
 152
 153
 154
 155 /*********************** BROADCAST FUNCTIONS **********************/
 156
 157
 158 void CmiFreeBroadcastAllFn(int size,  char *msg)
 159 {
 160     int i;
 161     for(i=0; i<_Cmi_numpes; i++)
 162        if (i!= _Cmi_mype) CmiSyncSendFn(i,size,msg);
 163
 164     CdsFifo_Enqueue(CpvAccess(CmiLocalQueue),msg);
 165 }
 166
 167
 168 void CmiSyncBroadcastFn(int size,  char *msg)   /* ALL_EXCEPT_ME  */
 169 {
 170     int i;
 171     for(i=0; i<_Cmi_numpes; i++)
 172        if (i!= _Cmi_mype) CmiSyncSendFn(i,size,msg);
 173 }
 174
 175
 176 void CmiSyncBroadcastAllFn(int size,  char *msg)
 177 {
 178      int i;
 179
 180      char *buf;
 181
 182      for(i=0; i<_Cmi_numpes; i++)
 183         if (i!= _Cmi_mype) CmiSyncSendFn(i,size,msg);
 184
 185      buf =  (char *) CmiAlloc(size);
 186      memcpy(buf,msg,size);
 187      CdsFifo_Enqueue(CpvAccess(CmiLocalQueue),buf);
 188 }
 189
 190
 191
 192 void CmiFreeBroadcastFn(int size,  char *msg)      /* ALL_EXCEPT_ME  */
 193 {
 194     CmiSyncBroadcastFn(size, msg);
 195     CmiFree(msg);
 196 }
 197
 198
 199
 200
 201
 202 CmiCommHandle CmiAsyncBroadcastFn(int size,  char *msg) /* ALL_EXCEPT_ME  */
 203 {
 204         CmiSyncBroadcastFn(size, msg);
 205         return 0 ;
 206 }
 207
 208
 209
 210
 211 CmiCommHandle CmiAsyncBroadcastAllFn(int size,  char *msg)
 212 {
 213         CmiSyncBroadcastAll(size,msg);
 214         return 0 ;
 215 }
 216
 217
 218 /************************** SETUP ***********************************/
 219
 220 void ConverseInit(int argc, char **argv, CmiStartFn fn, int usc, int initret)
 221 {
 222   void simulate();
 223   int i, requested_npe;
 224
 225   if ((usc)||(initret)) {
 226     fprintf(stderr,"ConverseInit in SIM version is limited:\n");
 227     fprintf(stderr," 1. User-Calls-Scheduler mode is not supported.\n");
 228     fprintf(stderr," 2. ConverseInit-Returns mode is not supported.\n");
 229     exit(1);
 230   }
 231
 232
 233   /* figure out number of processors required */
 234
 235   i = 0; requested_npe = 0;
 236   CmiGetArgInt(argv,"+p",&requested_npe);
 237   if (requested_npe <= 0) {
 238     printf("Error: requested number of processors is invalid %d\n",
 239            requested_npe);
 240     exit(1);
 241   }
 242
 243   _Cmi_numpes = requested_npe;
 244   _Cmi_mype   = 0;
 245
 246   McQueue = (void **) malloc(requested_npe * sizeof(void *));
 247   for(i=0; i<requested_npe; i++) McQueue[i] = CdsFifo_Create();
 248   CrnInit();
 249   sim_initialize("sim.param",requested_npe);
 250
 251   CsiTimerInit();
 252   for(i=0; i<CmiNumPes(); i++) {
 253     CmiUniContextSwitch(i);
 254     CpvInitialize(void*, CmiLocalQueue);
 255     CpvAccess(CmiLocalQueue) = CdsFifo_Create();
 256     CthInit(argv);
 257     ConverseCommonInit(argv);
 258     CcdCallOnConditionKeep(CcdPROCESSOR_STILL_IDLE, CmiNotifyIdleCcd, NULL);
 259     argc=CmiGetArgc(argv);
 260     fn(argc, CmiCopyArgs(argv));
 261     CpvAccess(CsdStopFlag) = 0;
 262   }
 263
 264   CsvAccess(CsdStopCount) = CmiNumPes();
 265   CmiUniContextSwitch(0);
 266
 267   while (CsvAccess(CsdStopCount)) simulate();
 268
 269   exit(0);
 270 }
 271
 272 /* ********************************************************************* */
 273 /*                      SIMULATOR                                        */
 274 /* ********************************************************************* */
 275
 276
 277
 278 #if CMK_TIMER_SIM_USE_TIMES
 279
 280 static struct tms inittime;
 281
 282 static void CsiTimerInit(void)
 283 {
 284   times(&inittime);
 285 }
 286
 287 static double CsiTimer(void)
 288 {
 289   double currenttime;
 290   int clk_tck;
 291     struct tms temp;
 292
 293     times(&temp);
 294     clk_tck=sysconf(_SC_CLK_TCK);
 295     currenttime =
 296      (((temp.tms_utime - inittime.tms_utime)+
 297        (temp.tms_stime - inittime.tms_stime))*1.0)/clk_tck;
 298     return (currenttime);
 299 }
 300
 301 #endif
 302
 303 #if CMK_TIMER_SIM_USE_GETRUSAGE
 304
 305 static struct rusage inittime;
 306
 307 static void CsiTimerInit(void)
 308 {
 309   getrusage(0, &inittime);
 310 }
 311
 312
 313 static double CsiTimer(void) {
 314   double currenttime;
 315
 316   struct rusage temp;
 317   getrusage(0, &temp);
 318   currenttime =
 319     (temp.ru_utime.tv_usec - inittime.ru_utime.tv_usec) * 0.000001+
 320       (temp.ru_utime.tv_sec - inittime.ru_utime.tv_sec) +
 321         (temp.ru_stime.tv_usec - inittime.ru_stime.tv_usec) * 0.000001+
 322           (temp.ru_stime.tv_sec - inittime.ru_stime.tv_sec) ;
 323
 324   return (currenttime);
 325 }
 326
 327 #endif
 328
 329
 330
 331 static double Csi_global_time;
 332 static double Csi_start_time;
 333
 334 void CmiTimerInit(char **argv) { }
 335
 336 double CmiTimer(void)
 337 {
 338   return (CsiTimer() - Csi_start_time  + Csi_global_time);
 339 }
 340
 341 double CmiWallTimer(void)
 342 {
 343   return (CsiTimer() - Csi_start_time  + Csi_global_time);
 344 }
 345
 346 double CmiCpuTimer(void)
 347 {
 348   return (CsiTimer() - Csi_start_time  + Csi_global_time);
 349 }
 350
 351 CmiNodeLock CmiCreateLock(void)
 352 {
 353   CmiNodeLock lk = (CmiNodeLock)malloc(sizeof(int));
 354   *lk = 0;
 355   return lk;
 356 }
 357
 358 void CmiLock(CmiNodeLock lk)
 359 {
 360   while (*lk) CmiGetNonLocal();
 361   *lk = 1;
 362 }
 363
 364 void CmiUnlock(CmiNodeLock lk)
 365 {
 366   if (*lk==0) {
 367     CmiError("CmiNodeLock not locked, can't unlock.");
 368     exit(1);
 369   }
 370   *lk = 0;
 371 }
 372
 373 int CmiTryLock(CmiNodeLock lk)
 374 {
 375   if (*lk==0) { *lk=1; return 0; }
 376   return -1;
 377 }
 378
 379 void CmiDestroyLock(CmiNodeLock lk)
 380 {
 381   free(lk);
 382 }
 383
 384 #include "ext_func.h"
 385 #include "sim.C"
 386 #include "heap.C"
 387 #include "net.C"
 388 #include "simqmng.C"
 389 #include "simrand.C"