XBT_PUBLIC(void) TRACE_msg_set_task_category (m_task_t task, const char *category);
XBT_PUBLIC(void) TRACE_msg_set_process_category (m_process_t process, const char *category);
XBT_PUBLIC(void) TRACE_set_mask (int mask);
-XBT_PUBLIC(void) __TRACE_host_variable (double time, const char *variable, double value, const char *what);
-XBT_PUBLIC(void) __TRACE_link_variable (double time, const char *src, const char *dst, const char *variable, double value, const char *what);
+XBT_PUBLIC(void) TRACE_user_host_variable (double time, const char *variable, double value, const char *what);
+XBT_PUBLIC(void) TRACE_user_link_variable (double time, const char *src, const char *dst, const char *variable, double value, const char *what);
XBT_PUBLIC(void) TRACE_declare_mark (const char *mark_type);
XBT_PUBLIC(void) TRACE_mark (const char *mark_type, const char *mark_value);
XBT_PUBLIC(int) TRACE_smpi_set_category (const char *category);
#define TRACE_host_variable_declare(var) \
- __TRACE_host_variable(0,var,0,"declare");
+ TRACE_user_host_variable(0,var,0,"declare");
#define TRACE_host_variable_set_with_time(time,var,value) \
- __TRACE_host_variable(time,var,value,"set");
+ TRACE_user_host_variable(time,var,value,"set");
#define TRACE_host_variable_add_with_time(time,var,value) \
- __TRACE_host_variable(time,var,value,"add");
+ TRACE_user_host_variable(time,var,value,"add");
#define TRACE_host_variable_sub_with_time(time,var,value) \
- __TRACE_host_variable(time,var,value,"sub");
+ TRACE_user_host_variable(time,var,value,"sub");
#define TRACE_host_variable_set(var,value) \
- __TRACE_host_variable(MSG_get_clock(),var,value,"set");
+ TRACE_user_host_variable(MSG_get_clock(),var,value,"set");
#define TRACE_host_variable_add(var,value) \
- __TRACE_host_variable(MSG_get_clock(),var,value,"add");
+ TRACE_user_host_variable(MSG_get_clock(),var,value,"add");
#define TRACE_host_variable_sub(var,value) \
- __TRACE_host_variable(MSG_get_clock(),var,value,"sub");
+ TRACE_user_host_variable(MSG_get_clock(),var,value,"sub");
#define TRACE_link_variable_declare(var) \
- __TRACE_link_variable(0,NULL,NULL,var,0,"declare");
+ TRACE_user_link_variable(0,NULL,NULL,var,0,"declare");
#define TRACE_link_variable_set_with_time(time,src,dst,var,value) \
- __TRACE_link_variable(time,src,dst,var,value,"set");
+ TRACE_user_link_variable(time,src,dst,var,value,"set");
#define TRACE_link_variable_add_with_time(time,src,dst,var,value) \
- __TRACE_link_variable(time,src,dst,var,value,"add");
+ TRACE_user_link_variable(time,src,dst,var,value,"add");
#define TRACE_link_variable_sub_with_time(time,src,dst,var,value) \
- __TRACE_link_variable(time,src,dst,var,value,"sub");
+ TRACE_user_link_variable(time,src,dst,var,value,"sub");
#define TRACE_link_variable_set(src,dst,var,value) \
- __TRACE_link_variable(MSG_get_clock(),src,dst,var,value,"set");
+ TRACE_user_link_variable(MSG_get_clock(),src,dst,var,value,"set");
#define TRACE_link_variable_add(src,dst,var,value) \
- __TRACE_link_variable(MSG_get_clock(),src,dst,var,value,"add");
+ TRACE_user_link_variable(MSG_get_clock(),src,dst,var,value,"add");
#define TRACE_link_variable_sub(src,dst,var,value) \
- __TRACE_link_variable(MSG_get_clock(),src,dst,var,value,"sub");
+ TRACE_user_link_variable(MSG_get_clock(),src,dst,var,value,"sub");
#else /* HAVE_TRACING */
static xbt_dict_t current_task_category = NULL;
-void __TRACE_category_init ()
+void TRACE_category_alloc ()
{
current_task_category = xbt_dict_new();
}
-void __TRACE_category_set (smx_process_t proc, const char *category)
+void TRACE_category_release ()
+{
+ xbt_dict_free (¤t_task_category);
+}
+
+void TRACE_category_set (smx_process_t proc, const char *category)
{
char processid[100];
char *var_cpy = NULL;
xbt_dict_set (current_task_category, processid, var_cpy, xbt_free);
}
-char *__TRACE_category_get (smx_process_t proc)
+char *TRACE_category_get (smx_process_t proc)
{
char processid[100];
snprintf (processid, 100, "%p", proc);
return xbt_dict_get_or_null (current_task_category, processid);
}
-void __TRACE_category_unset (smx_process_t proc)
+void TRACE_category_unset (smx_process_t proc)
{
char processid[100];
snprintf (processid, 100, "%p", proc);
}
}
-void __TRACE_msg_category_set (smx_process_t proc, m_task_t task)
+void TRACE_msg_category_set (smx_process_t proc, m_task_t task)
{
- __TRACE_category_set (proc, task->category);
+ TRACE_category_set (proc, task->category);
}
static int trace_configured = 0;
-int _TRACE_configured (void)
+int TRACE_is_configured (void)
{
return trace_configured;
}
-int _TRACE_smpi_enabled (void)
+int TRACE_smpi_is_enabled (void)
{
return xbt_cfg_get_int(_surf_cfg_set, OPT_TRACING_SMPI);
}
-int _TRACE_platform_enabled (void)
+int TRACE_platform_is_enabled (void)
{
return xbt_cfg_get_int(_surf_cfg_set, OPT_TRACING_PLATFORM);
}
-int _TRACE_msg_task_enabled (void)
+int TRACE_msg_task_is_enabled (void)
{
return xbt_cfg_get_int(_surf_cfg_set, OPT_TRACING_MSG_TASK);
}
-int _TRACE_msg_process_enabled (void)
+int TRACE_msg_process_is_enabled (void)
{
return xbt_cfg_get_int(_surf_cfg_set, OPT_TRACING_MSG_PROCESS);
}
-int _TRACE_msg_volume_enabled (void)
+int TRACE_msg_volume_is_enabled (void)
{
return xbt_cfg_get_int(_surf_cfg_set, OPT_TRACING_MSG_VOLUME);
}
-char *_TRACE_filename (void)
+char *TRACE_get_filename (void)
{
return xbt_cfg_get_string (_surf_cfg_set, OPT_TRACING_FILENAME);
}
-char *_TRACE_platform_method (void)
+char *TRACE_get_platform_method (void)
{
return xbt_cfg_get_string (_surf_cfg_set, OPT_TRACING_PLATFORM_METHOD);
}
int TRACE_start ()
{
- if (!_TRACE_configured()){
+ if (!TRACE_is_configured()){
THROW0 (tracing_error, TRACE_ERROR_START,
"TRACE_start should be called after SimGrid initialization functions.");
return 0;
return 0;
}
- char *filename = _TRACE_filename ();
+ char *filename = TRACE_get_filename ();
if (!filename){
THROW0 (tracing_error, TRACE_ERROR_START,
"Trace filename is not initialized.");
/* other trace initialization */
defined_types = xbt_dict_new();
created_categories = xbt_dict_new();
- __TRACE_msg_init();
- __TRACE_category_init ();
- TRACE_surf_init();
- __TRACE_msg_process_init ();
- __TRACE_smpi_init ();
+ TRACE_msg_task_alloc ();
+ TRACE_category_alloc ();
+ TRACE_surf_alloc ();
+ TRACE_msg_process_alloc ();
+ TRACE_smpi_alloc ();
return 0;
}
if (!IS_TRACING) return 1;
if (category != NULL){
int ret = TRACE_category (category);
- __TRACE_category_set (SIMIX_process_self(), category);
+ TRACE_category_set (SIMIX_process_self(), category);
return ret;
}else{
- __TRACE_category_unset (SIMIX_process_self());
+ TRACE_category_unset (SIMIX_process_self());
return 0;
}
}
static xbt_dict_t process_containers = NULL;
-void __TRACE_msg_process_init (void)
+void TRACE_msg_process_alloc (void)
{
process_containers = xbt_dict_new();
}
-void __TRACE_msg_process_location (m_process_t process)
+void TRACE_msg_process_release (void)
+{
+ xbt_dict_free (&process_containers);
+}
+
+static void TRACE_msg_process_location (m_process_t process)
{
char name[200], alias[200];
m_host_t host = NULL;
}
}
-void __TRACE_msg_process_present (m_process_t process)
+static void TRACE_msg_process_present (m_process_t process)
{
char alias[200];
m_host_t host = NULL;
process->category = xbt_strdup(category);
//create container of type "PROCESS" to indicate location
- __TRACE_msg_process_location (process);
- __TRACE_msg_process_present (process);
+ TRACE_msg_process_location (process);
+ TRACE_msg_process_present (process);
//create container of type "process" to indicate behavior
TRACE_process_container (process, name, 200);
TRACE_process_alias_container (process, old_host, alias, 200);
if (IS_TRACING_PROCESSES) pajePopState (MSG_get_clock(), "presence", alias);
- __TRACE_msg_process_location (process);
- __TRACE_msg_process_present (process);
+ TRACE_msg_process_location (process);
+ TRACE_msg_process_present (process);
}
void TRACE_msg_process_kill (m_process_t process)
static xbt_dict_t task_containers = NULL;
-void __TRACE_msg_init (void)
+void TRACE_msg_task_alloc (void)
{
task_containers = xbt_dict_new();
}
-void __TRACE_task_location (m_task_t task)
+void TRACE_msg_task_release (void)
+{
+ xbt_dict_free (&task_containers);
+}
+
+static void TRACE_task_location (m_task_t task)
{
char container[200];
char name[200], alias[200];
}
}
-void __TRACE_task_location_present (m_task_t task)
+static void TRACE_task_location_present (m_task_t task)
{
char alias[200];
m_process_t process = NULL;
pajePushState (MSG_get_clock(), "presence", alias, "presence");
}
-void __TRACE_task_location_not_present (m_task_t task)
+static void TRACE_task_location_not_present (m_task_t task)
{
char alias[200];
m_process_t process = NULL;
strncpy(task->category, category, strlen(category)+1);
//tracing task location based on host
- __TRACE_task_location (task);
- __TRACE_task_location_present (task);
+ TRACE_task_location (task);
+ TRACE_task_location_present (task);
TRACE_task_container (task, name, 200);
//create container of type "task" to indicate behavior
TRACE_task_container (task, name, 200);
if (IS_TRACING_TASKS) pajePushState (MSG_get_clock(), "task-state", name, "execute");
- __TRACE_msg_category_set (SIMIX_process_self(), task);
+ TRACE_msg_category_set (SIMIX_process_self(), task);
}
void TRACE_msg_task_execute_end (m_task_t task)
TRACE_task_container (task, name, 200);
if (IS_TRACING_TASKS) pajePopState (MSG_get_clock(), "task-state", name);
- __TRACE_category_unset(SIMIX_process_self());
+ TRACE_category_unset(SIMIX_process_self());
}
/* MSG_task_destroy related functions */
if (IS_TRACING_TASKS) pajeDestroyContainer (MSG_get_clock(), "task", name);
//finish the location of this task
- __TRACE_task_location_not_present (task);
+ TRACE_task_location_not_present (task);
//free category
xbt_free (task->category);
TRACE_task_container (task, name, 200);
if (IS_TRACING_TASKS) pajePopState (MSG_get_clock(), "task-state", name);
- __TRACE_msg_volume_finish (task);
+ TRACE_msg_volume_finish (task);
- __TRACE_task_location (task);
- __TRACE_task_location_present (task);
+ TRACE_task_location (task);
+ TRACE_task_location_present (task);
}
/* MSG_task_put related functions */
if (IS_TRACING_TASKS) pajePopState (MSG_get_clock(), "task-state", name);
if (IS_TRACING_TASKS) pajePushState (MSG_get_clock(), "task-state", name, "communicate");
- __TRACE_msg_volume_start (task);
+ TRACE_msg_volume_start (task);
//trace task location grouped by host
- __TRACE_task_location_not_present (task);
+ TRACE_task_location_not_present (task);
//set current category
- __TRACE_msg_category_set (SIMIX_process_self(), task);
+ TRACE_msg_category_set (SIMIX_process_self(), task);
return 1;
}
{
if (!IS_TRACING) return;
- __TRACE_category_unset (SIMIX_process_self());
+ TRACE_category_unset (SIMIX_process_self());
}
#endif
#ifdef HAVE_TRACING
-void __TRACE_msg_volume_start (m_task_t task)
+void TRACE_msg_volume_start (m_task_t task)
{
m_process_t process = NULL;
m_host_t host = NULL;
pajeStartLinkWithVolume (MSG_get_clock(), "volume", "0", task->category, process_alias, task_name, volume);
}
-void __TRACE_msg_volume_finish (m_task_t task)
+void TRACE_msg_volume_finish (m_task_t task)
{
char process_name[200], process_alias[200];
char task_name[200];
#define IS_TRACING (tracing_active)
#define IS_TRACED(n) (n->category)
-#define IS_TRACING_TASKS (_TRACE_msg_task_enabled())
-#define IS_TRACING_PLATFORM (_TRACE_platform_enabled())
-#define IS_TRACING_PROCESSES (_TRACE_msg_process_enabled())
-#define IS_TRACING_VOLUME (_TRACE_msg_volume_enabled())
-#define IS_TRACING_SMPI (_TRACE_smpi_enabled())
+#define IS_TRACING_TASKS (TRACE_msg_task_is_enabled())
+#define IS_TRACING_PLATFORM (TRACE_platform_is_enabled())
+#define IS_TRACING_PROCESSES (TRACE_msg_process_is_enabled())
+#define IS_TRACING_VOLUME (TRACE_msg_volume_is_enabled())
+#define IS_TRACING_SMPI (TRACE_smpi_is_enabled())
#include "instr/instr.h"
#include "msg/msg.h"
char *TRACE_task_alias_container (m_task_t task, m_process_t process, m_host_t host, char *output, int len);
/* from categories.c */
-void __TRACE_category_init (void);
-void __TRACE_category_set (smx_process_t proc, const char *category);
-char *__TRACE_category_get (smx_process_t proc);
-void __TRACE_category_unset (smx_process_t proc);
-void __TRACE_msg_category_set (smx_process_t proc, m_task_t task);
+void TRACE_category_alloc (void);
+void TRACE_category_release (void);
+void TRACE_category_set (smx_process_t proc, const char *category);
+char *TRACE_category_get (smx_process_t proc);
+void TRACE_category_unset (smx_process_t proc);
+void TRACE_msg_category_set (smx_process_t proc, m_task_t task);
/* declaration of instrumentation functions from msg_task_instr.c */
-void __TRACE_msg_init (void);
-void __TRACE_task_location (m_task_t task);
-void __TRACE_task_location_present (m_task_t task);
-void __TRACE_task_location_not_present (m_task_t task);
+void TRACE_msg_task_alloc (void);
+void TRACE_msg_task_release (void);
void TRACE_msg_task_create (m_task_t task);
void TRACE_msg_task_execute_start (m_task_t task);
void TRACE_msg_task_execute_end (m_task_t task);
void TRACE_msg_task_put_end (void);
/* declaration of instrumentation functions from msg_process_instr.c */
-void __TRACE_msg_process_init (void);
-void __TRACE_msg_process_location (m_process_t process);
-void __TRACE_msg_process_present (m_process_t process);
+void TRACE_msg_process_alloc (void);
+void TRACE_msg_process_release (void);
void TRACE_msg_process_change_host (m_process_t process, m_host_t old_host, m_host_t new_host);
void TRACE_msg_process_kill (m_process_t process);
void TRACE_msg_process_suspend (m_process_t process);
void TRACE_msg_process_end (m_process_t process);
/* declaration of instrumentation functions from msg_volume.c */
-void __TRACE_msg_volume_start (m_task_t task);
-void __TRACE_msg_volume_finish (m_task_t task);
+void TRACE_msg_volume_start (m_task_t task);
+void TRACE_msg_volume_finish (m_task_t task);
/* from smx.c */
void TRACE_smx_action_execute (smx_action_t act);
void TRACE_smx_action_destroy (smx_action_t act);
/* from surf.c */
-void TRACE_surf_init (void);
-void TRACE_surf_finalize (void);
+void TRACE_surf_alloc (void);
+void TRACE_surf_release (void);
void TRACE_surf_host_declaration (char *name, double power);
void TRACE_surf_host_set_power (double date, char *resource, double power);
void TRACE_surf_host_define_id (const char *name, int host_id);
void TRACE_surf_gtnets_destroy (void *action);
/* from smpi_instr.c */
-void __TRACE_smpi_init (void);
+void TRACE_smpi_alloc (void);
+void TRACE_smpi_release (void);
void TRACE_smpi_init (int rank);
void TRACE_smpi_finalize (int rank);
void TRACE_smpi_start (void);
-void TRACE_smpi_end (void);
void TRACE_smpi_collective_in (int rank, int root, const char *operation);
void TRACE_smpi_collective_out (int rank, int root, const char *operation);
void TRACE_smpi_ptp_in (int rank, int src, int dst, const char *operation);
void TRACE_smpi_recv (int rank, int src, int dst);
/* from instr_config.c */
-int _TRACE_configured (void);
-int _TRACE_smpi_enabled (void);
-int _TRACE_platform_enabled (void);
-int _TRACE_msg_task_enabled (void);
-int _TRACE_msg_process_enabled (void);
-int _TRACE_msg_volume_enabled (void);
-char *_TRACE_filename (void);
-char *_TRACE_platform_method (void);
+int TRACE_is_configured (void);
+int TRACE_smpi_is_enabled (void);
+int TRACE_platform_is_enabled (void);
+int TRACE_msg_task_is_enabled (void);
+int TRACE_msg_process_is_enabled (void);
+int TRACE_msg_volume_is_enabled (void);
+char *TRACE_get_filename (void);
+char *TRACE_get_platform_method (void);
void TRACE_global_init(int *argc, char **argv);
/* from resource_utilization.c */
void TRACE_surf_host_set_utilization (const char *name, smx_action_t smx_action, double value, double now, double delta);
void TRACE_surf_link_set_utilization (void *link, smx_action_t smx_action, double value, double now, double delta);
-void __TRACE_surf_resource_utilization_start (smx_action_t action);
-void __TRACE_surf_resource_utilization_event (smx_action_t action, double now, double delta, const char *variable, const char *resource, double value);
-void __TRACE_surf_resource_utilization_end (smx_action_t action);
-void __TRACE_surf_resource_utilization_initialize (void);
-void __TRACE_surf_resource_utilization_finalize (void);
+void TRACE_surf_resource_utilization_start (smx_action_t action);
+void TRACE_surf_resource_utilization_event (smx_action_t action, double now, double delta, const char *variable, const char *resource, double value);
+void TRACE_surf_resource_utilization_end (smx_action_t action);
+void TRACE_surf_resource_utilization_alloc (void);
+void TRACE_surf_resource_utilization_release (void);
#endif
/* end of check */
}
+#define A_METHOD
//A
static void __TRACE_surf_resource_utilization_A (double now, double delta, const char *variable, const char *resource, double value)
{
return;
}
+#define B_METHOD
//B
static void __TRACE_surf_resource_utilization_initialize_B ()
{
xbt_dict_free (&method_b_dict);
}
+#define C_METHOD
//C
static void __TRACE_surf_resource_utilization_start_C (smx_action_t action)
{
xbt_dict_free (&method_c_dict);
}
+#define RESOURCE_UTILIZATION_INTERFACE
/*
* TRACE_surf_link_set_utilization: entry point from SimGrid
*/
char resource[100];
snprintf (resource, 100, "%p", link);
snprintf (type, 100, "b%s", smx_action->category);
- __TRACE_surf_resource_utilization_event (smx_action, now, delta, type, resource, value);
+ TRACE_surf_resource_utilization_event (smx_action, now, delta, type, resource, value);
return;
}
if (!value) return;
snprintf (type, 100, "p%s", smx_action->category);
- __TRACE_surf_resource_utilization_event (smx_action, now, delta, type, name, value);
+ TRACE_surf_resource_utilization_event (smx_action, now, delta, type, name, value);
return;
}
/*
* __TRACE_surf_resource_utilization_*: entry points from tracing functions
*/
-void __TRACE_surf_resource_utilization_start (smx_action_t action)
+void TRACE_surf_resource_utilization_start (smx_action_t action)
{
if (currentMethod == methodC){
__TRACE_surf_resource_utilization_start_C (action);
}
}
-void __TRACE_surf_resource_utilization_end (smx_action_t action)
-{
- if (currentMethod == methodC){
- __TRACE_surf_resource_utilization_end_C (action);
- }
-}
-
-void __TRACE_surf_resource_utilization_event (smx_action_t action, double now, double delta, const char *variable, const char *resource, double value)
+void TRACE_surf_resource_utilization_event (smx_action_t action, double now, double delta, const char *variable, const char *resource, double value)
{
if (currentMethod == methodA){
__TRACE_surf_resource_utilization_A (now, delta, variable, resource, value);
}
}
-void __TRACE_surf_resource_utilization_initialize ()
+void TRACE_surf_resource_utilization_end (smx_action_t action)
+{
+ if (currentMethod == methodC){
+ __TRACE_surf_resource_utilization_end_C (action);
+ }
+}
+
+void TRACE_surf_resource_utilization_alloc ()
{
platform_variables = xbt_dict_new();
- __TRACE_define_method (_TRACE_platform_method());
+ __TRACE_define_method (TRACE_get_platform_method());
if (currentMethod == methodA){
}else if (currentMethod == methodB){
}
}
-void __TRACE_surf_resource_utilization_finalize ()
+void TRACE_surf_resource_utilization_release ()
{
if (currentMethod == methodA){
}else if (currentMethod == methodB){
static xbt_dict_t keys;
-static char *_TRACE_smpi_container (int rank, char *container, int n)
+static char *TRACE_smpi_container (int rank, char *container, int n)
{
snprintf (container, n, "rank-%d", rank);
return container;
}
-static char *_TRACE_smpi_put_key (int src, int dst, char *key, int n)
+static char *TRACE_smpi_put_key (int src, int dst, char *key, int n)
{
//get the dynar for src#dst
char aux[100];
return key;
}
-static char *_TRACE_smpi_get_key (int src, int dst, char *key, int n)
+static char *TRACE_smpi_get_key (int src, int dst, char *key, int n)
{
char aux[100];
snprintf (aux, 100, "%d#%d", src, dst);
return key;
}
-void __TRACE_smpi_init ()
+void TRACE_smpi_alloc ()
{
keys = xbt_dict_new();
}
}
}
-void TRACE_smpi_end (void)
+void TRACE_smpi_release (void)
{
- TRACE_surf_finalize ();
+ TRACE_surf_release ();
if (IS_TRACING_SMPI){
TRACE_end();
}
if (!IS_TRACING_SMPI) return;
char str[100];
- _TRACE_smpi_container (rank, str, 100);
+ TRACE_smpi_container (rank, str, 100);
pajeCreateContainer (SIMIX_get_clock(), str, "MPI_PROCESS",
SIMIX_host_get_name(SIMIX_host_self()), str);
}
char str[100];
pajeDestroyContainer (SIMIX_get_clock(), "MPI_PROCESS",
- _TRACE_smpi_container (rank, str, 100));
+ TRACE_smpi_container (rank, str, 100));
}
void TRACE_smpi_collective_in (int rank, int root, const char *operation)
char str[100];
pajePushState (SIMIX_get_clock(), "MPI_STATE",
- _TRACE_smpi_container (rank, str, 100), operation);
+ TRACE_smpi_container (rank, str, 100), operation);
}
void TRACE_smpi_collective_out (int rank, int root, const char *operation)
char str[100];
pajePopState (SIMIX_get_clock(), "MPI_STATE",
- _TRACE_smpi_container (rank, str, 100));
+ TRACE_smpi_container (rank, str, 100));
}
void TRACE_smpi_ptp_in (int rank, int src, int dst, const char *operation)
char str[100];
pajePushState (SIMIX_get_clock(), "MPI_STATE",
- _TRACE_smpi_container (rank, str, 100), operation);
+ TRACE_smpi_container (rank, str, 100), operation);
}
void TRACE_smpi_ptp_out (int rank, int src, int dst, const char *operation)
char str[100];
pajePopState (SIMIX_get_clock(), "MPI_STATE",
- _TRACE_smpi_container (rank, str, 100));
+ TRACE_smpi_container (rank, str, 100));
}
void TRACE_smpi_send (int rank, int src, int dst)
if (!IS_TRACING_SMPI) return;
char key[100], str[100];
- _TRACE_smpi_put_key (src, dst, key, 100);
+ TRACE_smpi_put_key (src, dst, key, 100);
pajeStartLink (SIMIX_get_clock(), "MPI_LINK", "0", "PTP",
- _TRACE_smpi_container (src, str, 100), key);
+ TRACE_smpi_container (src, str, 100), key);
}
void TRACE_smpi_recv (int rank, int src, int dst)
if (!IS_TRACING_SMPI) return;
char key[100], str[100];
- _TRACE_smpi_get_key (src, dst, key, 100);
+ TRACE_smpi_get_key (src, dst, key, 100);
pajeEndLink (SIMIX_get_clock(), "MPI_LINK", "0", "PTP",
- _TRACE_smpi_container (dst, str, 100), key);
+ TRACE_smpi_container (dst, str, 100), key);
}
#endif
if (!IS_TRACING) return;
act->counter = counter++;
- category = __TRACE_category_get (SIMIX_process_self());
+ category = TRACE_category_get (SIMIX_process_self());
if (category){
act->category = xbt_new (char, strlen (category)+1);
strncpy (act->category, category, strlen(category)+1);
}
- __TRACE_surf_resource_utilization_start (act);
+ TRACE_surf_resource_utilization_start (act);
}
void TRACE_smx_action_communicate (smx_action_t act, smx_process_t proc)
if (!IS_TRACING) return;
act->counter = counter++;
- category = __TRACE_category_get (proc);
+ category = TRACE_category_get (proc);
if (category){
act->category = xbt_strdup (category);
}
- __TRACE_surf_resource_utilization_start (act);
+ TRACE_surf_resource_utilization_start (act);
}
void TRACE_smx_action_destroy (smx_action_t act)
if (act->category){
xbt_free (act->category);
}
- __TRACE_surf_resource_utilization_end (act);
+ TRACE_surf_resource_utilization_end (act);
}
#endif
static xbt_dict_t gtnets_src; /* %p (action) -> %s */
static xbt_dict_t gtnets_dst; /* %p (action) -> %s */
-void TRACE_surf_init (void)
+void TRACE_surf_alloc (void)
{
created_links = xbt_dict_new();
host_containers = xbt_dict_new();
gtnets_src = xbt_dict_new ();
gtnets_dst = xbt_dict_new ();
- __TRACE_surf_resource_utilization_initialize();
+ TRACE_surf_resource_utilization_alloc();
}
-void TRACE_surf_finalize (void)
+void TRACE_surf_release (void)
{
char *key, *value;
xbt_dict_cursor_t cursor = NULL;
- __TRACE_surf_resource_utilization_finalize();
+ TRACE_surf_resource_utilization_release();
/* get all host from host_containers */
xbt_dict_foreach(host_containers, cursor, key, value) {
extern routing_global_t global_routing;
-void __TRACE_link_variable (double time, const char *src, const char *dst, const char *variable, double value, const char *what)
+void TRACE_user_link_variable (double time, const char *src, const char *dst, const char *variable, double value, const char *what)
{
if (!IS_TRACING || !IS_TRACING_PLATFORM) return;
}
}
-void __TRACE_host_variable (double time, const char *variable, double value, const char *what)
+void TRACE_user_host_variable (double time, const char *variable, double value, const char *what)
{
char valuestr[100];
if (!IS_TRACING || !IS_TRACING_PLATFORM) return;
m_process_t p = NULL;
#ifdef HAVE_TRACING
- TRACE_surf_finalize();
+ TRACE_surf_release ();
#endif
while ((p = xbt_fifo_pop(msg_global->process_list))) {
SIMIX_message_sizes_output("toto.txt");
#ifdef HAVE_TRACING
- TRACE_smpi_end ();
+ TRACE_smpi_release ();
#endif
SIMIX_clean();
"Vivaldi", surf_network_model);
#ifdef HAVE_TRACING
- __TRACE_host_variable(0,"vivaldi_x",0,"declare");
- __TRACE_host_variable(0,"vivaldi_y",0,"declare");
- __TRACE_host_variable(0,"vivaldi_h",0,"declare");
+ TRACE_user_host_variable(0,"vivaldi_x",0,"declare");
+ TRACE_user_host_variable(0,"vivaldi_y",0,"declare");
+ TRACE_user_host_variable(0,"vivaldi_h",0,"declare");
#endif
xbt_cfg_set_string(_surf_cfg_set, "routing", "none");