Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Fix failed merge
[simgrid.git] / src / surf / surf_action.c
1 /* Copyright (c) 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 "surf_private.h"
8 #include "network_private.h"
9 #include "xbt/mallocator.h"
10
11 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(surf_kernel);
12
13 /*
14  * Generic action
15  */
16
17 const char *surf_action_state_names[6] = {
18   "SURF_ACTION_READY",
19   "SURF_ACTION_RUNNING",
20   "SURF_ACTION_FAILED",
21   "SURF_ACTION_DONE",
22   "SURF_ACTION_TO_FREE",
23   "SURF_ACTION_NOT_IN_THE_SYSTEM"
24 };
25
26 /* Surf actions mallocator */
27 static xbt_mallocator_t action_mallocator = NULL;
28 static int action_mallocator_allocated_size = 0;
29 static void* surf_action_mallocator_new_f(void);
30 #define surf_action_mallocator_free_f xbt_free_f
31 static void surf_action_mallocator_reset_f(void* action);
32
33 /**
34  * \brief Initializes the action module of Surf.
35  */
36 void surf_action_init(void) {
37
38   /* the action mallocator will always provide actions of the following size,
39    * so this size should be set to the maximum size of the surf action structures
40    */
41   action_mallocator_allocated_size = sizeof(s_surf_action_network_CM02_t);
42   action_mallocator = xbt_mallocator_new(65536, surf_action_mallocator_new_f,
43       surf_action_mallocator_free_f, surf_action_mallocator_reset_f);
44 }
45
46 /**
47  * \brief Uninitializes the action module of Surf.
48  */
49 void surf_action_exit(void) {
50
51   xbt_mallocator_free(action_mallocator);
52 }
53
54 static void* surf_action_mallocator_new_f(void) {
55   return xbt_malloc(action_mallocator_allocated_size);
56 }
57
58 static void surf_action_mallocator_reset_f(void* action) {
59   memset(action, 0, action_mallocator_allocated_size);
60 }
61
62 void *surf_action_new(size_t size, double cost, surf_model_t model,
63                       int failed)
64 {
65   xbt_assert(size <= action_mallocator_allocated_size,
66       "Cannot create a surf action of size %zu: the mallocator only provides actions of size %d",
67       size, action_mallocator_allocated_size);
68
69   surf_action_t action = xbt_mallocator_get(action_mallocator);
70   action->refcount = 1;
71   action->cost = cost;
72   action->remains = cost;
73   action->priority = 1.0;
74   action->max_duration = NO_MAX_DURATION;
75   action->start = surf_get_clock();
76   action->finish = -1.0;
77   action->model_type = model;
78 #ifdef HAVE_TRACING
79   action->category = NULL;
80 #endif
81
82   if (failed)
83     action->state_set = model->states.failed_action_set;
84   else
85     action->state_set = model->states.running_action_set;
86
87   xbt_swag_insert(action, action->state_set);
88
89   return action;
90 }
91
92 e_surf_action_state_t surf_action_state_get(surf_action_t action)
93 {
94   surf_action_state_t action_state = &(action->model_type->states);
95
96   if (action->state_set == action_state->ready_action_set)
97     return SURF_ACTION_READY;
98   if (action->state_set == action_state->running_action_set)
99     return SURF_ACTION_RUNNING;
100   if (action->state_set == action_state->failed_action_set)
101     return SURF_ACTION_FAILED;
102   if (action->state_set == action_state->done_action_set)
103     return SURF_ACTION_DONE;
104   return SURF_ACTION_NOT_IN_THE_SYSTEM;
105 }
106
107 double surf_action_get_start_time(surf_action_t action)
108 {
109   return action->start;
110 }
111
112 double surf_action_get_finish_time(surf_action_t action)
113 {
114   /* keep the function behavior, some models (cpu_ti) change the finish time before the action end */
115   return action->remains == 0 ? action->finish : -1;
116 }
117
118 XBT_INLINE void surf_action_free(surf_action_t * action)
119 {
120   xbt_mallocator_release(action_mallocator, *action);
121   *action = NULL;
122 }
123
124 void surf_action_state_set(surf_action_t action,
125                            e_surf_action_state_t state)
126 {
127   surf_action_state_t action_state = &(action->model_type->states);
128   XBT_IN("(%p,%s)", action, surf_action_state_names[state]);
129   xbt_swag_remove(action, action->state_set);
130
131   if (state == SURF_ACTION_READY)
132     action->state_set = action_state->ready_action_set;
133   else if (state == SURF_ACTION_RUNNING)
134     action->state_set = action_state->running_action_set;
135   else if (state == SURF_ACTION_FAILED)
136     action->state_set = action_state->failed_action_set;
137   else if (state == SURF_ACTION_DONE)
138     action->state_set = action_state->done_action_set;
139   else
140     action->state_set = NULL;
141
142   if (action->state_set)
143     xbt_swag_insert(action, action->state_set);
144   XBT_OUT();
145 }
146
147 void surf_action_data_set(surf_action_t action, void *data)
148 {
149   action->data = data;
150 }
151
152 XBT_INLINE void surf_action_ref(surf_action_t action)
153 {
154   action->refcount++;
155 }
156
157 /*
158  * Maxmin action
159  */
160
161 /* added to manage the communication action's heap */
162 void surf_action_lmm_update_index_heap(void *action, int i) {
163   surf_action_lmm_t a = action;
164   a->index_heap = i;
165 }
166 /* insert action on heap using a given key and a hat (heap_action_type)
167  * a hat can be of three types for communications:
168  *
169  * NORMAL = this is a normal heap entry stating the date to finish transmitting
170  * LATENCY = this is a heap entry to warn us when the latency is payed
171  * MAX_DURATION =this is a heap entry to warn us when the max_duration limit is reached
172  */
173 void surf_action_lmm_heap_insert(xbt_heap_t heap, surf_action_lmm_t action, double key,
174     enum heap_action_type hat)
175 {
176   action->hat = hat;
177   xbt_heap_push(heap, action, key);
178 }
179
180 void surf_action_lmm_heap_remove(xbt_heap_t heap, surf_action_lmm_t action)
181 {
182   action->hat = NOTSET;
183   if (action->index_heap >= 0) {
184     xbt_heap_remove(heap, action->index_heap);
185   }
186 }
187
188 void surf_action_cancel(surf_action_t action)
189 {
190   surf_model_t model = action->model_type;
191   surf_action_state_set(action, SURF_ACTION_FAILED);
192   if (model->model_private->update_mechanism == UM_LAZY) {
193     xbt_swag_remove(action, model->model_private->modified_set);
194     surf_action_lmm_heap_remove(model->model_private->action_heap,(surf_action_lmm_t)action);
195   }
196   return;
197 }
198
199 int surf_action_unref(surf_action_t action)
200 {
201   surf_model_t model = action->model_type;
202   action->refcount--;
203   if (!action->refcount) {
204     xbt_swag_remove(action, action->state_set);
205     if (((surf_action_lmm_t) action)->variable)
206       lmm_variable_free(model->model_private->maxmin_system,
207                         ((surf_action_lmm_t) action)->variable);
208     if (model->model_private->update_mechanism == UM_LAZY) {
209       /* remove from heap */
210       surf_action_lmm_heap_remove(model->model_private->action_heap,(surf_action_lmm_t)action);
211       xbt_swag_remove(action, model->model_private->modified_set);
212     }
213 #ifdef HAVE_TRACING
214     xbt_free(action->category);
215 #endif
216     surf_action_free(&action);
217     return 1;
218   }
219   return 0;
220 }
221
222 void surf_action_suspend(surf_action_t action)
223 {
224   surf_model_t model = action->model_type;
225   XBT_IN("(%p)", action);
226   if (((surf_action_lmm_t) action)->suspended != 2) {
227     lmm_update_variable_weight(model->model_private->maxmin_system,
228                                ((surf_action_lmm_t) action)->variable,
229                                0.0);
230     ((surf_action_lmm_t) action)->suspended = 1;
231     if (model->model_private->update_mechanism == UM_LAZY)
232       surf_action_lmm_heap_remove(model->model_private->action_heap,(surf_action_lmm_t)action);
233   }
234   XBT_OUT();
235 }
236
237 void surf_action_resume(surf_action_t action)
238 {
239   surf_model_t model = action->model_type;
240   XBT_IN("(%p)", action);
241   if (((surf_action_lmm_t) action)->suspended != 2) {
242     lmm_update_variable_weight(model->model_private->maxmin_system,
243                                ((surf_action_lmm_t) action)->variable,
244                                action->priority);
245     ((surf_action_lmm_t) action)->suspended = 0;
246     if (model->model_private->update_mechanism == UM_LAZY)
247       surf_action_lmm_heap_remove(model->model_private->action_heap,(surf_action_lmm_t)action);
248   }
249   XBT_OUT();
250 }
251
252 int surf_action_is_suspended(surf_action_t action)
253 {
254   return (((surf_action_lmm_t) action)->suspended == 1);
255 }
256
257 void surf_action_set_max_duration(surf_action_t action, double duration)
258 {
259   surf_model_t model = action->model_type;
260   XBT_IN("(%p,%g)", action, duration);
261   action->max_duration = duration;
262   if (model->model_private->update_mechanism == UM_LAZY)      // remove action from the heap
263     surf_action_lmm_heap_remove(model->model_private->action_heap,(surf_action_lmm_t)action);
264   XBT_OUT();
265 }
266
267 void surf_action_set_priority(surf_action_t action, double priority)
268 {
269   surf_model_t model = action->model_type;
270   XBT_IN("(%p,%g)", action, priority);
271   action->priority = priority;
272   lmm_update_variable_weight(model->model_private->maxmin_system,
273                              ((surf_action_lmm_t) action)->variable,
274                              priority);
275
276   if (model->model_private->update_mechanism == UM_LAZY)
277     surf_action_lmm_heap_remove(model->model_private->action_heap,(surf_action_lmm_t)action);
278   XBT_OUT();
279 }
280
281 #ifdef HAVE_TRACING
282 void surf_action_set_category(surf_action_t action,
283                                     const char *category)
284 {
285   XBT_IN("(%p,%s)", action, category);
286   action->category = xbt_strdup(category);
287   XBT_OUT();
288 }
289 #endif
290
291 void generic_update_action_remaining_lazy( surf_action_lmm_t action, double now)
292 {
293   double delta = 0.0;
294   surf_model_t model = action->generic_action.model_type;
295
296   if(model == surf_network_model)
297   {
298     if (action->suspended != 0)
299       return;
300   }
301   else
302   {
303     xbt_assert(action->generic_action.state_set == model->states.running_action_set,
304         "You're updating an action that is not running.");
305
306       /* bogus priority, skip it */
307     xbt_assert(action->generic_action.priority > 0,
308         "You're updating an action that seems suspended.");
309   }
310
311   delta = now - action->last_update;
312
313   if (action->generic_action.remains > 0) {
314     XBT_DEBUG("Updating action(%p): remains was %lf, last_update was: %lf", action, action->generic_action.remains, action->last_update);
315     double_update(&(action->generic_action.remains),
316         action->last_value * delta);
317
318 #ifdef HAVE_TRACING
319     if (model == surf_cpu_model && TRACE_is_enabled()) {
320       surf_resource_t cpu =
321           lmm_constraint_id(lmm_get_cnst_from_var
322               (model->model_private->maxmin_system,
323                   action->variable, 0));
324       TRACE_surf_host_set_utilization(cpu->name,
325           action->generic_action.category,
326           action->last_value,
327           action->last_update,
328           now - action->last_update);
329     }
330 #endif
331     XBT_DEBUG("Updating action(%p): remains is now %lf", action,
332         action->generic_action.remains);
333   }
334
335   if(model == surf_network_model)
336   {
337     if (((surf_action_t)action)->max_duration != NO_MAX_DURATION)
338       double_update(&(((surf_action_t)action)->max_duration), delta);
339
340     if ((((surf_action_t)action)->remains <= 0) &&
341         (lmm_get_variable_weight(action->variable) > 0)) {
342       ((surf_action_t)action)->finish = surf_get_clock();
343       model->action_state_set((surf_action_t) action,
344           SURF_ACTION_DONE);
345
346       surf_action_lmm_heap_remove(model->model_private->action_heap,(surf_action_lmm_t)action);
347     } else if (((((surf_action_t)action)->max_duration != NO_MAX_DURATION)
348         && (((surf_action_t)action)->max_duration <= 0))) {
349       ((surf_action_t)action)->finish = surf_get_clock();
350       model->action_state_set((surf_action_t) action,
351           SURF_ACTION_DONE);
352       surf_action_lmm_heap_remove(model->model_private->action_heap,(surf_action_lmm_t)action);
353     }
354   }
355
356   action->last_update = now;
357   action->last_value = lmm_variable_getvalue(action->variable);
358 }
359
360 double surf_action_get_remains(surf_action_t action)
361 {
362   XBT_IN("(%p)", action);
363   surf_model_t model = action->model_type;
364   /* update remains before return it */
365   if (model->model_private->update_mechanism == UM_LAZY)      /* update remains before return it */
366     generic_update_action_remaining_lazy((surf_action_lmm_t)action, surf_get_clock());
367   XBT_OUT();
368   return action->remains;
369 }
370
371 void generic_update_actions_state_lazy(double now, double delta, surf_model_t model)
372 {
373   surf_action_lmm_t action;
374   while ((xbt_heap_size(model->model_private->action_heap) > 0)
375          && (double_equals(xbt_heap_maxkey(model->model_private->action_heap), now))) {
376     action = xbt_heap_pop(model->model_private->action_heap);
377     XBT_DEBUG("Something happened to action %p", action);
378 #ifdef HAVE_TRACING
379     if (TRACE_is_enabled()) {
380       if(model == surf_cpu_model){
381       surf_resource_t cpu =
382           lmm_constraint_id(lmm_get_cnst_from_var
383                             (model->model_private->maxmin_system,
384                              action->variable, 0));
385       TRACE_surf_host_set_utilization(cpu->name,
386                                       ((surf_action_t)action)->category,
387                                       lmm_variable_getvalue(action->variable),
388                                       action->last_update,
389                                       now - action->last_update);
390       }
391       else{
392         int n = lmm_get_number_of_cnst_from_var(model->model_private->maxmin_system, action->variable);
393         unsigned int i;
394         for (i = 0; i < n; i++){
395           lmm_constraint_t constraint = lmm_get_cnst_from_var(model->model_private->maxmin_system,
396                                                               action->variable,
397                                                               i);
398           link_CM02_t link = lmm_constraint_id(constraint);
399           TRACE_surf_link_set_utilization(link->lmm_resource.generic_resource.name,
400                                           ((surf_action_t)action)->category,
401                                           (lmm_variable_getvalue(action->variable)*
402                                               lmm_get_cnst_weight_from_var(model->model_private->maxmin_system,
403                                                   action->variable,
404                                                   i)),
405                                           action->last_update,
406                                           now - action->last_update);
407         }
408       }
409     }
410 #endif
411
412     if(model == surf_cpu_model){
413       action->generic_action.finish = surf_get_clock();
414       XBT_DEBUG("Action %p finished", action);
415
416       /* set the remains to 0 due to precision problems when updating the remaining amount */
417       action->generic_action.remains = 0;
418       surf_action_state_set((surf_action_t) action, SURF_ACTION_DONE);
419       surf_action_lmm_heap_remove(model->model_private->action_heap,action); //FIXME: strange call since action was already popped
420     }
421     else{
422       // if I am wearing a latency hat
423       if (action->hat == LATENCY) {
424         XBT_DEBUG("Latency paid for action %p. Activating", action);
425         lmm_update_variable_weight(model->model_private->maxmin_system, action->variable,
426             ((surf_action_network_CM02_t)(action))->weight);
427         surf_action_lmm_heap_remove(model->model_private->action_heap,action);
428         action->last_update = surf_get_clock();
429
430         // if I am wearing a max_duration or normal hat
431       } else if (action->hat == MAX_DURATION ||
432           action->hat == NORMAL) {
433         // no need to communicate anymore
434         // assume that flows that reached max_duration have remaining of 0
435         action->generic_action.finish = surf_get_clock();
436         XBT_DEBUG("Action %p finished", action);
437         action->generic_action.remains = 0;
438         ((surf_action_t)action)->finish = surf_get_clock();
439         model->action_state_set((surf_action_t) action,
440                                              SURF_ACTION_DONE);
441         surf_action_lmm_heap_remove(model->model_private->action_heap,action);
442
443         if (model->gap_remove && model == surf_network_model)
444           model->gap_remove(action);
445       }
446     }
447   }
448 #ifdef HAVE_TRACING
449   if (TRACE_is_enabled() && model == surf_cpu_model) {
450     //defining the last timestamp that we can safely dump to trace file
451     //without losing the event ascending order (considering all CPU's)
452     double smaller = -1;
453     xbt_swag_t running_actions = model->states.running_action_set;
454     xbt_swag_foreach(action, running_actions) {
455         if (smaller < 0) {
456           smaller = action->last_update;
457           continue;
458         }
459         if (action->last_update < smaller) {
460           smaller = action->last_update;
461         }
462     }
463     if (smaller > 0) {
464       TRACE_last_timestamp_to_dump = smaller;
465     }
466   }
467 #endif
468   return;
469 }
470
471 void generic_update_actions_state_full(double now, double delta, surf_model_t model)
472 {
473   surf_action_lmm_t action = NULL;
474   surf_action_lmm_t next_action = NULL;
475   xbt_swag_t running_actions = model->states.running_action_set;
476
477   xbt_swag_foreach_safe(action, next_action, running_actions) {
478
479     if(model == surf_network_model)
480     {
481       double deltap = 0.0;
482       deltap = delta;
483       if (((surf_action_network_CM02_t)action)->latency > 0) {
484         if (((surf_action_network_CM02_t)action)->latency > deltap) {
485           double_update(&(((surf_action_network_CM02_t)action)->latency), deltap);
486           deltap = 0.0;
487         } else {
488           double_update(&(deltap), ((surf_action_network_CM02_t)action)->latency);
489           ((surf_action_network_CM02_t)action)->latency = 0.0;
490         }
491         if ((((surf_action_network_CM02_t)action)->latency == 0.0) && !(action->suspended))
492           lmm_update_variable_weight(model->model_private->maxmin_system, action->variable,
493               ((surf_action_network_CM02_t)action)->weight);
494       }
495   #ifdef HAVE_TRACING
496       if (TRACE_is_enabled()) {
497         int n = lmm_get_number_of_cnst_from_var(model->model_private->maxmin_system, action->variable);
498         unsigned int i;
499         for (i = 0; i < n; i++){
500           lmm_constraint_t constraint = lmm_get_cnst_from_var(model->model_private->maxmin_system,
501                                                               action->variable,
502                                                               i);
503           link_CM02_t link = lmm_constraint_id(constraint);
504           TRACE_surf_link_set_utilization(link->lmm_resource.generic_resource.name,
505                                           ((surf_action_t)action)->category,
506                                           (lmm_variable_getvalue(action->variable)*
507                                           lmm_get_cnst_weight_from_var(model->model_private->maxmin_system,
508                                               action->variable,
509                                               i)),
510                                           now - delta,
511                                           delta);
512         }
513       }
514   #endif
515       if (!lmm_get_number_of_cnst_from_var
516           (model->model_private->maxmin_system, action->variable)) {
517         /* There is actually no link used, hence an infinite bandwidth.
518          * This happens often when using models like vivaldi.
519          * In such case, just make sure that the action completes immediately.
520          */
521         double_update(&(action->generic_action.remains),
522                       action->generic_action.remains);
523       }
524     }
525     else
526     {
527 #ifdef HAVE_TRACING
528       if (TRACE_is_enabled()) {
529         surf_resource_t x =
530             lmm_constraint_id(lmm_get_cnst_from_var
531                               (model->model_private->maxmin_system,
532                                action->variable, 0));
533
534         TRACE_surf_host_set_utilization(x->name,
535                                         ((surf_action_t)action)->category,
536                                         lmm_variable_getvalue(action->variable),
537                                         now - delta,
538                                         delta);
539         TRACE_last_timestamp_to_dump = now - delta;
540       }
541 #endif
542     }
543
544     double_update(&(action->generic_action.remains),
545                   lmm_variable_getvalue(action->variable) * delta);
546
547
548     if (action->generic_action.max_duration != NO_MAX_DURATION)
549       double_update(&(action->generic_action.max_duration), delta);
550
551
552     if ((action->generic_action.remains <= 0) &&
553         (lmm_get_variable_weight(action->variable) > 0)) {
554       action->generic_action.finish = surf_get_clock();
555       surf_action_state_set((surf_action_t) action, SURF_ACTION_DONE);
556
557       if (model->gap_remove && model == surf_network_model)
558         model->gap_remove(action);
559     } else if ((action->generic_action.max_duration != NO_MAX_DURATION) &&
560                (action->generic_action.max_duration <= 0)) {
561       action->generic_action.finish = surf_get_clock();
562       surf_action_state_set((surf_action_t) action, SURF_ACTION_DONE);
563
564       if (model->gap_remove && model == surf_network_model)
565         model->gap_remove(action);
566     }
567   }
568
569   return;
570 }