1 /* Copyright (c) 2010. The SimGrid Team.
2 * All rights reserved. */
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. */
7 #include "instr/instr_private.h"
11 //to check if variables were previously set to 0, otherwise paje won't simulate them
12 static xbt_dict_t platform_variables; /* host or link name -> array of categories */
15 static xbt_dict_t method_b_dict;
18 static xbt_dict_t method_c_dict;
20 //resource utilization tracing method
21 static void (*TRACE_method_alloc) (void) = NULL;
22 static void (*TRACE_method_release) (void) = NULL;
23 static void (*TRACE_method_start) (smx_action_t action) = NULL;
24 static void (*TRACE_method_event) (smx_action_t action, double now,
25 double delta, const char *variable,
26 const char *resource, double value) =
28 static void (*TRACE_method_end) (smx_action_t action) = NULL;
31 static void __TRACE_surf_check_variable_set_to_zero(double now,
35 /* check if we have to set it to 0 */
36 if (!xbt_dict_get_or_null(platform_variables, resource)) {
37 xbt_dynar_t array = xbt_dynar_new(sizeof(char *), xbt_free);
38 char *var_cpy = xbt_strdup(variable);
39 xbt_dynar_push(array, &var_cpy);
40 if (TRACE_platform_is_enabled())
41 pajeSetVariable(now, variable, resource, "0");
42 xbt_dict_set(platform_variables, resource, array,
43 xbt_dynar_free_voidp);
45 xbt_dynar_t array = xbt_dict_get(platform_variables, resource);
49 xbt_dynar_foreach(array, i, cat) {
50 if (strcmp(variable, cat) == 0) {
55 char *var_cpy = xbt_strdup(variable);
56 xbt_dynar_push(array, &var_cpy);
57 if (TRACE_platform_is_enabled())
58 pajeSetVariable(now, variable, resource, "0");
66 static void __TRACE_A_alloc(void)
70 static void __TRACE_A_release(void)
74 static void __TRACE_A_start(smx_action_t action)
78 static void __TRACE_A_event(smx_action_t action, double now, double delta,
79 const char *variable, const char *resource,
83 snprintf(valuestr, 100, "%f", value);
85 __TRACE_surf_check_variable_set_to_zero(now, variable, resource);
86 pajeAddVariable(now, variable, resource, valuestr);
87 pajeSubVariable(now + delta, variable, resource, valuestr);
90 static void __TRACE_A_end(smx_action_t action)
97 static void __TRACE_B_alloc(void)
99 method_b_dict = xbt_dict_new();
102 static void __TRACE_B_release(void)
105 xbt_dict_cursor_t cursor = NULL;
106 xbt_dict_foreach(method_b_dict, cursor, key, time) {
107 char resource[INSTR_DEFAULT_STR_SIZE];
108 char variable[INSTR_DEFAULT_STR_SIZE];
109 char what[INSTR_DEFAULT_STR_SIZE];
110 sscanf (key, "%s %s %s", resource, variable, what);
111 if (strcmp(what, "time")==0){
112 char key_value[INSTR_DEFAULT_STR_SIZE];
113 snprintf (key_value, INSTR_DEFAULT_STR_SIZE, "%s %s value", resource, variable);
114 char *value = xbt_dict_get_or_null (method_b_dict, key_value);
115 pajeSubVariable(atof(time), variable, resource, value);
118 xbt_dict_free(&method_b_dict);
121 static void __TRACE_B_start(smx_action_t action)
125 static void __TRACE_B_event(smx_action_t action, double now, double delta,
126 const char *variable, const char *resource,
129 char key_time[INSTR_DEFAULT_STR_SIZE];
130 char key_value[INSTR_DEFAULT_STR_SIZE];
131 char nowstr[INSTR_DEFAULT_STR_SIZE];
132 char valuestr[INSTR_DEFAULT_STR_SIZE];
133 char nowdeltastr[INSTR_DEFAULT_STR_SIZE];
135 snprintf (key_time, INSTR_DEFAULT_STR_SIZE, "%s %s time", resource, variable);
136 snprintf (key_value, INSTR_DEFAULT_STR_SIZE, "%s %s value", resource, variable);
137 snprintf (nowstr, INSTR_DEFAULT_STR_SIZE, "%f", now);
138 snprintf (valuestr, INSTR_DEFAULT_STR_SIZE, "%f", value);
139 snprintf (nowdeltastr, INSTR_DEFAULT_STR_SIZE, "%f", now+delta);
141 char *lasttimestr = xbt_dict_get_or_null(method_b_dict, key_time);
142 char *lastvaluestr = xbt_dict_get_or_null(method_b_dict, key_value);
143 if (lasttimestr == NULL){
144 __TRACE_surf_check_variable_set_to_zero(now, variable, resource);
145 pajeAddVariable(now, variable, resource, valuestr);
146 xbt_dict_set(method_b_dict, key_time, xbt_strdup(nowdeltastr), xbt_free);
147 xbt_dict_set(method_b_dict, key_value, xbt_strdup(valuestr), xbt_free);
149 double lasttime = atof (lasttimestr);
150 double lastvalue = atof (lastvaluestr);
152 if (lastvalue == value){
153 double dif = fabs(now - lasttime);
155 //perfect, just go on
157 //time changed, have to update
158 pajeSubVariable(lasttime, variable, resource, lastvaluestr);
159 pajeAddVariable(now, variable, resource, valuestr);
162 //value changed, have to update
163 pajeSubVariable(lasttime, variable, resource, lastvaluestr);
164 pajeAddVariable(now, variable, resource, valuestr);
166 xbt_dict_set(method_b_dict, key_time, xbt_strdup(nowdeltastr), xbt_free);
167 xbt_dict_set(method_b_dict, key_value, xbt_strdup(valuestr), xbt_free);
172 static void __TRACE_B_end(smx_action_t action)
178 static void __TRACE_C_alloc(void)
180 method_c_dict = xbt_dict_new();
183 static void __TRACE_C_release(void)
185 xbt_dict_free(&method_c_dict);
188 static void __TRACE_C_start(smx_action_t action)
191 snprintf(key, 100, "%p", action);
194 if (xbt_dict_get_or_null(method_c_dict, key)) {
195 xbt_dict_remove(method_c_dict, key); //should never execute here, but it does
197 xbt_dict_set(method_c_dict, key, xbt_dict_new(), xbt_free);
200 static void __TRACE_C_event(smx_action_t action, double now, double delta,
201 const char *variable, const char *resource,
205 snprintf(key, 100, "%p", action);
207 xbt_dict_t action_dict = xbt_dict_get(method_c_dict, key);
209 if (!xbt_dict_get_or_null(action_dict, "start")) {
210 char start_time[100];
211 snprintf(start_time, 100, "%f", now);
212 xbt_dict_set(action_dict, "start", xbt_strdup(start_time), xbt_free);
216 snprintf(end_time, 100, "%f", now + delta);
217 xbt_dict_set(action_dict, "end", xbt_strdup(end_time), xbt_free);
219 //accumulate the value resource-variable
221 snprintf(res_var, 300, "%s %s", resource, variable);
222 double current_value_f;
223 char *current_value = xbt_dict_get_or_null(action_dict, res_var);
225 current_value_f = atof(current_value);
226 current_value_f += value * delta;
228 current_value_f = value * delta;
230 char new_current_value[100];
231 snprintf(new_current_value, 100, "%f", current_value_f);
232 xbt_dict_set(action_dict, res_var, xbt_strdup(new_current_value),
236 static void __TRACE_C_end(smx_action_t action)
239 snprintf(key, 100, "%p", action);
241 xbt_dict_t action_dict = xbt_dict_get(method_c_dict, key);
242 double start_time = atof(xbt_dict_get(action_dict, "start"));
243 double end_time = atof(xbt_dict_get(action_dict, "end"));
245 xbt_dict_cursor_t cursor = NULL;
246 char *action_dict_key, *action_dict_value;
247 xbt_dict_foreach(action_dict, cursor, action_dict_key, action_dict_value) {
248 char resource[100], variable[100];
249 if (sscanf(action_dict_key, "%s %s", resource, variable) != 2)
251 __TRACE_surf_check_variable_set_to_zero(start_time, variable,
254 if (end_time - start_time != 0) {
255 snprintf(value_str, 100, "%f",
256 atof(action_dict_value) / (end_time - start_time));
257 pajeAddVariable(start_time, variable, resource, value_str);
258 pajeSubVariable(end_time, variable, resource, value_str);
261 xbt_dict_remove(method_c_dict, key);
264 #define RESOURCE_UTILIZATION_INTERFACE
266 * TRACE_surf_link_set_utilization: entry point from SimGrid
268 void TRACE_surf_link_set_utilization(void *link, smx_action_t smx_action,
269 surf_action_t surf_action,
270 double value, double now,
273 if (!TRACE_is_active())
277 //only trace link utilization if link is known by tracing mechanism
278 if (!TRACE_surf_link_is_traced(link))
284 snprintf(resource, 100, "%p", link);
286 //trace uncategorized link utilization
287 if (TRACE_uncategorized()){
288 TRACE_surf_resource_utilization_event(smx_action, now, delta,
289 "bandwidth_used", resource, value);
292 //trace categorized utilization
293 if (!surf_action->category)
296 snprintf(type, 100, "b%s", surf_action->category);
297 TRACE_surf_resource_utilization_event(smx_action, now, delta, type,
303 * TRACE_surf_host_set_utilization: entry point from SimGrid
305 void TRACE_surf_host_set_utilization(const char *name,
306 smx_action_t smx_action,
307 surf_action_t surf_action,
308 double value, double now,
311 if (!TRACE_is_active())
316 //trace uncategorized host utilization
317 if (TRACE_uncategorized()){
318 TRACE_surf_resource_utilization_event(smx_action, now, delta,
319 "power_used", name, value);
322 //trace categorized utilization
323 if (!surf_action->category)
326 snprintf(type, 100, "p%s", surf_action->category);
327 TRACE_surf_resource_utilization_event(smx_action, now, delta, type, name,
333 * __TRACE_surf_resource_utilization_*: entry points from tracing functions
335 void TRACE_surf_resource_utilization_start(smx_action_t action)
337 if (!TRACE_is_active())
339 TRACE_method_start(action);
342 void TRACE_surf_resource_utilization_event(smx_action_t action, double now,
344 const char *variable,
345 const char *resource,
348 if (!TRACE_is_active())
350 TRACE_method_event(action, now, delta, variable, resource, value);
353 void TRACE_surf_resource_utilization_end(smx_action_t action)
355 if (!TRACE_is_active())
357 TRACE_method_end(action);
360 void TRACE_surf_resource_utilization_release()
362 if (!TRACE_is_active())
364 TRACE_method_release();
367 static void __TRACE_define_method(char *method)
369 if (!strcmp(method, "a")) {
370 TRACE_method_alloc = __TRACE_A_alloc;
371 TRACE_method_release = __TRACE_A_release;
372 TRACE_method_start = __TRACE_A_start;
373 TRACE_method_event = __TRACE_A_event;
374 TRACE_method_end = __TRACE_A_end;
375 } else if (!strcmp(method, "c")) {
376 TRACE_method_alloc = __TRACE_C_alloc;
377 TRACE_method_release = __TRACE_C_release;
378 TRACE_method_start = __TRACE_C_start;
379 TRACE_method_event = __TRACE_C_event;
380 TRACE_method_end = __TRACE_C_end;
381 } else { //default is B
382 TRACE_method_alloc = __TRACE_B_alloc;
383 TRACE_method_release = __TRACE_B_release;
384 TRACE_method_start = __TRACE_B_start;
385 TRACE_method_event = __TRACE_B_event;
386 TRACE_method_end = __TRACE_B_end;
390 void TRACE_surf_resource_utilization_alloc()
392 platform_variables = xbt_dict_new();
393 __TRACE_define_method(TRACE_get_platform_method());
394 TRACE_method_alloc();
396 #endif /* HAVE_TRACING */