[trace] a source file to keep functions to deal with data structures for paje tracing

git-svn-id: svn+ssh://scm.gforge.inria.fr/svn/simgrid/simgrid/trunk@9309 48e7efb5-ca39-0410-a469-dd3cf9ba447f

diff --git a/buildtools/Cmake/DefinePackages.cmake b/buildtools/Cmake/DefinePackages.cmake
index 97be594..286d9b2 100644 (file)
--- a/buildtools/Cmake/DefinePackages.cmake
+++ b/buildtools/Cmake/DefinePackages.cmake
@@ -302,6 +302,7 @@ set(TRACING_SRC
        src/instr/instr_routing.c
        src/instr/instr_config.c
        src/instr/instr_interface.c
+       src/instr/instr_paje.c
        src/instr/instr_paje_trace.c
        src/instr/instr_msg_task.c
        src/instr/instr_msg_process.c

diff --git a/src/instr/instr_paje.c b/src/instr/instr_paje.c
new file mode 100644 (file)
index 0000000..d14083c
--- /dev/null
+++ b/src/instr/instr_paje.c
@@ -0,0 +1,266 @@
+/* Copyright (c) 2010. The SimGrid Team.
+ * All rights reserved.                                                     */
+
+/* This program is free software; you can redistribute it and/or modify it
+  * under the terms of the license (GNU LGPL) which comes with this package. */
+
+#include "instr/instr_private.h"
+
+#ifdef HAVE_TRACING
+
+XBT_LOG_NEW_DEFAULT_SUBCATEGORY (instr_paje, instr, "Paje tracing event system (data structures)");
+
+static type_t rootType = NULL;              /* the root type */
+static container_t rootContainer = NULL;    /* the root container */
+static xbt_dict_t allContainers = NULL;     /* all created containers indexed by name */
+xbt_dynar_t allLinkTypes = NULL;     /* all link types defined */
+xbt_dynar_t allHostTypes = NULL;     /* all host types defined */
+
+void instr_paje_init (container_t root)
+{
+  allContainers = xbt_dict_new ();
+  allLinkTypes = xbt_dynar_new (sizeof(s_type_t), NULL);
+  allHostTypes = xbt_dynar_new (sizeof(s_type_t), NULL);
+  rootContainer = root;
+}
+
+static long long int newTypeId ()
+{
+  static long long int counter = 0;
+  return counter++;
+}
+
+static type_t newType (const char *typename, const char *key, e_entity_types kind, type_t father)
+{
+  type_t ret = xbt_new0(s_type_t, 1);
+  ret->name = xbt_strdup (typename);
+  ret->father = father;
+  ret->kind = kind;
+  ret->children = xbt_dict_new ();
+
+  long long int id = newTypeId();
+  char str_id[INSTR_DEFAULT_STR_SIZE];
+  snprintf (str_id, INSTR_DEFAULT_STR_SIZE, "%lld", id);
+  ret->id = xbt_strdup (str_id);
+
+  if (father != NULL){
+    xbt_dict_set (father->children, key, ret, NULL);
+  }
+  return ret;
+}
+
+type_t getRootType ()
+{
+  return rootType;
+}
+
+type_t getContainerType (const char *typename, type_t father)
+{
+  type_t ret;
+  if (father == NULL){
+    ret = newType (typename, typename, TYPE_CONTAINER, father);
+    if (father) pajeDefineContainerType(ret->id, ret->father->id, ret->name);
+    rootType = ret;
+  }else{
+    //check if my father type already has my typename
+    ret = (type_t)xbt_dict_get_or_null (father->children, typename);
+    if (ret == NULL){
+      ret = newType (typename, typename, TYPE_CONTAINER, father);
+      pajeDefineContainerType(ret->id, ret->father->id, ret->name);
+    }
+  }
+  return ret;
+}
+
+type_t getEventType (const char *typename, const char *color, type_t father)
+{
+  type_t ret = xbt_dict_get_or_null (father->children, typename);
+  if (ret == NULL){
+    ret = newType (typename, typename, TYPE_EVENT, father);
+    //INFO4("EventType %s(%s), child of %s(%s)", ret->name, ret->id, father->name, father->id);
+    if (color){
+      pajeDefineEventTypeWithColor (ret->id, ret->father->id, ret->name, color);
+    }else{
+      pajeDefineEventType(ret->id, ret->father->id, ret->name);
+    }
+  }
+  return ret;
+}
+
+type_t getVariableType (const char *typename, const char *color, type_t father)
+{
+  type_t ret = xbt_dict_get_or_null (father->children, typename);
+  if (ret == NULL){
+    ret = newType (typename, typename, TYPE_VARIABLE, father);
+    //INFO4("VariableType %s(%s), child of %s(%s)", ret->name, ret->id, father->name, father->id);
+    if (color){
+      pajeDefineVariableTypeWithColor(ret->id, ret->father->id, ret->name, color);
+    }else{
+      pajeDefineVariableType(ret->id, ret->father->id, ret->name);
+    }
+  }
+  return ret;
+}
+
+type_t getLinkType (const char *typename, type_t father, type_t source, type_t dest)
+{
+  //FIXME should check using source and dest here and not by the typename (g5k example)
+  char key[INSTR_DEFAULT_STR_SIZE];
+  snprintf (key, INSTR_DEFAULT_STR_SIZE, "%s-%s-%s", typename, source->id, dest->id);
+  type_t ret = xbt_dict_get_or_null (father->children, key);
+  if (ret == NULL){
+    ret = newType (typename, key, TYPE_LINK, father);
+    //INFO8("LinkType %s(%s), child of %s(%s)  %s(%s)->%s(%s)", ret->name, ret->id, father->name, father->id, source->name, source->id, dest->name, dest->id);
+    pajeDefineLinkType(ret->id, ret->father->id, source->id, dest->id, ret->name);
+  }
+  return ret;
+}
+
+type_t getStateType (const char *typename, type_t father)
+{
+  type_t ret = xbt_dict_get_or_null (father->children, typename);
+  if (ret == NULL){
+    ret = newType (typename, typename, TYPE_STATE, father);
+    //INFO4("StateType %s(%s), child of %s(%s)", ret->name, ret->id, father->name, father->id);
+    pajeDefineStateType(ret->id, ret->father->id, ret->name);
+  }
+  return ret;
+}
+
+
+static long long int newContainedId ()
+{
+  static long long counter = 0;
+  return counter++;
+}
+
+container_t newContainer (const char *name, e_container_types kind, container_t father)
+{
+  long long int counter = newContainedId();
+  char id_str[INSTR_DEFAULT_STR_SIZE];
+  snprintf (id_str, INSTR_DEFAULT_STR_SIZE, "%lld", counter);
+
+  container_t new = xbt_new0(s_container_t, 1);
+  new->name = xbt_strdup (name); // name of the container
+  new->id = xbt_strdup (id_str); // id (or alias) of the container
+  new->father = father;
+  // level depends on level of father
+  if (new->father){
+    new->level = new->father->level+1;
+  }else{
+    new->level = 0;
+  }
+  // type definition (method depends on kind of this new container)
+  new->kind = kind;
+  if (new->kind == INSTR_AS){
+    //if this container is of an AS, its type name depends on its level
+    char as_typename[INSTR_DEFAULT_STR_SIZE];
+    snprintf (as_typename, INSTR_DEFAULT_STR_SIZE, "L%d", new->level);
+    if (new->father){
+      new->type = getContainerType (as_typename, new->father->type);
+    }else{
+      new->type = getContainerType ("0", NULL);
+    }
+  }else{
+    //otherwise, the name is its kind
+    switch (new->kind){
+      case INSTR_HOST: new->type = getContainerType ("HOST", new->father->type); break;
+      case INSTR_LINK: new->type = getContainerType ("LINK", new->father->type); break;
+      case INSTR_ROUTER: new->type = getContainerType ("ROUTER", new->father->type); break;
+      case INSTR_SMPI: new->type = getContainerType ("MPI", new->father->type); break;
+      case INSTR_MSG_PROCESS: new->type = getContainerType ("MSG_PROCESS", new->father->type); break;
+      case INSTR_MSG_TASK: new->type = getContainerType ("MSG_TASK", new->father->type); break;
+      default: xbt_die ("Congratulations, you have found a bug on newContainer function of instr_routing.c"); break;
+    }
+  }
+  new->children = xbt_dict_new();
+  if (new->father){
+    xbt_dict_set(new->father->children, new->name, new, NULL);
+    pajeCreateContainer (SIMIX_get_clock(), new->id, new->type->id, new->father->id, new->name);
+  }
+
+  //register hosts, routers, links containers
+  if (new->kind == INSTR_HOST || new->kind == INSTR_LINK || new->kind == INSTR_ROUTER) {
+    xbt_dict_set (allContainers, new->name, new, NULL);
+  }
+
+  //register the host container types
+  if (new->kind == INSTR_HOST){
+    xbt_dynar_push_as (allHostTypes, type_t, new->type);
+  }
+
+  //register the link container types
+  if (new->kind == INSTR_LINK){
+    xbt_dynar_push_as(allLinkTypes, type_t, new->type);
+  }
+  return new;
+}
+
+static container_t recursiveGetContainer (const char *name, container_t root)
+{
+  if (strcmp (root->name, name) == 0) return root;
+
+  xbt_dict_cursor_t cursor = NULL;
+  container_t child;
+  char *child_name;
+  xbt_dict_foreach(root->children, cursor, child_name, child) {
+    container_t ret = recursiveGetContainer(name, child);
+    if (ret) return ret;
+  }
+  return NULL;
+}
+
+container_t getContainer (const char *name)
+{
+  return recursiveGetContainer(name, rootContainer);
+}
+
+container_t getContainerByName (const char *name)
+{
+  return (container_t)xbt_dict_get (allContainers, name);
+}
+
+container_t getRootContainer ()
+{
+  return rootContainer;
+}
+
+static type_t recursiveGetType (const char *name, type_t root)
+{
+  if (strcmp (root->name, name) == 0) return root;
+
+  xbt_dict_cursor_t cursor = NULL;
+  type_t child;
+  char *child_name;
+  xbt_dict_foreach(root->children, cursor, child_name, child) {
+    type_t ret = recursiveGetType(name, child);
+    if (ret) return ret;
+  }
+  return NULL;
+}
+
+type_t getType (const char *name)
+{
+  return recursiveGetType (name, rootType);
+}
+
+void destroyContainer (container_t container)
+{
+  //remove me from my father
+  if (container->father){
+    xbt_dict_remove(container->father->children, container->name);
+  }
+
+  //trace my destruction
+  pajeDestroyContainer(SIMIX_get_clock(), container->type->id, container->id);
+
+  //free
+  xbt_free (container->name);
+  xbt_free (container->id);
+  xbt_free (container->children);
+  xbt_free (container);
+  container = NULL;
+}
+
+
+#endif /* HAVE_TRACING */

diff --git a/src/instr/instr_paje_trace.c b/src/instr/instr_paje_trace.c
index 9bb9f8a..8f5eb7d 100644 (file)
--- a/src/instr/instr_paje_trace.c
+++ b/src/instr/instr_paje_trace.c
@@ -10,7 +10,7 @@
 
 #define INSTR_PAJE_ASSERT(str) {xbt_assert1(str!=NULL&&strlen(str)>0, "'%s' is NULL or length is zero", #str);}
 
-XBT_LOG_NEW_DEFAULT_SUBCATEGORY(instr_paje, instr, "Paje tracing event system");
+XBT_LOG_NEW_DEFAULT_SUBCATEGORY(instr_paje_trace, instr, "Paje tracing event system");
 
 static FILE *tracing_file = NULL;
 

diff --git a/src/instr/instr_private.h b/src/instr/instr_private.h
index d5df639..05d2f1e 100644 (file)
--- a/src/instr/instr_private.h
+++ b/src/instr/instr_private.h
@@ -219,6 +219,10 @@ void TRACE_sd_task_destroy(SD_task_t task);
 /* instr_routing.c */
 container_t newContainer (const char *name, e_container_types kind, container_t father);
 container_t getContainer (const char *name);
+container_t getContainerByName (const char *name);
+container_t getRootContainer (void);
+void instr_paje_init (container_t root);
+type_t getRootType (void);
 type_t getContainerType (const char *name, type_t father);
 type_t getEventType (const char *name, const char *color, type_t father);
 type_t getVariableType (const char *name, const char *color, type_t father);

diff --git a/src/instr/instr_routing.c b/src/instr/instr_routing.c
index a0fef42..9c38de1 100644 (file)
--- a/src/instr/instr_routing.c
+++ b/src/instr/instr_routing.c
@@ -15,12 +15,7 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY (instr_routing, instr, "Tracing platform hierarc
 extern xbt_dict_t defined_types; /* from instr_interface.c */
 
 static int platform_created = 0;            /* indicate whether the platform file has been traced */
-static type_t rootType = NULL;              /* the root type */
-static container_t rootContainer = NULL;    /* the root container */
 static xbt_dynar_t currentContainer = NULL; /* push and pop, used only in creation */
-static xbt_dict_t allContainers = NULL;     /* all created containers indexed by name */
-xbt_dynar_t allLinkTypes = NULL;     /* all link types defined */
-xbt_dynar_t allHostTypes = NULL;     /* all host types defined */
 
 static void instr_routing_parse_start_AS (void);
 static void instr_routing_parse_end_AS (void);
@@ -32,104 +27,6 @@ static void instr_routing_parse_start_router (void);
 static void instr_routing_parse_end_router (void);
 static void instr_routing_parse_end_platform (void);
 
-static long long int newTypeId ()
-{
-  static long long int counter = 0;
-  return counter++;
-}
-
-static type_t newType (const char *typename, const char *key, e_entity_types kind, type_t father)
-{
-  type_t ret = xbt_new0(s_type_t, 1);
-  ret->name = xbt_strdup (typename);
-  ret->father = father;
-  ret->kind = kind;
-  ret->children = xbt_dict_new ();
-
-  long long int id = newTypeId();
-  char str_id[INSTR_DEFAULT_STR_SIZE];
-  snprintf (str_id, INSTR_DEFAULT_STR_SIZE, "%lld", id);
-  ret->id = xbt_strdup (str_id);
-
-  if (father != NULL){
-    xbt_dict_set (father->children, key, ret, NULL);
-  }
-  return ret;
-}
-
-type_t getContainerType (const char *typename, type_t father)
-{
-  type_t ret;
-  if (father == NULL){
-    ret = newType (typename, typename, TYPE_CONTAINER, father);
-    if (father) pajeDefineContainerType(ret->id, ret->father->id, ret->name);
-    rootType = ret;
-  }else{
-    //check if my father type already has my typename
-    ret = (type_t)xbt_dict_get_or_null (father->children, typename);
-    if (ret == NULL){
-      ret = newType (typename, typename, TYPE_CONTAINER, father);
-      pajeDefineContainerType(ret->id, ret->father->id, ret->name);
-    }
-  }
-  return ret;
-}
-
-type_t getEventType (const char *typename, const char *color, type_t father)
-{
-  type_t ret = xbt_dict_get_or_null (father->children, typename);
-  if (ret == NULL){
-    ret = newType (typename, typename, TYPE_EVENT, father);
-    //INFO4("EventType %s(%s), child of %s(%s)", ret->name, ret->id, father->name, father->id);
-    if (color){
-      pajeDefineEventTypeWithColor (ret->id, ret->father->id, ret->name, color);
-    }else{
-      pajeDefineEventType(ret->id, ret->father->id, ret->name);
-    }
-  }
-  return ret;
-}
-
-type_t getVariableType (const char *typename, const char *color, type_t father)
-{
-  type_t ret = xbt_dict_get_or_null (father->children, typename);
-  if (ret == NULL){
-    ret = newType (typename, typename, TYPE_VARIABLE, father);
-    //INFO4("VariableType %s(%s), child of %s(%s)", ret->name, ret->id, father->name, father->id);
-    if (color){
-      pajeDefineVariableTypeWithColor(ret->id, ret->father->id, ret->name, color);
-    }else{
-      pajeDefineVariableType(ret->id, ret->father->id, ret->name);
-    }
-  }
-  return ret;
-}
-
-type_t getLinkType (const char *typename, type_t father, type_t source, type_t dest)
-{
-  //FIXME should check using source and dest here and not by the typename (g5k example)
-  char key[INSTR_DEFAULT_STR_SIZE];
-  snprintf (key, INSTR_DEFAULT_STR_SIZE, "%s-%s-%s", typename, source->id, dest->id);
-  type_t ret = xbt_dict_get_or_null (father->children, key);
-  if (ret == NULL){
-    ret = newType (typename, key, TYPE_LINK, father);
-    //INFO8("LinkType %s(%s), child of %s(%s)  %s(%s)->%s(%s)", ret->name, ret->id, father->name, father->id, source->name, source->id, dest->name, dest->id);
-    pajeDefineLinkType(ret->id, ret->father->id, source->id, dest->id, ret->name);
-  }
-  return ret;
-}
-
-type_t getStateType (const char *typename, type_t father)
-{
-  type_t ret = xbt_dict_get_or_null (father->children, typename);
-  if (ret == NULL){
-    ret = newType (typename, typename, TYPE_STATE, father);
-    //INFO4("StateType %s(%s), child of %s(%s)", ret->name, ret->id, father->name, father->id);
-    pajeDefineStateType(ret->id, ret->father->id, ret->name);
-  }
-  return ret;
-}
-
 void instr_routing_define_callbacks ()
 {
   if (!TRACE_is_active())
@@ -145,130 +42,6 @@ void instr_routing_define_callbacks ()
   surfxml_add_callback(ETag_surfxml_platform_cb_list, &instr_routing_parse_end_platform);
 }
 
-static long long int newContainedId ()
-{
-  static long long counter = 0;
-  return counter++;
-}
-
-container_t newContainer (const char *name, e_container_types kind, container_t father)
-{
-  long long int counter = newContainedId();
-  char id_str[INSTR_DEFAULT_STR_SIZE];
-  snprintf (id_str, INSTR_DEFAULT_STR_SIZE, "%lld", counter);
-
-  container_t new = xbt_new0(s_container_t, 1);
-  new->name = xbt_strdup (name); // name of the container
-  new->id = xbt_strdup (id_str); // id (or alias) of the container
-  new->father = father;
-  // level depends on level of father
-  if (new->father){
-    new->level = new->father->level+1;
-  }else{
-    new->level = 0;
-  }
-  // type definition (method depends on kind of this new container)
-  new->kind = kind;
-  if (new->kind == INSTR_AS){
-    //if this container is of an AS, its type name depends on its level
-    char as_typename[INSTR_DEFAULT_STR_SIZE];
-    snprintf (as_typename, INSTR_DEFAULT_STR_SIZE, "L%d", new->level);
-    if (new->father){
-      new->type = getContainerType (as_typename, new->father->type);
-    }else{
-      new->type = getContainerType ("0", NULL);
-    }
-  }else{
-    //otherwise, the name is its kind
-    switch (new->kind){
-      case INSTR_HOST: new->type = getContainerType ("HOST", new->father->type); break;
-      case INSTR_LINK: new->type = getContainerType ("LINK", new->father->type); break;
-      case INSTR_ROUTER: new->type = getContainerType ("ROUTER", new->father->type); break;
-      case INSTR_SMPI: new->type = getContainerType ("MPI", new->father->type); break;
-      case INSTR_MSG_PROCESS: new->type = getContainerType ("MSG_PROCESS", new->father->type); break;
-      case INSTR_MSG_TASK: new->type = getContainerType ("MSG_TASK", new->father->type); break;
-      default: xbt_die ("Congratulations, you have found a bug on newContainer function of instr_routing.c"); break;
-    }
-  }
-  new->children = xbt_dict_new();
-  if (new->father){
-    xbt_dict_set(new->father->children, new->name, new, NULL);
-    pajeCreateContainer (SIMIX_get_clock(), new->id, new->type->id, new->father->id, new->name);
-  }
-
-  //register hosts, routers, links containers
-  if (new->kind == INSTR_HOST || new->kind == INSTR_LINK || new->kind == INSTR_ROUTER) {
-    xbt_dict_set (allContainers, new->name, new, NULL);
-  }
-
-  //register the host container types
-  if (new->kind == INSTR_HOST){
-    xbt_dynar_push_as (allHostTypes, type_t, new->type);
-  }
-
-  //register the link container types
-  if (new->kind == INSTR_LINK){
-    xbt_dynar_push_as(allLinkTypes, type_t, new->type);
-  }
-  return new;
-}
-
-static container_t recursiveGetContainer (const char *name, container_t root)
-{
-  if (strcmp (root->name, name) == 0) return root;
-
-  xbt_dict_cursor_t cursor = NULL;
-  container_t child;
-  char *child_name;
-  xbt_dict_foreach(root->children, cursor, child_name, child) {
-    container_t ret = recursiveGetContainer(name, child);
-    if (ret) return ret;
-  }
-  return NULL;
-}
-
-container_t getContainer (const char *name)
-{
-  return recursiveGetContainer(name, rootContainer);
-}
-
-static type_t recursiveGetType (const char *name, type_t root)
-{
-  if (strcmp (root->name, name) == 0) return root;
-
-  xbt_dict_cursor_t cursor = NULL;
-  type_t child;
-  char *child_name;
-  xbt_dict_foreach(root->children, cursor, child_name, child) {
-    type_t ret = recursiveGetType(name, child);
-    if (ret) return ret;
-  }
-  return NULL;
-}
-
-type_t getType (const char *name)
-{
-  return recursiveGetType (name, rootType);
-}
-
-void destroyContainer (container_t container)
-{
-  //remove me from my father
-  if (container->father){
-    xbt_dict_remove(container->father->children, container->name);
-  }
-
-  //trace my destruction
-  pajeDestroyContainer(SIMIX_get_clock(), container->type->id, container->id);
-
-  //free
-  xbt_free (container->name);
-  xbt_free (container->id);
-  xbt_free (container->children);
-  xbt_free (container);
-  container = NULL;
-}
-
 static container_t findChild (container_t root, container_t a1)
 {
   if (root == a1) return root;
@@ -305,13 +78,13 @@ static void linkContainers (const char *a1, const char *a2)
   if (strcmp (a1, "__loopback__") == 0 || strcmp (a2, "__loopback__") == 0)
     return;
 
-  container_t a1_container = ((container_t)xbt_dict_get (allContainers, a1));
+  container_t a1_container = getContainerByName (a1);
   type_t a1_type = a1_container->type;
 
-  container_t a2_container = ((container_t)xbt_dict_get (allContainers, a2));
+  container_t a2_container = getContainerByName (a2);
   type_t a2_type = a2_container->type;
 
-  container_t container = findCommonFather (rootContainer, a1_container, a2_container);
+  container_t container = findCommonFather (getRootContainer(), a1_container, a2_container);
   xbt_assert0 (container != NULL, "common father not found");
 
   //declare type
@@ -418,21 +191,19 @@ static void recursiveGraphExtraction (container_t container)
  */
 static void instr_routing_parse_start_AS ()
 {
-  if (rootContainer == NULL){
-    currentContainer = xbt_dynar_new (sizeof(container_t), NULL);
-    allContainers = xbt_dict_new ();
-    allLinkTypes = xbt_dynar_new (sizeof(s_type_t), NULL);
-    allHostTypes = xbt_dynar_new (sizeof(s_type_t), NULL);
+  if (getRootContainer() == NULL){
+    container_t root = newContainer ("0", INSTR_AS, NULL);
+    instr_paje_init (root);
 
-    rootContainer = newContainer ("0", INSTR_AS, NULL);
-    xbt_dynar_push (currentContainer, &rootContainer);
+    currentContainer = xbt_dynar_new (sizeof(container_t), NULL);
+    xbt_dynar_push (currentContainer, &root);
 
     if (TRACE_smpi_is_enabled()) {
       if (!TRACE_smpi_is_grouped()){
         container_t father = *(container_t*)xbt_dynar_get_ptr(currentContainer, xbt_dynar_length(currentContainer)-1);
         type_t mpi = getContainerType("MPI", father->type);
         getStateType ("MPI_STATE", mpi);
-        getLinkType ("MPI_LINK", rootType, mpi, mpi);
+        getLinkType ("MPI_LINK", getRootType(), mpi, mpi);
       }
     }
   }
@@ -481,20 +252,20 @@ static void instr_routing_parse_start_host ()
     if (TRACE_smpi_is_grouped()){
       type_t mpi = getContainerType("MPI", new->type);
       getStateType ("MPI_STATE", mpi);
-      getLinkType ("MPI_LINK", rootType, mpi, mpi);
+      getLinkType ("MPI_LINK", getRootType(), mpi, mpi);
     }
   }
 
   if (TRACE_msg_process_is_enabled()) {
     type_t msg_process = getContainerType("MSG_PROCESS", new->type);
     getStateType ("MSG_PROCESS_STATE", msg_process);
-    getLinkType ("MSG_PROCESS_LINK", rootType, msg_process, msg_process);
+    getLinkType ("MSG_PROCESS_LINK", getRootType(), msg_process, msg_process);
   }
 
   if (TRACE_msg_task_is_enabled()) {
     type_t msg_task = getContainerType ("MSG_TASK", new->type);
     getStateType ("MSG_TASK_STATE", msg_task);
-    getLinkType ("MSG_TASK_LINK", rootType, msg_task, msg_task);
+    getLinkType ("MSG_TASK_LINK", getRootType(), msg_task, msg_task);
   }
 }
 
@@ -516,7 +287,7 @@ static void instr_routing_parse_end_platform ()
 {
   xbt_dynar_free(&currentContainer);
   currentContainer = NULL;
-  recursiveGraphExtraction (rootContainer);
+  recursiveGraphExtraction (getRootContainer());
   platform_created = 1;
 }
 
@@ -525,7 +296,7 @@ static void instr_routing_parse_end_platform ()
  */
 int instr_link_is_traced (const char *name)
 {
-  if (((container_t)xbt_dict_get_or_null (allContainers, name))){
+  if (getContainerByName(name)){
     return 1;
   } else {
     return 0;
@@ -534,7 +305,7 @@ int instr_link_is_traced (const char *name)
 
 char *instr_variable_type (const char *name, const char *resource)
 {
-  container_t container = (container_t)xbt_dict_get (allContainers, resource);
+  container_t container = getContainerByName(resource);
   xbt_dict_cursor_t cursor = NULL;
   type_t type;
   char *type_name;
@@ -546,7 +317,7 @@ char *instr_variable_type (const char *name, const char *resource)
 
 char *instr_resource_type (const char *resource_name)
 {
-  return ((container_t)xbt_dict_get_or_null (allContainers, resource_name))->id;
+  return getContainerByName(resource_name)->id;
 }
 
 static void recursiveDestroyContainer (container_t container)
@@ -577,8 +348,8 @@ static void recursiveDestroyType (type_t type)
 
 void instr_destroy_platform ()
 {
-  if (rootContainer) recursiveDestroyContainer (rootContainer);
-  if (rootType) recursiveDestroyType (rootType);
+  if (getRootContainer()) recursiveDestroyContainer (getRootContainer());
+  if (getRootType()) recursiveDestroyType (getRootType());
 }
 
 /*
@@ -599,7 +370,7 @@ static void recursiveNewUserVariableType (const char *new_typename, const char *
 
 void instr_new_user_variable_type (const char *new_typename, const char *color)
 {
-  recursiveNewUserVariableType (new_typename, color, rootType);
+  recursiveNewUserVariableType (new_typename, color, getRootType());
 }
 
 static void recursiveNewUserLinkVariableType (const char *new_typename, const char *color, type_t root)
@@ -617,7 +388,7 @@ static void recursiveNewUserLinkVariableType (const char *new_typename, const ch
 
 void instr_new_user_link_variable_type  (const char *new_typename, const char *color)
 {
-  recursiveNewUserLinkVariableType (new_typename, color, rootType);
+  recursiveNewUserLinkVariableType (new_typename, color, getRootType());
 }
 
 
@@ -636,7 +407,7 @@ static void recursiveNewUserHostVariableType (const char *new_typename, const ch
 
 void instr_new_user_host_variable_type  (const char *new_typename, const char *color)
 {
-  recursiveNewUserHostVariableType (new_typename, color, rootType);
+  recursiveNewUserHostVariableType (new_typename, color, getRootType());
 }
 
 int instr_platform_traced ()