*/
void TRACE_host_set_state(const char* host, const char* state_name, const char* value_name)
{
- container_t container = simgrid::instr::Container::byName(host);
- simgrid::instr::StateType* state = static_cast<simgrid::instr::StateType*>(container->type_->byName(state_name));
+ container_t container = simgrid::instr::Container::byName(host);
+ simgrid::instr::StateType* state = container->getState(state_name);
state->addEntityValue(value_name);
- state->setEvent(MSG_get_clock(), container, value_name);
+ state->setEvent(value_name);
}
/** \ingroup TRACE_user_variables
*/
void TRACE_host_push_state(const char* host, const char* state_name, const char* value_name)
{
- container_t container = simgrid::instr::Container::byName(host);
- simgrid::instr::StateType* state = static_cast<simgrid::instr::StateType*>(container->type_->byName(state_name));
+ container_t container = simgrid::instr::Container::byName(host);
+ simgrid::instr::StateType* state = container->getState(state_name);
state->addEntityValue(value_name);
- state->pushEvent(MSG_get_clock(), container, value_name);
+ state->pushEvent(value_name);
}
/** \ingroup TRACE_user_variables
*/
void TRACE_host_pop_state(const char* host, const char* state_name)
{
- container_t container = simgrid::instr::Container::byName(host);
- simgrid::instr::StateType* state = static_cast<simgrid::instr::StateType*>(container->type_->byName(state_name));
- state->popEvent(MSG_get_clock(), container);
+ simgrid::instr::Container::byName(host)->getState(state_name)->popEvent();
}
/** \ingroup TRACE_API
THROW_IMPOSSIBLE;
}
}
+
+StateType* Container::getState(std::string name)
+{
+ StateType* ret = dynamic_cast<StateType*>(type_->byName(name));
+ ret->setCallingContainer(this);
+ return ret;
+}
}
}
namespace simgrid {
namespace instr {
class Type;
+class StateType;
class Container {
long long int id_;
void logCreation();
void logDestruction();
+ StateType* getState(std::string name);
static Container* getRootContainer();
};
events_.clear();
}
-void StateType::setEvent(double timestamp, Container* container, std::string value_name)
+void StateType::setEvent(std::string value_name)
{
- events_.push_back(new StateEvent(timestamp, container, this, PAJE_SetState, getEntityValue(value_name)));
+ events_.push_back(new StateEvent(SIMIX_get_clock(), issuer_, this, PAJE_SetState, getEntityValue(value_name)));
}
-void StateType::pushEvent(double timestamp, Container* container, std::string value_name, void* extra)
+void StateType::pushEvent(std::string value_name, void* extra)
{
- events_.push_back(new StateEvent(timestamp, container, this, PAJE_PushState, getEntityValue(value_name), extra));
+ events_.push_back(
+ new StateEvent(SIMIX_get_clock(), issuer_, this, PAJE_PushState, getEntityValue(value_name), extra));
}
-void StateType::pushEvent(double timestamp, Container* container, std::string value_name)
+void StateType::pushEvent(std::string value_name)
{
- events_.push_back(new StateEvent(timestamp, container, this, PAJE_PushState, getEntityValue(value_name)));
+ events_.push_back(new StateEvent(SIMIX_get_clock(), issuer_, this, PAJE_PushState, getEntityValue(value_name)));
}
-void StateType::popEvent(double timestamp, Container* container)
+void StateType::popEvent()
{
- events_.push_back(new StateEvent(timestamp, container, this, PAJE_PopState, nullptr));
+ events_.push_back(new StateEvent(SIMIX_get_clock(), issuer_, this, PAJE_PopState, nullptr));
}
VariableType::VariableType(std::string name, std::string color, Type* father) : Type(name, name, color, father)
LinkType::LinkType(std::string name, std::string alias, Type* father) : ValueType(name, alias, father)
{
}
-void LinkType::startEvent(double timestamp, Container* container, container_t endpoint, std::string value,
- std::string key)
+void LinkType::startEvent(Container* container, container_t endpoint, std::string value, std::string key)
{
- startEvent(timestamp, container, endpoint, value, key, -1);
+ startEvent(container, endpoint, value, key, -1);
}
-void LinkType::startEvent(double timestamp, Container* container, container_t endpoint, std::string value,
- std::string key, int size)
+void LinkType::startEvent(Container* container, container_t endpoint, std::string value, std::string key, int size)
{
- new LinkEvent(timestamp, container, this, PAJE_StartLink, endpoint, value, key, size);
+ new LinkEvent(SIMIX_get_clock(), container, this, PAJE_StartLink, endpoint, value, key, size);
}
-void LinkType::endEvent(double timestamp, Container* container, container_t endpoint, std::string value,
- std::string key)
+void LinkType::endEvent(Container* container, container_t endpoint, std::string value, std::string key)
{
- new LinkEvent(timestamp, container, this, PAJE_EndLink, endpoint, value, key);
+ new LinkEvent(SIMIX_get_clock(), container, this, PAJE_EndLink, endpoint, value, key);
}
void Type::logDefinition(e_event_type event_type)
bool isColored() { return not color_.empty(); }
Type* byName(std::string name);
-
ContainerType* getOrCreateContainerType(std::string name);
EventType* getOrCreateEventType(std::string name);
LinkType* getOrCreateLinkType(std::string name, Type* source, Type* dest);
+
StateType* getOrCreateStateType(std::string name);
+ StateType* getState(std::string name);
+
VariableType* getOrCreateVariableType(std::string name, std::string color);
void logDefinition(e_event_type event_type);
class LinkType : public ValueType {
public:
LinkType(std::string name, std::string alias, Type* father);
- void startEvent(double timestamp, Container* source_container, Container* sourceContainer, std::string value,
- std::string key);
- void startEvent(double timestamp, Container* source_container, Container* sourceContainer, std::string value,
- std::string key, int size);
- void endEvent(double timestamp, Container* source_container, Container* destContainer, std::string value,
- std::string key);
+ void startEvent(Container* source_container, Container* sourceContainer, std::string value, std::string key);
+ void startEvent(Container* source_container, Container* sourceContainer, std::string value, std::string key,
+ int size);
+ void endEvent(Container* source_container, Container* destContainer, std::string value, std::string key);
};
class EventType : public ValueType {
class StateType : public ValueType {
std::vector<StateEvent*> events_;
+ Container* issuer_ = nullptr;
public:
StateType(std::string name, Type* father);
~StateType();
- void setEvent(double timestamp, Container* container, std::string value_name);
- void pushEvent(double timestamp, Container* container, std::string value_name);
- void pushEvent(double timestamp, Container* container, std::string value_name, void* extra);
- void popEvent(double timestamp, Container* container);
+ void setCallingContainer(Container* container) { issuer_ = container; }
+ void setEvent(std::string value_name);
+ void pushEvent(std::string value_name);
+ void pushEvent(std::string value_name, void* extra);
+ void popEvent();
};
}
}
if (instr_fmt_type != instr_fmt_paje)
return;
std::stringstream stream;
- XBT_DEBUG("%s: event_type=%u", __FUNCTION__, simgrid::instr::PAJE_DefineEntityValue);
- stream << std::fixed << std::setprecision(TRACE_precision());
- stream << simgrid::instr::PAJE_DefineEntityValue;
+ XBT_DEBUG("%s: event_type=%u", __FUNCTION__, PAJE_DefineEntityValue);
+ stream << std::fixed << std::setprecision(TRACE_precision()) << PAJE_DefineEntityValue;
stream << " " << id_ << " " << father_->getId() << " " << name_;
if (not color_.empty())
stream << " \"" << color_ << "\"";
XBT_DEBUG("Dump %s", stream.str().c_str());
- stream << std::endl;
- fprintf(tracing_file, "%s", stream.str().c_str());
+ fprintf(tracing_file, "%s\n", stream.str().c_str());
}
}
XBT_LOG_NEW_DEFAULT_SUBCATEGORY (instr_msg_process, instr, "MSG process");
-std::string instr_process_id(msg_process_t proc)
+std::string instr_pid(msg_process_t proc)
{
return std::string(proc->getCname()) + "-" + std::to_string(proc->getPid());
}
std::string key = std::to_string(counter++);
//start link
- container_t msg = simgrid::instr::Container::byName(instr_process_id(process));
+ container_t msg = simgrid::instr::Container::byName(instr_pid(process));
simgrid::instr::LinkType* link =
static_cast<simgrid::instr::LinkType*>(simgrid::instr::Type::getRootType()->byName("MSG_PROCESS_LINK"));
- link->startEvent(MSG_get_clock(), simgrid::instr::Container::getRootContainer(), msg, "M", key);
+ link->startEvent(simgrid::instr::Container::getRootContainer(), msg, "M", key);
//destroy existing container of this process
TRACE_msg_process_destroy (MSG_process_get_name (process), MSG_process_get_PID (process));
TRACE_msg_process_create (MSG_process_get_name (process), MSG_process_get_PID (process), new_host);
//end link
- msg = simgrid::instr::Container::byName(instr_process_id(process));
- link->endEvent(MSG_get_clock(), simgrid::instr::Container::getRootContainer(), msg, "M", key);
+ msg = simgrid::instr::Container::byName(instr_pid(process));
+ link->endEvent(simgrid::instr::Container::getRootContainer(), msg, "M", key);
}
}
-void TRACE_msg_process_create (const char *process_name, int process_pid, msg_host_t host)
+void TRACE_msg_process_create(std::string process_name, int process_pid, msg_host_t host)
{
if (TRACE_msg_process_is_enabled()){
container_t host_container = simgrid::instr::Container::byName(host->getName());
- new simgrid::instr::Container(std::string(process_name) + "-" + std::to_string(process_pid), "MSG_PROCESS",
- host_container);
+ new simgrid::instr::Container(process_name + "-" + std::to_string(process_pid), "MSG_PROCESS", host_container);
}
}
-void TRACE_msg_process_destroy (const char *process_name, int process_pid)
+void TRACE_msg_process_destroy(std::string process_name, int process_pid)
{
if (TRACE_msg_process_is_enabled()) {
- container_t process =
- simgrid::instr::Container::byNameOrNull(std::string(process_name) + "-" + std::to_string(process_pid));
+ container_t process = simgrid::instr::Container::byNameOrNull(process_name + "-" + std::to_string(process_pid));
if (process) {
process->removeFromParent();
delete process;
void TRACE_msg_process_suspend(msg_process_t process)
{
- if (TRACE_msg_process_is_enabled()){
- container_t process_container = simgrid::instr::Container::byName(instr_process_id(process));
- simgrid::instr::StateType* state =
- static_cast<simgrid::instr::StateType*>(process_container->type_->byName("MSG_PROCESS_STATE"));
- state->pushEvent(MSG_get_clock(), process_container, "suspend");
- }
+ if (TRACE_msg_process_is_enabled())
+ simgrid::instr::Container::byName(instr_pid(process))->getState("MSG_PROCESS_STATE")->pushEvent("suspend");
}
void TRACE_msg_process_resume(msg_process_t process)
{
- if (TRACE_msg_process_is_enabled()){
- container_t process_container = simgrid::instr::Container::byName(instr_process_id(process));
- simgrid::instr::StateType* state =
- static_cast<simgrid::instr::StateType*>(process_container->type_->byName("MSG_PROCESS_STATE"));
- state->popEvent(MSG_get_clock(), process_container);
- }
+ if (TRACE_msg_process_is_enabled())
+ simgrid::instr::Container::byName(instr_pid(process))->getState("MSG_PROCESS_STATE")->popEvent();
}
void TRACE_msg_process_sleep_in(msg_process_t process)
{
- if (TRACE_msg_process_is_enabled()){
- container_t process_container = simgrid::instr::Container::byName(instr_process_id(process));
- simgrid::instr::StateType* state =
- static_cast<simgrid::instr::StateType*>(process_container->type_->byName("MSG_PROCESS_STATE"));
- state->pushEvent(MSG_get_clock(), process_container, "sleep");
- }
+ if (TRACE_msg_process_is_enabled())
+ simgrid::instr::Container::byName(instr_pid(process))->getState("MSG_PROCESS_STATE")->pushEvent("sleep");
}
void TRACE_msg_process_sleep_out(msg_process_t process)
{
- if (TRACE_msg_process_is_enabled()){
- container_t process_container = simgrid::instr::Container::byName(instr_process_id(process));
- simgrid::instr::StateType* state =
- static_cast<simgrid::instr::StateType*>(process_container->type_->byName("MSG_PROCESS_STATE"));
- state->popEvent(MSG_get_clock(), process_container);
- }
+ if (TRACE_msg_process_is_enabled())
+ simgrid::instr::Container::byName(instr_pid(process))->getState("MSG_PROCESS_STATE")->popEvent();
}
{
XBT_DEBUG("EXEC,in %p, %lld, %s", task, task->counter, task->category);
- if (TRACE_msg_process_is_enabled()){
- container_t process_container = simgrid::instr::Container::byName(instr_process_id(MSG_process_self()));
- simgrid::instr::StateType* state =
- static_cast<simgrid::instr::StateType*>(process_container->type_->byName("MSG_PROCESS_STATE"));
- state->pushEvent(MSG_get_clock(), process_container, "task_execute");
- }
+ if (TRACE_msg_process_is_enabled())
+ simgrid::instr::Container::byName(instr_pid(MSG_process_self()))
+ ->getState("MSG_PROCESS_STATE")
+ ->pushEvent("task_execute");
}
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()){
- container_t process_container = simgrid::instr::Container::byName(instr_process_id(MSG_process_self()));
- simgrid::instr::StateType* state =
- static_cast<simgrid::instr::StateType*>(process_container->type_->byName("MSG_PROCESS_STATE"));
- state->popEvent(MSG_get_clock(), process_container);
- }
+ if (TRACE_msg_process_is_enabled())
+ simgrid::instr::Container::byName(instr_pid(MSG_process_self()))->getState("MSG_PROCESS_STATE")->popEvent();
}
/* MSG_task_destroy related functions */
{
XBT_DEBUG("GET,in");
- if (TRACE_msg_process_is_enabled()){
- container_t process_container = simgrid::instr::Container::byName(instr_process_id(MSG_process_self()));
- simgrid::instr::StateType* state =
- static_cast<simgrid::instr::StateType*>(process_container->type_->byName("MSG_PROCESS_STATE"));
- state->pushEvent(MSG_get_clock(), process_container, "receive");
- }
+ if (TRACE_msg_process_is_enabled())
+ simgrid::instr::Container::byName(instr_pid(MSG_process_self()))
+ ->getState("MSG_PROCESS_STATE")
+ ->pushEvent("receive");
}
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()){
- container_t process_container = simgrid::instr::Container::byName(instr_process_id(MSG_process_self()));
- simgrid::instr::StateType* state =
- static_cast<simgrid::instr::StateType*>(process_container->type_->byName("MSG_PROCESS_STATE"));
- state->popEvent(MSG_get_clock(), process_container);
+ container_t process_container = simgrid::instr::Container::byName(instr_pid(MSG_process_self()));
+ process_container->getState("MSG_PROCESS_STATE")->popEvent();
std::string key = std::string("p") + std::to_string(task->counter);
simgrid::instr::LinkType* link =
static_cast<simgrid::instr::LinkType*>(simgrid::instr::Type::getRootType()->byName("MSG_PROCESS_TASK_LINK"));
- link->endEvent(MSG_get_clock(), simgrid::instr::Container::getRootContainer(), process_container, "SR", key);
+ link->endEvent(simgrid::instr::Container::getRootContainer(), process_container, "SR", key);
}
}
XBT_DEBUG("PUT,in %p, %lld, %s", task, task->counter, task->category);
if (TRACE_msg_process_is_enabled()){
- container_t process_container = simgrid::instr::Container::byName(instr_process_id(MSG_process_self()));
- simgrid::instr::StateType* state =
- static_cast<simgrid::instr::StateType*>(process_container->type_->byName("MSG_PROCESS_STATE"));
- state->pushEvent(MSG_get_clock(), process_container, "send");
+ container_t process_container = simgrid::instr::Container::byName(instr_pid(MSG_process_self()));
+ process_container->getState("MSG_PROCESS_STATE")->pushEvent("send");
std::string key = std::string("p") + std::to_string(task->counter);
simgrid::instr::LinkType* link =
static_cast<simgrid::instr::LinkType*>(simgrid::instr::Type::getRootType()->byName("MSG_PROCESS_TASK_LINK"));
- link->startEvent(MSG_get_clock(), simgrid::instr::Container::getRootContainer(), process_container, "SR", key);
+ link->startEvent(simgrid::instr::Container::getRootContainer(), process_container, "SR", key);
}
return 1;
{
XBT_DEBUG("PUT,out");
- if (TRACE_msg_process_is_enabled()){
- container_t process_container = simgrid::instr::Container::byName(instr_process_id(MSG_process_self()));
- simgrid::instr::StateType* state =
- static_cast<simgrid::instr::StateType*>(process_container->type_->byName("MSG_PROCESS_STATE"));
- state->popEvent(MSG_get_clock(), process_container);
- }
+ if (TRACE_msg_process_is_enabled())
+ simgrid::instr::Container::byName(instr_pid(MSG_process_self()))->getState("MSG_PROCESS_STATE")->popEvent();
}
};
typedef s_MSG_Global_t* MSG_Global_t;
-XBT_PRIVATE std::string instr_process_id(msg_process_t proc);
+XBT_PRIVATE std::string instr_pid(msg_process_t proc);
+XBT_PRIVATE void TRACE_msg_process_create(std::string process_name, int process_pid, msg_host_t host);
+XBT_PRIVATE void TRACE_msg_process_destroy(std::string process_name, int process_pid);
extern "C" {
/* declaration of instrumentation functions from msg_process_instr.c */
XBT_PRIVATE void TRACE_msg_process_change_host(msg_process_t process, msg_host_t new_host);
-XBT_PRIVATE void TRACE_msg_process_create(const char* process_name, int process_pid, msg_host_t host);
-XBT_PRIVATE void TRACE_msg_process_destroy(const char* process_name, int process_pid);
XBT_PRIVATE void TRACE_msg_process_kill(smx_process_exit_status_t status, msg_process_t process);
XBT_PRIVATE void TRACE_msg_process_suspend(msg_process_t process);
XBT_PRIVATE void TRACE_msg_process_resume(msg_process_t process);
simcall_process_set_data(smx_actor, nullptr);
}
- TRACE_msg_process_destroy(smx_actor->name.c_str(), smx_actor->pid);
+ TRACE_msg_process_destroy(smx_actor->name, smx_actor->pid);
// free the data if a function was provided
if (msg_actor && msg_actor->data && msg_global->process_data_cleanup) {
msg_global->process_data_cleanup(msg_actor->data);
{
vm->start();
if (TRACE_msg_vm_is_enabled()) {
- container_t vm_container = simgrid::instr::Container::byName(vm->getName());
- simgrid::instr::StateType* state =
- static_cast<simgrid::instr::StateType*>(vm_container->type_->byName("MSG_VM_STATE"));
+ simgrid::instr::StateType* state = simgrid::instr::Container::byName(vm->getName())->getState("MSG_VM_STATE");
state->addEntityValue("start", "0 0 1"); // start is blue
- state->pushEvent(MSG_get_clock(), vm_container, "start");
+ state->pushEvent("start");
}
}
container_t msg = simgrid::instr::Container::byName(vm->getName());
simgrid::instr::LinkType* link =
static_cast<simgrid::instr::LinkType*>(simgrid::instr::Type::getRootType()->byName("MSG_VM_LINK"));
- link->startEvent(MSG_get_clock(), simgrid::instr::Container::getRootContainer(), msg, "M", key);
+ link->startEvent(simgrid::instr::Container::getRootContainer(), msg, "M", key);
// destroy existing container of this vm
container_t existing_container = simgrid::instr::Container::byName(vm->getName());
// end link
msg = simgrid::instr::Container::byName(vm->getName());
- link->endEvent(MSG_get_clock(), simgrid::instr::Container::getRootContainer(), msg, "M", key);
+ link->endEvent(simgrid::instr::Container::getRootContainer(), msg, "M", key);
}
// Inform the SRC that the migration has been correctly performed
XBT_DEBUG("vm_suspend done");
if (TRACE_msg_vm_is_enabled()) {
- container_t vm_container = simgrid::instr::Container::byName(vm->getName());
- simgrid::instr::StateType* state =
- static_cast<simgrid::instr::StateType*>(vm_container->type_->byName("MSG_VM_STATE"));
+ simgrid::instr::StateType* state = simgrid::instr::Container::byName(vm->getName())->getState("MSG_VM_STATE");
state->addEntityValue("suspend", "1 0 0"); // suspend is red
- state->pushEvent(MSG_get_clock(), vm_container, "suspend");
+ state->pushEvent("suspend");
}
}
{
vm->pimpl_vm_->resume();
- if (TRACE_msg_vm_is_enabled()) {
- container_t vm_container = simgrid::instr::Container::byName(vm->getName());
- simgrid::instr::StateType* state =
- static_cast<simgrid::instr::StateType*>(vm_container->type_->byName("MSG_VM_STATE"));
- state->popEvent(MSG_get_clock(), vm_container);
- }
+ if (TRACE_msg_vm_is_enabled())
+ simgrid::instr::Container::byName(vm->getName())->getState("MSG_VM_STATE")->popEvent();
}
/** @brief Get the physical host of a given VM.
intrusive_ptr_add_ref(process);
/* Tracing the process creation */
- TRACE_msg_process_create(process->getCname(), process->pid, process->host);
+ TRACE_msg_process_create(process->getName(), process->pid, process->host);
return process;
}
simix_global->process_to_run.push_back(process);
/* Tracing the process creation */
- TRACE_msg_process_create(process->getCname(), process->pid, process->host);
+ TRACE_msg_process_create(process->getName(), process->pid, process->host);
auto context = dynamic_cast<simgrid::kernel::context::AttachContext*>(process->context);
if (not context)
return;
}
- container_t container = simgrid::instr::Container::byName(smpi_container(rank));
- simgrid::instr::StateType* state = static_cast<simgrid::instr::StateType*>(container->type_->byName("MPI_STATE"));
+ simgrid::instr::StateType* state = simgrid::instr::Container::byName(smpi_container(rank))->getState("MPI_STATE");
const char *color = instr_find_color (operation);
state->addEntityValue(operation, color);
- state->pushEvent(SIMIX_get_clock(), container, operation, static_cast<void*>(extra));
+ state->pushEvent(operation, static_cast<void*>(extra));
}
void TRACE_smpi_collective_out(int rank, const char *operation)
{
- if (not TRACE_smpi_is_enabled())
- return;
-
- container_t container = simgrid::instr::Container::byName(smpi_container(rank));
- simgrid::instr::StateType* state = static_cast<simgrid::instr::StateType*>(container->type_->byName("MPI_STATE"));
- state->popEvent(SIMIX_get_clock(), container);
+ if (TRACE_smpi_is_enabled())
+ simgrid::instr::Container::byName(smpi_container(rank))->getState("MPI_STATE")->popEvent();
}
void TRACE_smpi_computing_init(int rank)
if (not TRACE_smpi_is_enabled() || not TRACE_smpi_is_computing())
return;
- container_t container = simgrid::instr::Container::byName(smpi_container(rank));
- simgrid::instr::StateType* state = static_cast<simgrid::instr::StateType*>(container->type_->byName("MPI_STATE"));
+ simgrid::instr::StateType* state = simgrid::instr::Container::byName(smpi_container(rank))->getState("MPI_STATE");
state->addEntityValue("computing", instr_find_color("computing"));
- state->pushEvent(SIMIX_get_clock(), container, "computing");
+ state->pushEvent("computing");
}
void TRACE_smpi_computing_in(int rank, instr_extra_data extra)
return;
}
- container_t container = simgrid::instr::Container::byName(smpi_container(rank));
- simgrid::instr::StateType* state = static_cast<simgrid::instr::StateType*>(container->type_->byName("MPI_STATE"));
+ simgrid::instr::StateType* state = simgrid::instr::Container::byName(smpi_container(rank))->getState("MPI_STATE");
state->addEntityValue("computing");
- state->pushEvent(SIMIX_get_clock(), container, "computing", static_cast<void*>(extra));
+ state->pushEvent("computing", static_cast<void*>(extra));
}
void TRACE_smpi_computing_out(int rank)
if (not TRACE_smpi_is_enabled() || not TRACE_smpi_is_computing())
return;
- container_t container = simgrid::instr::Container::byName(smpi_container(rank));
- simgrid::instr::StateType* state = static_cast<simgrid::instr::StateType*>(container->type_->byName("MPI_STATE"));
- state->popEvent(SIMIX_get_clock(), container);
+ simgrid::instr::Container::byName(smpi_container(rank))->getState("MPI_STATE")->popEvent();
}
void TRACE_smpi_sleeping_init(int rank)
if (not TRACE_smpi_is_enabled() || not TRACE_smpi_is_sleeping())
return;
- container_t container = simgrid::instr::Container::byName(smpi_container(rank));
- simgrid::instr::StateType* state = static_cast<simgrid::instr::StateType*>(container->type_->byName("MPI_STATE"));
+ simgrid::instr::StateType* state = simgrid::instr::Container::byName(smpi_container(rank))->getState("MPI_STATE");
state->addEntityValue("sleeping", instr_find_color("sleeping"));
- state->pushEvent(SIMIX_get_clock(), container, "sleeping");
+ state->pushEvent("sleeping");
}
void TRACE_smpi_sleeping_in(int rank, instr_extra_data extra)
return;
}
- container_t container = simgrid::instr::Container::byName(smpi_container(rank));
- simgrid::instr::StateType* state = static_cast<simgrid::instr::StateType*>(container->type_->byName("MPI_STATE"));
+ simgrid::instr::StateType* state = simgrid::instr::Container::byName(smpi_container(rank))->getState("MPI_STATE");
state->addEntityValue("sleeping");
- state->pushEvent(SIMIX_get_clock(), container, "sleeping", static_cast<void*>(extra));
+ state->pushEvent("sleeping", static_cast<void*>(extra));
}
void TRACE_smpi_sleeping_out(int rank)
if (not TRACE_smpi_is_enabled() || not TRACE_smpi_is_sleeping())
return;
- container_t container = simgrid::instr::Container::byName(smpi_container(rank));
- simgrid::instr::StateType* state = static_cast<simgrid::instr::StateType*>(container->type_->byName("MPI_STATE"));
- state->popEvent(SIMIX_get_clock(), container);
+ simgrid::instr::Container::byName(smpi_container(rank))->getState("MPI_STATE")->popEvent();
}
void TRACE_smpi_testing_in(int rank, instr_extra_data extra)
return;
}
- container_t container = simgrid::instr::Container::byName(smpi_container(rank));
- simgrid::instr::StateType* state = static_cast<simgrid::instr::StateType*>(container->type_->byName("MPI_STATE"));
+ simgrid::instr::StateType* state = simgrid::instr::Container::byName(smpi_container(rank))->getState("MPI_STATE");
state->addEntityValue("test");
- state->pushEvent(SIMIX_get_clock(), container, "test", static_cast<void*>(extra));
+ state->pushEvent("test", static_cast<void*>(extra));
}
void TRACE_smpi_testing_out(int rank)
{
- if (not TRACE_smpi_is_enabled())
- return;
-
- container_t container = simgrid::instr::Container::byName(smpi_container(rank));
- simgrid::instr::StateType* state = static_cast<simgrid::instr::StateType*>(container->type_->byName("MPI_STATE"));
- state->popEvent(SIMIX_get_clock(), container);
+ if (TRACE_smpi_is_enabled())
+ simgrid::instr::Container::byName(smpi_container(rank))->getState("MPI_STATE")->popEvent();
}
void TRACE_smpi_ptp_in(int rank, const char *operation, instr_extra_data extra)
return;
}
- container_t container = simgrid::instr::Container::byName(smpi_container(rank));
- simgrid::instr::StateType* state = static_cast<simgrid::instr::StateType*>(container->type_->byName("MPI_STATE"));
+ simgrid::instr::StateType* state = simgrid::instr::Container::byName(smpi_container(rank))->getState("MPI_STATE");
state->addEntityValue(operation, instr_find_color(operation));
- state->pushEvent(SIMIX_get_clock(), container, operation, static_cast<void*>(extra));
+ state->pushEvent(operation, static_cast<void*>(extra));
}
void TRACE_smpi_ptp_out(int rank, int dst, const char *operation)
{
- if (not TRACE_smpi_is_enabled())
- return;
-
- container_t container = simgrid::instr::Container::byName(smpi_container(rank));
- simgrid::instr::StateType* state = static_cast<simgrid::instr::StateType*>(container->type_->byName("MPI_STATE"));
- state->popEvent(SIMIX_get_clock(), container);
+ if (TRACE_smpi_is_enabled())
+ simgrid::instr::Container::byName(smpi_container(rank))->getState("MPI_STATE")->popEvent();
}
void TRACE_smpi_send(int rank, int src, int dst, int tag, int size)
simgrid::instr::LinkType* link =
static_cast<simgrid::instr::LinkType*>(simgrid::instr::Type::getRootType()->byName("MPI_LINK"));
XBT_DEBUG("Send tracing from %d to %d, tag %d, with key %s", src, dst, tag, key.c_str());
- link->startEvent(SIMIX_get_clock(), simgrid::instr::Container::getRootContainer(), container, "PTP", key, size);
+ link->startEvent(simgrid::instr::Container::getRootContainer(), container, "PTP", key, size);
}
void TRACE_smpi_recv(int src, int dst, int tag)
simgrid::instr::LinkType* link =
static_cast<simgrid::instr::LinkType*>(simgrid::instr::Type::getRootType()->byName("MPI_LINK"));
XBT_DEBUG("Recv tracing from %d to %d, tag %d, with key %s", src, dst, tag, key.c_str());
- link->endEvent(SIMIX_get_clock(), simgrid::instr::Container::getRootContainer(), container, "PTP", key);
+ link->endEvent(simgrid::instr::Container::getRootContainer(), container, "PTP", key);
}
std::string key = std::to_string(counter);
counter++;
- link->startEvent(SIMIX_get_clock(), father, src, "topology", key);
- link->endEvent(SIMIX_get_clock(), father, dst, "topology", key);
+ link->startEvent(father, src, "topology", key);
+ link->endEvent(father, dst, "topology", key);
XBT_DEBUG(" linkContainers %s <-> %s", src->getCname(), dst->getCname());
}