Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
e36b315e8e0c5cd999ed42b23c6f44b6fb36f927
[simgrid.git] / src / surf / cpu.c
1 /* Copyright (c) 2004, 2005, 2006, 2007, 2008, 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
9 typedef s_surf_action_lmm_t s_surf_action_cpu_Cas01_t,
10   *surf_action_cpu_Cas01_t;
11
12 typedef struct cpu_Cas01 {
13   s_surf_resource_t generic_resource;
14   double power_peak;
15   double power_scale;
16   tmgr_trace_event_t power_event;
17   e_surf_resource_state_t state_current;
18   tmgr_trace_event_t state_event;
19   lmm_constraint_t constraint;
20 } s_cpu_Cas01_t, *cpu_Cas01_t;
21
22 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_cpu, surf,
23                                 "Logging specific to the SURF CPU module");
24
25
26
27 surf_model_t surf_cpu_model = NULL;
28 lmm_system_t cpu_maxmin_system = NULL;
29
30
31 static xbt_swag_t cpu_running_action_set_that_does_not_need_being_checked = NULL;
32
33 static cpu_Cas01_t cpu_new(char *name, double power_peak,
34                            double power_scale,
35                            tmgr_trace_t power_trace,
36                            e_surf_resource_state_t state_initial,
37                            tmgr_trace_t state_trace,
38                            xbt_dict_t cpu_properties)
39 {
40   cpu_Cas01_t cpu = xbt_new0(s_cpu_Cas01_t, 1);
41   xbt_assert1(!surf_model_resource_by_name(surf_cpu_model, name),
42               "Host '%s' declared several times in the platform file", name);
43   cpu->generic_resource.model = surf_cpu_model;
44   cpu->generic_resource.name = name;
45   cpu->generic_resource.properties = cpu_properties;
46   cpu->power_peak = power_peak;
47   xbt_assert0(cpu->power_peak > 0, "Power has to be >0");
48   cpu->power_scale = power_scale;
49   if (power_trace)
50     cpu->power_event =
51       tmgr_history_add_trace(history, power_trace, 0.0, 0, cpu);
52
53   cpu->state_current = state_initial;
54   if (state_trace)
55     cpu->state_event =
56       tmgr_history_add_trace(history, state_trace, 0.0, 0, cpu);
57
58   cpu->constraint =
59     lmm_constraint_new(cpu_maxmin_system, cpu,
60                        cpu->power_scale * cpu->power_peak);
61
62   xbt_dict_set(surf_model_resource_set(surf_cpu_model), name, cpu,
63                surf_resource_free);
64 #ifdef HAVE_TRACING
65   TRACE_surf_host_declaration (name, cpu->power_scale * cpu->power_peak);
66 #endif
67
68   return cpu;
69 }
70
71
72 static void parse_cpu_init(void)
73 {
74   double power_peak = 0.0;
75   double power_scale = 0.0;
76   tmgr_trace_t power_trace = NULL;
77   e_surf_resource_state_t state_initial = SURF_RESOURCE_OFF;
78   tmgr_trace_t state_trace = NULL;
79
80   power_peak = get_cpu_power(A_surfxml_host_power);
81   surf_parse_get_double(&power_scale, A_surfxml_host_availability);
82   power_trace = tmgr_trace_new(A_surfxml_host_availability_file);
83
84   xbt_assert0((A_surfxml_host_state == A_surfxml_host_state_ON) ||
85               (A_surfxml_host_state == A_surfxml_host_state_OFF),
86               "Invalid state");
87   if (A_surfxml_host_state == A_surfxml_host_state_ON)
88     state_initial = SURF_RESOURCE_ON;
89   if (A_surfxml_host_state == A_surfxml_host_state_OFF)
90     state_initial = SURF_RESOURCE_OFF;
91   state_trace = tmgr_trace_new(A_surfxml_host_state_file);
92
93   current_property_set = xbt_dict_new();
94   cpu_new(xbt_strdup(A_surfxml_host_id), power_peak, power_scale,
95           power_trace, state_initial, state_trace, current_property_set);
96
97 }
98
99 static void add_traces_cpu(void)
100 {
101   xbt_dict_cursor_t cursor = NULL;
102   char *trace_name, *elm;
103
104   static int called = 0;
105
106   if (called)
107     return;
108   called = 1;
109
110
111   /* connect all traces relative to hosts */
112   xbt_dict_foreach(trace_connect_list_host_avail, cursor, trace_name, elm) {
113     tmgr_trace_t trace = xbt_dict_get_or_null(traces_set_list, trace_name);
114     cpu_Cas01_t host = surf_model_resource_by_name(surf_cpu_model, elm);
115
116     xbt_assert1(host, "Host %s undefined", elm);
117     xbt_assert1(trace, "Trace %s undefined", trace_name);
118
119     host->state_event = tmgr_history_add_trace(history, trace, 0.0, 0, host);
120   }
121
122   xbt_dict_foreach(trace_connect_list_power, cursor, trace_name, elm) {
123     tmgr_trace_t trace = xbt_dict_get_or_null(traces_set_list, trace_name);
124     cpu_Cas01_t host = surf_model_resource_by_name(surf_cpu_model, elm);
125
126     xbt_assert1(host, "Host %s undefined", elm);
127     xbt_assert1(trace, "Trace %s undefined", trace_name);
128
129     host->power_event = tmgr_history_add_trace(history, trace, 0.0, 0, host);
130   }
131 }
132
133 static void cpu_define_callbacks(const char *file)
134 {
135   surf_parse_reset_parser();
136   surfxml_add_callback(STag_surfxml_host_cb_list, parse_cpu_init);
137   surfxml_add_callback(ETag_surfxml_platform_cb_list, &add_traces_cpu);
138 }
139
140 static int cpu_resource_used(void *resource_id)
141 {
142   return lmm_constraint_used(cpu_maxmin_system,
143                              ((cpu_Cas01_t) resource_id)->constraint);
144 }
145
146 static int cpu_action_unref(surf_action_t action)
147 {
148   action->refcount--;
149   if (!action->refcount) {
150     xbt_swag_remove(action, action->state_set);
151     if (((surf_action_cpu_Cas01_t) action)->variable)
152       lmm_variable_free(cpu_maxmin_system,
153                         ((surf_action_cpu_Cas01_t) action)->variable);
154 #ifdef HAVE_TRACING
155     if (action->category) xbt_free (action->category);
156 #endif
157     free(action);
158     return 1;
159   }
160   return 0;
161 }
162
163 static void cpu_action_cancel(surf_action_t action)
164 {
165   surf_action_state_set(action, SURF_ACTION_FAILED);
166   return;
167 }
168
169 static void cpu_action_state_set(surf_action_t action,
170                                  e_surf_action_state_t state)
171 {
172 /*   if((state==SURF_ACTION_DONE) || (state==SURF_ACTION_FAILED)) */
173 /*     if(((surf_action_cpu_Cas01_t)action)->variable) { */
174 /*       lmm_variable_disable(cpu_maxmin_system, ((surf_action_cpu_Cas01_t)action)->variable); */
175 /*       ((surf_action_cpu_Cas01_t)action)->variable = NULL; */
176 /*     } */
177
178   surf_action_state_set(action, state);
179   return;
180 }
181
182 static double cpu_share_resources(double now)
183 {
184   s_surf_action_cpu_Cas01_t action;
185   return generic_maxmin_share_resources(surf_cpu_model->
186                                         states.running_action_set,
187                                         xbt_swag_offset(action, variable),
188                                         cpu_maxmin_system, lmm_solve);
189 }
190
191 static void cpu_update_actions_state(double now, double delta)
192 {
193   surf_action_cpu_Cas01_t action = NULL;
194   surf_action_cpu_Cas01_t next_action = NULL;
195   xbt_swag_t running_actions = surf_cpu_model->states.running_action_set;
196
197   xbt_swag_foreach_safe(action, next_action, running_actions) {
198 #ifdef HAVE_TRACING
199     cpu_Cas01_t x = lmm_constraint_id(lmm_get_cnst_from_var (cpu_maxmin_system, action->variable, 0));
200
201     TRACE_surf_host_set_utilization (x->generic_resource.name,
202               action->generic_action.data, lmm_variable_getvalue(action->variable), now-delta, delta);
203 #endif
204     double_update(&(action->generic_action.remains),
205                   lmm_variable_getvalue(action->variable) * delta);
206     if (action->generic_action.max_duration != NO_MAX_DURATION)
207       double_update(&(action->generic_action.max_duration), delta);
208     if ((action->generic_action.remains <= 0) &&
209         (lmm_get_variable_weight(action->variable) > 0)) {
210       action->generic_action.finish = surf_get_clock();
211       cpu_action_state_set((surf_action_t) action, SURF_ACTION_DONE);
212     } else if ((action->generic_action.max_duration != NO_MAX_DURATION) &&
213                (action->generic_action.max_duration <= 0)) {
214       action->generic_action.finish = surf_get_clock();
215       cpu_action_state_set((surf_action_t) action, SURF_ACTION_DONE);
216     }
217   }
218
219   return;
220 }
221
222 static void cpu_update_resource_state(void *id,
223                                   tmgr_trace_event_t event_type,
224                                   double value, double date)
225 {
226   cpu_Cas01_t cpu = id;
227
228   if (event_type == cpu->power_event) {
229     cpu->power_scale = value;
230     lmm_update_constraint_bound(cpu_maxmin_system, cpu->constraint,
231                                 cpu->power_scale * cpu->power_peak);
232 #ifdef HAVE_TRACING
233     TRACE_surf_host_set_power (date, cpu->generic_resource.name, cpu->power_scale * cpu->power_peak);
234 #endif
235     if (tmgr_trace_event_free(event_type))
236       cpu->power_event = NULL;
237   } else if (event_type == cpu->state_event) {
238     if (value > 0)
239       cpu->state_current = SURF_RESOURCE_ON;
240     else {
241       lmm_constraint_t cnst = cpu->constraint;
242       lmm_variable_t var = NULL;
243       lmm_element_t elem = NULL;
244
245       cpu->state_current = SURF_RESOURCE_OFF;
246
247       while ((var = lmm_get_var_from_cnst(cpu_maxmin_system, cnst, &elem))) {
248         surf_action_t action = lmm_variable_id(var);
249
250         if (surf_action_state_get(action) == SURF_ACTION_RUNNING ||
251             surf_action_state_get(action) == SURF_ACTION_READY ||
252             surf_action_state_get(action) == SURF_ACTION_NOT_IN_THE_SYSTEM) {
253           action->finish = date;
254           cpu_action_state_set(action, SURF_ACTION_FAILED);
255         }
256       }
257     }
258     if (tmgr_trace_event_free(event_type))
259       cpu->state_event = NULL;
260   } else {
261     CRITICAL0("Unknown event ! \n");
262     xbt_abort();
263   }
264
265   return;
266 }
267
268 static surf_action_t cpu_execute(void *cpu, double size)
269 {
270   surf_action_cpu_Cas01_t action = NULL;
271   cpu_Cas01_t CPU = cpu;
272
273   XBT_IN2("(%s,%g)", surf_resource_name(CPU), size);
274   action =
275     surf_action_new(sizeof(s_surf_action_cpu_Cas01_t), size, surf_cpu_model,
276                     CPU->state_current != SURF_RESOURCE_ON);
277
278   action->suspended = 0;        /* Should be useless because of the
279                                    calloc but it seems to help valgrind... */
280
281   action->variable = lmm_variable_new(cpu_maxmin_system, action,
282                                       action->generic_action.priority,
283                                       -1.0, 1);
284   lmm_expand(cpu_maxmin_system, CPU->constraint, action->variable, 1.0);
285   XBT_OUT;
286   return (surf_action_t) action;
287 }
288
289 static surf_action_t cpu_action_sleep(void *cpu, double duration)
290 {
291   surf_action_cpu_Cas01_t action = NULL;
292
293   if (duration > 0)
294     duration = MAX(duration, MAXMIN_PRECISION);
295
296   XBT_IN2("(%s,%g)", surf_resource_name(cpu), duration);
297   action = (surf_action_cpu_Cas01_t) cpu_execute(cpu, 1.0);
298   action->generic_action.max_duration = duration;
299   action->suspended = 2;
300   if (duration == NO_MAX_DURATION) {
301     /* Move to the *end* of the corresponding action set. This convention
302        is used to speed up update_resource_state  */
303     xbt_swag_remove(action, ((surf_action_t) action)->state_set);
304     ((surf_action_t) action)->state_set =
305       cpu_running_action_set_that_does_not_need_being_checked;
306     xbt_swag_insert(action, ((surf_action_t) action)->state_set);
307   }
308
309   lmm_update_variable_weight(cpu_maxmin_system, action->variable, 0.0);
310   XBT_OUT;
311   return (surf_action_t) action;
312 }
313
314 static void cpu_action_suspend(surf_action_t action)
315 {
316   XBT_IN1("(%p)", action);
317   if (((surf_action_cpu_Cas01_t) action)->suspended != 2) {
318     lmm_update_variable_weight(cpu_maxmin_system,
319                                ((surf_action_cpu_Cas01_t) action)->variable,
320                                0.0);
321     ((surf_action_cpu_Cas01_t) action)->suspended = 1;
322   }
323   XBT_OUT;
324 }
325
326 static void cpu_action_resume(surf_action_t action)
327 {
328   XBT_IN1("(%p)", action);
329   if (((surf_action_cpu_Cas01_t) action)->suspended != 2) {
330     lmm_update_variable_weight(cpu_maxmin_system,
331                                ((surf_action_cpu_Cas01_t) action)->variable,
332                                action->priority);
333     ((surf_action_cpu_Cas01_t) action)->suspended = 0;
334   }
335   XBT_OUT;
336 }
337
338 static int cpu_action_is_suspended(surf_action_t action)
339 {
340   return (((surf_action_cpu_Cas01_t) action)->suspended == 1);
341 }
342
343 static void cpu_action_set_max_duration(surf_action_t action, double duration)
344 {
345   XBT_IN2("(%p,%g)", action, duration);
346   action->max_duration = duration;
347   XBT_OUT;
348 }
349
350 static void cpu_action_set_priority(surf_action_t action, double priority)
351 {
352   XBT_IN2("(%p,%g)", action, priority);
353   action->priority = priority;
354   lmm_update_variable_weight(cpu_maxmin_system,
355                              ((surf_action_cpu_Cas01_t) action)->variable,
356                              priority);
357
358   XBT_OUT;
359 }
360
361 static double cpu_action_get_remains(surf_action_t action)
362 {
363   XBT_IN1("(%p)", action);
364   return action->remains;
365   XBT_OUT;
366 }
367
368 static e_surf_resource_state_t cpu_get_state(void *cpu)
369 {
370   return ((cpu_Cas01_t) cpu)->state_current;
371 }
372
373 static double cpu_get_speed(void *cpu, double load)
374 {
375   return load * (((cpu_Cas01_t) cpu)->power_peak);
376 }
377
378 static double cpu_get_available_speed(void *cpu)
379 {
380   /* number between 0 and 1 */
381   return ((cpu_Cas01_t) cpu)->power_scale;
382 }
383
384 static void cpu_create_resource(char *name, double power_peak,
385         double power_scale,
386         tmgr_trace_t power_trace,
387         e_surf_resource_state_t state_initial,
388         tmgr_trace_t state_trace,
389         xbt_dict_t cpu_properties)
390 {
391         cpu_new(name,power_peak,power_scale,power_trace,
392                                           state_initial,state_trace,cpu_properties);
393 }
394
395 static void cpu_finalize(void)
396 {
397   lmm_system_free(cpu_maxmin_system);
398   cpu_maxmin_system = NULL;
399
400   surf_model_exit(surf_cpu_model);
401   surf_cpu_model = NULL;
402
403   xbt_swag_free(cpu_running_action_set_that_does_not_need_being_checked);
404   cpu_running_action_set_that_does_not_need_being_checked = NULL;
405 }
406
407 static void surf_cpu_model_init_internal(void)
408 {
409   s_surf_action_t action;
410
411   surf_cpu_model = surf_model_init();
412
413   cpu_running_action_set_that_does_not_need_being_checked =
414     xbt_swag_new(xbt_swag_offset(action, state_hookup));
415
416   surf_cpu_model->name = "CPU";
417
418   surf_cpu_model->action_unref = cpu_action_unref;
419   surf_cpu_model->action_cancel = cpu_action_cancel;
420   surf_cpu_model->action_state_set = cpu_action_state_set;
421
422   surf_cpu_model->model_private->resource_used = cpu_resource_used;
423   surf_cpu_model->model_private->share_resources = cpu_share_resources;
424   surf_cpu_model->model_private->update_actions_state = cpu_update_actions_state;
425   surf_cpu_model->model_private->update_resource_state =
426     cpu_update_resource_state;
427   surf_cpu_model->model_private->finalize = cpu_finalize;
428
429   surf_cpu_model->suspend = cpu_action_suspend;
430   surf_cpu_model->resume = cpu_action_resume;
431   surf_cpu_model->is_suspended = cpu_action_is_suspended;
432   surf_cpu_model->set_max_duration = cpu_action_set_max_duration;
433   surf_cpu_model->set_priority = cpu_action_set_priority;
434   surf_cpu_model->get_remains = cpu_action_get_remains;
435
436   surf_cpu_model->extension.cpu.execute = cpu_execute;
437   surf_cpu_model->extension.cpu.sleep = cpu_action_sleep;
438
439   surf_cpu_model->extension.cpu.get_state = cpu_get_state;
440   surf_cpu_model->extension.cpu.get_speed = cpu_get_speed;
441   surf_cpu_model->extension.cpu.get_available_speed = cpu_get_available_speed;
442   surf_cpu_model->extension.cpu.create_resource = cpu_create_resource;
443   surf_cpu_model->extension.cpu.add_traces = add_traces_cpu;
444
445   if (!cpu_maxmin_system)
446     cpu_maxmin_system = lmm_system_new();
447 }
448
449 /*********************************************************************/
450 /* Basic sharing model for CPU: that is where all this started... ;) */
451 /*********************************************************************/
452 /* @InProceedings{casanova01simgrid, */
453 /*   author =       "H. Casanova", */
454 /*   booktitle =    "Proceedings of the IEEE Symposium on Cluster Computing */
455 /*                  and the Grid (CCGrid'01)", */
456 /*   publisher =    "IEEE Computer Society", */
457 /*   title =        "Simgrid: {A} Toolkit for the Simulation of Application */
458 /*                  Scheduling", */
459 /*   year =         "2001", */
460 /*   month =        may, */
461 /*   note =         "Available at */
462 /*                  \url{http://grail.sdsc.edu/papers/simgrid_ccgrid01.ps.gz}." */
463 /* } */
464 void surf_cpu_model_init_Cas01(const char *filename)
465 {
466   if (surf_cpu_model)
467     return;
468   surf_cpu_model_init_internal();
469   cpu_define_callbacks(filename);
470   xbt_dynar_push(model_list, &surf_cpu_model);
471 }