src/instr/instr_resource_utilization.c

   1 /* Copyright (c) 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 "instr/instr_private.h"
   8
   9 #ifdef HAVE_TRACING
  10
  11 XBT_LOG_NEW_DEFAULT_SUBCATEGORY (instr_resource, instr, "tracing (un)-categorized resource utilization");
  12
  13 //to check if variables were previously set to 0, otherwise paje won't simulate them
  14 static xbt_dict_t platform_variables;
  15
  16 //used by all methods
  17 static void __TRACE_surf_check_variable_set_to_zero(double now,
  18                                                     const char *variable,
  19                                                     const char *resource)
  20 {
  21   /*
  22    * To trace resource utilization, we use pajeAddVariable and pajeSubVariable only.
  23    * The Paje simulator needs a pajeSetVariable in the first place so it knows
  24    * the initial value of all variables for subsequent adds/subs. If we don't do
  25    * so, the first pajeAddVariable is added to a non-determined value within
  26    * the Paje simulator, causing analysis problems.
  27    */
  28
  29   // create a key considering the resource and variable
  30   int n = strlen(variable)+strlen(resource)+1;
  31   char *key = (char*)xbt_malloc(n*sizeof(char));
  32   snprintf (key, n, "%s%s", resource, variable);
  33
  34   // check if key exists: if it doesn't, set the variable to zero and mark this in the dict
  35   if (!xbt_dict_get_or_null(platform_variables, key)) {
  36     container_t container = PJ_container_get (resource);
  37     type_t type = PJ_type_get (variable, container->type);
  38     new_pajeSetVariable (now, container, type, 0);
  39     xbt_dict_set(platform_variables, key, (char*)"", NULL);
  40   }
  41   xbt_free(key);
  42 }
  43
  44 static void instr_event (double now, double delta, type_t variable, container_t resource, double value)
  45 {
  46   __TRACE_surf_check_variable_set_to_zero(now, variable->name, resource->name);
  47   new_pajeAddVariable(now, resource, variable, value);
  48   new_pajeSubVariable(now + delta, resource, variable, value);
  49 }
  50
  51 /*
  52  * TRACE_surf_link_set_utilization: entry point from SimGrid
  53  */
  54 void TRACE_surf_link_set_utilization(const char *resource,
  55                                      const char *category,
  56                                      double value,
  57                                      double now,
  58                                      double delta)
  59 {
  60   //only trace link utilization if link is known by tracing mechanism
  61   if (!PJ_container_get_or_null(resource))
  62     return;
  63   if (!value)
  64     return;
  65
  66   //trace uncategorized link utilization
  67   if (TRACE_uncategorized()){
  68     XBT_DEBUG("UNCAT LINK [%f - %f] %s bandwidth_used %f", now, now+delta, resource, value);
  69     container_t container = PJ_container_get (resource);
  70     type_t type = PJ_type_get ("bandwidth_used", container->type);
  71     instr_event (now, delta, type, container, value);
  72   }
  73
  74   //trace categorized utilization
  75   if (TRACE_categorized()){
  76     if (!category)
  77       return;
  78     //variable of this category starts by 'b', because we have a link here
  79     char category_type[INSTR_DEFAULT_STR_SIZE];
  80     snprintf (category_type, INSTR_DEFAULT_STR_SIZE, "b%s", category);
  81     XBT_DEBUG("CAT LINK [%f - %f] %s %s %f", now, now+delta, resource, category_type, value);
  82     container_t container = PJ_container_get (resource);
  83     type_t type = PJ_type_get (category_type, container->type);
  84     instr_event (now, delta, type, container, value);
  85   }
  86   return;
  87 }
  88
  89 /*
  90  * TRACE_surf_host_set_utilization: entry point from SimGrid
  91  */
  92 void TRACE_surf_host_set_utilization(const char *resource,
  93                                      const char *category,
  94                                      double value,
  95                                      double now,
  96                                      double delta)
  97 {
  98   //only trace host utilization if host is known by tracing mechanism
  99   if (!PJ_container_get_or_null(resource))
 100     return;
 101   if (!value)
 102     return;
 103
 104   //trace uncategorized host utilization
 105   if (TRACE_uncategorized()){
 106     XBT_DEBUG("UNCAT HOST [%f - %f] %s power_used %f", now, now+delta, resource, value);
 107     container_t container = PJ_container_get (resource);
 108     type_t type = PJ_type_get ("power_used", container->type);
 109     instr_event (now, delta, type, container, value);
 110   }
 111
 112   //trace categorized utilization
 113   if (TRACE_categorized()){
 114     if (!category)
 115       return;
 116     //variable of this category starts by 'p', because we have a host here
 117     char category_type[INSTR_DEFAULT_STR_SIZE];
 118     snprintf (category_type, INSTR_DEFAULT_STR_SIZE, "p%s", category);
 119     XBT_DEBUG("CAT HOST [%f - %f] %s %s %f", now, now+delta, resource, category_type, value);
 120     container_t container = PJ_container_get (resource);
 121     type_t type = PJ_type_get (category_type, container->type);
 122     instr_event (now, delta, type, container, value);
 123   }
 124   return;
 125 }
 126
 127 void TRACE_surf_resource_utilization_alloc()
 128 {
 129   platform_variables = xbt_dict_new_homogeneous(NULL);
 130 }
 131
 132 void TRACE_surf_resource_utilization_release()
 133 {
 134   xbt_dict_free(&platform_variables);
 135 }
 136 #endif /* HAVE_TRACING */