/*
* TRACE_surf_host_set_utilization: entry point from SimGrid
*/
void TRACE_surf_host_set_utilization(const char *resource,
const char *category,
double value,
double now,
double delta)
{
//only trace host utilization if host is known by tracing mechanism
if (!PJ_container_get_or_null(resource))
return;
if (!value)
return;
//trace uncategorized host utilization
if (TRACE_uncategorized()){
XBT_DEBUG("UNCAT HOST [%f - %f] %s power_used %f", now, now+delta, resource, value);
container_t container = PJ_container_get (resource);
type_t type = PJ_type_get ("power_used", container->type);
instr_event (now, delta, type, container, value);
}
//trace categorized utilization
if (TRACE_categorized()){
if (!category)
return;
//variable of this category starts by 'p', because we have a host here
char category_type[INSTR_DEFAULT_STR_SIZE];
snprintf (category_type, INSTR_DEFAULT_STR_SIZE, "p%s", category);
XBT_DEBUG("CAT HOST [%f - %f] %s %s %f", now, now+delta, resource, category_type, value);
container_t container = PJ_container_get (resource);
type_t type = PJ_type_get (category_type, container->type);
instr_event (now, delta, type, container, value);
}
return;
}
/*
* Instrumentation functions to trace MSG processes (msg_process_t)
*/
void TRACE_msg_process_change_host(msg_process_t process, msg_host_t old_host, msg_host_t new_host)
{
if (TRACE_msg_process_is_enabled()){
static long long int counter = 0;
char key[INSTR_DEFAULT_STR_SIZE];
snprintf (key, INSTR_DEFAULT_STR_SIZE, "%lld", counter++);
int len = INSTR_DEFAULT_STR_SIZE;
char str[INSTR_DEFAULT_STR_SIZE];
//start link
container_t msg = PJ_container_get (instr_process_id(process, str, len));
type_t type = PJ_type_get ("MSG_PROCESS_LINK", PJ_type_get_root());
new_pajeStartLink (MSG_get_clock(), PJ_container_get_root(), type, msg, "M", key);
//destroy existing container of this process
TRACE_msg_process_destroy (MSG_process_get_name (process), MSG_process_get_PID (process));
//create new container on the new_host location
TRACE_msg_process_create (MSG_process_get_name (process), MSG_process_get_PID (process), new_host);
//end link
msg = PJ_container_get(instr_process_id(process, str, len));
type = PJ_type_get ("MSG_PROCESS_LINK", PJ_type_get_root());
new_pajeEndLink (MSG_get_clock(), PJ_container_get_root(), type, msg, "M", key);
}
}
//used by all methods
static void __TRACE_surf_check_variable_set_to_zero(double now,
const char *variable,
const char *resource)
{
/*
* To trace resource utilization, we use pajeAddVariable and pajeSubVariable only.
* The Paje simulator needs a pajeSetVariable in the first place so it knows
* the initial value of all variables for subsequent adds/subs. If we don't do
* so, the first pajeAddVariable is added to a non-determined value within
* the Paje simulator, causing analysis problems.
*/
// create a key considering the resource and variable
int n = strlen(variable)+strlen(resource)+1;
char *key = (char*)xbt_malloc(n*sizeof(char));
snprintf (key, n, "%s%s", resource, variable);
// check if key exists: if it doesn't, set the variable to zero and mark this in the dict
if (!xbt_dict_get_or_null(platform_variables, key)) {
container_t container = PJ_container_get (resource);
type_t type = PJ_type_get (variable, container->type);
new_pajeSetVariable (now, container, type, 0);
xbt_dict_set(platform_variables, key, (char*)"", NULL);
}
xbt_free(key);
}
void TRACE_surf_host_set_power(double date, const char *resource, double power)
{
if (TRACE_categorized() || TRACE_uncategorized() || TRACE_platform()) {
container_t container = PJ_container_get(resource);
type_t type = PJ_type_get ("power", container->type);
new_pajeSetVariable(date, container, type, power);
}
}
void TRACE_surf_link_set_bandwidth(double date, const char *resource, double bandwidth)
{
if (TRACE_categorized() || TRACE_uncategorized() || TRACE_platform()) {
container_t container = PJ_container_get(resource);
type_t type = PJ_type_get ("bandwidth", container->type);
new_pajeSetVariable(date, container, type, bandwidth);
}
}
void TRACE_msg_process_destroy (const char *process_name, int process_pid, msg_host_t host)
{
int len = INSTR_DEFAULT_STR_SIZE;
char str[INSTR_DEFAULT_STR_SIZE];
container_t process = PJ_container_get (instr_process_id_2 (process_name, process_pid, str, len));
PJ_container_remove_from_parent (process);
PJ_container_free (process);
}
void TRACE_smpi_finalize(int rank)
{
if (!TRACE_smpi_is_enabled()) return;
char str[INSTR_DEFAULT_STR_SIZE];
container_t container = PJ_container_get(smpi_container(rank, str, INSTR_DEFAULT_STR_SIZE));
PJ_container_remove_from_parent (container);
PJ_container_free (container);
}
void TRACE_smpi_computing_out(int rank)
{
if (!TRACE_smpi_is_enabled()|| !TRACE_smpi_is_computing()) return;
char str[INSTR_DEFAULT_STR_SIZE];
smpi_container(rank, str, INSTR_DEFAULT_STR_SIZE);
container_t container = PJ_container_get (str);
type_t type = PJ_type_get ("MPI_STATE", container->type);
new_pajePopState (SIMIX_get_clock(), container, type);
}
void TRACE_msg_process_create (const char *process_name, int process_pid, msg_host_t host)
{
if (TRACE_msg_process_is_enabled()){
int len = INSTR_DEFAULT_STR_SIZE;
char str[INSTR_DEFAULT_STR_SIZE];
container_t host_container = PJ_container_get (sg_host_get_name(host));
PJ_container_new(instr_process_id_2(process_name, process_pid, str, len), INSTR_MSG_PROCESS, host_container);
}
}
void TRACE_msg_process_sleep_out(msg_process_t process)
{
if (TRACE_msg_process_is_enabled()){
int len = INSTR_DEFAULT_STR_SIZE;
char str[INSTR_DEFAULT_STR_SIZE];
container_t process_container = PJ_container_get (instr_process_id(process, str, len));
type_t type = PJ_type_get ("MSG_PROCESS_STATE", process_container->type);
new_pajePopState (MSG_get_clock(), process_container, type);
}
}
void TRACE_smpi_ptp_out(int rank, int src, int dst, const char *operation)
{
if (!TRACE_smpi_is_enabled()) return;
char str[INSTR_DEFAULT_STR_SIZE];
smpi_container(rank, str, INSTR_DEFAULT_STR_SIZE);
container_t container = PJ_container_get (str);
type_t type = PJ_type_get ("MPI_STATE", container->type);
new_pajePopState (SIMIX_get_clock(), container, type);
}
void TRACE_smpi_computing_in(int rank)
{
//do not forget to set the color first, otherwise this will explode
if (!TRACE_smpi_is_enabled()|| !TRACE_smpi_is_computing()) return;
char str[INSTR_DEFAULT_STR_SIZE];
smpi_container(rank, str, INSTR_DEFAULT_STR_SIZE);
container_t container = PJ_container_get (str);
type_t type = PJ_type_get ("MPI_STATE", container->type);
val_t value = PJ_value_get_or_new ("computing", NULL, type);
new_pajePushState (SIMIX_get_clock(), container, type, value);
}
void TRACE_msg_process_end(msg_process_t process)
{
if (TRACE_msg_process_is_enabled()) {
int len = INSTR_DEFAULT_STR_SIZE;
char str[INSTR_DEFAULT_STR_SIZE];
//that's the end, let's destroy it
container_t container = PJ_container_get (instr_process_id(process, str, len));
PJ_container_remove_from_parent (container);
PJ_container_free (container);
}
}
void TRACE_smpi_collective_in(int rank, int root, const char *operation)
{
if (!TRACE_smpi_is_enabled()) return;
char str[INSTR_DEFAULT_STR_SIZE];
smpi_container(rank, str, INSTR_DEFAULT_STR_SIZE);
container_t container = PJ_container_get (str);
type_t type = PJ_type_get ("MPI_STATE", container->type);
const char *color = instr_find_color (operation);
val_t value = PJ_value_get_or_new (operation, color, type);
new_pajePushState (SIMIX_get_clock(), container, type, value);
}
void TRACE_msg_task_execute_end(msg_task_t task)
{
XBT_DEBUG("EXEC,out %p, %lld, %s", task, task->counter, task->category);
if (TRACE_msg_process_is_enabled()){
int len = INSTR_DEFAULT_STR_SIZE;
char str[INSTR_DEFAULT_STR_SIZE];
container_t process_container = PJ_container_get (instr_process_id(MSG_process_self(), str, len));
type_t type = PJ_type_get ("MSG_PROCESS_STATE", process_container->type);
new_pajePopState (MSG_get_clock(), process_container, type);
}
}
void TRACE_msg_task_put_end(void)
{
XBT_DEBUG("PUT,out");
if (TRACE_msg_process_is_enabled()){
int len = INSTR_DEFAULT_STR_SIZE;
char str[INSTR_DEFAULT_STR_SIZE];
container_t process_container = PJ_container_get (instr_process_id(MSG_process_self(), str, len));
type_t type = PJ_type_get ("MSG_PROCESS_STATE", process_container->type);
new_pajePopState (MSG_get_clock(), process_container, type);
}
}
/* MSG_task_get related functions */
void TRACE_msg_task_get_start(void)
{
XBT_DEBUG("GET,in");
if (TRACE_msg_process_is_enabled()){
int len = INSTR_DEFAULT_STR_SIZE;
char str[INSTR_DEFAULT_STR_SIZE];
container_t process_container = PJ_container_get (instr_process_id(MSG_process_self(), str, len));
type_t type = PJ_type_get ("MSG_PROCESS_STATE", process_container->type);
val_t value = PJ_value_get ("receive", type);
new_pajePushState (MSG_get_clock(), process_container, type, value);
}
}
void TRACE_smpi_computing_init(int rank)
{
//first use, initialize the color in the trace
//TODO : check with lucas and Pierre how to generalize this approach
//to avoid unnecessary access to the color array
if (!TRACE_smpi_is_enabled() || !TRACE_smpi_is_computing()) return;
char str[INSTR_DEFAULT_STR_SIZE];
smpi_container(rank, str, INSTR_DEFAULT_STR_SIZE);
container_t container = PJ_container_get (str);
type_t type = PJ_type_get ("MPI_STATE", container->type);
const char *color = instr_find_color ("computing");
val_t value = PJ_value_get_or_new ("computing", color, type);
new_pajePushState (SIMIX_get_clock(), container, type, value);
}
void TRACE_smpi_recv(int rank, int src, int dst)
{
if (!TRACE_smpi_is_enabled()) return;
char key[INSTR_DEFAULT_STR_SIZE];
bzero (key, INSTR_DEFAULT_STR_SIZE);
TRACE_smpi_get_key(src, dst, key, INSTR_DEFAULT_STR_SIZE);
char str[INSTR_DEFAULT_STR_SIZE];
smpi_container(dst, str, INSTR_DEFAULT_STR_SIZE);
container_t container = PJ_container_get (str);
type_t type = PJ_type_get ("MPI_LINK", PJ_type_get_root());
new_pajeEndLink (SIMIX_get_clock(), PJ_container_get_root(), type, container, "PTP", key);
}
void TRACE_smpi_init(int rank)
{
if (!TRACE_smpi_is_enabled()) return;
char str[INSTR_DEFAULT_STR_SIZE];
smpi_container(rank, str, INSTR_DEFAULT_STR_SIZE);
container_t father;
if (TRACE_smpi_is_grouped()){
father = PJ_container_get (SIMIX_host_self_get_name());
}else{
father = PJ_container_get_root ();
}
xbt_assert(father!=NULL,
"Could not find a parent for mpi rank %s at function %s", str, __FUNCTION__);
PJ_container_new(str, INSTR_SMPI, father);
}
void TRACE_msg_task_get_end(double start_time, msg_task_t task)
{
XBT_DEBUG("GET,out %p, %lld, %s", task, task->counter, task->category);
if (TRACE_msg_process_is_enabled()){
int len = INSTR_DEFAULT_STR_SIZE;
char str[INSTR_DEFAULT_STR_SIZE];
container_t process_container = PJ_container_get (instr_process_id(MSG_process_self(), str, len));
type_t type = PJ_type_get ("MSG_PROCESS_STATE", process_container->type);
new_pajePopState (MSG_get_clock(), process_container, type);
char key[INSTR_DEFAULT_STR_SIZE];
snprintf (key, INSTR_DEFAULT_STR_SIZE, "p%lld", task->counter);
type = PJ_type_get ("MSG_PROCESS_TASK_LINK", PJ_type_get_root());
new_pajeEndLink(MSG_get_clock(), PJ_container_get_root(), type, process_container, "SR", key);
}
}
/* MSG_task_put related functions */
int TRACE_msg_task_put_start(msg_task_t task)
{
XBT_DEBUG("PUT,in %p, %lld, %s", task, task->counter, task->category);
if (TRACE_msg_process_is_enabled()){
int len = INSTR_DEFAULT_STR_SIZE;
char str[INSTR_DEFAULT_STR_SIZE];
container_t process_container = PJ_container_get (instr_process_id(MSG_process_self(), str, len));
type_t type = PJ_type_get ("MSG_PROCESS_STATE", process_container->type);
val_t value = PJ_value_get ("send", type);
new_pajePushState (MSG_get_clock(), process_container, type, value);
char key[INSTR_DEFAULT_STR_SIZE];
snprintf (key, INSTR_DEFAULT_STR_SIZE, "p%lld", task->counter);
type = PJ_type_get ("MSG_PROCESS_TASK_LINK", PJ_type_get_root());
new_pajeStartLink(MSG_get_clock(), PJ_container_get_root(), type, process_container, "SR", key);
}
return 1;
}
