Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Merge branch 'vmtrace'
authorJonathan Rouzaud-Cornabas <jonathan.rouzaud-cornabas@ens-lyon.fr>
Wed, 16 Jan 2013 23:19:37 +0000 (00:19 +0100)
committerJonathan Rouzaud-Cornabas <jonathan.rouzaud-cornabas@ens-lyon.fr>
Wed, 16 Jan 2013 23:19:37 +0000 (00:19 +0100)
buildtools/Cmake/CompleteInFiles.cmake
include/msg/msg.h
src/instr/instr_config.c
src/instr/instr_private.h
src/surf/instr_routing.c
src/surf/surf_action.c
src/xbt/heap.c

index abcd9c9..2cb506e 100644 (file)
@@ -156,10 +156,10 @@ else()
 endif()
 
 # Our usage of mmap is Linux-specific (flag MAP_ANONYMOUS), but kFreeBSD uses a GNU libc
-IF(NOT "${CMAKE_SYSTEM}" MATCHES "Linux" AND NOT "${CMAKE_SYSTEM}" MATCHES "kFreeBSD" AND NOT "${CMAKE_SYSTEM}" MATCHES "GNU" AND NOT  "${CMAKE_SYSTEM}" MATCHES "Darwin")
+IF(NOT "${CMAKE_SYSTEM}" MATCHES "Linux" AND NOT "${CMAKE_SYSTEM}" MATCHES "kFreeBSD" AND NOT "${CMAKE_SYSTEM}" MATCHES "GNU")
   SET(HAVE_MMAP 0)
   message(STATUS "Warning: MMAP is thought as non functional on this architecture (${CMAKE_SYSTEM})")
-ENDIF(NOT "${CMAKE_SYSTEM}" MATCHES "Linux" AND NOT "${CMAKE_SYSTEM}" MATCHES "kFreeBSD" AND NOT "${CMAKE_SYSTEM}" MATCHES "GNU" AND NOT  "${CMAKE_SYSTEM}" MATCHES "Darwin")
+ENDIF()
 
 if(WIN32) #THOSE FILES ARE FUNCTIONS ARE NOT DETECTED BUT THEY SHOULD...
   set(HAVE_UCONTEXT_H 1)
index afac0e9..93dde90 100644 (file)
@@ -324,6 +324,8 @@ XBT_PUBLIC(msg_error_t) MSG_set_channel_number(int number);
 XBT_PUBLIC(int) MSG_get_channel_number(void);
 #endif
 
+#include "instr/instr.h"
+
 /** @brief Opaque type describing a Virtual Machine.
  *  @ingroup msg_VMs
  *
@@ -332,6 +334,7 @@ XBT_PUBLIC(int) MSG_get_channel_number(void);
  * Usual lack of guaranty of any kind applies here, and is even increased.
  *
  */
+typedef struct msg_vm *msg_vm_t;
 /* This function should not be called directly, but rather from MSG_vm_start_from_template that does not exist yet*/
 XBT_PUBLIC(msg_vm_t) MSG_vm_start(msg_host_t location, const char *name, int coreAmount);
 
@@ -376,7 +379,6 @@ xbt_dynar_t<msg_vm_t> MSG_vm_get_list_from_host(msg_host_t)
 xbt_dynar_t<msg_vm_t> MSG_vm_get_list_from_hosts(msg_dynar_t<msg_host_t>)
 + des fonctions de filtrage sur les dynar
 */
-#include "instr/instr.h"
 
 
 
index 6527b0c..2483061 100644 (file)
@@ -55,20 +55,28 @@ static int trace_active = 0;
 
 static void TRACE_getopts(void)
 {
-  trace_enabled = xbt_cfg_get_int(_surf_cfg_set, OPT_TRACING);
-  trace_platform = xbt_cfg_get_int(_surf_cfg_set, OPT_TRACING_PLATFORM);
-  trace_platform_topology = xbt_cfg_get_int(_surf_cfg_set, OPT_TRACING_TOPOLOGY);
-  trace_smpi_enabled = xbt_cfg_get_int(_surf_cfg_set, OPT_TRACING_SMPI);
-  trace_smpi_grouped = xbt_cfg_get_int(_surf_cfg_set, OPT_TRACING_SMPI_GROUP);
-  trace_smpi_computing = xbt_cfg_get_int(_surf_cfg_set, OPT_TRACING_SMPI_COMPUTING);
-  trace_categorized = xbt_cfg_get_int(_surf_cfg_set, OPT_TRACING_CATEGORIZED);
-  trace_uncategorized = xbt_cfg_get_int(_surf_cfg_set, OPT_TRACING_UNCATEGORIZED);
-  trace_msg_process_enabled = xbt_cfg_get_int(_surf_cfg_set, OPT_TRACING_MSG_PROCESS);
-  trace_msg_vm_enabled = xbt_cfg_get_int(_surf_cfg_set, OPT_TRACING_MSG_VM);
-  trace_buffer = xbt_cfg_get_int(_surf_cfg_set, OPT_TRACING_BUFFER);
-  trace_onelink_only = xbt_cfg_get_int(_surf_cfg_set, OPT_TRACING_ONELINK_ONLY);
-  trace_disable_destroy = xbt_cfg_get_int(_surf_cfg_set, OPT_TRACING_DISABLE_DESTROY);
-  trace_basic = xbt_cfg_get_int(_surf_cfg_set, OPT_TRACING_BASIC);
+  trace_enabled = xbt_cfg_get_int(_sg_cfg_set, OPT_TRACING);
+  trace_platform = xbt_cfg_get_int(_sg_cfg_set, OPT_TRACING_PLATFORM);
+  trace_platform_topology = xbt_cfg_get_int(_sg_cfg_set, OPT_TRACING_TOPOLOGY);
+  trace_smpi_enabled = xbt_cfg_get_int(_sg_cfg_set, OPT_TRACING_SMPI);
+  trace_smpi_grouped = xbt_cfg_get_int(_sg_cfg_set, OPT_TRACING_SMPI_GROUP);
+  trace_smpi_computing = xbt_cfg_get_int(_sg_cfg_set, OPT_TRACING_SMPI_COMPUTING);
+  trace_categorized = xbt_cfg_get_int(_sg_cfg_set, OPT_TRACING_CATEGORIZED);
+  trace_uncategorized = xbt_cfg_get_int(_sg_cfg_set, OPT_TRACING_UNCATEGORIZED);
+  trace_msg_process_enabled = xbt_cfg_get_int(_sg_cfg_set, OPT_TRACING_MSG_PROCESS);
+  trace_msg_vm_enabled = xbt_cfg_get_int(_sg_cfg_set, OPT_TRACING_MSG_VM);
+  trace_buffer = xbt_cfg_get_int(_sg_cfg_set, OPT_TRACING_BUFFER);
+  trace_onelink_only = xbt_cfg_get_int(_sg_cfg_set, OPT_TRACING_ONELINK_ONLY);
+  trace_disable_destroy = xbt_cfg_get_int(_sg_cfg_set, OPT_TRACING_DISABLE_DESTROY);
+  trace_basic = xbt_cfg_get_int(_sg_cfg_set, OPT_TRACING_BASIC);
+}
+
+xbt_dynar_t TRACE_start_functions = NULL;
+void TRACE_add_start_function(void (*func) ())
+{
+  if (TRACE_start_functions == NULL)
+    TRACE_start_functions = xbt_dynar_new(sizeof(void (*)()), NULL);
+  xbt_dynar_push(TRACE_start_functions, &func);
 }
 
 int TRACE_start()
@@ -105,17 +113,7 @@ int TRACE_start()
       }
     }
   }
-  trace_active = 1;
-  XBT_DEBUG ("Tracing is on");
-
-  /* other trace initialization */
-  created_categories = xbt_dict_new_homogeneous(xbt_free);
-  declared_marks = xbt_dict_new_homogeneous (xbt_free);
-  user_host_variables = xbt_dict_new_homogeneous (xbt_free);
-  user_vm_variables = xbt_dict_new_homogeneous (xbt_free);
-  user_link_variables = xbt_dict_new_homogeneous (xbt_free);
-  TRACE_surf_alloc();
-  TRACE_smpi_alloc();
+  xbt_dynar_free(&TRACE_start_functions);
   return 0;
 }
 
@@ -129,50 +127,61 @@ void TRACE_add_end_function(void (*func) (void))
 
 int TRACE_end()
 {
-  if (!trace_active)
-    return 1;
-
-  TRACE_generate_viva_uncat_conf();
-  TRACE_generate_viva_cat_conf();
-
-  /* dump trace buffer */
-  TRACE_last_timestamp_to_dump = surf_get_clock();
-  TRACE_paje_dump_buffer(1);
-
-  /* destroy all data structures of tracing (and free) */
-  PJ_container_free_all();
-  PJ_type_free_all();
-  PJ_container_release();
-  PJ_type_release();
-  TRACE_smpi_release();
-  TRACE_surf_release();
-  xbt_dict_free(&user_link_variables);
-  xbt_dict_free(&user_host_variables);
-  xbt_dict_free(&user_vm_variables);
-
-  xbt_dict_free(&declared_marks);
-  xbt_dict_free(&created_categories);
-
-  /* close the trace file */
-  TRACE_paje_end();
-
-  /* de-activate trace */
-  trace_active = 0;
-  XBT_DEBUG ("Tracing is off");
-  XBT_DEBUG("Tracing system is shutdown");
-  return 0;
+  int retval;
+  if (!trace_active) {
+    retval = 1;
+  } else {
+    retval = 0;
+
+    TRACE_generate_viva_uncat_conf();
+    TRACE_generate_viva_cat_conf();
+
+    /* dump trace buffer */
+    TRACE_last_timestamp_to_dump = surf_get_clock();
+    TRACE_paje_dump_buffer(1);
+
+    /* destroy all data structures of tracing (and free) */
+    PJ_container_free_all();
+    PJ_type_free_all();
+    PJ_container_release();
+    PJ_type_release();
+
+    if (TRACE_end_functions != NULL) {
+      void (*func) (void);
+      unsigned int iter;
+      xbt_dynar_foreach(TRACE_end_functions, iter, func) {
+        func();
+      }
+    }
+
+    xbt_dict_free(&user_link_variables);
+    xbt_dict_free(&user_host_variables);
+    xbt_dict_free(&declared_marks);
+    xbt_dict_free(&created_categories);
+
+    /* close the trace file */
+    TRACE_paje_end();
+
+    /* de-activate trace */
+    trace_active = 0;
+    XBT_DEBUG("Tracing is off");
+    XBT_DEBUG("Tracing system is shutdown");
+  }
+  xbt_dynar_free(&TRACE_end_functions);
+  return retval;
 }
 
 int TRACE_needs_platform (void)
 {
   return TRACE_msg_process_is_enabled() ||
-         TRACE_msg_vm_is_enabled() ||
          TRACE_categorized() ||
          TRACE_uncategorized() ||
+         TRACE_msg_vm_is_enabled() ||
          TRACE_platform () ||
          (TRACE_smpi_is_enabled() && TRACE_smpi_is_grouped());
 }
 
+
 int TRACE_is_enabled(void)
 {
   return trace_enabled;
@@ -347,11 +356,10 @@ void TRACE_global_init(int *argc, char **argv)
                    "Tracing of MSG process behavior.",
                    xbt_cfgelm_int, &default_tracing_msg_process, 0, 1,
                    NULL, NULL);
-
-  /* msg process */
+  /* msg vm */
   int default_tracing_msg_vm = 0;
-  xbt_cfg_register(&_surf_cfg_set, OPT_TRACING_MSG_VM,
-                   "Tracing of MSG process behavior.",
+  xbt_cfg_register(&_sg_cfg_set, OPT_TRACING_MSG_VM,
+                   "Tracing of MSG VM behavior.",
                    xbt_cfgelm_int, &default_tracing_msg_vm, 0, 1,
                    NULL, NULL);
 
index 1c57b14..44a161c 100644 (file)
@@ -166,14 +166,6 @@ void TRACE_msg_vm_sleep_in(msg_vm_t vm);
 void TRACE_msg_vm_sleep_out(msg_vm_t vm);
 void TRACE_msg_vm_end(msg_vm_t vm);
 
-/* from surf_instr.c */
-void TRACE_surf_alloc(void);
-void TRACE_surf_release(void);
-void TRACE_surf_host_set_power(double date, const char *resource, double power);
-void TRACE_surf_link_set_bandwidth(double date, const char *resource, double bandwidth);
-void TRACE_surf_link_set_latency(double date, const char *resource, double latency);
-void TRACE_surf_action(surf_action_t surf_action, const char *category);
-
 //for tracing gtnets
 void TRACE_surf_gtnets_communicate(void *action, void *src, void *dst);
 
index c5fc212..2a5e64e 100644 (file)
@@ -136,6 +136,7 @@ static int graph_extraction_filter_out (container_t c1, container_t c2)
       c1->kind == INSTR_SMPI ||
       c1->kind == INSTR_MSG_PROCESS ||
       c1->kind == INSTR_MSG_TASK ||
+      c1->kind == INSTR_MSG_VM ||
       (c2 && strcmp (c1->name, c2->name) == 0))
     return 1;
   else
@@ -165,12 +166,11 @@ static void recursiveGraphExtraction (AS_t rc, container_t container, xbt_dict_t
   container_t child1, child2;
   const char *child1_name, *child2_name;
   xbt_dict_foreach(container->children, cursor1, child1_name, child1) {
-    //if child1 is not a link, a smpi node, a msg process, a msg vm or a msg task
-    if (child1->kind == INSTR_LINK || child1->kind == INSTR_SMPI || child1->kind == INSTR_MSG_PROCESS || child1->kind == INSTR_MSG_VM || child1->kind == INSTR_MSG_TASK) continue;
+    if (graph_extraction_filter_out (child1, NULL)) continue;
 
     xbt_dict_foreach(container->children, cursor2, child2_name, child2) {
-      //if child2 is not a link, a smpi node, a msg process, a msg vm or a msg task
-      if (child2->kind == INSTR_LINK || child2->kind == INSTR_SMPI || child2->kind == INSTR_MSG_PROCESS || child2->kind == INSTR_MSG_VM || child2->kind == INSTR_MSG_TASK) continue;
+      if (graph_extraction_filter_out (child2, child1)) continue;
+      XBT_DEBUG ("get_route from %s to %s", child1_name, child2_name);
 
       //if child1 is not child2
       if (strcmp (child1_name, child2_name) == 0) continue;
index 59e775f..e05e199 100644 (file)
@@ -374,7 +374,8 @@ void generic_update_actions_state_lazy(double now, double delta, surf_model_t mo
   while ((xbt_heap_size(model->model_private->action_heap) > 0)
          && (double_equals(xbt_heap_maxkey(model->model_private->action_heap), now))) {
     action = xbt_heap_pop(model->model_private->action_heap);
-    XBT_DEBUG("Something happened to action %p", action);
+    XBT_DEBUG("Action %p: finish", action);
+    action->generic_action.finish = surf_get_clock();
 #ifdef HAVE_TRACING
     if (TRACE_is_enabled()) {
       if(model == surf_cpu_model){
@@ -410,9 +411,6 @@ void generic_update_actions_state_lazy(double now, double delta, surf_model_t mo
 #endif
 
     if(model == surf_cpu_model){
-      action->generic_action.finish = surf_get_clock();
-      XBT_DEBUG("Action %p finished", action);
-
       /* set the remains to 0 due to precision problems when updating the remaining amount */
       action->generic_action.remains = 0;
       surf_action_state_set((surf_action_t) action, SURF_ACTION_DONE);
@@ -421,7 +419,6 @@ void generic_update_actions_state_lazy(double now, double delta, surf_model_t mo
     else{
       // if I am wearing a latency hat
       if (action->hat == LATENCY) {
-        XBT_DEBUG("Latency paid for action %p. Activating", action);
         lmm_update_variable_weight(model->model_private->maxmin_system, action->variable,
             ((surf_action_network_CM02_t)(action))->weight);
         surf_action_lmm_heap_remove(model->model_private->action_heap,action);
@@ -432,9 +429,7 @@ void generic_update_actions_state_lazy(double now, double delta, surf_model_t mo
           action->hat == NORMAL) {
         // no need to communicate anymore
         // assume that flows that reached max_duration have remaining of 0
-       action->generic_action.finish = surf_get_clock();
-       XBT_DEBUG("Action %p finished", action);
-       action->generic_action.remains = 0;
+        action->generic_action.remains = 0;
         ((surf_action_t)action)->finish = surf_get_clock();
         model->action_state_set((surf_action_t) action,
                                              SURF_ACTION_DONE);
index c795b76..e124aab 100644 (file)
@@ -11,7 +11,6 @@
 #include "heap_private.h"
 
 #include <stdio.h>
-XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_heap, xbt, "Heap");
 
 static void xbt_heap_max_heapify(xbt_heap_t H);
 static void xbt_heap_increase_key(xbt_heap_t H, int i);
@@ -104,7 +103,6 @@ void xbt_heap_push(xbt_heap_t H, void *content, double key)
   item->key = key;
   item->content = content;
   xbt_heap_increase_key(H, count - 1);
-  XBT_DEBUG("Heap has now %d elements and max elem is %g",xbt_heap_size(H),xbt_heap_maxkey(H));
   return;
 }
 
@@ -123,8 +121,6 @@ void *xbt_heap_pop(xbt_heap_t H)
   int size = H->size;
   void *max;
 
-  XBT_DEBUG("Heap has %d elements before extraction and max elem was %g",xbt_heap_size(H),xbt_heap_maxkey(H));
-
   if (H->count == 0)
     return NULL;
 
@@ -156,8 +152,6 @@ void *xbt_heap_pop(xbt_heap_t H)
  */
 void *xbt_heap_remove(xbt_heap_t H, int i)
 {
-  XBT_DEBUG("Heap has %d elements: extracting element %d",xbt_heap_size(H),i);
-
   if ((i < 0) || (i > H->count - 1))
     return NULL;
   /* put element i at head */