static bool trace_view_internals;
static bool trace_categorized;
static bool trace_uncategorized;
-static bool trace_msg_process_enabled;
+static bool trace_actor_enabled;
static bool trace_msg_vm_enabled;
static bool trace_buffer;
static bool trace_onelink_only;
trace_view_internals = xbt_cfg_get_boolean(OPT_TRACING_SMPI_INTERNALS);
trace_categorized = xbt_cfg_get_boolean(OPT_TRACING_CATEGORIZED);
trace_uncategorized = xbt_cfg_get_boolean(OPT_TRACING_UNCATEGORIZED);
- trace_msg_process_enabled = xbt_cfg_get_boolean(OPT_TRACING_MSG_PROCESS);
+ trace_actor_enabled = trace_enabled && xbt_cfg_get_boolean(OPT_TRACING_MSG_PROCESS);
trace_msg_vm_enabled = xbt_cfg_get_boolean(OPT_TRACING_MSG_VM);
trace_buffer = xbt_cfg_get_boolean(OPT_TRACING_BUFFER);
trace_onelink_only = xbt_cfg_get_boolean(OPT_TRACING_ONELINK_ONLY);
bool TRACE_needs_platform ()
{
- return TRACE_msg_process_is_enabled() || TRACE_msg_vm_is_enabled() || TRACE_categorized() ||
- TRACE_uncategorized() || TRACE_platform () || (TRACE_smpi_is_enabled() && TRACE_smpi_is_grouped());
+ return TRACE_actor_is_enabled() || TRACE_msg_vm_is_enabled() || TRACE_categorized() || TRACE_uncategorized() ||
+ TRACE_platform() || (TRACE_smpi_is_enabled() && TRACE_smpi_is_grouped());
}
bool TRACE_is_enabled()
return trace_uncategorized;
}
-bool TRACE_msg_process_is_enabled()
+bool TRACE_actor_is_enabled()
{
- return trace_msg_process_enabled && TRACE_is_enabled();
+ return trace_actor_enabled;
}
bool TRACE_msg_vm_is_enabled()
extern XBT_PRIVATE std::set<std::string> user_vm_variables;
extern XBT_PRIVATE std::set<std::string> user_link_variables;
extern XBT_PRIVATE double TRACE_last_timestamp_to_dump;
+XBT_PRIVATE std::string instr_pid(s4u_Actor* proc);
/* instr_paje_header.c */
XBT_PRIVATE void TRACE_header(bool basic, int size);
XBT_PRIVATE bool TRACE_is_configured();
XBT_PRIVATE bool TRACE_categorized();
XBT_PRIVATE bool TRACE_uncategorized();
-XBT_PRIVATE bool TRACE_msg_process_is_enabled();
+XBT_PRIVATE bool TRACE_actor_is_enabled();
XBT_PRIVATE bool TRACE_msg_vm_is_enabled();
XBT_PRIVATE bool TRACE_buffer();
XBT_PRIVATE bool TRACE_disable_link();
void TRACE_msg_process_change_host(msg_process_t process, msg_host_t new_host)
{
- if (TRACE_msg_process_is_enabled()){
+ if (TRACE_actor_is_enabled()) {
static long long int counter = 0;
std::string key = std::to_string(counter);
void TRACE_msg_process_create(std::string process_name, int process_pid, msg_host_t host)
{
- if (TRACE_msg_process_is_enabled()){
+ if (TRACE_actor_is_enabled()) {
container_t host_container = simgrid::instr::Container::byName(host->getName());
new simgrid::instr::Container(process_name + "-" + std::to_string(process_pid), "MSG_PROCESS", host_container);
}
void TRACE_msg_process_destroy(std::string process_name, int process_pid)
{
- if (TRACE_msg_process_is_enabled()) {
+ if (TRACE_actor_is_enabled()) {
container_t process = simgrid::instr::Container::byNameOrNull(process_name + "-" + std::to_string(process_pid));
if (process) {
process->removeFromParent();
void TRACE_msg_process_kill(smx_process_exit_status_t status, msg_process_t process)
{
- if (TRACE_msg_process_is_enabled() && status == SMX_EXIT_FAILURE) {
+ if (TRACE_actor_is_enabled() && status == SMX_EXIT_FAILURE) {
//kill means that this process no longer exists, let's destroy it
TRACE_msg_process_destroy(process->getCname(), process->getPid());
}
}
-
-void TRACE_msg_process_suspend(msg_process_t process)
-{
- 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())
- 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())
- 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())
- 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())
+ if (TRACE_actor_is_enabled())
simgrid::instr::Container::byName(instr_pid(MSG_process_self()))
->getState("MSG_PROCESS_STATE")
->pushEvent("task_execute");
{
XBT_DEBUG("EXEC,out %p, %lld, %s", task, task->counter, task->category);
- if (TRACE_msg_process_is_enabled())
+ if (TRACE_actor_is_enabled())
simgrid::instr::Container::byName(instr_pid(MSG_process_self()))->getState("MSG_PROCESS_STATE")->popEvent();
}
{
XBT_DEBUG("GET,in");
- if (TRACE_msg_process_is_enabled())
+ if (TRACE_actor_is_enabled())
simgrid::instr::Container::byName(instr_pid(MSG_process_self()))
->getState("MSG_PROCESS_STATE")
->pushEvent("receive");
{
XBT_DEBUG("GET,out %p, %lld, %s", task, task->counter, task->category);
- if (TRACE_msg_process_is_enabled()){
+ if (TRACE_actor_is_enabled()) {
container_t process_container = simgrid::instr::Container::byName(instr_pid(MSG_process_self()));
process_container->getState("MSG_PROCESS_STATE")->popEvent();
{
XBT_DEBUG("PUT,in %p, %lld, %s", task, task->counter, task->category);
- if (TRACE_msg_process_is_enabled()){
+ if (TRACE_actor_is_enabled()) {
container_t process_container = simgrid::instr::Container::byName(instr_pid(MSG_process_self()));
process_container->getState("MSG_PROCESS_STATE")->pushEvent("send");
{
XBT_DEBUG("PUT,out");
- if (TRACE_msg_process_is_enabled())
+ if (TRACE_actor_is_enabled())
simgrid::instr::Container::byName(instr_pid(MSG_process_self()))->getState("MSG_PROCESS_STATE")->popEvent();
}
{
msg_error_t status = MSG_OK;
- TRACE_msg_process_sleep_in(MSG_process_self());
+ if (TRACE_actor_is_enabled())
+ simgrid::instr::Container::byName(instr_pid(MSG_process_self()))->getState("MSG_PROCESS_STATE")->pushEvent("sleep");
try {
simcall_process_sleep(nb_sec);
throw;
}
- TRACE_msg_process_sleep_out(MSG_process_self());
+ if (TRACE_actor_is_enabled())
+ simgrid::instr::Container::byName(instr_pid(MSG_process_self()))->getState("MSG_PROCESS_STATE")->popEvent();
+
return status;
}
* \param alias The name of the mailbox
*/
void MSG_mailbox_set_async(const char *alias){
- simgrid::s4u::MailboxPtr mailbox = simgrid::s4u::Mailbox::byName(alias);
- mailbox->setReceiver(simgrid::s4u::Actor::self());
+ simgrid::s4u::Mailbox::byName(alias)->setReceiver(simgrid::s4u::Actor::self());
XBT_VERB("%s mailbox set to receive eagerly for myself\n",alias);
}
}
};
typedef s_MSG_Global_t* MSG_Global_t;
-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);
/* 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_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);
-XBT_PRIVATE void TRACE_msg_process_sleep_in(msg_process_t process); // called from msg/gos.c
-XBT_PRIVATE void TRACE_msg_process_sleep_out(msg_process_t process);
}
inline void s_simdata_task_t::setUsed()
* \param timeout wait until the process is over, or the timeout occurs
*/
msg_error_t MSG_process_join(msg_process_t process, double timeout){
- simcall_process_join(process->getImpl(), timeout);
+ process->join(timeout);
return MSG_OK;
}
if (process == nullptr) {
return SIMIX_process_self()->host;
} else {
- return process->getImpl()->host;
+ return process->getHost();
}
}
*/
msg_error_t MSG_process_set_kill_time(msg_process_t process, double kill_time)
{
- simcall_process_set_kill_time(process->getImpl(), kill_time);
+ process->setKillTime(kill_time);
return MSG_OK;
}
* and the exceptions, so it would be called back again and again */
if (process == nullptr || process->getImpl() == nullptr)
return 0;
- return process->getImpl()->pid;
+ return process->getPid();
}
/** \ingroup m_process_management
*/
int MSG_process_get_PPID(msg_process_t process)
{
- return process->getImpl()->ppid;
+ return process->getPpid();
}
/** \ingroup m_process_management
{
xbt_assert(process != nullptr, "Invalid parameter: First argument must not be nullptr");
xbt_dict_t as_dict = xbt_dict_new_homogeneous(xbt_free_f);
- std::map<std::string, std::string>* props =
- simgrid::simix::kernelImmediate([process] { return process->getImpl()->getProperties(); });
+ std::map<std::string, std::string>* props = process->getProperties();
if (props == nullptr)
return nullptr;
for (auto const& elm : *props) {
msg_error_t MSG_process_suspend(msg_process_t process)
{
xbt_assert(process != nullptr, "Invalid parameter: First argument must not be nullptr");
-
- TRACE_msg_process_suspend(process);
- simcall_process_suspend(process->getImpl());
+ process->suspend();
return MSG_OK;
}
msg_error_t MSG_process_resume(msg_process_t process)
{
xbt_assert(process != nullptr, "Invalid parameter: First argument must not be nullptr");
-
- TRACE_msg_process_resume(process);
process->resume();
return MSG_OK;
}
void Actor::suspend()
{
+ if (TRACE_actor_is_enabled())
+ simgrid::instr::Container::byName(instr_pid(this))->getState("MSG_PROCESS_STATE")->pushEvent("suspend");
+
simcall_process_suspend(pimpl_);
}
void Actor::resume()
{
simgrid::simix::kernelImmediate([this] { pimpl_->resume(); });
+ if (TRACE_actor_is_enabled())
+ simgrid::instr::Container::byName(instr_pid(this))->getState("MSG_PROCESS_STATE")->popEvent();
}
int Actor::isSuspended()
void suspend()
{
+ if (TRACE_actor_is_enabled())
+ instr::Container::byName(getName() + "-" + std::to_string(getPid()))
+ ->getState("MSG_PROCESS_STATE")
+ ->pushEvent("suspend");
simcall_process_suspend(SIMIX_process_self());
}
{
smx_actor_t process = SIMIX_process_self();
simgrid::simix::kernelImmediate([process] { process->resume(); });
+
+ if (TRACE_actor_is_enabled())
+ instr::Container::byName(getName() + "-" + std::to_string(getPid()))->getState("MSG_PROCESS_STATE")->popEvent();
}
bool isSuspended()
if (TRACE_smpi_is_enabled() && TRACE_smpi_is_grouped())
container->type_->getOrCreateContainerType("MPI")->getOrCreateStateType("MPI_STATE");
- if (TRACE_msg_process_is_enabled()) {
+ if (TRACE_actor_is_enabled()) {
simgrid::instr::ContainerType* msg_process = container->type_->getOrCreateContainerType("MSG_PROCESS");
simgrid::instr::StateType* state = msg_process->getOrCreateStateType("MSG_PROCESS_STATE");
state->addEntityValue("suspend", "1 0 1");