X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/d589e05e37970bcf9c4c1fa6e59e0c6040bfa1d7..0b57cd385897350c3d6d3fedbc4d44f61f4a9fa3:/src/surf/trace_mgr.c diff --git a/src/surf/trace_mgr.c b/src/surf/trace_mgr.c index 7a3b76aecb..3d174c40a8 100644 --- a/src/surf/trace_mgr.c +++ b/src/surf/trace_mgr.c @@ -17,10 +17,6 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_trace, surf, "Surf trace management"); static xbt_dict_t trace_list = NULL; -// a unique RngStream structure for everyone -// FIXME : has to be created by someone -static RngStream common_rng_stream = NULL; - XBT_INLINE tmgr_history_t tmgr_history_new(void) { tmgr_history_t h; @@ -38,99 +34,218 @@ XBT_INLINE void tmgr_history_free(tmgr_history_t h) free(h); } -tmgr_trace_t tmgr_trace_new_from_generator(const char *id, - probabilist_event_generator_t generator1, - probabilist_event_generator_t generator2) + +/** + * \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. 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 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. + * \return The new #tmgr_trace_t + */ +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; - unsigned int id_hash; - RngStream rng_stream = NULL; - - rng_stream = RngStream_CopyStream(common_rng_stream); - id_hash = xbt_str_hash(id); - RngStream_AdvanceState(rng_stream, 0, id_hash); - + 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]->rng_stream = rng_stream; - tmgr_event_generator_next_value(trace->s_probabilist.event_generator[0]); - - //FIXME : may also be a parameter - trace->s_probabilist.next_event = 0; - - if(generator2 == NULL) { - trace->s_probabilist.event_generator[1] = generator1; - } else { - trace->s_probabilist.event_generator[1] = generator2; - trace->s_probabilist.event_generator[1]->rng_stream = rng_stream; - tmgr_event_generator_next_value(trace->s_probabilist.event_generator[1]); - } - + + trace->s_probabilist.event_generator[0] = date_generator; + trace->s_probabilist.event_generator[1] = value_generator; + trace->s_probabilist.is_state_trace = 0; + return trace; } -probabilist_event_generator_t tmgr_event_generator_new_uniform(double alpha, - double beta) -{ +/** + * \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 + * + * This generator will generate uniformly distributed random values between min and max + * The id is important : it controls the seed of the generator. So, generators with the + * same id and the same parameters will generate the same values. + * + * \param id The name of the generator + * \param min The minimal generated value + * \param max The maximal generated value + * \return a new #probabilist_event_generator_t + */ +probabilist_event_generator_t tmgr_event_generator_new_uniform(const char* id, + double min, + double max) +{ probabilist_event_generator_t event_generator = NULL; - + RngStream rng_stream = NULL; + + rng_stream = sg_platf_rng_stream_get(id); + event_generator = xbt_new0(s_probabilist_event_generator_t, 1); event_generator->type = e_generator_uniform; - event_generator->s_uniform_parameters.alpha = alpha; - event_generator->s_uniform_parameters.beta = beta; + event_generator->s_uniform_parameters.min = min; + event_generator->s_uniform_parameters.max = max; + event_generator->rng_stream = rng_stream; tmgr_event_generator_next_value(event_generator); - + return event_generator; } -probabilist_event_generator_t tmgr_event_generator_new_exponential(double lambda) -{ + +/** + * \brief Create a new #probabilist_event_generator_t following the exponential distribution + * + * This generator will generate random values following the exponential distribution. + * The mean value is 1/rate . + * The id is important : it controls the seed of the generator. So, generators with the + * same id and the same parameters will generate the same values. + * + * \param id The name of the generator + * \param rate The rate parameter + * \return a new #probabilist_event_generator_t + */ +probabilist_event_generator_t tmgr_event_generator_new_exponential(const char* id, + double rate) +{ probabilist_event_generator_t event_generator = NULL; - + RngStream rng_stream = NULL; + + rng_stream = sg_platf_rng_stream_get(id); + event_generator = xbt_new0(s_probabilist_event_generator_t, 1); event_generator->type = e_generator_exponential; - event_generator->s_exponential_parameters.lambda = lambda; + event_generator->s_exponential_parameters.rate = rate; + event_generator->rng_stream = rng_stream; + + tmgr_event_generator_next_value(event_generator); return event_generator; } -probabilist_event_generator_t tmgr_event_generator_new_weibull(double lambda, - double k) -{ +/** + * \brief Create a new #probabilist_event_generator_t following the weibull distribution + * + * This generator will generate random values following the weibull distribution. + * The id is important : it controls the seed of the generator. So, generators with the + * same id and the same parameters will generate the same values. + * + * \param id The name of the generator + * \param scale The scale parameter + * \param shape The shape parameter + * \return a new #probabilist_event_generator_t + */ +probabilist_event_generator_t tmgr_event_generator_new_weibull(const char* id, + double scale, + double shape) +{ probabilist_event_generator_t event_generator = NULL; - + RngStream rng_stream = NULL; + + rng_stream = sg_platf_rng_stream_get(id); + event_generator = xbt_new0(s_probabilist_event_generator_t, 1); event_generator->type = e_generator_weibull; - event_generator->s_weibull_parameters.lambda = lambda; - event_generator->s_weibull_parameters.k = k; + event_generator->s_weibull_parameters.scale = scale; + event_generator->s_weibull_parameters.shape = shape; + event_generator->rng_stream = rng_stream; tmgr_event_generator_next_value(event_generator); - + return event_generator; } - +/** + * \brief Get the next random value of a #probabilist_event_generator_t + * \param generator The #probabilist_event_generator_t + * \return the next random value + */ double tmgr_event_generator_next_value(probabilist_event_generator_t generator) { - + switch(generator->type) { case e_generator_uniform: generator->next_value = (RngStream_RandU01(generator->rng_stream) - * (generator->s_uniform_parameters.beta - generator->s_uniform_parameters.alpha)) - + generator->s_uniform_parameters.alpha; + * (generator->s_uniform_parameters.max - generator->s_uniform_parameters.min)) + + generator->s_uniform_parameters.min; break; case e_generator_exponential: generator->next_value = -log(RngStream_RandU01(generator->rng_stream)) - / generator->s_exponential_parameters.lambda; + / generator->s_exponential_parameters.rate; break; case e_generator_weibull: - generator->next_value = - generator->s_weibull_parameters.lambda - * pow( log(RngStream_RandU01(generator->rng_stream)), - 1.0 / generator->s_weibull_parameters.k ); + generator->next_value = generator->s_weibull_parameters.scale + * pow( -log(RngStream_RandU01(generator->rng_stream)), + 1.0 / generator->s_weibull_parameters.shape ); } - + return generator->next_value; } @@ -181,6 +296,13 @@ tmgr_trace_t tmgr_trace_new_from_string(const char *id, const char *input, id, linecount, last_event->delta, event.delta, input); } last_event->delta = event.delta - last_event->delta; + } else { + if(event.delta > 0.0){ + s_tmgr_event_t first_event; + first_event.delta=event.delta; + first_event.value=-1.0; + xbt_dynar_push(trace->s_list.event_list, &first_event); + } } xbt_dynar_push(trace->s_list.event_list, &event); last_event = @@ -248,7 +370,7 @@ XBT_INLINE void tmgr_trace_free(tmgr_trace_t trace) { if (!trace) return; - + switch(trace->type) { case e_trace_list: xbt_dynar_free(&(trace->s_list.event_list)); @@ -276,7 +398,7 @@ tmgr_trace_event_t tmgr_history_add_trace(tmgr_history_t h, xbt_assert((trace_event->idx < xbt_dynar_length(trace->s_list.event_list)), "You're referring to an event that does not exist!"); } - + xbt_heap_push(h->heap, trace_event, start_time); return trace_event; @@ -309,10 +431,10 @@ tmgr_trace_event_t tmgr_history_get_next_event_leq(tmgr_history_t h, trace = trace_event->trace; *model = trace_event->model; - + switch(trace->type) { case e_trace_list: - + event = xbt_dynar_get_ptr(trace->s_list.event_list, trace_event->idx); *value = event->value; @@ -322,26 +444,31 @@ tmgr_trace_event_t tmgr_history_get_next_event_leq(tmgr_history_t h, trace_event->idx++; } else if (event->delta > 0) { /* Last element, checking for periodicity */ xbt_heap_push(h->heap, trace_event, event_date + event->delta); - trace_event->idx = 0; + trace_event->idx = 1; /* not 0 as the first event is a placeholder to handle when events really start */ } else { /* We don't need this trace_event anymore */ trace_event->free_me = 1; } break; - + case e_trace_probabilist: - - //FIXME : Simplist and not tested - //Would only work for failure events for now - *value = (double) trace->s_probabilist.next_event; - if(trace->s_probabilist.next_event == 0) { - event_delta = tmgr_event_generator_next_value(trace->s_probabilist.event_generator[0]); - trace->s_probabilist.next_event = 0; + + //FIXME : not tested yet + if(trace->s_probabilist.is_state_trace) { + *value = (double) trace->s_probabilist.next_event; + if(trace->s_probabilist.next_event == 0) { + event_delta = tmgr_event_generator_next_value(trace->s_probabilist.event_generator[0]); + trace->s_probabilist.next_event = 1; + } else { + event_delta = tmgr_event_generator_next_value(trace->s_probabilist.event_generator[1]); + trace->s_probabilist.next_event = 0; + } } else { - event_delta = tmgr_event_generator_next_value(trace->s_probabilist.event_generator[1]); - trace->s_probabilist.next_event = 1; + event_delta = tmgr_event_generator_next_value(trace->s_probabilist.event_generator[0]); + *value = tmgr_event_generator_next_value(trace->s_probabilist.event_generator[1]); } xbt_heap_push(h->heap, trace_event, event_date + event_delta); - + XBT_DEBUG("Generating a new event at date %f, with value %f", event_date + event_delta, *value); + break; }