From 6e9085979401423afcde6d001562b6ffd23021e8 Mon Sep 17 00:00:00 2001 From: schnorr Date: Tue, 7 Dec 2010 09:56:12 +0000 Subject: [PATCH] [trace] new system call to make categorized host utilization tracing possible again git-svn-id: svn+ssh://scm.gforge.inria.fr/svn/simgrid/simgrid/trunk@9028 48e7efb5-ca39-0410-a469-dd3cf9ba447f --- include/simix/simix.h | 3 +++ src/include/surf/surf.h | 3 +++ src/instr/instr_msg_task.c | 4 ---- src/msg/gos.c | 3 +++ src/simix/host_private.h | 3 +++ src/simix/smurf_private.h | 10 ++++++++++ src/simix/smx_host.c | 7 +++++++ src/simix/smx_smurf.c | 9 +++++++++ src/simix/smx_user.c | 19 +++++++++++++++++++ src/surf/cpu.c | 12 ++++++++++++ src/surf/cpu_im.c | 13 +++++++++++++ src/surf/workstation.c | 15 +++++++++++++++ 12 files changed, 97 insertions(+), 4 deletions(-) diff --git a/include/simix/simix.h b/include/simix/simix.h index fe8bd2f43d..0c60ed11f9 100644 --- a/include/simix/simix.h +++ b/include/simix/simix.h @@ -117,6 +117,9 @@ XBT_PUBLIC(void) SIMIX_req_host_execution_cancel(smx_action_t execution); XBT_PUBLIC(double) SIMIX_req_host_execution_get_remains(smx_action_t execution); XBT_PUBLIC(e_smx_state_t) SIMIX_req_host_execution_get_state(smx_action_t execution); XBT_PUBLIC(void) SIMIX_req_host_execution_set_priority(smx_action_t execution, double priority); +#ifdef HAVE_TRACING +XBT_PUBLIC(void) SIMIX_req_host_execution_set_category(smx_action_t execution, const char *category); +#endif XBT_PUBLIC(void) SIMIX_req_host_execution_wait(smx_action_t execution); diff --git a/src/include/surf/surf.h b/src/include/surf/surf.h index baee26ed4c..0b0bece3e9 100644 --- a/src/include/surf/surf.h +++ b/src/include/surf/surf.h @@ -271,6 +271,9 @@ typedef struct surf_model { int (*is_suspended) (surf_action_t action); /**< Return whether an action is suspended */ void (*set_max_duration) (surf_action_t action, double duration); /**< Set the max duration of an action*/ void (*set_priority) (surf_action_t action, double priority); /**< Set the priority of an action */ +#ifdef HAVE_TRACING + void (*set_category) (surf_action_t action, const char *category); /**< Set the category of an action */ +#endif double (*get_remains) (surf_action_t action); /**< Get the remains of an action */ #ifdef HAVE_LATENCY_BOUND_TRACKING int (*get_latency_limited) (surf_action_t action); /**< Return 1 if action is limited by latency, 0 otherwise */ diff --git a/src/instr/instr_msg_task.c b/src/instr/instr_msg_task.c index 5b0e9ea518..4bbae37668 100644 --- a/src/instr/instr_msg_task.c +++ b/src/instr/instr_msg_task.c @@ -161,8 +161,6 @@ void TRACE_msg_task_execute_start(m_task_t task) TRACE_task_container(task, name, 200); if (TRACE_msg_task_is_enabled()) pajePushState(MSG_get_clock(), "task-state", name, "execute"); - - TRACE_category_set(SIMIX_process_self(), task->category); } void TRACE_msg_task_execute_end(m_task_t task) @@ -178,8 +176,6 @@ void TRACE_msg_task_execute_end(m_task_t task) if (TRACE_msg_task_is_enabled()) pajePopState(MSG_get_clock(), "task-state", name); - TRACE_category_unset(SIMIX_process_self()); - DEBUG3("EXEC,out %p, %lld, %s", task, task->counter, task->category); } diff --git a/src/msg/gos.c b/src/msg/gos.c index 3749d9c0e8..ba361cc989 100644 --- a/src/msg/gos.c +++ b/src/msg/gos.c @@ -66,6 +66,9 @@ MSG_error_t MSG_task_execute(m_task_t task) SIMIX_req_host_execute(task->name, SIMIX_host_self(), simdata->computation_amount); SIMIX_req_host_execution_set_priority(simdata->compute, simdata->priority); +#ifdef HAVE_TRACING + SIMIX_req_host_execution_set_category(simdata->compute, task->category); +#endif self->simdata->waiting_action = simdata->compute; SIMIX_req_host_execution_wait(simdata->compute); diff --git a/src/simix/host_private.h b/src/simix/host_private.h index 63041a1838..65a48b6918 100644 --- a/src/simix/host_private.h +++ b/src/simix/host_private.h @@ -37,6 +37,9 @@ void SIMIX_host_execution_cancel(smx_action_t action); double SIMIX_host_execution_get_remains(smx_action_t action); e_smx_state_t SIMIX_host_execution_get_state(smx_action_t action); void SIMIX_host_execution_set_priority(smx_action_t action, double priority); +#ifdef HAVE_TRACING +void SIMIX_host_execution_set_category(smx_action_t action, const char *category); +#endif void SIMIX_pre_host_execution_wait(smx_req_t req); void SIMIX_host_execution_suspend(smx_action_t action); diff --git a/src/simix/smurf_private.h b/src/simix/smurf_private.h index 7a67a35d69..7a80c3f82c 100644 --- a/src/simix/smurf_private.h +++ b/src/simix/smurf_private.h @@ -24,6 +24,9 @@ typedef enum { REQ_HOST_EXECUTION_GET_REMAINS, REQ_HOST_EXECUTION_GET_STATE, REQ_HOST_EXECUTION_SET_PRIORITY, +#ifdef HAVE_TRACING + REQ_HOST_EXECUTION_SET_CATEGORY, +#endif REQ_HOST_EXECUTION_WAIT, REQ_PROCESS_CREATE, REQ_PROCESS_KILL, @@ -170,6 +173,13 @@ typedef struct s_smx_req { double priority; } host_execution_set_priority; +#ifdef HAVE_TRACING + struct { + smx_action_t execution; + const char *category; + } host_execution_set_category; +#endif + struct { smx_action_t execution; } host_execution_wait; diff --git a/src/simix/smx_host.c b/src/simix/smx_host.c index 744bfc8327..48ef546185 100644 --- a/src/simix/smx_host.c +++ b/src/simix/smx_host.c @@ -297,6 +297,13 @@ void SIMIX_host_execution_set_priority(smx_action_t action, double priority) surf_workstation_model->set_priority(action->execution.surf_exec, priority); } +#ifdef HAVE_TRACING +void SIMIX_host_execution_set_category(smx_action_t action, const char *category) +{ + surf_workstation_model->set_category(action->execution.surf_exec, category); +} +#endif + void SIMIX_pre_host_execution_wait(smx_req_t req) { smx_action_t action = req->host_execution_wait.execution; diff --git a/src/simix/smx_smurf.c b/src/simix/smx_smurf.c index 1c21595506..bed8cd05b1 100644 --- a/src/simix/smx_smurf.c +++ b/src/simix/smx_smurf.c @@ -193,6 +193,15 @@ void SIMIX_request_pre(smx_req_t req) SIMIX_request_answer(req); break; +#ifdef HAVE_TRACING + case REQ_HOST_EXECUTION_SET_CATEGORY: + SIMIX_host_execution_set_category( + req->host_execution_set_category.execution, + req->host_execution_set_category.category); + SIMIX_request_answer(req); + break; +#endif + case REQ_HOST_EXECUTION_WAIT: SIMIX_pre_host_execution_wait(req); break; diff --git a/src/simix/smx_user.c b/src/simix/smx_user.c index 60b71b1a9f..dae8115567 100644 --- a/src/simix/smx_user.c +++ b/src/simix/smx_user.c @@ -268,6 +268,25 @@ void SIMIX_req_host_execution_set_priority(smx_action_t execution, double priori SIMIX_request_push(&req); } +#ifdef HAVE_TRACING +/** + * \brief Set the category of an execution action. + * + * This functions changes the priority only. It calls a surf function. + * \param execution The execution action + * \param priority The new priority + */ +void SIMIX_req_host_execution_set_category(smx_action_t execution, const char *category) +{ + s_smx_req_t req; + + req.call = REQ_HOST_EXECUTION_SET_CATEGORY; + req.host_execution_set_category.execution = execution; + req.host_execution_set_category.category = xbt_strdup (category); + SIMIX_request_push(&req); +} +#endif + /** * \brief Waits for the completion of an execution action. * diff --git a/src/surf/cpu.c b/src/surf/cpu.c index e8e838b546..8e5f51fba7 100644 --- a/src/surf/cpu.c +++ b/src/surf/cpu.c @@ -387,6 +387,15 @@ static void cpu_action_set_priority(surf_action_t action, double priority) XBT_OUT; } +#ifdef HAVE_TRACING +static void cpu_action_set_category(surf_action_t action, const char *category) +{ + XBT_IN2("(%p,%s)", action, category); + action->category = xbt_strdup (category); + XBT_OUT; +} +#endif + static double cpu_action_get_remains(surf_action_t action) { XBT_IN1("(%p)", action); @@ -462,6 +471,9 @@ static void surf_cpu_model_init_internal(void) surf_cpu_model->is_suspended = cpu_action_is_suspended; surf_cpu_model->set_max_duration = cpu_action_set_max_duration; surf_cpu_model->set_priority = cpu_action_set_priority; +#ifdef HAVE_TRACING + surf_cpu_model->set_category = cpu_action_set_category; +#endif surf_cpu_model->get_remains = cpu_action_get_remains; surf_cpu_model->extension.cpu.execute = cpu_execute; diff --git a/src/surf/cpu_im.c b/src/surf/cpu_im.c index f4dfd90967..01268322cf 100644 --- a/src/surf/cpu_im.c +++ b/src/surf/cpu_im.c @@ -522,6 +522,16 @@ static void cpu_im_action_set_priority(surf_action_t action, XBT_OUT; } +#ifdef HAVE_TRACING +static void cpu_im_action_set_category(surf_action_t action, + const char *category) +{ + XBT_IN2("(%p,%s)", action, category); + action->category = xbt_strdup (category); + XBT_OUT; +} +#endif + static double cpu_im_action_get_remains(surf_action_t action) { XBT_IN1("(%p)", action); @@ -618,6 +628,9 @@ static void surf_cpu_im_model_init_internal(void) surf_cpu_model->is_suspended = cpu_im_action_is_suspended; surf_cpu_model->set_max_duration = cpu_im_action_set_max_duration; surf_cpu_model->set_priority = cpu_im_action_set_priority; +#ifdef HAVE_TRACING + surf_cpu_model->set_category = cpu_im_action_set_category; +#endif surf_cpu_model->get_remains = cpu_im_action_get_remains; surf_cpu_model->extension.cpu.execute = cpu_im_execute; diff --git a/src/surf/workstation.c b/src/surf/workstation.c index 4d6fd9adca..1d154ba66e 100644 --- a/src/surf/workstation.c +++ b/src/surf/workstation.c @@ -179,6 +179,18 @@ static void ws_action_set_priority(surf_action_t action, double priority) DIE_IMPOSSIBLE; } +#ifdef HAVE_TRACING +static void ws_action_set_category(surf_action_t action, const char *category) +{ + if (action->model_type == surf_network_model) + surf_network_model->set_category(action, category); + else if (action->model_type == surf_cpu_model) + surf_cpu_model->set_category(action, category); + else + DIE_IMPOSSIBLE; +} +#endif + #ifdef HAVE_LATENCY_BOUND_TRACKING static int ws_get_latency_limited(surf_action_t action) { @@ -295,6 +307,9 @@ static void surf_workstation_model_init_internal(void) surf_workstation_model->is_suspended = ws_action_is_suspended; surf_workstation_model->set_max_duration = ws_action_set_max_duration; surf_workstation_model->set_priority = ws_action_set_priority; +#ifdef HAVE_TRACING + surf_workstation_model->set_category = ws_action_set_category; +#endif surf_workstation_model->get_remains = ws_action_get_remains; #ifdef HAVE_LATENCY_BOUND_TRACKING surf_workstation_model->get_latency_limited = ws_get_latency_limited; -- 2.20.1