src/surf/trace_mgr.c

   1 /* Copyright (c) 2004, 2005, 2007, 2009, 2010. The SimGrid Team.
   2  * All rights reserved.                                                     */
   3
   4 /* This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the license (GNU LGPL) which comes with this package. */
   6
   7 #include "xbt/sysdep.h"
   8 #include "xbt/log.h"
   9 #include "xbt/str.h"
  10 #include "xbt/dict.h"
  11 #include "trace_mgr_private.h"
  12 #include "surf_private.h"
  13 #include "xbt/RngStream.h"
  14
  15 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_trace, surf, "Surf trace management");
  16
  17 static xbt_dict_t trace_list = NULL;
  18
  19 // a unique RngStream structure for everyone
  20 // FIXME : has to be created by someone
  21 static RngStream common_rng_stream = NULL;
  22
  23 XBT_INLINE tmgr_history_t tmgr_history_new(void)
  24 {
  25   tmgr_history_t h;
  26
  27   h = xbt_new0(s_tmgr_history_t, 1);
  28
  29   h->heap = xbt_heap_new(8, xbt_free_f);        /* Why 8 ? Well, why not... */
  30
  31   return h;
  32 }
  33
  34 XBT_INLINE void tmgr_history_free(tmgr_history_t h)
  35 {
  36   xbt_heap_free(h->heap);
  37   free(h);
  38 }
  39
  40 RngStream tmgr_rng_stream_from_id(char* id)
  41 {
  42   unsigned int id_hash;
  43   RngStream rng_stream = NULL;
  44
  45   rng_stream = RngStream_CopyStream(common_rng_stream);
  46   id_hash = xbt_dict_hash(id);
  47   RngStream_AdvanceState(rng_stream, 0, id_hash);
  48
  49   return rng_stream;
  50 }
  51
  52 probabilist_event_generator_t tmgr_event_generator_new_uniform(RngStream rng_stream,
  53                                                                double alpha,
  54                                                                double beta)
  55 {
  56   probabilist_event_generator_t event_generator = NULL;
  57
  58   event_generator = xbt_new0(s_probabilist_event_generator_t, 1);
  59   event_generator->type = e_generator_uniform;
  60   event_generator->s_uniform_parameters.alpha = alpha;
  61   event_generator->s_uniform_parameters.beta = beta;
  62   event_generator->rng_stream = rng_stream;
  63
  64   //FIXME Generate a new event date
  65
  66   return event_generator;
  67 }
  68
  69 probabilist_event_generator_t tmgr_event_generator_new_exponential(RngStream rng_stream,
  70                                                                    double lambda)
  71 {
  72   probabilist_event_generator_t event_generator = NULL;
  73
  74   event_generator = xbt_new0(s_probabilist_event_generator_t, 1);
  75   event_generator->type = e_generator_exponential;
  76   event_generator->s_exponential_parameters.lambda = lambda;
  77   event_generator->rng_stream = rng_stream;
  78
  79   //FIXME Generate a new event date
  80
  81   return event_generator;
  82 }
  83
  84 probabilist_event_generator_t tmgr_event_generator_new_weibull(RngStream rng_stream,
  85                                                                double lambda,
  86                                                                double k)
  87 {
  88   probabilist_event_generator_t event_generator = NULL;
  89
  90   event_generator = xbt_new0(s_probabilist_event_generator_t, 1);
  91   event_generator->type = e_generator_weibull;
  92   event_generator->s_weibull_parameters.lambda = lambda;
  93   event_generator->s_weibull_parameters.k = k;
  94   event_generator->rng_stream = rng_stream;
  95
  96   // FIXME Generate a new event date
  97
  98   return event_generator;
  99 }
 100
 101 tmgr_trace_t tmgr_trace_new_from_string(const char *id, const char *input,
 102                                         double periodicity)
 103 {
 104   tmgr_trace_t trace = NULL;
 105   int linecount = 0;
 106   s_tmgr_event_t event;
 107   tmgr_event_t last_event = NULL;
 108   xbt_dynar_t list;
 109   unsigned int cpt;
 110   char *val;
 111
 112   if (trace_list) {
 113     trace = xbt_dict_get_or_null(trace_list, id);
 114     if (trace) {
 115       XBT_WARN("Ignoring redefinition of trace %s", id);
 116       return trace;
 117     }
 118   }
 119
 120   xbt_assert(periodicity >= 0,
 121               "Invalid periodicity %lg (must be positive)", periodicity);
 122
 123   trace = xbt_new0(s_tmgr_trace_t, 1);
 124   trace->type = e_trace_list;
 125   trace->s_list.event_list = xbt_dynar_new(sizeof(s_tmgr_event_t), NULL);
 126
 127   list = xbt_str_split(input, "\n\r");
 128
 129   xbt_dynar_foreach(list, cpt, val) {
 130     linecount++;
 131     xbt_str_trim(val, " \t\n\r\x0B");
 132     if (val[0] == '#' || val[0] == '\0' || val[0] == '%')
 133       continue;
 134
 135     if (sscanf(val, "PERIODICITY " "%lg" "\n", &periodicity) == 1)
 136       continue;
 137
 138     if (sscanf(val, "%lg" " " "%lg" "\n", &event.delta, &event.value) != 2)
 139       xbt_die("%s:%d: Syntax error in trace\n%s", id, linecount, input);
 140
 141     if (last_event) {
 142       if (last_event->delta > event.delta) {
 143         xbt_die("%s:%d: Invalid trace: Events must be sorted, "
 144                 "but time %lg > time %lg.\n%s",
 145                 id, linecount, last_event->delta, event.delta, input);
 146       }
 147       last_event->delta = event.delta - last_event->delta;
 148     }
 149     xbt_dynar_push(trace->s_list.event_list, &event);
 150     last_event =
 151         xbt_dynar_get_ptr(trace->s_list.event_list,
 152                           xbt_dynar_length(trace->s_list.event_list) - 1);
 153   }
 154   if (last_event)
 155     last_event->delta = periodicity;
 156
 157   if (!trace_list)
 158     trace_list = xbt_dict_new_homogeneous((void (*)(void *)) tmgr_trace_free);
 159
 160   xbt_dict_set(trace_list, id, (void *) trace, NULL);
 161
 162   xbt_dynar_free(&list);
 163   return trace;
 164 }
 165
 166 tmgr_trace_t tmgr_trace_new_from_file(const char *filename)
 167 {
 168   char *tstr = NULL;
 169   FILE *f = NULL;
 170   tmgr_trace_t trace = NULL;
 171
 172   if ((!filename) || (strcmp(filename, "") == 0))
 173     return NULL;
 174
 175   if (trace_list) {
 176     trace = xbt_dict_get_or_null(trace_list, filename);
 177     if (trace) {
 178       XBT_WARN("Ignoring redefinition of trace %s", filename);
 179       return trace;
 180     }
 181   }
 182
 183   f = surf_fopen(filename, "r");
 184   xbt_assert(f != NULL, "Cannot open file '%s' (path=%s)", filename,
 185               xbt_str_join(surf_path, ":"));
 186
 187   tstr = xbt_str_from_file(f);
 188   fclose(f);
 189   trace = tmgr_trace_new_from_string(filename, tstr, 0.);
 190   xbt_free(tstr);
 191
 192   return trace;
 193 }
 194
 195 tmgr_trace_t tmgr_empty_trace_new(void)
 196 {
 197   tmgr_trace_t trace = NULL;
 198   s_tmgr_event_t event;
 199
 200   trace = xbt_new0(s_tmgr_trace_t, 1);
 201   trace->s_list.event_list = xbt_dynar_new(sizeof(s_tmgr_event_t), NULL);
 202
 203   event.delta = 0.0;
 204   event.value = 0.0;
 205   xbt_dynar_push(trace->s_list.event_list, &event);
 206
 207   return trace;
 208 }
 209
 210 XBT_INLINE void tmgr_trace_free(tmgr_trace_t trace)
 211 {
 212   if (!trace)
 213     return;
 214   xbt_dynar_free(&(trace->s_list.event_list));
 215   free(trace);
 216 }
 217
 218 tmgr_trace_event_t tmgr_history_add_trace(tmgr_history_t h,
 219                                           tmgr_trace_t trace,
 220                                           double start_time,
 221                                           unsigned int offset, void *model)
 222 {
 223   tmgr_trace_event_t trace_event = NULL;
 224
 225   trace_event = xbt_new0(s_tmgr_trace_event_t, 1);
 226   trace_event->trace = trace;
 227   trace_event->idx = offset;
 228   trace_event->model = model;
 229
 230   xbt_assert((trace_event->idx < xbt_dynar_length(trace->s_list.event_list)),
 231               "You're referring to an event that does not exist!");
 232
 233   xbt_heap_push(h->heap, trace_event, start_time);
 234
 235   return trace_event;
 236 }
 237
 238 XBT_INLINE double tmgr_history_next_date(tmgr_history_t h)
 239 {
 240   if (xbt_heap_size(h->heap))
 241     return (xbt_heap_maxkey(h->heap));
 242   else
 243     return -1.0;
 244 }
 245
 246 tmgr_trace_event_t tmgr_history_get_next_event_leq(tmgr_history_t h,
 247                                                    double date,
 248                                                    double *value,
 249                                                    void **model)
 250 {
 251   double event_date = tmgr_history_next_date(h);
 252   tmgr_trace_event_t trace_event = NULL;
 253   tmgr_event_t event = NULL;
 254   tmgr_trace_t trace = NULL;
 255
 256   if (event_date > date)
 257     return NULL;
 258
 259   if (!(trace_event = xbt_heap_pop(h->heap)))
 260     return NULL;
 261
 262   trace = trace_event->trace;
 263   event = xbt_dynar_get_ptr(trace->s_list.event_list, trace_event->idx);
 264
 265   *value = event->value;
 266   *model = trace_event->model;
 267
 268   if (trace_event->idx < xbt_dynar_length(trace->s_list.event_list) - 1) {
 269     xbt_heap_push(h->heap, trace_event, event_date + event->delta);
 270     trace_event->idx++;
 271   } else if (event->delta > 0) {        /* Last element, checking for periodicity */
 272     xbt_heap_push(h->heap, trace_event, event_date + event->delta);
 273     trace_event->idx = 0;
 274   } else {                      /* We don't need this trace_event anymore */
 275     trace_event->free_me = 1;
 276   }
 277
 278   return trace_event;
 279 }
 280
 281 XBT_INLINE void tmgr_finalize(void)
 282 {
 283   xbt_dict_free(&trace_list);
 284 }
 285
 286 int tmgr_trace_event_free(tmgr_trace_event_t trace_event)
 287 {
 288   if (trace_event->free_me) {
 289     xbt_free(trace_event);
 290     return 1;
 291   }
 292   return 0;
 293 }