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