[trace] changing the interface to write on the tracing file

details:
- this is a first step towards event buffering and friends

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

diff --git a/src/instr/instr_interface.c b/src/instr/instr_interface.c
index ee767b7..34d03af 100644 (file)
--- a/src/instr/instr_interface.c
+++ b/src/instr/instr_interface.c
@@ -72,7 +72,7 @@ void TRACE_declare_mark(const char *mark_type)
     return;
 
   DEBUG1("MARK,declare %s", mark_type);
     return;
 
   DEBUG1("MARK,declare %s", mark_type);

-  pajeDefineEventType(mark_type, "0", mark_type);
+  getEventType(mark_type, NULL, getRootType());

 }
 
 void TRACE_mark(const char *mark_type, const char *mark_value)
 }
 
 void TRACE_mark(const char *mark_type, const char *mark_value)


@@ -83,7 +83,8 @@ void TRACE_mark(const char *mark_type, const char *mark_value)
     return;
 
   DEBUG2("MARK %s %s", mark_type, mark_value);
     return;
 
   DEBUG2("MARK %s %s", mark_type, mark_value);

-  pajeNewEvent(MSG_get_clock(), mark_type, "0", mark_value);
+  type_t type = getEventType (mark_type, NULL, getRootContainer()->type);
+  new_pajeNewEvent (MSG_get_clock(), getRootContainer(), type, mark_value);

 }
 
 
 }
 
 


@@ -103,14 +104,14 @@ void TRACE_user_link_variable(double time, const char *resource,
   if (strcmp(what, "declare") == 0) {
     instr_new_user_link_variable_type (variable, NULL);
   } else{
   if (strcmp(what, "declare") == 0) {
     instr_new_user_link_variable_type (variable, NULL);
   } else{

-    char *variable_id = getVariableTypeIdByName(variable, getContainerByName(resource)->type);
-    char *resource_id = getContainerIdByName(resource);
+    container_t container = getContainerByName (resource);
+    type_t type = getVariableType (variable, NULL, container->type);

     if (strcmp(what, "set") == 0) {
     if (strcmp(what, "set") == 0) {

-      pajeSetVariable(time, variable_id, resource_id, valuestr);
+      new_pajeSetVariable(time, container, type, value);

     } else if (strcmp(what, "add") == 0) {
     } else if (strcmp(what, "add") == 0) {

-      pajeAddVariable(time, variable_id, resource_id, valuestr);
+      new_pajeAddVariable(time, container, type, value);

     } else if (strcmp(what, "sub") == 0) {
     } else if (strcmp(what, "sub") == 0) {

-      pajeSubVariable(time, variable_id, resource_id, valuestr);
+      new_pajeSubVariable(time, container, type, value);

     }
   }
 }
     }
   }
 }


@@ -131,17 +132,16 @@ void TRACE_user_host_variable(double time, const char *variable,
     instr_new_user_host_variable_type (variable, NULL);
   } else{
     char *host_name = MSG_host_self()->name;
     instr_new_user_host_variable_type (variable, NULL);
   } else{
     char *host_name = MSG_host_self()->name;

-    char *variable_id = getVariableTypeIdByName(variable, getContainerByName(host_name)->type);
-    char *resource_id = getContainerIdByName(host_name);
+    container_t container = getContainerByName(host_name);
+    type_t type = getVariableType (variable, NULL, container->type);

     if (strcmp(what, "set") == 0) {
     if (strcmp(what, "set") == 0) {

-      pajeSetVariable(time, variable_id, resource_id, valuestr);
+      new_pajeSetVariable(time, container, type, value);

     } else if (strcmp(what, "add") == 0) {
     } else if (strcmp(what, "add") == 0) {

-      pajeAddVariable(time, variable_id, resource_id, valuestr);
+      new_pajeAddVariable(time, container, type, value);

     } else if (strcmp(what, "sub") == 0) {
     } else if (strcmp(what, "sub") == 0) {

-      pajeSubVariable(time, variable_id, resource_id, valuestr);
+      new_pajeSubVariable(time, container, type, value);

     }
   }
 }
 
     }
   }
 }
 

-

 #endif /* HAVE_TRACING */
 #endif /* HAVE_TRACING */

diff --git a/src/instr/instr_msg_process.c b/src/instr/instr_msg_process.c
index f5f2213..a6e1a95 100644 (file)
--- a/src/instr/instr_msg_process.c
+++ b/src/instr/instr_msg_process.c
@@ -46,10 +46,10 @@ void TRACE_msg_set_process_category(m_process_t process, const char *category, c
   if (!type){
     type = getVariableType(category, color, msg->type);
   }
   if (!type){
     type = getVariableType(category, color, msg->type);
   }

-  pajeSetVariable(SIMIX_get_clock(), type->id, msg->id, "1");
+  new_pajeSetVariable (SIMIX_get_clock(), msg, type, 1);

 
   type = getType ("MSG_PROCESS_STATE");
 
   type = getType ("MSG_PROCESS_STATE");

-  pajeSetState (MSG_get_clock(), type->id, msg->id, "executing");
+  new_pajeSetState (MSG_get_clock(), msg, type, "executing");

 }
 
 /*
 }
 
 /*


@@ -68,7 +68,7 @@ void TRACE_msg_process_change_host(m_process_t process, m_host_t old_host, m_hos
   //start link
   container_t msg = getContainer(process->name);
   type_t type = getType ("MSG_PROCESS_LINK");
   //start link
   container_t msg = getContainer(process->name);
   type_t type = getType ("MSG_PROCESS_LINK");

-  pajeStartLink (MSG_get_clock(), type->id, "0", "M", msg->id, key);
+  new_pajeStartLink (MSG_get_clock(), getRootContainer(), type, msg, "M", key);

 
   //destroy existing container of this process
   destroyContainer(getContainer(process->name));
 
   //destroy existing container of this process
   destroyContainer(getContainer(process->name));


@@ -76,12 +76,12 @@ void TRACE_msg_process_change_host(m_process_t process, m_host_t old_host, m_hos
   //create new container on the new_host location
   msg = newContainer(process->name, INSTR_MSG_PROCESS, getContainer(new_host->name));
   type = getType (process->category);
   //create new container on the new_host location
   msg = newContainer(process->name, INSTR_MSG_PROCESS, getContainer(new_host->name));
   type = getType (process->category);

-  pajeSetVariable(SIMIX_get_clock(), type->id, msg->id, "1");
+  new_pajeSetVariable (MSG_get_clock(), msg, type, 1);

 
   //end link
   msg = getContainer(process->name);
   type = getType ("MSG_PROCESS_LINK");
 
   //end link
   msg = getContainer(process->name);
   type = getType ("MSG_PROCESS_LINK");

-  pajeEndLink (MSG_get_clock(), type->id, "0", "M", msg->id, key);
+  new_pajeEndLink (MSG_get_clock(), getRootContainer(), type, msg, "M", key);

 }
 
 void TRACE_msg_process_kill(m_process_t process)
 }
 
 void TRACE_msg_process_kill(m_process_t process)


@@ -102,7 +102,7 @@ void TRACE_msg_process_suspend(m_process_t process)
 
   container_t process_container = getContainer (process->name);
   type_t type = getType ("MSG_PROCESS_STATE");
 
   container_t process_container = getContainer (process->name);
   type_t type = getType ("MSG_PROCESS_STATE");

-  pajePushState (MSG_get_clock(), type->id, process_container->id, "suspend");
+  new_pajePushState (MSG_get_clock(), process_container, type, "suspend");

 }
 
 void TRACE_msg_process_resume(m_process_t process)
 }
 
 void TRACE_msg_process_resume(m_process_t process)


@@ -113,7 +113,7 @@ void TRACE_msg_process_resume(m_process_t process)
 
   container_t process_container = getContainer (process->name);
   type_t type = getType ("MSG_PROCESS_STATE");
 
   container_t process_container = getContainer (process->name);
   type_t type = getType ("MSG_PROCESS_STATE");

-  pajePopState (MSG_get_clock(), type->id, process_container->id);
+  new_pajePopState (MSG_get_clock(), process_container, type);

 }
 
 void TRACE_msg_process_sleep_in(m_process_t process)
 }
 
 void TRACE_msg_process_sleep_in(m_process_t process)


@@ -124,7 +124,7 @@ void TRACE_msg_process_sleep_in(m_process_t process)
 
   container_t process_container = getContainer (process->name);
   type_t type = getType ("MSG_PROCESS_STATE");
 
   container_t process_container = getContainer (process->name);
   type_t type = getType ("MSG_PROCESS_STATE");

-  pajePushState (MSG_get_clock(), type->id, process_container->id, "sleep");
+  new_pajePushState (MSG_get_clock(), process_container, type, "sleep");

 }
 
 void TRACE_msg_process_sleep_out(m_process_t process)
 }
 
 void TRACE_msg_process_sleep_out(m_process_t process)


@@ -135,7 +135,7 @@ void TRACE_msg_process_sleep_out(m_process_t process)
 
   container_t process_container = getContainer (process->name);
   type_t type = getType ("MSG_PROCESS_STATE");
 
   container_t process_container = getContainer (process->name);
   type_t type = getType ("MSG_PROCESS_STATE");

-  pajePopState (MSG_get_clock(), type->id, process_container->id);
+  new_pajePopState (MSG_get_clock(), process_container, type);

 }
 
 void TRACE_msg_process_end(m_process_t process)
 }
 
 void TRACE_msg_process_end(m_process_t process)

diff --git a/src/instr/instr_msg_task.c b/src/instr/instr_msg_task.c
index 73018af..5155dfb 100644 (file)
--- a/src/instr/instr_msg_task.c
+++ b/src/instr/instr_msg_task.c
@@ -56,10 +56,10 @@ void TRACE_msg_set_task_category(m_task_t task, const char *category)
     if (!type){
       type = getVariableType(task->category, NULL, msg->type);
     }
     if (!type){
       type = getVariableType(task->category, NULL, msg->type);
     }

-    pajeSetVariable(SIMIX_get_clock(), type->id, msg->id, "1");
+    new_pajeSetVariable (SIMIX_get_clock(), msg, type, 1);

 
     type = getType ("MSG_TASK_STATE");
 
     type = getType ("MSG_TASK_STATE");

-    pajePushState (MSG_get_clock(), type->id, msg->id, "created");
+    new_pajePushState (MSG_get_clock(), msg, type, "created");

 
     xbt_dict_set (tasks_created, task->name, xbt_strdup("1"), xbt_free);
   }
 
     xbt_dict_set (tasks_created, task->name, xbt_strdup("1"), xbt_free);
   }


@@ -85,7 +85,7 @@ void TRACE_msg_task_execute_start(m_task_t task)
 
   container_t task_container = getContainer (task->name);
   type_t type = getType ("MSG_TASK_STATE");
 
   container_t task_container = getContainer (task->name);
   type_t type = getType ("MSG_TASK_STATE");

-  pajePushState (MSG_get_clock(), type->id, task_container->id, "MSG_task_execute");
+  new_pajePushState (MSG_get_clock(), task_container, type, "MSG_task_execute");

 }
 
 void TRACE_msg_task_execute_end(m_task_t task)
 }
 
 void TRACE_msg_task_execute_end(m_task_t task)


@@ -98,7 +98,7 @@ void TRACE_msg_task_execute_end(m_task_t task)
 
   container_t task_container = getContainer (task->name);
   type_t type = getType ("MSG_TASK_STATE");
 
   container_t task_container = getContainer (task->name);
   type_t type = getType ("MSG_TASK_STATE");

-  pajePopState (MSG_get_clock(), type->id, task_container->id);
+  new_pajePopState (MSG_get_clock(), task_container, type);

 }
 
 /* MSG_task_destroy related functions */
 }
 
 /* MSG_task_destroy related functions */


@@ -148,15 +148,15 @@ void TRACE_msg_task_get_end(double start_time, m_task_t task)
   container_t host_container = getContainer(host->name);
   container_t msg = newContainer(task->name, INSTR_MSG_TASK, host_container);
   type_t type = getType (task->category);
   container_t host_container = getContainer(host->name);
   container_t msg = newContainer(task->name, INSTR_MSG_TASK, host_container);
   type_t type = getType (task->category);

-  pajeSetVariable(SIMIX_get_clock(), type->id, msg->id, "1");
+  new_pajeSetVariable (SIMIX_get_clock(), msg, type, 1);

 
   type = getType ("MSG_TASK_STATE");
 
   type = getType ("MSG_TASK_STATE");

-  pajePushState (MSG_get_clock(), type->id, msg->id, "created");
+  new_pajePushState (MSG_get_clock(), msg, type, "created");

 
   type = getType ("MSG_TASK_LINK");
   char key[INSTR_DEFAULT_STR_SIZE];
   snprintf (key, INSTR_DEFAULT_STR_SIZE, "%lld", task->counter);
 
   type = getType ("MSG_TASK_LINK");
   char key[INSTR_DEFAULT_STR_SIZE];
   snprintf (key, INSTR_DEFAULT_STR_SIZE, "%lld", task->counter);

-  pajeEndLink(MSG_get_clock(), type->id, "0", "SR", msg->id, key);
+  new_pajeEndLink (MSG_get_clock(), getRootContainer(), type, msg, "SR", key);

 }
 
 /* MSG_task_put related functions */
 }
 
 /* MSG_task_put related functions */


@@ -170,12 +170,12 @@ int TRACE_msg_task_put_start(m_task_t task)
 
   container_t msg = getContainer (task->name);
   type_t type = getType ("MSG_TASK_STATE");
 
   container_t msg = getContainer (task->name);
   type_t type = getType ("MSG_TASK_STATE");

-  pajePopState (MSG_get_clock(), type->id, msg->id);
+  new_pajePopState (MSG_get_clock(), msg, type);

 
   type = getType ("MSG_TASK_LINK");
   char key[INSTR_DEFAULT_STR_SIZE];
   snprintf (key, INSTR_DEFAULT_STR_SIZE, "%lld", task->counter);
 
   type = getType ("MSG_TASK_LINK");
   char key[INSTR_DEFAULT_STR_SIZE];
   snprintf (key, INSTR_DEFAULT_STR_SIZE, "%lld", task->counter);

-  pajeStartLink(MSG_get_clock(), type->id, "0", "SR", msg->id, key);
+  new_pajeStartLink(MSG_get_clock(), getRootContainer(), type, msg, "SR", key);

 
   destroyContainer (msg);
 
 
   destroyContainer (msg);
 

diff --git a/src/instr/instr_paje.c b/src/instr/instr_paje.c
index f8ce9de..39f1510 100644 (file)
--- a/src/instr/instr_paje.c
+++ b/src/instr/instr_paje.c
@@ -59,14 +59,14 @@ type_t getContainerType (const char *typename, type_t father)
   type_t ret;
   if (father == NULL){
     ret = newType (typename, typename, TYPE_CONTAINER, father);
   type_t ret;
   if (father == NULL){
     ret = newType (typename, typename, TYPE_CONTAINER, father);

-    if (father) pajeDefineContainerType(ret->id, ret->father->id, ret->name);
+    if (father) new_pajeDefineContainerType (ret);

     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);
     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);
+      new_pajeDefineContainerType (ret);

     }
   }
   return ret;
     }
   }
   return ret;


@@ -77,12 +77,9 @@ 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);
   type_t ret = xbt_dict_get_or_null (father->children, typename);
   if (ret == NULL){
     ret = newType (typename, typename, TYPE_EVENT, father);

+    ret->color = xbt_strdup (color);

     //INFO4("EventType %s(%s), child of %s(%s)", ret->name, ret->id, father->name, father->id);
     //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);
-    }
+    new_pajeDefineEventType(ret);

   }
   return ret;
 }
   }
   return ret;
 }


@@ -92,12 +89,9 @@ 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);
   type_t ret = xbt_dict_get_or_null (father->children, typename);
   if (ret == NULL){
     ret = newType (typename, typename, TYPE_VARIABLE, father);

+    ret->color = xbt_strdup (color);

     //INFO4("VariableType %s(%s), child of %s(%s)", ret->name, ret->id, father->name, father->id);
     //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);
-    }
+    new_pajeDefineVariableType (ret);

   }
   return ret;
 }
   }
   return ret;
 }


@@ -121,7 +115,7 @@ type_t getLinkType (const char *typename, type_t father, type_t source, type_t d
   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);
   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);
+    new_pajeDefineLinkType(ret, source, dest);

   }
   return ret;
 }
   }
   return ret;
 }


@@ -132,7 +126,7 @@ type_t getStateType (const char *typename, type_t father)
   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);
   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);
+    new_pajeDefineStateType(ret);

   }
   return ret;
 }
   }
   return ret;
 }


@@ -186,7 +180,7 @@ container_t newContainer (const char *name, e_container_types kind, container_t
   new->children = xbt_dict_new();
   if (new->father){
     xbt_dict_set(new->father->children, new->name, new, NULL);
   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);
+    new_pajeCreateContainer (new);

   }
 
   //register hosts, routers, links containers
   }
 
   //register hosts, routers, links containers


@@ -260,7 +254,7 @@ void destroyContainer (container_t container)
   }
 
   //trace my destruction
   }
 
   //trace my destruction

-  pajeDestroyContainer(SIMIX_get_clock(), container->type->id, container->id);
+  new_pajeDestroyContainer(container);

 
   //free
   xbt_free (container->name);
 
   //free
   xbt_free (container->name);

diff --git a/src/instr/instr_paje_trace.c b/src/instr/instr_paje_trace.c
index 8f5eb7d..33b3a05 100644 (file)
--- a/src/instr/instr_paje_trace.c
+++ b/src/instr/instr_paje_trace.c
@@ -12,6 +12,150 @@
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(instr_paje_trace, instr, "Paje tracing event system");
 
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(instr_paje_trace, instr, "Paje tracing event system");
 

+typedef struct paje_event *paje_event_t;
+typedef struct paje_event {
+  char *name;
+  char *header;
+  unsigned int id;
+  double timestamp;
+} s_paje_event_t;
+
+typedef struct s_defineContainerType *defineContainerType_t;
+typedef struct s_defineContainerType {
+  s_paje_event_t event;
+  type_t type;
+  void (*print) (defineContainerType_t event);
+}s_defineContainerType_t;
+
+typedef struct s_defineVariableType *defineVariableType_t;
+typedef struct s_defineVariableType {
+  s_paje_event_t event;
+  type_t type;
+  void (*print) (defineVariableType_t event);
+}s_defineVariableType_t;
+
+typedef struct s_defineStateType *defineStateType_t;
+typedef struct s_defineStateType {
+  s_paje_event_t event;
+  type_t type;
+  void (*print) (defineStateType_t event);
+}s_defineStateType_t;
+
+typedef struct s_defineEventType *defineEventType_t;
+typedef struct s_defineEventType {
+  s_paje_event_t event;
+  type_t type;
+  void (*print) (defineEventType_t event);
+}s_defineEventType_t;
+
+typedef struct s_defineLinkType *defineLinkType_t;
+typedef struct s_defineLinkType {
+  s_paje_event_t event;
+  type_t type;
+  type_t source;
+  type_t dest;
+  void (*print) (defineLinkType_t event);
+}s_defineLinkType_t;
+
+typedef struct s_createContainer *createContainer_t;
+typedef struct s_createContainer {
+  s_paje_event_t event;
+  container_t container;
+  void (*print) (createContainer_t event);
+}s_createContainer_t;
+
+typedef struct s_destroyContainer *destroyContainer_t;
+typedef struct s_destroyContainer {
+  s_paje_event_t event;
+  container_t container;
+  void (*print) (destroyContainer_t event);
+}s_destroyContainer_t;
+
+typedef struct s_setVariable *setVariable_t;
+typedef struct s_setVariable {
+  s_paje_event_t event;
+  container_t container;
+  type_t type;
+  double value;
+  void (*print) (setVariable_t event);
+}s_setVariable_t;
+
+typedef struct s_addVariable *addVariable_t;
+typedef struct s_addVariable {
+  s_paje_event_t event;
+  container_t container;
+  type_t type;
+  double value;
+  void (*print) (addVariable_t event);
+}s_addVariable_t;
+
+typedef struct s_subVariable *subVariable_t;
+typedef struct s_subVariable {
+  s_paje_event_t event;
+  container_t container;
+  type_t type;
+  double value;
+  void (*print) (subVariable_t event);
+}s_subVariable_t;
+
+typedef struct s_setState *setState_t;
+typedef struct s_setState {
+  s_paje_event_t event;
+  container_t container;
+  type_t type;
+  char *value;
+  void (*print) (setState_t event);
+}s_setState_t;
+
+typedef struct s_pushState *pushState_t;
+typedef struct s_pushState {
+  s_paje_event_t event;
+  container_t container;
+  type_t type;
+  char *value;
+  void (*print) (pushState_t event);
+}s_pushState_t;
+
+typedef struct s_popState *popState_t;
+typedef struct s_popState {
+  s_paje_event_t event;
+  container_t container;
+  type_t type;
+  char *value;
+  void (*print) (popState_t event);
+}s_popState_t;
+
+typedef struct s_startLink *startLink_t;
+typedef struct s_startLink {
+  s_paje_event_t event;
+  type_t type;
+  container_t container;
+  container_t sourceContainer;
+  char *value;
+  char *key;
+  void (*print) (startLink_t event);
+}s_startLink_t;
+
+typedef struct s_endLink *endLink_t;
+typedef struct s_endLink {
+  s_paje_event_t event;
+  type_t type;
+  container_t container;
+  container_t destContainer;
+  char *value;
+  char *key;
+  void (*print) (endLink_t event);
+}s_endLink_t;
+
+typedef struct s_newEvent *newEvent_t;
+typedef struct s_newEvent {
+  s_paje_event_t event;
+  type_t type;
+  container_t container;
+  char *value;
+  void (*print) (newEvent_t event);
+}s_newEvent_t;
+

 static FILE *tracing_file = NULL;
 
 static int pajeDefineContainerTypeId = 0;
 static FILE *tracing_file = NULL;
 
 static int pajeDefineContainerTypeId = 0;


@@ -40,7 +184,7 @@ static int pajeSetVariableId = 22;
 static int pajeAddVariableId = 23;
 static int pajeSubVariableId = 24;
 static int pajeDefineVariableTypeId = 25;
 static int pajeAddVariableId = 23;
 static int pajeSubVariableId = 24;
 static int pajeDefineVariableTypeId = 25;

-static int pajeStartLinkWithVolumeId = 26;
+#define UNUSED001 26

 static int pajeNewEventId = 27;
 
 #define TRACE_LINE_SIZE 1000
 static int pajeNewEventId = 27;
 
 #define TRACE_LINE_SIZE 1000


@@ -175,331 +319,637 @@ void TRACE_paje_create_header(void)
 %%       Name string \n\
 %%       Color color \n\
 %%EndEventDef \n\
 %%       Name string \n\
 %%       Color color \n\
 %%EndEventDef \n\

-%%EventDef PajeStartLink %d \n\
-%%       Time date \n\
-%%       EntityType string \n\
-%%       Container string \n\
-%%       Value string \n\
-%%       SourceContainer string \n\
-%%       Key string \n\
-%%       Volume string \n\
-%%EndEventDef\n\

 %%EventDef PajeNewEvent %d \n\
 %%       Time date \n\
 %%       EntityType string \n\
 %%       Container string \n\
 %%       Value string \n\
 %%EventDef PajeNewEvent %d \n\
 %%       Time date \n\
 %%       EntityType string \n\
 %%       Container string \n\
 %%       Value string \n\

-%%EndEventDef\n", pajeDefineContainerTypeId, pajeDefineStateTypeId, pajeDefineEntityValueId, pajeDefineEventTypeWithColorId, pajeDefineEventTypeId, pajeDefineLinkTypeId, pajeCreateContainerId, pajeDestroyContainerId, pajeSetStateId, pajePopStateId, pajeStartLinkId, pajeEndLinkId, pajePushStateId, pajeSetVariableId, pajeAddVariableId, pajeSubVariableId, pajeDefineVariableTypeId, pajeDefineVariableTypeWithColorId, pajeStartLinkWithVolumeId, pajeNewEventId);
+%%EndEventDef\n", pajeDefineContainerTypeId, pajeDefineStateTypeId, pajeDefineEntityValueId, pajeDefineEventTypeWithColorId, pajeDefineEventTypeId, pajeDefineLinkTypeId, pajeCreateContainerId, pajeDestroyContainerId, pajeSetStateId, pajePopStateId, pajeStartLinkId, pajeEndLinkId, pajePushStateId, pajeSetVariableId, pajeAddVariableId, pajeSubVariableId, pajeDefineVariableTypeId, pajeDefineVariableTypeWithColorId, pajeNewEventId);
+}
+
+/* internal do the instrumentation module */
+static void print_pajeDefineContainerType(defineContainerType_t event)
+{
+  fprintf(tracing_file, "%d %s %s %s\n",
+      event->event.id,
+      event->type->id,
+      event->type->father->id,
+      event->type->name);
+}
+
+static void print_pajeDefineVariableType(defineVariableType_t event)
+{
+  fprintf(tracing_file, "%d %s %s %s \"%s\"\n",
+      event->event.id,
+      event->type->id,
+      event->type->father->id,
+      event->type->name,
+      event->type->color);
+}
+
+static void print_pajeDefineStateType(defineStateType_t event)
+{
+  fprintf(tracing_file, "%d %s %s %s\n",
+      event->event.id,
+      event->type->id,
+      event->type->father->id,
+      event->type->name);
+}
+
+static void print_pajeDefineEventType(defineEventType_t event)
+{
+  fprintf(tracing_file, "%d %s %s %s \"%s\"\n",
+      event->event.id,
+      event->type->id,
+      event->type->father->id,
+      event->type->name,
+      event->type->color);

 }
 
 }
 

-/* internal to this file */
-static void __pajeCreateContainer(char *output, int len, int eventid,
-                                  double time, const char *alias,
-                                  const char *type, const char *container,
-                                  const char *name)
+static void print_pajeDefineLinkType(defineLinkType_t event)

 {
 {

-  if (time == 0){
-    snprintf(output, len, "%d 0 %s %s %s %s", eventid,
-           alias, type, container, name);
+  fprintf(tracing_file, "%d %s %s %s %s %s\n",
+      event->event.id,
+      event->type->id,
+      event->type->father->id,
+      event->source->id,
+      event->dest->id,
+      event->type->name);
+}
+
+static void print_pajeCreateContainer(createContainer_t event)
+{
+  if (event->event.timestamp == 0){
+    fprintf(tracing_file, "%d 0 %s %s %s %s\n",
+        event->event.id,
+        event->container->id,
+        event->container->type->id,
+        event->container->father->id,
+        event->container->name);

   }else{
   }else{

-    snprintf(output, len, "%d %lf %s %s %s %s", eventid, time,
-           alias, type, container, name);
+    fprintf(tracing_file, "%d %lf %s %s %s %s\n",
+        event->event.id,
+        event->event.timestamp,
+        event->container->id,
+        event->container->type->id,
+        event->container->father->id,
+        event->container->name);

   }
 }
 
   }
 }
 

-static void __pajeSetState(char *output, int len, int eventid, double time,
-                           const char *entityType, const char *container,
-                           const char *value)
+static void print_pajeDestroyContainer(destroyContainer_t event)

 {
 {

-  if (time == 0){
-    snprintf(output, len, "%d 0 %s %s %s", eventid, entityType,
-           container, value);
+  if (event->event.timestamp == 0){
+    fprintf(tracing_file, "%d 0 %s %s\n",
+        event->event.id,
+        event->container->type->id,
+        event->container->id);

   }else{
   }else{

-    snprintf(output, len, "%d %lf %s %s %s", eventid, time, entityType,
-           container, value);
+    fprintf(tracing_file, "%d %lf %s %s\n",
+        event->event.id,
+        event->event.timestamp,
+        event->container->type->id,
+        event->container->id);

   }
 }
 
   }
 }
 

-static void __pajeSetVariable(char *output, int len, int eventid,
-                              double time, const char *entityType,
-                              const char *container, const char *value)
+static void print_pajeSetVariable(setVariable_t event)

 {
 {

-  if (time == 0){
-    snprintf(output, len, "%d 0 %s %s %s", eventid, entityType,
-           container, value);
+  if (event->event.timestamp == 0){
+    fprintf(tracing_file, "%d 0 %s %s %f\n",
+        event->event.id,
+        event->type->id,
+        event->container->id,
+        event->value);

   }else{
   }else{

-    snprintf(output, len, "%d %lf %s %s %s", eventid, time, entityType,
-           container, value);
+    fprintf(tracing_file, "%d %lf %s %s %f\n",
+        event->event.id,
+        event->event.timestamp,
+        event->type->id,
+        event->container->id,
+        event->value);

   }
 }
 
   }
 }
 

-static void __pajeStartLink(char *output, int len, int eventid,
-                            double time, const char *entityType,
-                            const char *container, const char *value,
-                            const char *sourceContainer, const char *key)
+static void print_pajeAddVariable(addVariable_t event)

 {
 {

-  if (time == 0){
-    snprintf(output, len, "%d 0 %s %s %s %s %s", eventid, entityType,
-           container, value, sourceContainer, key);
+  if (event->event.timestamp == 0){
+    fprintf(tracing_file, "%d 0 %s %s %f\n",
+        event->event.id,
+        event->type->id,
+        event->container->id,
+        event->value);

   }else{
   }else{

-    snprintf(output, len, "%d %lf %s %s %s %s %s", eventid, time, entityType,
-           container, value, sourceContainer, key);
+    fprintf(tracing_file, "%d %lf %s %s %f\n",
+        event->event.id,
+        event->event.timestamp,
+        event->type->id,
+        event->container->id,
+        event->value);

   }
 }
 
   }
 }
 

-/* internal do the instrumentation module */
-void pajeDefineContainerType(const char *alias, const char *containerType,
-                             const char *name)
+static void print_pajeSubVariable(subVariable_t event)

 {
 {

-  INSTR_PAJE_ASSERT(alias);
-  INSTR_PAJE_ASSERT(containerType);
-  INSTR_PAJE_ASSERT(name);
-
-  fprintf(tracing_file, "%d %s %s %s\n", pajeDefineContainerTypeId, alias,
-          containerType, name);
+  if (event->event.timestamp == 0){
+    fprintf(tracing_file, "%d 0 %s %s %f\n",
+        event->event.id,
+        event->type->id,
+        event->container->id,
+        event->value);
+  }else{
+    fprintf(tracing_file, "%d %lf %s %s %f\n",
+        event->event.id,
+        event->event.timestamp,
+        event->type->id,
+        event->container->id,
+        event->value);
+  }

 }
 
 }
 

-void pajeDefineStateType(const char *alias, const char *containerType,
-                         const char *name)
+static void print_pajeSetState(setState_t event)

 {
 {

-  INSTR_PAJE_ASSERT(alias);
-  INSTR_PAJE_ASSERT(containerType);
-  INSTR_PAJE_ASSERT(name);
-
-  fprintf(tracing_file, "%d %s %s %s\n", pajeDefineStateTypeId, alias,
-          containerType, name);
+  if (event->event.timestamp == 0){
+    fprintf(tracing_file, "%d 0 %s %s %s\n",
+        event->event.id,
+        event->type->id,
+        event->container->id,
+        event->value);
+  }else{
+    fprintf(tracing_file, "%d %lf %s %s %s\n",
+        event->event.id,
+        event->event.timestamp,
+        event->type->id,
+        event->container->id,
+        event->value);
+  }

 }
 
 }
 

-void pajeDefineEventTypeWithColor(const char *alias, const char *containerType,
-                         const char *name, const char *color)
+static void print_pajePushState(pushState_t event)

 {
 {

-  INSTR_PAJE_ASSERT(alias);
-  INSTR_PAJE_ASSERT(containerType);
-  INSTR_PAJE_ASSERT(name);
-  INSTR_PAJE_ASSERT(name);
-
-  fprintf(tracing_file, "%d %s %s %s %s\n", pajeDefineEventTypeWithColorId, alias,
-          containerType, name, color);
+  if (event->event.timestamp == 0){
+    fprintf(tracing_file, "%d 0 %s %s %s\n",
+        event->event.id,
+        event->type->id,
+        event->container->id,
+        event->value);
+  }else{
+    fprintf(tracing_file, "%d %lf %s %s %s\n",
+        event->event.id,
+        event->event.timestamp,
+        event->type->id,
+        event->container->id,
+        event->value);
+  }

 }
 
 }
 

-void pajeDefineEventType(const char *alias, const char *containerType,
-                         const char *name)
+static void print_pajePopState(popState_t event)

 {
 {

-  INSTR_PAJE_ASSERT(alias);
-  INSTR_PAJE_ASSERT(containerType);
-  INSTR_PAJE_ASSERT(name);
-
-  fprintf(tracing_file, "%d %s %s %s\n", pajeDefineEventTypeId, alias,
-          containerType, name);
+  if (event->event.timestamp == 0){
+    fprintf(tracing_file, "%d 0 %s %s\n",
+        event->event.id,
+        event->type->id,
+        event->container->id);
+  }else{
+    fprintf(tracing_file, "%d %lf %s %s\n",
+        event->event.id,
+        event->event.timestamp,
+        event->type->id,
+        event->container->id);
+  }

 }
 
 }
 

-void pajeDefineLinkType(const char *alias, const char *containerType,
-                        const char *sourceContainerType,
-                        const char *destContainerType, const char *name)
+static void print_pajeStartLink(startLink_t event)

 {
 {

-  INSTR_PAJE_ASSERT(alias);
-  INSTR_PAJE_ASSERT(containerType);
-  INSTR_PAJE_ASSERT(sourceContainerType);
-  INSTR_PAJE_ASSERT(destContainerType);
-  INSTR_PAJE_ASSERT(name);
-
-  fprintf(tracing_file, "%d %s %s %s %s %s\n", pajeDefineLinkTypeId, alias,
-          containerType, sourceContainerType, destContainerType, name);
+  if (event->event.timestamp == 0){
+    fprintf(tracing_file, "%d 0 %s %s %s %s %s\n",
+        event->event.id,
+        event->type->id,
+        event->container->id,
+        event->value,
+        event->sourceContainer->id,
+        event->key);
+  }else {
+    fprintf(tracing_file, "%d %lf %s %s %s %s %s\n",
+        event->event.id,
+        event->event.timestamp,
+        event->type->id,
+        event->container->id,
+        event->value,
+        event->sourceContainer->id,
+        event->key);
+  }

 }
 
 }
 

-void pajeCreateContainer(double time, const char *alias, const char *type,
-                         const char *container, const char *name)
+static void print_pajeEndLink(endLink_t event)

 {
 {

-  INSTR_PAJE_ASSERT(alias);
-  INSTR_PAJE_ASSERT(type);
-  INSTR_PAJE_ASSERT(container);
-  INSTR_PAJE_ASSERT(name);
-
-  char line[TRACE_LINE_SIZE];
-  __pajeCreateContainer(line, TRACE_LINE_SIZE, pajeCreateContainerId, time,
-                        alias, type, container, name);
-  fprintf(tracing_file, "%s\n", line);
+  if (event->event.timestamp == 0){
+    fprintf(tracing_file, "%d 0 %s %s %s %s %s\n",
+        event->event.id,
+        event->type->id,
+        event->container->id,
+        event->value,
+        event->destContainer->id,
+        event->key);
+  }else {
+    fprintf(tracing_file, "%d %lf %s %s %s %s %s\n",
+        event->event.id,
+        event->event.timestamp,
+        event->type->id,
+        event->container->id,
+        event->value,
+        event->destContainer->id,
+        event->key);
+  }

 }
 
 }
 

-void pajeDestroyContainer(double time, const char *type,
-                          const char *container)
+static void print_pajeNewEvent (newEvent_t event)

 {
 {

-  INSTR_PAJE_ASSERT(type);
-  INSTR_PAJE_ASSERT(container);
-
-  if (time == 0){
-    fprintf(tracing_file, "%d 0 %s %s\n", pajeDestroyContainerId,
-          type, container);
+  if (event->event.timestamp == 0){
+    fprintf(tracing_file, "%d 0 %s %s %s\n",
+        event->event.id,
+        event->type->id,
+        event->container->id,
+        event->value);

   }else{
   }else{

-    fprintf(tracing_file, "%d %lf %s %s\n", pajeDestroyContainerId, time,
-          type, container);
+    fprintf(tracing_file, "%d %lf %s %s %s\n",
+        event->event.id,
+        event->event.timestamp,
+        event->type->id,
+        event->container->id,
+        event->value);

   }
 }
 
   }
 }
 

-void pajeSetState(double time, const char *entityType,
-                  const char *container, const char *value)
+void new_pajeDefineContainerType(type_t type)

 {
 {

-  INSTR_PAJE_ASSERT(entityType);
-  INSTR_PAJE_ASSERT(container);
-  INSTR_PAJE_ASSERT(value);
-
-  char line[TRACE_LINE_SIZE];
-  __pajeSetState(line, TRACE_LINE_SIZE, pajeSetStateId, time, entityType,
-                 container, value);
-  fprintf(tracing_file, "%s\n", line);
+  defineContainerType_t event = xbt_new0(s_defineContainerType_t, 1);
+  event->type = type;
+  event->print = print_pajeDefineContainerType;
+  event->event.name = xbt_strdup("PajeDefineContainerType");
+  event->event.id = pajeDefineContainerTypeId;
+  event->event.timestamp = 0;
+  event->event.header = xbt_strdup("");
+
+  //print it
+  event->print (event);
+
+  //destroy it
+  xbt_free (event->event.name);
+  xbt_free (event->event.header);
+  xbt_free (event);
+  event = NULL;

 }
 
 }
 

-void pajePushState(double time, const char *entityType,
-                   const char *container, const char *value)
+void new_pajeDefineVariableType(type_t type)

 {
 {

-  INSTR_PAJE_ASSERT(entityType);
-  INSTR_PAJE_ASSERT(container);
-  INSTR_PAJE_ASSERT(value);
-
-  char line[TRACE_LINE_SIZE];
-  __pajeSetState(line, TRACE_LINE_SIZE, pajePushStateId, time, entityType,
-                 container, value);
-  fprintf(tracing_file, "%s\n", line);
+  defineVariableType_t event = xbt_new0(s_defineVariableType_t, 1);
+  event->type = type;
+  event->print = print_pajeDefineVariableType;
+  event->event.name = xbt_strdup("PajeDefineVariableType");
+  event->event.id = pajeDefineVariableTypeWithColorId;
+  event->event.timestamp = 0;
+  event->event.header = xbt_strdup ("");
+
+  //print it
+  event->print (event);
+
+  //destroy it
+  xbt_free (event->event.name);
+  xbt_free (event->event.header);
+  xbt_free (event);
+  event = NULL;

 }
 
 }
 

-void pajePopState(double time, const char *entityType,
-                  const char *container)
+void new_pajeDefineStateType(type_t type)

 {
 {

-  INSTR_PAJE_ASSERT(entityType);
-  INSTR_PAJE_ASSERT(container);
-
-  fprintf(tracing_file, "%d %lf %s %s\n", pajePopStateId, time, entityType,
-          container);
+  defineStateType_t event = xbt_new0(s_defineStateType_t, 1);
+  event->type = type;
+  event->print = print_pajeDefineStateType;
+  event->event.name = xbt_strdup("PajeDefineStateType");
+  event->event.id = pajeDefineStateTypeId;
+  event->event.timestamp = 0;
+  event->event.header = xbt_strdup ("");
+
+  //print it
+  event->print (event);
+
+  //destroy it
+  xbt_free (event->event.name);
+  xbt_free (event->event.header);
+  xbt_free (event);
+  event = NULL;

 }
 
 }
 

-void pajeStartLink(double time, const char *entityType,
-                   const char *container, const char *value,
-                   const char *sourceContainer, const char *key)
+void new_pajeDefineEventType(type_t type)

 {
 {

-  INSTR_PAJE_ASSERT(entityType);
-  INSTR_PAJE_ASSERT(container);
-  INSTR_PAJE_ASSERT(value);
-  INSTR_PAJE_ASSERT(sourceContainer);
-  INSTR_PAJE_ASSERT(key);
-
-  char line[TRACE_LINE_SIZE];
-  __pajeStartLink(line, TRACE_LINE_SIZE, pajeStartLinkId, time, entityType,
-                  container, value, sourceContainer, key);
-  fprintf(tracing_file, "%s\n", line);
+  defineEventType_t event = xbt_new0(s_defineEventType_t, 1);
+  event->type = type;
+  event->print = print_pajeDefineEventType;
+  event->event.name = xbt_strdup("PajeDefineEventType");
+  event->event.id = pajeDefineEventTypeWithColorId;
+  event->event.timestamp = 0;
+  event->event.header = xbt_strdup ("");
+
+  //print it
+  event->print (event);
+
+  //destroy it
+  xbt_free (event->event.name);
+  xbt_free (event->event.header);
+  xbt_free (event);
+  event = NULL;

 }
 
 }
 

-void pajeStartLinkWithVolume(double time, const char *entityType,
-                             const char *container, const char *value,
-                             const char *sourceContainer, const char *key,
-                             double volume)
+void new_pajeDefineLinkType(type_t type, type_t source, type_t dest)

 {
 {

-  INSTR_PAJE_ASSERT(entityType);
-  INSTR_PAJE_ASSERT(container);
-  INSTR_PAJE_ASSERT(value);
-  INSTR_PAJE_ASSERT(sourceContainer);
-  INSTR_PAJE_ASSERT(key);
-
-  char line[TRACE_LINE_SIZE];
-  __pajeStartLink(line, TRACE_LINE_SIZE, pajeStartLinkWithVolumeId, time,
-                  entityType, container, value, sourceContainer, key);
-  fprintf(tracing_file, "%s %f\n", line, volume);
+  defineLinkType_t event = xbt_new0(s_defineLinkType_t, 1);
+  event->type = type;
+  event->source = source;
+  event->dest = dest;
+  event->print = print_pajeDefineLinkType;
+  event->event.name = xbt_strdup("PajeDefineLinkType");
+  event->event.id = pajeDefineLinkTypeId;
+  event->event.timestamp = 0;
+  event->event.header = xbt_strdup ("");
+
+  //print it
+  event->print (event);
+
+  //destroy it
+  xbt_free (event->event.name);
+  xbt_free (event->event.header);
+  xbt_free (event);
+  event = NULL;

 }
 
 }
 

-void pajeEndLink(double time, const char *entityType,
-                 const char *container, const char *value,
-                 const char *destContainer, const char *key)
+void new_pajeCreateContainer (container_t container)

 {
 {

-  INSTR_PAJE_ASSERT(entityType);
-  INSTR_PAJE_ASSERT(container);
-  INSTR_PAJE_ASSERT(value);
-  INSTR_PAJE_ASSERT(destContainer);
-  INSTR_PAJE_ASSERT(key);
-
-  if (time == 0){
-    fprintf(tracing_file, "%d 0 %s %s %s %s %s\n", pajeEndLinkId,
-            entityType, container, value, destContainer, key);
-  }else {
-    fprintf(tracing_file, "%d %lf %s %s %s %s %s\n", pajeEndLinkId, time,
-          entityType, container, value, destContainer, key);
-  }
+  createContainer_t event = xbt_new0(s_createContainer_t, 1);
+  event->container = container;
+  event->print = print_pajeCreateContainer;
+  event->event.name = xbt_strdup("PajeCreateContainer");
+  event->event.id = pajeCreateContainerId;
+  event->event.timestamp = SIMIX_get_clock();
+  event->event.header = xbt_strdup("");
+
+  //print it
+  event->print (event);
+
+  //destroy it
+  xbt_free (event->event.name);
+  xbt_free (event->event.header);
+  xbt_free (event);
+  event = NULL;

 }
 
 }
 

-void pajeDefineVariableType(const char *alias, const char *containerType,
-                            const char *name)
+void new_pajeDestroyContainer (container_t container)

 {
 {

-  INSTR_PAJE_ASSERT(alias);
-  INSTR_PAJE_ASSERT(containerType);
-  INSTR_PAJE_ASSERT(name);
-
-  fprintf(tracing_file, "%d %s %s %s\n", pajeDefineVariableTypeId, alias,
-          containerType, name);
+  destroyContainer_t event = xbt_new0(s_destroyContainer_t, 1);
+  event->container = container;
+  event->print = print_pajeDestroyContainer;
+  event->event.name = xbt_strdup("PajeDestroyContainer");
+  event->event.id = pajeDestroyContainerId;
+  event->event.timestamp = SIMIX_get_clock();
+  event->event.header = xbt_strdup("");
+
+  //print it
+  event->print (event);
+
+  //destroy it
+  xbt_free (event->event.name);
+  xbt_free (event->event.header);
+  xbt_free (event);
+  event = NULL;
+
+  fflush (tracing_file);

 }
 
 }
 

-void pajeDefineVariableTypeWithColor(const char *alias, const char *containerType,
-                            const char *name, const char *color)
+void new_pajeSetVariable (double timestamp, container_t container, type_t type, double value)

 {
 {

-  INSTR_PAJE_ASSERT(alias);
-  INSTR_PAJE_ASSERT(containerType);
-  INSTR_PAJE_ASSERT(name);
-  INSTR_PAJE_ASSERT(color);
-
-  fprintf(tracing_file, "%d %s %s %s \"%s\"\n", pajeDefineVariableTypeWithColorId, alias,
-          containerType, name, color);
+  setVariable_t event = xbt_new0(s_setVariable_t, 1);
+  event->type = type;
+  event->container = container;
+  event->value = value;
+  event->print = print_pajeSetVariable;
+  event->event.name = xbt_strdup("PajeSetVariable");
+  event->event.id = pajeSetVariableId;
+  event->event.timestamp = timestamp;
+  event->event.header = xbt_strdup("");
+
+  //print it
+  event->print (event);
+
+  //destroy it
+  xbt_free (event->event.name);
+  xbt_free (event->event.header);
+  xbt_free (event);
+  event = NULL;

 }
 
 }
 

-void pajeSetVariable(double time, const char *entityType,
-                     const char *container, const char *value)
+
+void new_pajeAddVariable (double timestamp, container_t container, type_t type, double value)

 {
 {

-  INSTR_PAJE_ASSERT(entityType);
-  INSTR_PAJE_ASSERT(container);
-  INSTR_PAJE_ASSERT(value);
+  addVariable_t event = xbt_new0(s_addVariable_t, 1);
+  event->type = type;
+  event->container = container;
+  event->value = value;
+  event->print = print_pajeAddVariable;
+  event->event.name = xbt_strdup("PajeAddVariable");
+  event->event.id = pajeAddVariableId;
+  event->event.timestamp = timestamp;
+  event->event.header = xbt_strdup("");
+
+  //print it
+  event->print (event);
+
+  //destroy it
+  xbt_free (event->event.name);
+  xbt_free (event->event.header);
+  xbt_free (event);
+  event = NULL;
+}

 
 

-  char line[TRACE_LINE_SIZE];
-  __pajeSetVariable(line, TRACE_LINE_SIZE, pajeSetVariableId, time,
-                    entityType, container, value);
-  fprintf(tracing_file, "%s\n", line);
+void new_pajeSubVariable (double timestamp, container_t container, type_t type, double value)
+{
+  subVariable_t event = xbt_new0(s_subVariable_t, 1);
+  event->type = type;
+  event->container = container;
+  event->value = value;
+  event->print = print_pajeSubVariable;
+  event->event.name = xbt_strdup("PajeSubVariable");
+  event->event.id = pajeSubVariableId;
+  event->event.timestamp = timestamp;
+  event->event.header = xbt_strdup("");
+
+  //print it
+  event->print (event);
+
+  //destroy it
+  xbt_free (event->event.name);
+  xbt_free (event->event.header);
+  xbt_free (event);
+  event = NULL;

 }
 
 }
 

-void pajeAddVariable(double time, const char *entityType,
-                     const char *container, const char *value)
+void new_pajeSetState (double timestamp, container_t container, type_t type, const char *value)

 {
 {

-  INSTR_PAJE_ASSERT(entityType);
-  INSTR_PAJE_ASSERT(container);
-  INSTR_PAJE_ASSERT(value);
+  setState_t event = xbt_new0(s_setState_t, 1);
+  event->type = type;
+  event->container = container;
+  event->value = xbt_strdup(value);
+  event->print = print_pajeSetState;
+  event->event.name = xbt_strdup("PajeSetState");
+  event->event.id = pajeSetStateId;
+  event->event.timestamp = timestamp;
+  event->event.header = xbt_strdup("");
+
+  //print it
+  event->print (event);
+
+  //destroy it
+  xbt_free (event->value);
+  xbt_free (event->event.name);
+  xbt_free (event->event.header);
+  xbt_free (event);
+  event = NULL;
+}
+

 
 

-  char line[TRACE_LINE_SIZE];
-  __pajeSetVariable(line, TRACE_LINE_SIZE, pajeAddVariableId, time,
-                    entityType, container, value);
-  fprintf(tracing_file, "%s\n", line);
+void new_pajePushState (double timestamp, container_t container, type_t type, const char *value)
+{
+  pushState_t event = xbt_new0(s_pushState_t, 1);
+  event->type = type;
+  event->container = container;
+  event->value = xbt_strdup(value);
+  event->print = print_pajePushState;
+  event->event.name = xbt_strdup("PajePushState");
+  event->event.id = pajePushStateId;
+  event->event.timestamp = timestamp;
+  event->event.header = xbt_strdup("");
+
+  //print it
+  event->print (event);
+
+  //destroy it
+  xbt_free (event->value);
+  xbt_free (event->event.name);
+  xbt_free (event->event.header);
+  xbt_free (event);
+  event = NULL;

 }
 
 }
 

-void pajeSubVariable(double time, const char *entityType,
-                     const char *container, const char *value)
+
+void new_pajePopState (double timestamp, container_t container, type_t type)

 {
 {

-  INSTR_PAJE_ASSERT(entityType);
-  INSTR_PAJE_ASSERT(container);
-  INSTR_PAJE_ASSERT(value);
+  popState_t event = xbt_new0(s_popState_t, 1);
+  event->type = type;
+  event->container = container;
+  event->print = print_pajePopState;
+  event->event.name = xbt_strdup("PajePopState");
+  event->event.id = pajePopStateId;
+  event->event.timestamp = timestamp;
+  event->event.header = xbt_strdup("");
+
+  //print it
+  event->print (event);
+
+  //destroy it
+  xbt_free (event->event.name);
+  xbt_free (event->event.header);
+  xbt_free (event);
+  event = NULL;
+}

 
 

-  char line[TRACE_LINE_SIZE];
-  __pajeSetVariable(line, TRACE_LINE_SIZE, pajeSubVariableId, time,
-                    entityType, container, value);
-  fprintf(tracing_file, "%s\n", line);
+void new_pajeStartLink (double timestamp, container_t container, type_t type, container_t sourceContainer, const char *value, const char *key)
+{
+  startLink_t event = xbt_new0(s_startLink_t, 1);
+  event->type = type;
+  event->container = container;
+  event->sourceContainer = sourceContainer;
+  event->value = xbt_strdup (value);
+  event->key = xbt_strdup (key);
+  event->print = print_pajeStartLink;
+  event->event.name = xbt_strdup("PajeStartLink");
+  event->event.id = pajeStartLinkId;
+  event->event.timestamp = timestamp;
+  event->event.header = xbt_strdup("");
+
+  //print it
+  event->print (event);
+
+  //destroy it
+  xbt_free (event->value);
+  xbt_free (event->key);
+  xbt_free (event->event.name);
+  xbt_free (event->event.header);
+  xbt_free (event);
+  event = NULL;

 }
 
 }
 

-void pajeNewEvent(double time, const char *entityType,
-                  const char *container, const char *value)
+void new_pajeEndLink (double timestamp, container_t container, type_t type, container_t destContainer, const char *value, const char *key)

 {
 {

-  INSTR_PAJE_ASSERT(entityType);
-  INSTR_PAJE_ASSERT(container);
-  INSTR_PAJE_ASSERT(value);
+  endLink_t event = xbt_new0(s_endLink_t, 1);
+  event->type = type;
+  event->container = container;
+  event->destContainer = destContainer;
+  event->value = xbt_strdup (value);
+  event->key = xbt_strdup (key);
+  event->print = print_pajeEndLink;
+  event->event.name = xbt_strdup("PajeEndLink");
+  event->event.id = pajeEndLinkId;
+  event->event.timestamp = timestamp;
+  event->event.header = xbt_strdup("");
+
+  //print it
+  event->print (event);
+
+  //destroy it
+  xbt_free (event->value);
+  xbt_free (event->key);
+  xbt_free (event->event.name);
+  xbt_free (event->event.header);
+  xbt_free (event);
+  event = NULL;
+}

 
 

-  if (time == 0){
-    fprintf(tracing_file, "%d 0 %s %s %s\n", pajeNewEventId,
-          entityType, container, value);
-  }else{
-    fprintf(tracing_file, "%d %lf %s %s %s\n", pajeNewEventId, time,
-          entityType, container, value);
-  }
+void new_pajeNewEvent (double timestamp, container_t container, type_t type, const char *value)
+{
+  newEvent_t event = xbt_new0(s_newEvent_t, 1);
+  event->type = type;
+  event->container = container;
+  event->value = xbt_strdup (value);
+  event->print = print_pajeNewEvent;
+  event->event.name = xbt_strdup("PajeNewEvent");
+  event->event.id = pajeNewEventId;
+  event->event.timestamp = timestamp;
+  event->event.header = xbt_strdup("");
+
+  //print it
+  event->print (event);
+
+  //destroy it
+  xbt_free (event->value);
+  xbt_free (event->event.name);
+  xbt_free (event->event.header);
+  xbt_free (event);
+  event = NULL;

 }
 }

+//
+//void pajeNewEvent(double time, const char *entityType,
+//                  const char *container, const char *value)
+//{
+//  INSTR_PAJE_ASSERT(entityType);
+//  INSTR_PAJE_ASSERT(container);
+//  INSTR_PAJE_ASSERT(value);
+//
+//  if (time == 0){
+//    fprintf(tracing_file, "%d 0 %s %s %s\n", pajeNewEventId,
+//          entityType, container, value);
+//  }else{
+//    fprintf(tracing_file, "%d %lf %s %s %s\n", pajeNewEventId, time,
+//          entityType, container, value);
+//  }
+//}

 
 #endif /* HAVE_TRACING */
 
 #endif /* HAVE_TRACING */

diff --git a/src/instr/instr_private.h b/src/instr/instr_private.h
index 424a5e3..4ea88e4 100644 (file)
--- a/src/instr/instr_private.h
+++ b/src/instr/instr_private.h
@@ -30,6 +30,7 @@ typedef struct s_type *type_t;
 typedef struct s_type {
   char *id;
   char *name;
 typedef struct s_type {
   char *id;
   char *name;

+  char *color;

   e_entity_types kind;
   struct s_type *father;
   xbt_dict_t children;
   e_entity_types kind;
   struct s_type *father;
   xbt_dict_t children;


@@ -62,49 +63,22 @@ extern xbt_dict_t created_categories;
 void TRACE_paje_create_header(void);
 void TRACE_paje_start(void);
 void TRACE_paje_end(void);
 void TRACE_paje_create_header(void);
 void TRACE_paje_start(void);
 void TRACE_paje_end(void);

-void pajeDefineContainerType(const char *alias, const char *containerType,
-                             const char *name);
-void pajeDefineStateType(const char *alias, const char *containerType,
-                         const char *name);
-void pajeDefineEventTypeWithColor(const char *alias, const char *containerType,
-                         const char *name, const char *color);
-void pajeDefineEventType(const char *alias, const char *containerType,
-                         const char *name);
-void pajeDefineLinkType(const char *alias, const char *containerType,
-                        const char *sourceContainerType,
-                        const char *destContainerType, const char *name);
-void pajeCreateContainer(double time, const char *alias, const char *type,
-                         const char *container, const char *name);
-void pajeDestroyContainer(double time, const char *type,
-                          const char *container);
-void pajeSetState(double time, const char *entityType,
-                  const char *container, const char *value);
-void pajePushState(double time, const char *entityType,
-                   const char *container, const char *value);
-void pajePopState(double time, const char *entityType,
-                  const char *container);
-void pajeStartLink(double time, const char *entityType,
-                   const char *container, const char *value,
-                   const char *sourceContainer, const char *key);
-void pajeStartLinkWithVolume(double time, const char *entityType,
-                             const char *container, const char *value,
-                             const char *sourceContainer, const char *key,
-                             double volume);
-void pajeEndLink(double time, const char *entityType,
-                 const char *container, const char *value,
-                 const char *destContainer, const char *key);
-void pajeDefineVariableType(const char *alias, const char *containerType,
-                            const char *name);
-void pajeDefineVariableTypeWithColor(const char *alias, const char *containerType,
-                            const char *name, const char *color);
-void pajeSetVariable(double time, const char *entityType,
-                     const char *container, const char *value);
-void pajeAddVariable(double time, const char *entityType,
-                     const char *container, const char *value);
-void pajeSubVariable(double time, const char *entityType,
-                     const char *container, const char *value);
-void pajeNewEvent(double time, const char *entityType,
-                  const char *container, const char *value);
+void new_pajeDefineContainerType(type_t type);
+void new_pajeDefineVariableType(type_t type);
+void new_pajeDefineStateType(type_t type);
+void new_pajeDefineEventType(type_t type);
+void new_pajeDefineLinkType(type_t type, type_t source, type_t dest);
+void new_pajeCreateContainer (container_t container);
+void new_pajeDestroyContainer (container_t container);
+void new_pajeSetVariable (double timestamp, container_t container, type_t type, double value);
+void new_pajeAddVariable (double timestamp, container_t container, type_t type, double value);
+void new_pajeSubVariable (double timestamp, container_t container, type_t type, double value);
+void new_pajeSetState (double timestamp, container_t container, type_t type, const char *value);
+void new_pajePushState (double timestamp, container_t container, type_t type, const char *value);
+void new_pajePopState (double timestamp, container_t container, type_t type);
+void new_pajeStartLink (double timestamp, container_t container, type_t type, container_t sourceContainer, const char *value, const char *key);
+void new_pajeEndLink (double timestamp, container_t container, type_t type, container_t destContainer, const char *value, const char *key);
+void new_pajeNewEvent (double timestamp, container_t container, type_t type, const char *value);

 
 /* declaration of instrumentation functions from msg_task_instr.c */
 char *TRACE_task_container(m_task_t task, char *output, int len);
 
 /* declaration of instrumentation functions from msg_task_instr.c */
 char *TRACE_task_container(m_task_t task, char *output, int len);

diff --git a/src/instr/instr_resource_utilization.c b/src/instr/instr_resource_utilization.c
index 9bd1bee..3308f3c 100644 (file)
--- a/src/instr/instr_resource_utilization.c
+++ b/src/instr/instr_resource_utilization.c
@@ -39,8 +39,11 @@ static void __TRACE_surf_check_variable_set_to_zero(double now,
     xbt_dynar_t array = xbt_dynar_new(sizeof(char *), xbt_free);
     char *var_cpy = xbt_strdup(variable);
     xbt_dynar_push(array, &var_cpy);
     xbt_dynar_t array = xbt_dynar_new(sizeof(char *), xbt_free);
     char *var_cpy = xbt_strdup(variable);
     xbt_dynar_push(array, &var_cpy);

-    if (TRACE_categorized ())
-      pajeSetVariable(now, variable, resource, "0");
+    if (TRACE_categorized ()){
+      container_t container = getContainerByName (resource);
+      type_t type = getVariableType (variable, NULL, container->type);
+      new_pajeSetVariable (now, container, type, 0);
+    }

     xbt_dict_set(platform_variables, resource, array,
                  xbt_dynar_free_voidp);
   } else {
     xbt_dict_set(platform_variables, resource, array,
                  xbt_dynar_free_voidp);
   } else {


@@ -56,8 +59,11 @@ static void __TRACE_surf_check_variable_set_to_zero(double now,
     if (flag == 0) {
       char *var_cpy = xbt_strdup(variable);
       xbt_dynar_push(array, &var_cpy);
     if (flag == 0) {
       char *var_cpy = xbt_strdup(variable);
       xbt_dynar_push(array, &var_cpy);

-      if (TRACE_categorized ())
-        pajeSetVariable(now, variable, resource, "0");
+      if (TRACE_categorized ()){
+        container_t container = getContainerByName (resource);
+        type_t type = getVariableType (variable, NULL, container->type);
+        new_pajeSetVariable (now, container, type, 0);
+      }

     }
   }
   /* end of check */
     }
   }
   /* end of check */


@@ -85,8 +91,10 @@ static void __TRACE_A_event(smx_action_t action, double now, double delta,
   snprintf(valuestr, 100, "%f", value);
 
   __TRACE_surf_check_variable_set_to_zero(now, variable, resource);
   snprintf(valuestr, 100, "%f", value);
 
   __TRACE_surf_check_variable_set_to_zero(now, variable, resource);

-  pajeAddVariable(now, variable, resource, valuestr);
-  pajeSubVariable(now + delta, variable, resource, valuestr);
+  container_t container = getContainerByName (resource);
+  type_t type = getVariableType (variable, NULL, container->type);
+  new_pajeAddVariable(now, container, type, value);
+  new_pajeSubVariable(now + delta, container, type, value);

 }
 
 static void __TRACE_A_end(smx_action_t action)
 }
 
 static void __TRACE_A_end(smx_action_t action)


@@ -114,7 +122,9 @@ static void __TRACE_B_release(void)
       char key_value[INSTR_DEFAULT_STR_SIZE];
       snprintf (key_value, INSTR_DEFAULT_STR_SIZE, "%s %s value", resource, variable);
       char *value = xbt_dict_get_or_null (method_b_dict, key_value);
       char key_value[INSTR_DEFAULT_STR_SIZE];
       snprintf (key_value, INSTR_DEFAULT_STR_SIZE, "%s %s value", resource, variable);
       char *value = xbt_dict_get_or_null (method_b_dict, key_value);

-      pajeSubVariable(atof(time), variable, resource, value);
+      container_t container = getContainerByName (resource);
+      type_t type = getVariableType (variable, NULL, container->type);
+      new_pajeSubVariable(atof(time), container, type, atof(value));

     }
   }
   xbt_dict_free(&method_b_dict);
     }
   }
   xbt_dict_free(&method_b_dict);


@@ -144,7 +154,9 @@ static void __TRACE_B_event(smx_action_t action, double now, double delta,
   char *lastvaluestr = xbt_dict_get_or_null(method_b_dict, key_value);
   if (lasttimestr == NULL){
     __TRACE_surf_check_variable_set_to_zero(now, variable, resource);
   char *lastvaluestr = xbt_dict_get_or_null(method_b_dict, key_value);
   if (lasttimestr == NULL){
     __TRACE_surf_check_variable_set_to_zero(now, variable, resource);

-    pajeAddVariable(now, variable, resource, valuestr);
+    container_t container = getContainerByName (resource);
+    type_t type = getVariableType (variable, NULL, container->type);
+    new_pajeAddVariable(now, container, type, value);

     xbt_dict_set(method_b_dict, key_time, xbt_strdup(nowdeltastr), xbt_free);
     xbt_dict_set(method_b_dict, key_value, xbt_strdup(valuestr), xbt_free);
   }else{
     xbt_dict_set(method_b_dict, key_time, xbt_strdup(nowdeltastr), xbt_free);
     xbt_dict_set(method_b_dict, key_value, xbt_strdup(valuestr), xbt_free);
   }else{


@@ -157,13 +169,17 @@ static void __TRACE_B_event(smx_action_t action, double now, double delta,
         //perfect, just go on
       }else{
         //time changed, have to update
         //perfect, just go on
       }else{
         //time changed, have to update

-        pajeSubVariable(lasttime, variable, resource, lastvaluestr);
-        pajeAddVariable(now, variable, resource, valuestr);
+        container_t container = getContainerByName (resource);
+        type_t type = getVariableType (variable, NULL, container->type);
+        new_pajeSubVariable(lasttime, container, type, lastvalue);
+        new_pajeAddVariable(now, container, type, value);

       }
     }else{
       //value changed, have to update
       }
     }else{
       //value changed, have to update

-      pajeSubVariable(lasttime, variable, resource, lastvaluestr);
-      pajeAddVariable(now, variable, resource, valuestr);
+      container_t container = getContainerByName (resource);
+      type_t type = getVariableType (variable, NULL, container->type);
+      new_pajeSubVariable(lasttime, container, type, lastvalue);
+      new_pajeAddVariable(now, container, type, value);

     }
     xbt_dict_set(method_b_dict, key_time, xbt_strdup(nowdeltastr), xbt_free);
     xbt_dict_set(method_b_dict, key_value, xbt_strdup(valuestr), xbt_free);
     }
     xbt_dict_set(method_b_dict, key_time, xbt_strdup(nowdeltastr), xbt_free);
     xbt_dict_set(method_b_dict, key_value, xbt_strdup(valuestr), xbt_free);


@@ -252,12 +268,12 @@ static void __TRACE_C_end(smx_action_t action)
       continue;
     __TRACE_surf_check_variable_set_to_zero(start_time, variable,
                                             resource);
       continue;
     __TRACE_surf_check_variable_set_to_zero(start_time, variable,
                                             resource);

-    char value_str[100];

     if (end_time - start_time != 0) {
     if (end_time - start_time != 0) {

-      snprintf(value_str, 100, "%f",
-               atof(action_dict_value) / (end_time - start_time));
-      pajeAddVariable(start_time, variable, resource, value_str);
-      pajeSubVariable(end_time, variable, resource, value_str);
+      container_t container = getContainerByName (resource);
+      type_t type = getVariableType (variable, NULL, container->type);
+      double val = atof(action_dict_value) / (end_time - start_time);
+      new_pajeSubVariable(start_time, container, type, val);
+      new_pajeAddVariable(end_time, container, type, val);

     }
   }
   xbt_dict_remove(method_c_dict, key);
     }
   }
   xbt_dict_remove(method_c_dict, key);


@@ -285,9 +301,9 @@ void TRACE_surf_link_set_utilization(const char *resource, smx_action_t smx_acti
   //trace uncategorized link utilization
   if (TRACE_uncategorized()){
     DEBUG4("UNCAT LINK [%f - %f] %s bandwidth_used %f", now, now+delta, resource, value);
   //trace uncategorized link utilization
   if (TRACE_uncategorized()){
     DEBUG4("UNCAT LINK [%f - %f] %s bandwidth_used %f", now, now+delta, resource, value);

-    char *variable_type = getVariableTypeIdByName("bandwidth_used", getContainerByName(resource)->type);
-    char *resource_id = getContainerIdByName (resource);
-    TRACE_surf_resource_utilization_event(smx_action, now, delta, variable_type, resource_id, value);
+    container_t container = getContainerByName (resource);
+    type_t type = getVariableType("bandwidth_used", NULL, container->type);
+    TRACE_surf_resource_utilization_event(smx_action, now, delta, type->name, container->name, value);

   }
 
   //trace categorized utilization
   }
 
   //trace categorized utilization


@@ -295,9 +311,9 @@ void TRACE_surf_link_set_utilization(const char *resource, smx_action_t smx_acti
     if (!surf_action->category)
       return;
     DEBUG5("CAT LINK [%f - %f] %s %s %f", now, now+delta, resource, surf_action->category, value);
     if (!surf_action->category)
       return;
     DEBUG5("CAT LINK [%f - %f] %s %s %f", now, now+delta, resource, surf_action->category, value);

-    char *variable_type = getVariableTypeIdByName(surf_action->category, getContainerByName(resource)->type);
-    char *resource_id = getContainerIdByName (resource);
-    TRACE_surf_resource_utilization_event(smx_action, now, delta, variable_type, resource_id, value);
+    container_t container = getContainerByName (resource);
+    type_t type = getVariableType(surf_action->category, NULL, container->type);
+    TRACE_surf_resource_utilization_event(smx_action, now, delta, type->name, container->name, value);

   }
   return;
 }
   }
   return;
 }


@@ -319,9 +335,9 @@ void TRACE_surf_host_set_utilization(const char *resource,
   //trace uncategorized host utilization
   if (TRACE_uncategorized()){
     DEBUG4("UNCAT HOST [%f - %f] %s power_used %f", now, now+delta, resource, value);
   //trace uncategorized host utilization
   if (TRACE_uncategorized()){
     DEBUG4("UNCAT HOST [%f - %f] %s power_used %f", now, now+delta, resource, value);

-    char *variable_type = getVariableTypeIdByName ("power_used", getContainerByName(resource)->type);
-    char *resource_id = getContainerIdByName (resource);
-    TRACE_surf_resource_utilization_event(smx_action, now, delta, variable_type, resource_id, value);
+    container_t container = getContainerByName (resource);
+    type_t type = getVariableType("power_used", NULL, container->type);
+    TRACE_surf_resource_utilization_event(smx_action, now, delta, type->name, container->name, value);

   }
 
   //trace categorized utilization
   }
 
   //trace categorized utilization


@@ -329,9 +345,9 @@ void TRACE_surf_host_set_utilization(const char *resource,
     if (!surf_action->category)
       return;
     DEBUG5("CAT HOST [%f - %f] %s %s %f", now, now+delta, resource, surf_action->category, value);
     if (!surf_action->category)
       return;
     DEBUG5("CAT HOST [%f - %f] %s %s %f", now, now+delta, resource, surf_action->category, value);

-    char *variable_type = getVariableTypeIdByName (surf_action->category, getContainerByName(resource)->type);
-    char *resource_id = getContainerIdByName (resource);
-    TRACE_surf_resource_utilization_event(smx_action, now, delta, variable_type, resource_id, value);
+    container_t container = getContainerByName (resource);
+    type_t type = getVariableType(surf_action->category, NULL, container->type);
+    TRACE_surf_resource_utilization_event(smx_action, now, delta, type->name, container->name, value);

   }
   return;
 }
   }
   return;
 }

diff --git a/src/instr/instr_routing.c b/src/instr/instr_routing.c
index 15cd349..8113389 100644 (file)
--- a/src/instr/instr_routing.c
+++ b/src/instr/instr_routing.c
@@ -74,8 +74,8 @@ static void linkContainers (const char *a1, const char *a2)
   static long long counter = 0;
   char key[INSTR_DEFAULT_STR_SIZE];
   snprintf (key, INSTR_DEFAULT_STR_SIZE, "%lld", counter++);
   static long long counter = 0;
   char key[INSTR_DEFAULT_STR_SIZE];
   snprintf (key, INSTR_DEFAULT_STR_SIZE, "%lld", counter++);

-  pajeStartLink(SIMIX_get_clock(), link_type->id, container->id, "G", a1_container->id, key);
-  pajeEndLink(SIMIX_get_clock(), link_type->id, container->id, "G", a2_container->id, key);
+  new_pajeStartLink(SIMIX_get_clock(), container, link_type, a1_container, "G", key);
+  new_pajeEndLink(SIMIX_get_clock(), container, link_type, a2_container, "G", key);

 }
 
 static void recursiveGraphExtraction (container_t container)
 }
 
 static void recursiveGraphExtraction (container_t container)


@@ -204,8 +204,8 @@ static void instr_routing_parse_start_link ()
 
   type_t bandwidth = getVariableType ("bandwidth", NULL, new->type);
   type_t latency = getVariableType ("latency", NULL, new->type);
 
   type_t bandwidth = getVariableType ("bandwidth", NULL, new->type);
   type_t latency = getVariableType ("latency", NULL, new->type);

-  pajeSetVariable (0, bandwidth->id, new->id, A_surfxml_link_bandwidth);
-  pajeSetVariable (0, latency->id, new->id, A_surfxml_link_latency);
+  new_pajeSetVariable (0, new, bandwidth, atof(A_surfxml_link_bandwidth));
+  new_pajeSetVariable (0, new, latency, atof(A_surfxml_link_latency));

   if (TRACE_uncategorized()){
     getVariableType ("bandwidth_used", "0.5 0.5 0.5", new->type);
   }
   if (TRACE_uncategorized()){
     getVariableType ("bandwidth_used", "0.5 0.5 0.5", new->type);
   }


@@ -221,7 +221,7 @@ static void instr_routing_parse_start_host ()
   container_t new = newContainer (A_surfxml_host_id, INSTR_HOST, father);
 
   type_t power = getVariableType ("power", NULL, new->type);
   container_t new = newContainer (A_surfxml_host_id, INSTR_HOST, father);
 
   type_t power = getVariableType ("power", NULL, new->type);

-  pajeSetVariable (0, power->id, new->id, A_surfxml_host_power);
+  new_pajeSetVariable (0, new, power, atof(A_surfxml_host_power));

   if (TRACE_uncategorized()){
     getVariableType ("power_used", "0.5 0.5 0.5", new->type);
   }
   if (TRACE_uncategorized()){
     getVariableType ("power_used", "0.5 0.5 0.5", new->type);
   }

diff --git a/src/instr/instr_smpi.c b/src/instr/instr_smpi.c
index 5293a45..99207bb 100644 (file)
--- a/src/instr/instr_smpi.c
+++ b/src/instr/instr_smpi.c
@@ -144,7 +144,7 @@ void TRACE_smpi_collective_in(int rank, int root, const char *operation)
   container_t container = getContainer (str);
   type_t type = getType ("MPI_STATE");
 
   container_t container = getContainer (str);
   type_t type = getType ("MPI_STATE");
 

-  pajePushState(SIMIX_get_clock(), type->id, container->id, operation);
+  new_pajePushState (SIMIX_get_clock(), container, type, operation);

 }
 
 void TRACE_smpi_collective_out(int rank, int root, const char *operation)
 }
 
 void TRACE_smpi_collective_out(int rank, int root, const char *operation)


@@ -157,7 +157,7 @@ void TRACE_smpi_collective_out(int rank, int root, const char *operation)
   container_t container = getContainer (str);
   type_t type = getType ("MPI_STATE");
 
   container_t container = getContainer (str);
   type_t type = getType ("MPI_STATE");
 

-  pajePopState(SIMIX_get_clock(), type->id, container->id);
+  new_pajePopState (SIMIX_get_clock(), container, type);

 }
 
 void TRACE_smpi_ptp_in(int rank, int src, int dst, const char *operation)
 }
 
 void TRACE_smpi_ptp_in(int rank, int src, int dst, const char *operation)


@@ -170,7 +170,7 @@ void TRACE_smpi_ptp_in(int rank, int src, int dst, const char *operation)
   container_t container = getContainer (str);
   type_t type = getType ("MPI_STATE");
 
   container_t container = getContainer (str);
   type_t type = getType ("MPI_STATE");
 

-  pajePushState(SIMIX_get_clock(), type->id, container->id, operation);
+  new_pajePushState (SIMIX_get_clock(), container, type, operation);

 }
 
 void TRACE_smpi_ptp_out(int rank, int src, int dst, const char *operation)
 }
 
 void TRACE_smpi_ptp_out(int rank, int src, int dst, const char *operation)


@@ -183,7 +183,7 @@ void TRACE_smpi_ptp_out(int rank, int src, int dst, const char *operation)
   container_t container = getContainer (str);
   type_t type = getType ("MPI_STATE");
 
   container_t container = getContainer (str);
   type_t type = getType ("MPI_STATE");
 

-  pajePopState(SIMIX_get_clock(), type->id, container->id);
+  new_pajePopState (SIMIX_get_clock(), container, type);

 }
 
 void TRACE_smpi_send(int rank, int src, int dst)
 }
 
 void TRACE_smpi_send(int rank, int src, int dst)


@@ -199,7 +199,7 @@ void TRACE_smpi_send(int rank, int src, int dst)
   container_t container = getContainer (str);
   type_t type = getType ("MPI_LINK");
 
   container_t container = getContainer (str);
   type_t type = getType ("MPI_LINK");
 

-  pajeStartLink(SIMIX_get_clock(), type->id, type->father->id, "PTP", container->id, key);
+  new_pajeStartLink (SIMIX_get_clock(), getRootContainer(), type, container, "PTP", key);

 }
 
 void TRACE_smpi_recv(int rank, int src, int dst)
 }
 
 void TRACE_smpi_recv(int rank, int src, int dst)


@@ -215,6 +215,6 @@ void TRACE_smpi_recv(int rank, int src, int dst)
   container_t container = getContainer (str);
   type_t type = getType ("MPI_LINK");
 
   container_t container = getContainer (str);
   type_t type = getType ("MPI_LINK");
 

-  pajeEndLink(SIMIX_get_clock(), type->id, type->father->id, "PTP", container->id, key);
+  new_pajeEndLink (SIMIX_get_clock(), getRootContainer(), type, container, "PTP", key);

 }
 #endif /* HAVE_TRACING */
 }
 #endif /* HAVE_TRACING */

diff --git a/src/instr/instr_surf.c b/src/instr/instr_surf.c
index 8df49ad..19a044b 100644 (file)
--- a/src/instr/instr_surf.c
+++ b/src/instr/instr_surf.c
@@ -26,10 +26,9 @@ static void TRACE_surf_set_resource_variable(double date,
                                              const char *resource,
                                              double value)
 {
                                              const char *resource,
                                              double value)
 {

-  char value_str[INSTR_DEFAULT_STR_SIZE];
-  snprintf(value_str, 100, "%f", value);
-  char *variable_type = getVariableTypeIdByName(variable, getContainerByName(resource)->type);
-  pajeSetVariable(date, variable, variable_type, value_str);
+  container_t container = getContainerByName(resource);
+  type_t type = getVariableType(variable, NULL, container->type);
+  new_pajeSetVariable(date, container, type, value);

 }
 
 void TRACE_surf_host_set_power(double date, const char *resource, double power)
 }
 
 void TRACE_surf_host_set_power(double date, const char *resource, double power)