src/gras/Virtu/sg_emul.c

   1 /* $Id$ */
   2
   3 /* sg_emul - Emulation support (simulation)                                 */
   4
   5 /* Copyright (c) 2003-5 Arnaud Legrand, Martin Quinson. All rights reserved.*/
   6
   7 /* This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the license (GNU LGPL) which comes with this package. */
   9
  10 #include "gras/emul.h"
  11 #include "gras/Virtu/virtu_sg.h"
  12 #include "gras_modinter.h"
  13
  14 #include "xbt/xbt_portability.h" /* timers */
  15 #include "xbt/dict.h"
  16 #include "xbt/ex.h"
  17
  18 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(gras_virtu_emul,gras_virtu,"Emulation support");
  19
  20 /*** Timing macros ***/
  21 static xbt_os_timer_t timer;
  22 static int benchmarking = 0;
  23 static xbt_dict_t benchmark_set = NULL;
  24 static double reference = .00000000523066250047108838; /* FIXME: we should benchmark host machine to set this; unit=s/flop */
  25 static double duration = 0.0;
  26
  27 static char* locbuf = NULL;
  28 static int locbufsize;
  29
  30 void gras_emul_init(void)
  31 {
  32   if(!benchmark_set) {
  33     benchmark_set = xbt_dict_new();
  34     timer = xbt_os_timer_new();
  35   }
  36 }
  37
  38 void gras_emul_exit(void) {
  39   if (locbuf) free(locbuf);
  40   xbt_dict_free(&benchmark_set);
  41   xbt_os_timer_free(timer);
  42 }
  43
  44
  45 static void store_in_dict(xbt_dict_t dict, const char *key, double value)
  46 {
  47   double *ir;
  48
  49   ir = xbt_dict_get_or_null(dict, key);
  50   if (!ir) {
  51     ir = xbt_new0(double,1);
  52     xbt_dict_set(dict, key, ir, free);
  53   }
  54   *ir = value;
  55 }
  56
  57 static double get_from_dict(xbt_dict_t dict, const char *key) {
  58   double *ir = xbt_dict_get(dict, key);
  59
  60   return *ir;
  61 }
  62
  63 int gras_bench_always_begin(const char *location,int line)
  64 {
  65   xbt_assert0(!benchmarking,"Already benchmarking");
  66   benchmarking = 1;
  67
  68   if (!timer)
  69   xbt_os_timer_start(timer);
  70   return 0;
  71 }
  72
  73 int gras_bench_always_end(void)
  74 {
  75   m_task_t task = NULL;
  76
  77   xbt_assert0(benchmarking,"Not benchmarking yet");
  78   benchmarking = 0;
  79   xbt_os_timer_stop(timer);
  80   duration = xbt_os_timer_elapsed(timer);
  81   task = MSG_task_create("task", (duration)/reference, 0 , NULL);
  82   MSG_task_execute(task);
  83   MSG_task_destroy(task);
  84   return 0;
  85 }
  86
  87 int gras_bench_once_begin(const char *location,int line) {
  88   double *ir = NULL;
  89   xbt_assert0(!benchmarking,"Already benchmarking");
  90   benchmarking = 1;
  91
  92   if (!locbuf || locbufsize < strlen(location) + 64) {
  93      locbufsize = strlen(location) + 64;
  94      locbuf = xbt_realloc(locbuf,locbufsize);
  95   }
  96   sprintf(locbuf,"%s:%d",location, line);
  97
  98   ir = xbt_dict_get_or_null(benchmark_set, locbuf);
  99   if(!ir) {
 100     DEBUG1("%s",locbuf);
 101     duration = 1;
 102     xbt_os_timer_start(timer);
 103     return 1;
 104   } else {
 105     duration = -1.0;
 106     return 0;
 107   }
 108 }
 109
 110 int gras_bench_once_end(void)
 111 {
 112   m_task_t task = NULL;
 113
 114   xbt_assert0(benchmarking,"Not benchmarking yet");
 115   benchmarking = 0;
 116   if(duration>0) {
 117     xbt_os_timer_stop(timer);
 118     duration = xbt_os_timer_elapsed(timer);
 119     store_in_dict(benchmark_set, locbuf, duration);
 120   } else {
 121     duration = get_from_dict(benchmark_set,locbuf);
 122   }
 123   DEBUG2("Simulate the run of a task of %f sec for %s",duration,locbuf);
 124   task = MSG_task_create("task", (duration)/reference, 0 , NULL);
 125   MSG_task_execute(task);
 126   MSG_task_destroy(task);
 127   return 0;
 128 }
 129
 130
 131 /*** Conditional execution support ***/
 132
 133 int gras_if_RL(void) {
 134    return 0;
 135 }
 136
 137 int gras_if_SG(void) {
 138    return 1;
 139 }
 140
 141