From 0ea75ed937bc712436c752ac8bfb69140800ac18 Mon Sep 17 00:00:00 2001 From: schnorr Date: Mon, 27 Dec 2010 16:56:16 +0000 Subject: [PATCH] [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 --- src/instr/instr_interface.c | 26 +- src/instr/instr_msg_process.c | 18 +- src/instr/instr_msg_task.c | 18 +- src/instr/instr_paje.c | 26 +- src/instr/instr_paje_trace.c | 926 ++++++++++++++++++------- src/instr/instr_private.h | 60 +- src/instr/instr_resource_utilization.c | 74 +- src/instr/instr_routing.c | 10 +- src/instr/instr_smpi.c | 12 +- src/instr/instr_surf.c | 7 +- 10 files changed, 805 insertions(+), 372 deletions(-) diff --git a/src/instr/instr_interface.c b/src/instr/instr_interface.c index ee767b76c9..34d03af197 100644 --- 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); - pajeDefineEventType(mark_type, "0", mark_type); + getEventType(mark_type, NULL, getRootType()); } 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); - 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{ - 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) { - pajeSetVariable(time, variable_id, resource_id, valuestr); + new_pajeSetVariable(time, container, type, value); } 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) { - 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; - 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) { - pajeSetVariable(time, variable_id, resource_id, valuestr); + new_pajeSetVariable(time, container, type, value); } 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) { - pajeSubVariable(time, variable_id, resource_id, valuestr); + new_pajeSubVariable(time, container, type, value); } } } - #endif /* HAVE_TRACING */ diff --git a/src/instr/instr_msg_process.c b/src/instr/instr_msg_process.c index f5f22138d4..a6e1a95d13 100644 --- 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); } - pajeSetVariable(SIMIX_get_clock(), type->id, msg->id, "1"); + new_pajeSetVariable (SIMIX_get_clock(), msg, type, 1); 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"); - 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)); @@ -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); - 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"); - 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) @@ -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"); - 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) @@ -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"); - 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) @@ -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"); - 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) @@ -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"); - 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) diff --git a/src/instr/instr_msg_task.c b/src/instr/instr_msg_task.c index 73018afec4..5155dfbac0 100644 --- 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); } - pajeSetVariable(SIMIX_get_clock(), type->id, msg->id, "1"); + new_pajeSetVariable (SIMIX_get_clock(), msg, type, 1); 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); } @@ -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"); - 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) @@ -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"); - pajePopState (MSG_get_clock(), type->id, task_container->id); + new_pajePopState (MSG_get_clock(), task_container, type); } /* 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); - pajeSetVariable(SIMIX_get_clock(), type->id, msg->id, "1"); + new_pajeSetVariable (SIMIX_get_clock(), msg, type, 1); 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); - 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 */ @@ -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"); - 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); - pajeStartLink(MSG_get_clock(), type->id, "0", "SR", msg->id, key); + new_pajeStartLink(MSG_get_clock(), getRootContainer(), type, msg, "SR", key); destroyContainer (msg); diff --git a/src/instr/instr_paje.c b/src/instr/instr_paje.c index f8ce9de522..39f1510070 100644 --- 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); - 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); - pajeDefineContainerType(ret->id, ret->father->id, ret->name); + new_pajeDefineContainerType (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); + ret->color = xbt_strdup (color); //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; } @@ -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); + ret->color = xbt_strdup (color); //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; } @@ -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); - pajeDefineLinkType(ret->id, ret->father->id, source->id, dest->id, ret->name); + new_pajeDefineLinkType(ret, source, dest); } 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); - pajeDefineStateType(ret->id, ret->father->id, ret->name); + new_pajeDefineStateType(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); - pajeCreateContainer (SIMIX_get_clock(), new->id, new->type->id, new->father->id, new->name); + new_pajeCreateContainer (new); } //register hosts, routers, links containers @@ -260,7 +254,7 @@ void destroyContainer (container_t container) } //trace my destruction - pajeDestroyContainer(SIMIX_get_clock(), container->type->id, container->id); + new_pajeDestroyContainer(container); //free xbt_free (container->name); diff --git a/src/instr/instr_paje_trace.c b/src/instr/instr_paje_trace.c index 8f5eb7d8e3..33b3a059ce 100644 --- 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"); +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; @@ -40,7 +184,7 @@ static int pajeSetVariableId = 22; 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 @@ -175,331 +319,637 @@ void TRACE_paje_create_header(void) %% 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\ -%%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{ - 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{ - 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{ - 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{ - 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{ - 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 */ diff --git a/src/instr/instr_private.h b/src/instr/instr_private.h index 424a5e3526..4ea88e41b0 100644 --- 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; + char *color; 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 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); diff --git a/src/instr/instr_resource_utilization.c b/src/instr/instr_resource_utilization.c index 9bd1bee1d5..3308f3cf71 100644 --- 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); - 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 { @@ -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 (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 */ @@ -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); - 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) @@ -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); - 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); @@ -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); - 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{ @@ -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 - 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 - 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); @@ -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); - char value_str[100]; 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); @@ -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); - 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 @@ -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); - 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; } @@ -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); - 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 @@ -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); - 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; } diff --git a/src/instr/instr_routing.c b/src/instr/instr_routing.c index 15cd349270..8113389e3b 100644 --- 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++); - 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) @@ -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); - 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); } @@ -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); - 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); } diff --git a/src/instr/instr_smpi.c b/src/instr/instr_smpi.c index 5293a4508a..99207bbee4 100644 --- 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"); - 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) @@ -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"); - 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) @@ -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"); - 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) @@ -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"); - 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) @@ -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"); - 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) @@ -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"); - 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 */ diff --git a/src/instr/instr_surf.c b/src/instr/instr_surf.c index 8df49ad20e..19a044b745 100644 --- 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) { - 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) -- 2.20.1