Event trace generation: Change interface of constructors

The previous interface was not intuitive, even for me. I hope this one is better.
Replace 1 function by 3, and add the choice of the first value for state trace.

diff --git a/include/simgrid/platf.h b/include/simgrid/platf.h
index 652332f..31851b4 100644 (file)
--- a/include/simgrid/platf.h
+++ b/include/simgrid/platf.h
@@ -15,31 +15,6 @@ typedef struct s_routing_edge *sg_routing_edge_t;
 
 XBT_PUBLIC(sg_routing_edge_t) sg_routing_edge_by_name_or_null(const char *name);
 
-
-
-typedef struct tmgr_trace *tmgr_trace_t; /**< Opaque structure defining an availability trace */
-
-/** opaque structure defining a event generator for availability based on a probability distribution */
-typedef struct probabilist_event_generator *probabilist_event_generator_t;
-
-XBT_PUBLIC(tmgr_trace_t) tmgr_trace_new_from_file(const char *filename);
-XBT_PUBLIC(tmgr_trace_t) tmgr_trace_new_from_string(const char *id,
-                                                    const char *input,
-                                                    double periodicity);
-XBT_PUBLIC(tmgr_trace_t) tmgr_trace_new_from_generator(const char *id,
-                                                  probabilist_event_generator_t generator1,
-                                                  probabilist_event_generator_t generator2,
-                                                  int is_state_trace);
-
-XBT_PUBLIC(probabilist_event_generator_t) tmgr_event_generator_new_uniform(const char* id,
-                                                                           double min,
-                                                                           double max);
-XBT_PUBLIC(probabilist_event_generator_t) tmgr_event_generator_new_exponential(const char* id,
-                                                                           double rate);
-XBT_PUBLIC(probabilist_event_generator_t) tmgr_event_generator_new_weibull(const char* id,
-                                                                           double scale,
-                                                                           double shape);
-
 /** Defines whether a given resource is working or not */
 typedef enum {
   SURF_RESOURCE_ON = 1,                   /**< Up & ready        */
@@ -65,6 +40,37 @@ typedef enum {
   SURF_PROCESS_ON_FAILURE_RESTART = 0
 } e_surf_process_on_failure_t;
 
+
+typedef struct tmgr_trace *tmgr_trace_t; /**< Opaque structure defining an availability trace */
+
+/** opaque structure defining a event generator for availability based on a probability distribution */
+typedef struct probabilist_event_generator *probabilist_event_generator_t;
+
+XBT_PUBLIC(tmgr_trace_t) tmgr_trace_new_from_file(const char *filename);
+XBT_PUBLIC(tmgr_trace_t) tmgr_trace_new_from_string(const char *id,
+                                                    const char *input,
+                                                    double periodicity);
+
+XBT_PUBLIC(tmgr_trace_t) tmgr_trace_generator_value(const char *id,
+                                              probabilist_event_generator_t date_generator,
+                                              probabilist_event_generator_t value_generator);
+XBT_PUBLIC(tmgr_trace_t) tmgr_trace_generator_state(const char *id,
+                                              probabilist_event_generator_t date_generator,
+                                              e_surf_resource_state_t first_event_value);
+XBT_PUBLIC(tmgr_trace_t) tmgr_trace_generator_avail_unavail(const char *id,
+                                              probabilist_event_generator_t avail_duration_generator,
+                                              probabilist_event_generator_t unavail_duration_generator,
+                                              e_surf_resource_state_t first_event_value);
+
+XBT_PUBLIC(probabilist_event_generator_t) tmgr_event_generator_new_uniform(const char* id,
+                                                                           double min,
+                                                                           double max);
+XBT_PUBLIC(probabilist_event_generator_t) tmgr_event_generator_new_exponential(const char* id,
+                                                                           double rate);
+XBT_PUBLIC(probabilist_event_generator_t) tmgr_event_generator_new_weibull(const char* id,
+                                                                           double scale,
+                                                                           double shape);
+
 /*
  * Platform creation functions. Instead of passing 123 arguments to the creation functions
  * (one for each possible XML attribute), we pass structures containing them all. It removes the

diff --git a/src/surf/trace_mgr.c b/src/surf/trace_mgr.c
index 79ec300..e2a61fe 100644 (file)
--- a/src/surf/trace_mgr.c
+++ b/src/surf/trace_mgr.c
@@ -39,47 +39,94 @@ XBT_INLINE void tmgr_history_free(tmgr_history_t h)
  * \brief Create a #tmgr_trace_t from probabilist generators
  *
  * This trace will generate an infinite set of events.
- * It needs two #probabilist_event_generator_t. For regular events, the first one is
- * used as a date generator, the second as a value generator. For a state trace, the
- * event values are 0 or 1. The first generator rules the time between state changes.
- * If the second generator is set, it is used to set the duration of unavailability,
- * while the first one set the duration of availability.
+ * It needs two #probabilist_event_generator_t. The date when the event are
+ * triggered is directed by date_generator, and will be interpreted as seconds.
+ * The value of the event is set by value_generator. The value should be between
+ * 0 and 1.
  *
  * \param id The name of the trace
- * \param generator1 The #probabilist_event_generator_t which generates the time
- *        between two events, or which rules the duration of availability for state trace
+ * \param date_generator The #probabilist_event_generator_t which generates the time
+ *        between two events
  * \param generator2 The #probabilist_event_generator_t which generates the value
- *        of each events, or the duration of unavailability for state trace.
- * \param is_state_trace Is the trace will be used as a state trace
+ *        of each events.
  * \return The new #tmgr_trace_t
  */
-tmgr_trace_t tmgr_trace_new_from_generator(const char *id,
-                                          probabilist_event_generator_t generator1,
-                                          probabilist_event_generator_t generator2,
-                                          int is_state_trace)
+tmgr_trace_t tmgr_trace_generator_value(const char *id,
+                                  probabilist_event_generator_t date_generator,
+                                  probabilist_event_generator_t value_generator)
 {
   tmgr_trace_t trace = NULL;
 
   trace = xbt_new0(s_tmgr_trace_t, 1);
   trace->type = e_trace_probabilist;
 
-  trace->s_probabilist.event_generator[0] = generator1;
+  trace->s_probabilist.event_generator[0] = date_generator;
+  trace->s_probabilist.event_generator[1] = value_generator;
+  trace->s_probabilist.is_state_trace = 0;
 
-  //FIXME : may also be a parameter
-  trace->s_probabilist.next_event = 0;
-  trace->s_probabilist.is_state_trace = is_state_trace;
+  return trace;
+}
 
-  if(generator2 != NULL) {
-    trace->s_probabilist.event_generator[1] = generator2;
-  } else if(is_state_trace) {
-    trace->s_probabilist.event_generator[1] = generator1;
-  } else {
-    THROW_IMPOSSIBLE; //That case should have been checked before, anyway...
-  }
+/**
+ * \brief Create a #tmgr_trace_t from probabilist generators
+ *
+ * This trace will generate an infinite set of events. Value of the events
+ * will be alternatively 0 and 1, so this should be used as a state trace.
+ *
+ * \param id The name of the trace
+ * \param date_generator The #probabilist_event_generator_t which generates the time
+ *        between two events
+ * \param first_event_value Set the first event value
+ * \return The new #tmgr_trace_t
+ */
+tmgr_trace_t tmgr_trace_generator_state(const char *id,
+                                  probabilist_event_generator_t date_generator,
+                                  e_surf_resource_state_t first_event_value)
+{
+  tmgr_trace_t trace = NULL;
+
+  trace = xbt_new0(s_tmgr_trace_t, 1);
+  trace->type = e_trace_probabilist;
+
+  trace->s_probabilist.event_generator[0] = date_generator;
+  trace->s_probabilist.event_generator[1] = date_generator;
+  trace->s_probabilist.is_state_trace = 1;
+  trace->s_probabilist.next_event = (first_event_value==SURF_RESOURCE_ON ? 1 : 0);
 
   return trace;
 }
 
+/**
+ * \brief Create a #tmgr_trace_t from probabilist generators
+ *
+ * This trace will generate an infinite set of events. Value of the events
+ * will be alternatively 0 and 1, so this should be used as a state trace.
+ *
+ * \param id The name of the trace
+ * \param avail_duration_generator The #probabilist_event_generator_t which
+ *        set the duration of the available state, (ie 1 value)
+ * \param unavail_duration_generator The #probabilist_event_generator_t which
+ *        set the duration of the unavailable state, (ie 0 value)
+ * \param first_event_value Set the first event value
+ * \return The new #tmgr_trace_t
+ */
+tmgr_trace_t tmgr_trace_generator_avail_unavail(const char *id,
+                                probabilist_event_generator_t avail_duration_generator,
+                                probabilist_event_generator_t unavail_duration_generator,
+                                e_surf_resource_state_t first_event_value)
+{
+  tmgr_trace_t trace = NULL;
+
+  trace = xbt_new0(s_tmgr_trace_t, 1);
+  trace->type = e_trace_probabilist;
+
+  trace->s_probabilist.event_generator[0] = unavail_duration_generator;
+  trace->s_probabilist.event_generator[1] = avail_duration_generator;
+  trace->s_probabilist.is_state_trace = 1;
+  trace->s_probabilist.next_event = (first_event_value==SURF_RESOURCE_ON ? 1 : 0);
+
+  return trace;
+}
 
 /**
  * \brief Create a new #probabilist_event_generator_t following the uniform distribution