X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/5f01b2607885913a36ab1c4790079ac5d5c134ac..8d9283f70767d924231914c13674153d4b90a168:/src/instr/instr_platform.cpp

diff --git a/src/instr/instr_platform.cpp b/src/instr/instr_platform.cpp
index 573d0683d0..329dedde58 100644
--- a/src/instr/instr_platform.cpp
+++ b/src/instr/instr_platform.cpp
@@ -11,6 +11,7 @@
 #include "simgrid/s4u/Engine.hpp"
 #include "simgrid/s4u/Host.hpp"
 #include "simgrid/s4u/VirtualMachine.hpp"
+#include "src/surf/cpu_interface.hpp"
 #include "src/surf/network_interface.hpp"
 #include "src/surf/xml/platf_private.hpp"
 #include "surf/surf.hpp"
@@ -99,7 +100,7 @@ static void linkContainers(container_t src, container_t dst, std::set<std::strin
   std::string link_typename = father->type_->get_name() + "-" + src->type_->get_name() +
                               std::to_string(src->type_->get_id()) + "-" + dst->type_->get_name() +
                               std::to_string(dst->type_->get_id());
-  simgrid::instr::LinkType* link = father->type_->getOrCreateLinkType(link_typename, src->type_, dst->type_);
+  simgrid::instr::LinkType* link = father->type_->by_name_or_create(link_typename, src->type_, dst->type_);
   link->setCallingContainer(father);
 
   // register EDGE types for triva configuration
@@ -158,13 +159,13 @@ static void instr_netzone_on_creation(simgrid::s4u::NetZone& netzone)
     simgrid::instr::NetZoneContainer* root = new simgrid::instr::NetZoneContainer(id, 0, nullptr);
 
     if (TRACE_smpi_is_enabled()) {
-      simgrid::instr::Type* mpi = root->type_->getOrCreateContainerType("MPI");
+      simgrid::instr::ContainerType* mpi = root->type_->by_name_or_create<simgrid::instr::ContainerType>("MPI");
       if (not TRACE_smpi_is_grouped())
-        mpi->getOrCreateStateType("MPI_STATE");
-      root->type_->getOrCreateLinkType("MPI_LINK", mpi, mpi);
+        mpi->by_name_or_create<simgrid::instr::StateType>("MPI_STATE");
+      root->type_->by_name_or_create("MPI_LINK", mpi, mpi);
       // TODO See if we can move this to the LoadBalancer plugin
-      root->type_->getOrCreateLinkType("MIGRATE_LINK", mpi, mpi);
-      mpi->getOrCreateStateType("MIGRATE_STATE");
+      root->type_->by_name_or_create("MIGRATE_LINK", mpi, mpi);
+      mpi->by_name_or_create<simgrid::instr::StateType>("MIGRATE_STATE");
     }
 
     if (TRACE_needs_platform()) {
@@ -192,19 +193,18 @@ static void instr_link_on_creation(simgrid::s4u::Link& link)
   if (currentContainer.empty()) // No ongoing parsing. Are you creating the loopback?
     return;
 
-  container_t father    = currentContainer.back();
-  container_t container = new simgrid::instr::Container(link.get_name(), "LINK", father);
+  container_t container = new simgrid::instr::Container(link.get_name(), "LINK", currentContainer.back());
 
   if ((TRACE_categorized() || TRACE_uncategorized() || TRACE_platform()) && (not TRACE_disable_link())) {
-    simgrid::instr::VariableType* bandwidth = container->type_->getOrCreateVariableType("bandwidth", "");
+    simgrid::instr::VariableType* bandwidth = container->type_->by_name_or_create("bandwidth", "");
     bandwidth->setCallingContainer(container);
     bandwidth->setEvent(0, link.bandwidth());
-    simgrid::instr::VariableType* latency = container->type_->getOrCreateVariableType("latency", "");
+    simgrid::instr::VariableType* latency = container->type_->by_name_or_create("latency", "");
     latency->setCallingContainer(container);
     latency->setEvent(0, link.latency());
   }
   if (TRACE_uncategorized()) {
-    container->type_->getOrCreateVariableType("bandwidth_used", "0.5 0.5 0.5");
+    container->type_->by_name_or_create("bandwidth_used", "0.5 0.5 0.5");
   }
 }
 
@@ -214,23 +214,32 @@ static void instr_host_on_creation(simgrid::s4u::Host& host)
   container_t root      = simgrid::instr::Container::getRoot();
 
   if ((TRACE_categorized() || TRACE_uncategorized() || TRACE_platform()) && (not TRACE_disable_speed())) {
-    simgrid::instr::VariableType* power = container->type_->getOrCreateVariableType("power", "");
+    simgrid::instr::VariableType* power = container->type_->by_name_or_create("power", "");
     power->setCallingContainer(container);
     power->setEvent(0, host.getSpeed());
   }
 
   if (TRACE_uncategorized())
-    container->type_->getOrCreateVariableType("power_used", "0.5 0.5 0.5");
+    container->type_->by_name_or_create("power_used", "0.5 0.5 0.5");
 
   if (TRACE_smpi_is_enabled() && TRACE_smpi_is_grouped()) {
-    simgrid::instr::ContainerType* mpi = container->type_->getOrCreateContainerType("MPI");
-    mpi->getOrCreateStateType("MPI_STATE");
+    simgrid::instr::ContainerType* mpi = container->type_->by_name_or_create<simgrid::instr::ContainerType>("MPI");
+    mpi->by_name_or_create<simgrid::instr::StateType>("MPI_STATE");
     // TODO See if we can move this to the LoadBalancer plugin
-    root->type_->getOrCreateLinkType("MIGRATE_LINK", mpi, mpi);
-    mpi->getOrCreateStateType("MIGRATE_STATE");
+    root->type_->by_name_or_create("MIGRATE_LINK", mpi, mpi);
+    mpi->by_name_or_create<simgrid::instr::StateType>("MIGRATE_STATE");
   }
 }
 
+static void instr_cpu_action_on_state_change(simgrid::surf::CpuAction* action,
+                                             simgrid::kernel::resource::Action::State /* previous */)
+{
+  simgrid::surf::Cpu* cpu = static_cast<simgrid::surf::Cpu*>(action->get_variable()->get_constraint(0)->get_id());
+  TRACE_surf_resource_set_utilization("HOST", "power_used", cpu->get_cname(), action->get_category(),
+                                      action->get_variable()->get_value(), action->get_last_update(),
+                                      SIMIX_get_clock() - action->get_last_update());
+}
+
 static void instr_netpoint_on_creation(simgrid::kernel::routing::NetPoint* netpoint)
 {
   if (netpoint->is_router() && TRACE_needs_platform() && TRACE_is_enabled())
@@ -242,8 +251,8 @@ static void instr_on_platform_created()
   currentContainer.clear();
   std::set<std::string>* filter = new std::set<std::string>;
   XBT_DEBUG("Starting graph extraction.");
-  recursiveGraphExtraction(simgrid::s4u::Engine::get_instance()->getNetRoot(), simgrid::instr::Container::getRoot(),
-                           filter);
+  recursiveGraphExtraction(simgrid::s4u::Engine::get_instance()->get_netzone_root(),
+                           simgrid::instr::Container::getRoot(), filter);
   XBT_DEBUG("Graph extraction finished.");
   delete filter;
   TRACE_paje_dump_buffer(true);
@@ -255,15 +264,16 @@ static void instr_actor_on_creation(simgrid::s4u::ActorPtr actor)
   container_t container = simgrid::instr::Container::byName(actor->get_host()->get_name());
 
   container->createChild(instr_pid(actor.get()), "ACTOR");
-  simgrid::instr::ContainerType* actor_type = container->type_->getOrCreateContainerType("ACTOR");
-  simgrid::instr::StateType* state          = actor_type->getOrCreateStateType("ACTOR_STATE");
+  simgrid::instr::ContainerType* actor_type =
+      container->type_->by_name_or_create<simgrid::instr::ContainerType>("ACTOR");
+  simgrid::instr::StateType* state = actor_type->by_name_or_create<simgrid::instr::StateType>("ACTOR_STATE");
   state->addEntityValue("suspend", "1 0 1");
   state->addEntityValue("sleep", "1 1 0");
   state->addEntityValue("receive", "1 0 0");
   state->addEntityValue("send", "0 0 1");
   state->addEntityValue("task_execute", "0 1 1");
-  root->type_->getOrCreateLinkType("ACTOR_LINK", actor_type, actor_type);
-  root->type_->getOrCreateLinkType("ACTOR_TASK_LINK", actor_type, actor_type);
+  root->type_->by_name_or_create("ACTOR_LINK", actor_type, actor_type);
+  root->type_->by_name_or_create("ACTOR_TASK_LINK", actor_type, actor_type);
 }
 
 static void instr_actor_on_suspend(simgrid::s4u::ActorPtr actor)
@@ -301,37 +311,37 @@ static void instr_actor_on_migration_end(simgrid::s4u::ActorPtr actor)
 
 static void instr_vm_on_creation(simgrid::s4u::Host& host)
 {
-  container_t container                 = new simgrid::instr::HostContainer(host, currentContainer.back());
-  container_t root                      = simgrid::instr::Container::getRoot();
-  simgrid::instr::ContainerType* msg_vm = container->type_->getOrCreateContainerType("MSG_VM");
-  simgrid::instr::StateType* state      = msg_vm->getOrCreateStateType("MSG_VM_STATE");
+  container_t container             = new simgrid::instr::HostContainer(host, currentContainer.back());
+  container_t root                  = simgrid::instr::Container::getRoot();
+  simgrid::instr::ContainerType* vm = container->type_->by_name_or_create<simgrid::instr::ContainerType>("VM");
+  simgrid::instr::StateType* state  = vm->by_name_or_create<simgrid::instr::StateType>("VM_STATE");
   state->addEntityValue("suspend", "1 0 1");
   state->addEntityValue("sleep", "1 1 0");
   state->addEntityValue("receive", "1 0 0");
   state->addEntityValue("send", "0 0 1");
   state->addEntityValue("task_execute", "0 1 1");
-  root->type_->getOrCreateLinkType("MSG_VM_LINK", msg_vm, msg_vm);
-  root->type_->getOrCreateLinkType("MSG_VM_ACTOR_LINK", msg_vm, msg_vm);
+  root->type_->by_name_or_create("VM_LINK", vm, vm);
+  root->type_->by_name_or_create("VM_ACTOR_LINK", vm, vm);
 }
 
 static void instr_vm_on_start(simgrid::s4u::VirtualMachine& vm)
 {
-  simgrid::instr::Container::byName(vm.get_name())->getState("MSG_VM_STATE")->pushEvent("start");
+  simgrid::instr::Container::byName(vm.get_name())->getState("VM_STATE")->pushEvent("start");
 }
 
 static void instr_vm_on_started(simgrid::s4u::VirtualMachine& vm)
 {
-  simgrid::instr::Container::byName(vm.get_name())->getState("MSG_VM_STATE")->popEvent();
+  simgrid::instr::Container::byName(vm.get_name())->getState("VM_STATE")->popEvent();
 }
 
 static void instr_vm_on_suspend(simgrid::s4u::VirtualMachine& vm)
 {
-  simgrid::instr::Container::byName(vm.get_name())->getState("MSG_VM_STATE")->pushEvent("suspend");
+  simgrid::instr::Container::byName(vm.get_name())->getState("VM_STATE")->pushEvent("suspend");
 }
 
 static void instr_vm_on_resume(simgrid::s4u::VirtualMachine& vm)
 {
-  simgrid::instr::Container::byName(vm.get_name())->getState("MSG_VM_STATE")->popEvent();
+  simgrid::instr::Container::byName(vm.get_name())->getState("VM_STATE")->popEvent();
 }
 
 static void instr_vm_on_destruction(simgrid::s4u::Host& host)
@@ -352,6 +362,8 @@ void instr_define_callbacks()
   simgrid::s4u::NetZone::onSeal.connect(instr_netzone_on_seal);
   simgrid::kernel::routing::NetPoint::onCreation.connect(instr_netpoint_on_creation);
 
+  simgrid::surf::CpuAction::onStateChange.connect(instr_cpu_action_on_state_change);
+
   if (TRACE_actor_is_enabled()) {
     simgrid::s4u::Actor::on_creation.connect(instr_actor_on_creation);
     simgrid::s4u::Actor::on_suspend.connect(instr_actor_on_suspend);
@@ -374,11 +386,11 @@ void instr_define_callbacks()
  */
 static void recursiveNewVariableType(std::string new_typename, std::string color, simgrid::instr::Type* root)
 {
-  if (root->get_name() == "HOST" || root->get_name() == "MSG_VM")
-    root->getOrCreateVariableType(std::string("p") + new_typename, color);
+  if (root->get_name() == "HOST" || root->get_name() == "VM")
+    root->by_name_or_create(std::string("p") + new_typename, color);
 
   if (root->get_name() == "LINK")
-    root->getOrCreateVariableType(std::string("b") + new_typename, color);
+    root->by_name_or_create(std::string("b") + new_typename, color);
 
   for (auto elm : root->children_) {
     recursiveNewVariableType(new_typename, color, elm.second);
@@ -394,7 +406,7 @@ static void recursiveNewUserVariableType(std::string father_type, std::string ne
                                          simgrid::instr::Type* root)
 {
   if (root->get_name() == father_type) {
-    root->getOrCreateVariableType(new_typename, color);
+    root->by_name_or_create(new_typename, color);
   }
   for (auto elm : root->children_)
     recursiveNewUserVariableType(father_type, new_typename, color, elm.second);
@@ -408,7 +420,7 @@ void instr_new_user_variable_type(std::string father_type, std::string new_typen
 static void recursiveNewUserStateType(std::string father_type, std::string new_typename, simgrid::instr::Type* root)
 {
   if (root->get_name() == father_type)
-    root->getOrCreateStateType(new_typename);
+    root->by_name_or_create<simgrid::instr::StateType>(new_typename);
 
   for (auto elm : root->children_)
     recursiveNewUserStateType(father_type, new_typename, elm.second);
@@ -456,7 +468,7 @@ xbt_graph_t instr_routing_platform_graph()
   xbt_graph_t ret                          = xbt_graph_new_graph(0, nullptr);
   std::map<std::string, xbt_node_t>* nodes = new std::map<std::string, xbt_node_t>;
   std::map<std::string, xbt_edge_t>* edges = new std::map<std::string, xbt_edge_t>;
-  recursiveXBTGraphExtraction(ret, nodes, edges, simgrid::s4u::Engine::get_instance()->getNetRoot(),
+  recursiveXBTGraphExtraction(ret, nodes, edges, simgrid::s4u::Engine::get_instance()->get_netzone_root(),
                               simgrid::instr::Container::getRoot());
   delete nodes;
   delete edges;