snake_case in instr

diff --git a/src/instr/instr_config.cpp b/src/instr/instr_config.cpp
index 20f4014..b271e71 100644 (file)
--- a/src/instr/instr_config.cpp
+++ b/src/instr/instr_config.cpp
@@ -144,9 +144,9 @@ static void TRACE_end()
   TRACE_last_timestamp_to_dump = surf_get_clock();
   TRACE_paje_dump_buffer(true);
 
-  simgrid::instr::Type* root_type = simgrid::instr::Container::getRoot()->type_;
+  simgrid::instr::Type* root_type = simgrid::instr::Container::get_root()->type_;
   /* destroy all data structures of tracing (and free) */
-  delete simgrid::instr::Container::getRoot();
+  delete simgrid::instr::Container::get_root();
   delete root_type;
 
   /* close the trace files */

diff --git a/src/instr/instr_interface.cpp b/src/instr/instr_interface.cpp
index 75b55ab..4b9c0f1 100644 (file)
--- a/src/instr/instr_interface.cpp
+++ b/src/instr/instr_interface.cpp
@@ -147,7 +147,7 @@ void TRACE_declare_mark(const char *mark_type)
   }
 
   XBT_DEBUG("MARK,declare %s", mark_type);
-  simgrid::instr::Container::getRoot()->type_->by_name_or_create<simgrid::instr::EventType>(mark_type);
+  simgrid::instr::Container::get_root()->type_->by_name_or_create<simgrid::instr::EventType>(mark_type);
   declared_marks.insert(mark_type);
 }
 
@@ -178,7 +178,7 @@ void TRACE_declare_mark_value_with_color (const char *mark_type, const char *mar
     THROWF (tracing_error, 1, "mark_value is nullptr");
 
   simgrid::instr::EventType* type =
-      static_cast<simgrid::instr::EventType*>(simgrid::instr::Container::getRoot()->type_->by_name(mark_type));
+      static_cast<simgrid::instr::EventType*>(simgrid::instr::Container::get_root()->type_->by_name(mark_type));
   if (not type) {
     THROWF (tracing_error, 1, "mark_type with name (%s) is not declared", mark_type);
   } else {
@@ -186,7 +186,7 @@ void TRACE_declare_mark_value_with_color (const char *mark_type, const char *mar
       mark_color = "1.0 1.0 1.0" /*white*/;
 
     XBT_DEBUG("MARK,declare_value %s %s %s", mark_type, mark_value, mark_color);
-    type->addEntityValue(mark_value, mark_color);
+    type->add_entity_value(mark_value, mark_color);
   }
 }
 
@@ -234,13 +234,13 @@ void TRACE_mark(const char *mark_type, const char *mark_value)
 
   //check if mark_type is already declared
   simgrid::instr::EventType* type =
-      static_cast<simgrid::instr::EventType*>(simgrid::instr::Container::getRoot()->type_->by_name(mark_type));
+      static_cast<simgrid::instr::EventType*>(simgrid::instr::Container::get_root()->type_->by_name(mark_type));
   if (not type) {
     THROWF (tracing_error, 1, "mark_type with name (%s) is not declared", mark_type);
   } else {
     XBT_DEBUG("MARK %s %s", mark_type, mark_value);
-    new simgrid::instr::NewEvent(MSG_get_clock(), simgrid::instr::Container::getRoot(), type,
-                                 type->getEntityValue(mark_value));
+    new simgrid::instr::NewEvent(MSG_get_clock(), simgrid::instr::Container::get_root(), type,
+                                 type->get_entity_value(mark_value));
   }
 }
 
@@ -275,16 +275,17 @@ static void instr_user_variable(double time, const char* resource, const char* v
     }
   }else{
     if (created != filter->end()) { // declared, let's work
-      simgrid::instr::VariableType* variable = simgrid::instr::Container::byName(resource)->getVariable(variable_name);
+      simgrid::instr::VariableType* variable =
+          simgrid::instr::Container::by_name(resource)->get_variable(variable_name);
       switch (what){
         case InstrUserVariable::SET:
-          variable->setEvent(time, value);
+          variable->set_event(time, value);
           break;
         case InstrUserVariable::ADD:
-          variable->addEvent(time, value);
+          variable->add_event(time, value);
           break;
         case InstrUserVariable::SUB:
-          variable->subEvent(time, value);
+          variable->sub_event(time, value);
           break;
         default:
           THROW_IMPOSSIBLE;
@@ -937,9 +938,9 @@ void TRACE_host_state_declare_value (const char *state, const char *value, const
  */
 void TRACE_host_set_state(const char* host, const char* state_name, const char* value_name)
 {
-  simgrid::instr::StateType* state = simgrid::instr::Container::byName(host)->getState(state_name);
-  state->addEntityValue(value_name);
-  state->setEvent(value_name);
+  simgrid::instr::StateType* state = simgrid::instr::Container::by_name(host)->get_state(state_name);
+  state->add_entity_value(value_name);
+  state->set_event(value_name);
 }
 
 /** \ingroup TRACE_user_variables
@@ -955,7 +956,7 @@ void TRACE_host_set_state(const char* host, const char* state_name, const char*
  */
 void TRACE_host_push_state(const char* host, const char* state_name, const char* value_name)
 {
-  simgrid::instr::Container::byName(host)->getState(state_name)->pushEvent(value_name);
+  simgrid::instr::Container::by_name(host)->get_state(state_name)->push_event(value_name);
 }
 
 /** \ingroup TRACE_user_variables
@@ -970,7 +971,7 @@ void TRACE_host_push_state(const char* host, const char* state_name, const char*
  */
 void TRACE_host_pop_state(const char* host, const char* state_name)
 {
-  simgrid::instr::Container::byName(host)->getState(state_name)->popEvent();
+  simgrid::instr::Container::by_name(host)->get_state(state_name)->pop_event();
 }
 
 /** \ingroup TRACE_API

diff --git a/src/instr/instr_paje_containers.cpp b/src/instr/instr_paje_containers.cpp
index f5428d8..52994b4 100644 (file)
--- a/src/instr/instr_paje_containers.cpp
+++ b/src/instr/instr_paje_containers.cpp
@@ -27,7 +27,7 @@ long long int instr_new_paje_id ()
 namespace simgrid {
 namespace instr {
 
-container_t Container::getRoot()
+container_t Container::get_root()
 {
   return rootContainer;
 }
@@ -41,7 +41,7 @@ NetZoneContainer::NetZoneContainer(std::string name, unsigned int level, NetZone
     std::string type_name = std::string("L") + std::to_string(level);
     type_                 = father_->type_->by_name_or_create<ContainerType>(type_name);
     father_->children_.insert({get_name(), this});
-    logCreation();
+    log_creation();
   } else {
     type_         = new ContainerType("0");
     rootContainer = this;
@@ -81,7 +81,7 @@ Container::Container(std::string name, std::string type_name, Container* father)
     if (not type_name.empty()) {
       type_ = father_->type_->by_name_or_create<ContainerType>(type_name);
       father_->children_.insert({name_, this});
-      logCreation();
+      log_creation();
     }
   }
 
@@ -108,34 +108,34 @@ Container::~Container()
   TRACE_paje_dump_buffer(true);
 
   // trace my destruction, but not if user requests so or if the container is root
-  if (not TRACE_disable_destroy() && this != Container::getRoot())
-    logDestruction();
+  if (not TRACE_disable_destroy() && this != Container::get_root())
+    log_destruction();
 
   // remove me from the allContainers data structure
   allContainers.erase(name_);
 }
 
-void Container::createChild(std::string name, std::string type_name)
+void Container::create_child(std::string name, std::string type_name)
 {
   new Container(name, type_name, this);
 }
 
-Container* Container::byNameOrNull(std::string name)
+Container* Container::by_name_or_null(std::string name)
 {
   auto cont = allContainers.find(name);
   return cont == allContainers.end() ? nullptr : cont->second;
 }
 
-Container* Container::byName(std::string name)
+Container* Container::by_name(std::string name)
 {
-  Container* ret = Container::byNameOrNull(name);
+  Container* ret = Container::by_name_or_null(name);
   if (ret == nullptr)
     THROWF(tracing_error, 1, "container with name %s not found", name.c_str());
 
   return ret;
 }
 
-void Container::removeFromParent()
+void Container::remove_from_parent()
 {
   if (father_) {
     XBT_DEBUG("removeChildContainer (%s) FromContainer (%s) ", get_cname(), father_->get_cname());
@@ -144,7 +144,7 @@ void Container::removeFromParent()
   delete this;
 }
 
-void Container::logCreation()
+void Container::log_creation()
 {
   double timestamp = SIMIX_get_clock();
   std::stringstream stream;
@@ -183,7 +183,7 @@ void Container::logCreation()
   }
 }
 
-void Container::logDestruction()
+void Container::log_destruction()
 {
   std::stringstream stream;
   double timestamp = SIMIX_get_clock();
@@ -206,24 +206,24 @@ void Container::logDestruction()
   }
 }
 
-StateType* Container::getState(std::string name)
+StateType* Container::get_state(std::string name)
 {
   StateType* ret = dynamic_cast<StateType*>(type_->by_name(name));
-  ret->setCallingContainer(this);
+  ret->set_calling_container(this);
   return ret;
 }
 
-LinkType* Container::getLink(std::string name)
+LinkType* Container::get_link(std::string name)
 {
   LinkType* ret = dynamic_cast<LinkType*>(type_->by_name(name));
-  ret->setCallingContainer(this);
+  ret->set_calling_container(this);
   return ret;
 }
 
-VariableType* Container::getVariable(std::string name)
+VariableType* Container::get_variable(std::string name)
 {
   VariableType* ret = dynamic_cast<VariableType*>(type_->by_name(name));
-  ret->setCallingContainer(this);
+  ret->set_calling_container(this);
   return ret;
 }
 }

diff --git a/src/instr/instr_paje_containers.hpp b/src/instr/instr_paje_containers.hpp
index 0106898..0498243 100644 (file)
--- a/src/instr/instr_paje_containers.hpp
+++ b/src/instr/instr_paje_containers.hpp
@@ -28,20 +28,20 @@ public:
   std::map<std::string, Container*> children_;
   kernel::routing::NetPoint* netpoint_ = nullptr;
 
-  static Container* byNameOrNull(std::string name);
-  static Container* byName(std::string name);
+  static Container* by_name_or_null(std::string name);
+  static Container* by_name(std::string name);
   std::string get_name() { return name_; }
   const char* get_cname() { return name_.c_str(); }
   long long int get_id() { return id_; }
-  void removeFromParent();
-  void logCreation();
-  void logDestruction();
-
-  StateType* getState(std::string name);
-  LinkType* getLink(std::string name);
-  VariableType* getVariable(std::string name);
-  void createChild(std::string name, std::string type_name);
-  static Container* getRoot();
+  void remove_from_parent();
+  void log_creation();
+  void log_destruction();
+
+  StateType* get_state(std::string name);
+  LinkType* get_link(std::string name);
+  VariableType* get_variable(std::string name);
+  void create_child(std::string name, std::string type_name);
+  static Container* get_root();
 };
 
 class NetZoneContainer : public Container {

diff --git a/src/instr/instr_paje_events.cpp b/src/instr/instr_paje_events.cpp
index 92e53e1..45fafca 100644 (file)
--- a/src/instr/instr_paje_events.cpp
+++ b/src/instr/instr_paje_events.cpp
@@ -23,7 +23,7 @@ PajeEvent::PajeEvent(Container* container, Type* type, double timestamp, e_event
     stream_ << std::fixed << std::setprecision(TRACE_precision());
     stream_ << eventType_ << " " << timestamp_ << " " << type_->get_id() << " " << container_->get_id();
   }
-  insertIntoBuffer();
+  insert_into_buffer();
 };
 
 void PajeEvent::print()
@@ -52,7 +52,7 @@ void NewEvent::print()
   if (trace_format != simgrid::instr::TraceFormat::Paje)
     return;
 
-  stream_ << " " << value->getId();
+  stream_ << " " << value->get_id();
 
   XBT_DEBUG("Dump %s", stream_.str().c_str());
   tracing_file << stream_.str() << std::endl;
@@ -88,7 +88,7 @@ void StateEvent::print()
   if (trace_format == simgrid::instr::TraceFormat::Paje) {
 
     if (value != nullptr) // PAJE_PopState Event does not need to have a value
-      stream_ << " " << value->getId();
+      stream_ << " " << value->get_id();
 
     if (TRACE_display_sizes())
       stream_ << " " << ((extra_ != nullptr) ? extra_->display_size() : 0);
@@ -107,13 +107,13 @@ void StateEvent::print()
     /* Unimplemented calls are: WAITANY, SENDRECV, SCAN, EXSCAN, SSEND, and ISSEND. */
 
     // FIXME: dirty extract "rank-" from the name, as we want the bare process id here
-    if (getContainer()->get_name().find("rank-") != 0)
-      stream_ << getContainer()->get_name() << " " << extra_->print();
+    if (get_container()->get_name().find("rank-") != 0)
+      stream_ << get_container()->get_name() << " " << extra_->print();
     else
       /* Subtract -1 because this is the process id and we transform it to the rank id */
-      stream_ << stoi(getContainer()->get_name().erase(0, 5)) - 1 << " " << extra_->print();
+      stream_ << stoi(get_container()->get_name().erase(0, 5)) - 1 << " " << extra_->print();
 
-    *tracing_files.at(getContainer()) << stream_.str() << std::endl;
+    *tracing_files.at(get_container()) << stream_.str() << std::endl;
   } else {
     THROW_IMPOSSIBLE;
   }

diff --git a/src/instr/instr_paje_events.hpp b/src/instr/instr_paje_events.hpp
index bf82373..eb4041e 100644 (file)
--- a/src/instr/instr_paje_events.hpp
+++ b/src/instr/instr_paje_events.hpp
@@ -40,7 +40,7 @@ class PajeEvent {
   Container* container_;
   Type* type_;
 protected:
-  Container* getContainer() { return container_; }
+  Container* get_container() { return container_; }
 public:
   double timestamp_;
   e_event_type eventType_;
@@ -49,7 +49,7 @@ public:
   PajeEvent(Container* container, Type* type, double timestamp, e_event_type eventType);
   virtual ~PajeEvent() = default;
   virtual void print();
-  void insertIntoBuffer();
+  void insert_into_buffer();
 };
 
 class VariableEvent : public PajeEvent {

diff --git a/src/instr/instr_paje_trace.cpp b/src/instr/instr_paje_trace.cpp
index f37c0e1..04445d2 100644 (file)
--- a/src/instr/instr_paje_trace.cpp
+++ b/src/instr/instr_paje_trace.cpp
@@ -85,7 +85,7 @@ static void buffer_debug(std::vector<simgrid::instr::PajeEvent*>* buf)
 }
 
 /* internal do the instrumentation module */
-void simgrid::instr::PajeEvent::insertIntoBuffer()
+void simgrid::instr::PajeEvent::insert_into_buffer()
 {
   if (not TRACE_buffer()) {
     print();

diff --git a/src/instr/instr_paje_types.cpp b/src/instr/instr_paje_types.cpp
index 6a1556d..141c330 100644 (file)
--- a/src/instr/instr_paje_types.cpp
+++ b/src/instr/instr_paje_types.cpp
@@ -45,19 +45,19 @@ ValueType::~ValueType()
 ContainerType::ContainerType(std::string name, Type* father) : Type(name, name, "", father)
 {
   XBT_DEBUG("ContainerType %s(%lld), child of %s(%lld)", get_cname(), get_id(), father->get_cname(), father->get_id());
-  logDefinition(PAJE_DefineContainerType);
+  log_definition(PAJE_DefineContainerType);
 }
 
 EventType::EventType(std::string name, Type* father) : ValueType(name, father)
 {
   XBT_DEBUG("EventType %s(%lld), child of %s(%lld)", get_cname(), get_id(), father->get_cname(), father->get_id());
-  logDefinition(PAJE_DefineEventType);
+  log_definition(PAJE_DefineEventType);
 }
 
 StateType::StateType(std::string name, Type* father) : ValueType(name, father)
 {
   XBT_DEBUG("StateType %s(%lld), child of %s(%lld)", get_cname(), get_id(), father->get_cname(), father->get_id());
-  logDefinition(PAJE_DefineStateType);
+  log_definition(PAJE_DefineStateType);
 }
 
 StateType::~StateType()
@@ -65,27 +65,27 @@ StateType::~StateType()
   events_.clear();
 }
 
-void StateType::setEvent(std::string value_name)
+void StateType::set_event(std::string value_name)
 {
-  events_.push_back(new StateEvent(issuer_, this, PAJE_SetState, getEntityValue(value_name), nullptr));
+  events_.push_back(new StateEvent(issuer_, this, PAJE_SetState, get_entity_value(value_name), nullptr));
 }
 
-void StateType::pushEvent(std::string value_name, TIData* extra)
+void StateType::push_event(std::string value_name, TIData* extra)
 {
-  events_.push_back(new StateEvent(issuer_, this, PAJE_PushState, getEntityValue(value_name), extra));
+  events_.push_back(new StateEvent(issuer_, this, PAJE_PushState, get_entity_value(value_name), extra));
 }
 
-void StateType::pushEvent(std::string value_name)
+void StateType::push_event(std::string value_name)
 {
-  events_.push_back(new StateEvent(issuer_, this, PAJE_PushState, getEntityValue(value_name), nullptr));
+  events_.push_back(new StateEvent(issuer_, this, PAJE_PushState, get_entity_value(value_name), nullptr));
 }
 
-void StateType::popEvent()
+void StateType::pop_event()
 {
   events_.push_back(new StateEvent(issuer_, this, PAJE_PopState, nullptr, nullptr));
 }
 
-void StateType::popEvent(TIData* extra)
+void StateType::pop_event(TIData* extra)
 {
   events_.push_back(new StateEvent(issuer_, this, PAJE_PopState, nullptr, extra));
 }
@@ -93,7 +93,7 @@ void StateType::popEvent(TIData* extra)
 VariableType::VariableType(std::string name, std::string color, Type* father) : Type(name, name, color, father)
 {
   XBT_DEBUG("VariableType %s(%lld), child of %s(%lld)", get_cname(), get_id(), father->get_cname(), father->get_id());
-  logDefinition(PAJE_DefineVariableType);
+  log_definition(PAJE_DefineVariableType);
 }
 
 VariableType::~VariableType()
@@ -113,25 +113,25 @@ void VariableType::instr_event(double now, double delta, const char* resource, d
 
   // check if key exists: if it doesn't, set the variable to zero and mark this in the global map.
   if (platform_variables.find(key) == platform_variables.end()) {
-    setEvent(now, 0);
+    set_event(now, 0);
     platform_variables.insert(key);
   }
 
-  addEvent(now, value);
-  subEvent(now + delta, value);
+  add_event(now, value);
+  sub_event(now + delta, value);
 }
 
-void VariableType::setEvent(double timestamp, double value)
+void VariableType::set_event(double timestamp, double value)
 {
   events_.push_back(new VariableEvent(timestamp, issuer_, this, PAJE_SetVariable, value));
 }
 
-void VariableType::addEvent(double timestamp, double value)
+void VariableType::add_event(double timestamp, double value)
 {
   events_.push_back(new VariableEvent(timestamp, issuer_, this, PAJE_AddVariable, value));
 }
 
-void VariableType::subEvent(double timestamp, double value)
+void VariableType::sub_event(double timestamp, double value)
 {
   events_.push_back(new VariableEvent(timestamp, issuer_, this, PAJE_SubVariable, value));
 }
@@ -139,34 +139,34 @@ void VariableType::subEvent(double timestamp, double value)
 LinkType::LinkType(std::string name, std::string alias, Type* father) : ValueType(name, alias, father)
 {
 }
-void LinkType::startEvent(Container* startContainer, std::string value, std::string key)
+void LinkType::start_event(Container* startContainer, std::string value, std::string key)
 {
-  startEvent(startContainer, value, key, -1);
+  start_event(startContainer, value, key, -1);
 }
 
-void LinkType::startEvent(Container* startContainer, std::string value, std::string key, int size)
+void LinkType::start_event(Container* startContainer, std::string value, std::string key, int size)
 {
   new LinkEvent(issuer_, this, PAJE_StartLink, startContainer, value, key, size);
 }
 
-void LinkType::endEvent(Container* endContainer, std::string value, std::string key)
+void LinkType::end_event(Container* endContainer, std::string value, std::string key)
 {
   new LinkEvent(issuer_, this, PAJE_EndLink, endContainer, value, key, -1);
 }
 
-void Type::logDefinition(e_event_type event_type)
+void Type::log_definition(e_event_type event_type)
 {
   if (trace_format != simgrid::instr::TraceFormat::Paje)
     return;
   XBT_DEBUG("%s: event_type=%u, timestamp=%.*f", __func__, event_type, TRACE_precision(), 0.);
   stream_ << event_type << " " << get_id() << " " << father_->get_id() << " " << get_name();
-  if (isColored())
+  if (is_colored())
     stream_ << " \"" << color_ << "\"";
   XBT_DEBUG("Dump %s", stream_.str().c_str());
   tracing_file << stream_.str() << std::endl;
 }
 
-void Type::logDefinition(simgrid::instr::Type* source, simgrid::instr::Type* dest)
+void Type::log_definition(simgrid::instr::Type* source, simgrid::instr::Type* dest)
 {
   if (trace_format != simgrid::instr::TraceFormat::Paje)
     return;
@@ -194,12 +194,12 @@ Type* Type::by_name(std::string name)
   return ret;
 }
 
-void ValueType::addEntityValue(std::string name)
+void ValueType::add_entity_value(std::string name)
 {
-  addEntityValue(name, "");
+  add_entity_value(name, "");
 }
 
-void ValueType::addEntityValue(std::string name, std::string color)
+void ValueType::add_entity_value(std::string name, std::string color)
 {
   if (name.empty())
     THROWF(tracing_error, 0, "can't get a value with no name");
@@ -213,7 +213,7 @@ void ValueType::addEntityValue(std::string name, std::string color)
   }
 }
 
-EntityValue* ValueType::getEntityValue(std::string name)
+EntityValue* ValueType::get_entity_value(std::string name)
 {
   auto ret = values_.find(name);
   if (ret == values_.end()) {
@@ -237,7 +237,7 @@ LinkType* Type::by_name_or_create(std::string name, Type* source, Type* dest)
     LinkType* ret = new LinkType(name, alias, this);
     XBT_DEBUG("LinkType %s(%lld), child of %s(%lld)  %s(%lld)->%s(%lld)", ret->get_cname(), ret->get_id(), get_cname(),
               get_id(), source->get_cname(), source->get_id(), dest->get_cname(), dest->get_id());
-    ret->logDefinition(source, dest);
+    ret->log_definition(source, dest);
     return ret;
   } else
     return static_cast<LinkType*>(it->second);

diff --git a/src/instr/instr_paje_types.hpp b/src/instr/instr_paje_types.hpp
index 4ac25a5..7784cfa 100644 (file)
--- a/src/instr/instr_paje_types.hpp
+++ b/src/instr/instr_paje_types.hpp
@@ -33,7 +33,7 @@ public:
   std::string get_name() { return name_; }
   const char* get_cname() { return name_.c_str(); }
   long long int get_id() { return id_; }
-  bool isColored() { return not color_.empty(); }
+  bool is_colored() { return not color_.empty(); }
 
   Type* by_name(std::string name);
   LinkType* by_name_or_create(std::string name, Type* source, Type* dest);
@@ -45,10 +45,10 @@ public:
     return cont == children_.end() ? new T(name, this) : static_cast<T*>(cont->second);
   }
 
-  void setCallingContainer(Container* container) { issuer_ = container; }
+  void set_calling_container(Container* container) { issuer_ = container; }
 
-  void logDefinition(e_event_type event_type);
-  void logDefinition(Type* source, Type* dest);
+  void log_definition(e_event_type event_type);
+  void log_definition(Type* source, Type* dest);
 };
 
 class ContainerType : public Type {
@@ -63,9 +63,9 @@ public:
   VariableType(std::string name, std::string color, Type* father);
   ~VariableType();
   void instr_event(double now, double delta, const char* resource, double value);
-  void setEvent(double timestamp, double value);
-  void addEvent(double timestamp, double value);
-  void subEvent(double timestamp, double value);
+  void set_event(double timestamp, double value);
+  void add_event(double timestamp, double value);
+  void sub_event(double timestamp, double value);
 };
 
 class ValueType : public Type {
@@ -74,17 +74,17 @@ public:
   ValueType(std::string name, std::string alias, Type* father) : Type(name, alias, "", father){};
   ValueType(std::string name, Type* father) : Type(name, name, "", father){};
   virtual ~ValueType();
-  void addEntityValue(std::string name, std::string color);
-  void addEntityValue(std::string name);
-  EntityValue* getEntityValue(std::string name);
+  void add_entity_value(std::string name, std::string color);
+  void add_entity_value(std::string name);
+  EntityValue* get_entity_value(std::string name);
 };
 
 class LinkType : public ValueType {
 public:
   LinkType(std::string name, std::string alias, Type* father);
-  void startEvent(Container* startContainer, std::string value, std::string key);
-  void startEvent(Container* startContainer, std::string value, std::string key, int size);
-  void endEvent(Container* endContainer, std::string value, std::string key);
+  void start_event(Container* startContainer, std::string value, std::string key);
+  void start_event(Container* startContainer, std::string value, std::string key, int size);
+  void end_event(Container* endContainer, std::string value, std::string key);
 };
 
 class EventType : public ValueType {
@@ -97,11 +97,11 @@ class StateType : public ValueType {
 public:
   StateType(std::string name, Type* father);
   ~StateType();
-  void setEvent(std::string value_name);
-  void pushEvent(std::string value_name);
-  void pushEvent(std::string value_name, TIData* extra);
-  void popEvent();
-  void popEvent(TIData* extra);
+  void set_event(std::string value_name);
+  void push_event(std::string value_name);
+  void push_event(std::string value_name, TIData* extra);
+  void pop_event();
+  void pop_event(TIData* extra);
 };
 }
 }

diff --git a/src/instr/instr_paje_values.hpp b/src/instr/instr_paje_values.hpp
index 23a502c..53626d5 100644 (file)
--- a/src/instr/instr_paje_values.hpp
+++ b/src/instr/instr_paje_values.hpp
@@ -21,8 +21,8 @@ class EntityValue {
 public:
   explicit EntityValue(std::string name, std::string color, Type* father);
   ~EntityValue() = default;
-  const char* getCname() { return name_.c_str(); }
-  long long int getId() { return id_; }
+  const char* get_cname() { return name_.c_str(); }
+  long long int get_id() { return id_; }
   void print();
 };
 }

diff --git a/src/instr/instr_platform.cpp b/src/instr/instr_platform.cpp
index 329dedd..bb7827e 100644 (file)
--- a/src/instr/instr_platform.cpp
+++ b/src/instr/instr_platform.cpp
@@ -101,7 +101,7 @@ static void linkContainers(container_t src, container_t dst, std::set<std::strin
                               std::to_string(src->type_->get_id()) + "-" + dst->type_->get_name() +
                               std::to_string(dst->type_->get_id());
   simgrid::instr::LinkType* link = father->type_->by_name_or_create(link_typename, src->type_, dst->type_);
-  link->setCallingContainer(father);
+  link->set_calling_container(father);
 
   // register EDGE types for triva configuration
   trivaEdgeTypes.insert(link->get_name());
@@ -112,8 +112,8 @@ static void linkContainers(container_t src, container_t dst, std::set<std::strin
   std::string key = std::to_string(counter);
   counter++;
 
-  link->startEvent(src, "topology", key);
-  link->endEvent(dst, "topology", key);
+  link->start_event(src, "topology", key);
+  link->end_event(dst, "topology", key);
 
   XBT_DEBUG("  linkContainers %s <-> %s", src->get_cname(), dst->get_cname());
 }
@@ -141,8 +141,8 @@ static void recursiveGraphExtraction(simgrid::s4u::NetZone* netzone, container_t
   static_cast<simgrid::kernel::routing::NetZoneImpl*>(netzone)->get_graph(graph, nodes, edges);
   for (auto elm : *edges) {
     xbt_edge_t edge = elm.second;
-    linkContainers(simgrid::instr::Container::byName(static_cast<const char*>(edge->src->data)),
-                   simgrid::instr::Container::byName(static_cast<const char*>(edge->dst->data)), filter);
+    linkContainers(simgrid::instr::Container::by_name(static_cast<const char*>(edge->src->data)),
+                   simgrid::instr::Container::by_name(static_cast<const char*>(edge->dst->data)), filter);
   }
   delete nodes;
   delete edges;
@@ -155,7 +155,7 @@ static void recursiveGraphExtraction(simgrid::s4u::NetZone* netzone, container_t
 static void instr_netzone_on_creation(simgrid::s4u::NetZone& netzone)
 {
   std::string id = netzone.get_name();
-  if (simgrid::instr::Container::getRoot() == nullptr) {
+  if (simgrid::instr::Container::get_root() == nullptr) {
     simgrid::instr::NetZoneContainer* root = new simgrid::instr::NetZoneContainer(id, 0, nullptr);
 
     if (TRACE_smpi_is_enabled()) {
@@ -197,11 +197,11 @@ static void instr_link_on_creation(simgrid::s4u::Link& link)
 
   if ((TRACE_categorized() || TRACE_uncategorized() || TRACE_platform()) && (not TRACE_disable_link())) {
     simgrid::instr::VariableType* bandwidth = container->type_->by_name_or_create("bandwidth", "");
-    bandwidth->setCallingContainer(container);
-    bandwidth->setEvent(0, link.bandwidth());
+    bandwidth->set_calling_container(container);
+    bandwidth->set_event(0, link.bandwidth());
     simgrid::instr::VariableType* latency = container->type_->by_name_or_create("latency", "");
-    latency->setCallingContainer(container);
-    latency->setEvent(0, link.latency());
+    latency->set_calling_container(container);
+    latency->set_event(0, link.latency());
   }
   if (TRACE_uncategorized()) {
     container->type_->by_name_or_create("bandwidth_used", "0.5 0.5 0.5");
@@ -211,12 +211,12 @@ static void instr_link_on_creation(simgrid::s4u::Link& link)
 static void instr_host_on_creation(simgrid::s4u::Host& host)
 {
   container_t container = new simgrid::instr::HostContainer(host, currentContainer.back());
-  container_t root      = simgrid::instr::Container::getRoot();
+  container_t root      = simgrid::instr::Container::get_root();
 
   if ((TRACE_categorized() || TRACE_uncategorized() || TRACE_platform()) && (not TRACE_disable_speed())) {
     simgrid::instr::VariableType* power = container->type_->by_name_or_create("power", "");
-    power->setCallingContainer(container);
-    power->setEvent(0, host.getSpeed());
+    power->set_calling_container(container);
+    power->set_event(0, host.getSpeed());
   }
 
   if (TRACE_uncategorized())
@@ -252,7 +252,7 @@ static void instr_on_platform_created()
   std::set<std::string>* filter = new std::set<std::string>;
   XBT_DEBUG("Starting graph extraction.");
   recursiveGraphExtraction(simgrid::s4u::Engine::get_instance()->get_netzone_root(),
-                           simgrid::instr::Container::getRoot(), filter);
+                           simgrid::instr::Container::get_root(), filter);
   XBT_DEBUG("Graph extraction finished.");
   delete filter;
   TRACE_paje_dump_buffer(true);
@@ -260,30 +260,30 @@ static void instr_on_platform_created()
 
 static void instr_actor_on_creation(simgrid::s4u::ActorPtr actor)
 {
-  container_t root      = simgrid::instr::Container::getRoot();
-  container_t container = simgrid::instr::Container::byName(actor->get_host()->get_name());
+  container_t root      = simgrid::instr::Container::get_root();
+  container_t container = simgrid::instr::Container::by_name(actor->get_host()->get_name());
 
-  container->createChild(instr_pid(actor.get()), "ACTOR");
+  container->create_child(instr_pid(actor.get()), "ACTOR");
   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");
+  state->add_entity_value("suspend", "1 0 1");
+  state->add_entity_value("sleep", "1 1 0");
+  state->add_entity_value("receive", "1 0 0");
+  state->add_entity_value("send", "0 0 1");
+  state->add_entity_value("task_execute", "0 1 1");
   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)
 {
-  simgrid::instr::Container::byName(instr_pid(actor.get()))->getState("ACTOR_STATE")->pushEvent("suspend");
+  simgrid::instr::Container::by_name(instr_pid(actor.get()))->get_state("ACTOR_STATE")->push_event("suspend");
 }
 
 static void instr_actor_on_resume(simgrid::s4u::ActorPtr actor)
 {
-  simgrid::instr::Container::byName(instr_pid(actor.get()))->getState("ACTOR_STATE")->popEvent();
+  simgrid::instr::Container::by_name(instr_pid(actor.get()))->get_state("ACTOR_STATE")->pop_event();
 }
 
 static long long int counter = 0;
@@ -291,62 +291,62 @@ static long long int counter = 0;
 static void instr_actor_on_migration_start(simgrid::s4u::ActorPtr actor)
 {
   // start link
-  container_t container = simgrid::instr::Container::byName(instr_pid(actor.get()));
-  simgrid::instr::Container::getRoot()->getLink("ACTOR_LINK")->startEvent(container, "M", std::to_string(counter));
+  container_t container = simgrid::instr::Container::by_name(instr_pid(actor.get()));
+  simgrid::instr::Container::get_root()->get_link("ACTOR_LINK")->start_event(container, "M", std::to_string(counter));
 
   // destroy existing container of this process
-  container->removeFromParent();
+  container->remove_from_parent();
 }
 
 static void instr_actor_on_migration_end(simgrid::s4u::ActorPtr actor)
 {
   // create new container on the new_host location
-  simgrid::instr::Container::byName(actor->get_host()->get_name())->createChild(instr_pid(actor.get()), "ACTOR");
+  simgrid::instr::Container::by_name(actor->get_host()->get_name())->create_child(instr_pid(actor.get()), "ACTOR");
   // end link
-  simgrid::instr::Container::getRoot()
-      ->getLink("ACTOR_LINK")
-      ->endEvent(simgrid::instr::Container::byName(instr_pid(actor.get())), "M", std::to_string(counter));
+  simgrid::instr::Container::get_root()
+      ->get_link("ACTOR_LINK")
+      ->end_event(simgrid::instr::Container::by_name(instr_pid(actor.get())), "M", std::to_string(counter));
   counter++;
 }
 
 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();
+  container_t root                  = simgrid::instr::Container::get_root();
   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");
+  state->add_entity_value("suspend", "1 0 1");
+  state->add_entity_value("sleep", "1 1 0");
+  state->add_entity_value("receive", "1 0 0");
+  state->add_entity_value("send", "0 0 1");
+  state->add_entity_value("task_execute", "0 1 1");
   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("VM_STATE")->pushEvent("start");
+  simgrid::instr::Container::by_name(vm.get_name())->get_state("VM_STATE")->push_event("start");
 }
 
 static void instr_vm_on_started(simgrid::s4u::VirtualMachine& vm)
 {
-  simgrid::instr::Container::byName(vm.get_name())->getState("VM_STATE")->popEvent();
+  simgrid::instr::Container::by_name(vm.get_name())->get_state("VM_STATE")->pop_event();
 }
 
 static void instr_vm_on_suspend(simgrid::s4u::VirtualMachine& vm)
 {
-  simgrid::instr::Container::byName(vm.get_name())->getState("VM_STATE")->pushEvent("suspend");
+  simgrid::instr::Container::by_name(vm.get_name())->get_state("VM_STATE")->push_event("suspend");
 }
 
 static void instr_vm_on_resume(simgrid::s4u::VirtualMachine& vm)
 {
-  simgrid::instr::Container::byName(vm.get_name())->getState("VM_STATE")->popEvent();
+  simgrid::instr::Container::by_name(vm.get_name())->get_state("VM_STATE")->pop_event();
 }
 
 static void instr_vm_on_destruction(simgrid::s4u::Host& host)
 {
-  simgrid::instr::Container::byName(host.get_name())->removeFromParent();
+  simgrid::instr::Container::by_name(host.get_name())->remove_from_parent();
 }
 
 void instr_define_callbacks()
@@ -399,7 +399,7 @@ static void recursiveNewVariableType(std::string new_typename, std::string color
 
 void instr_new_variable_type(std::string new_typename, std::string color)
 {
-  recursiveNewVariableType(new_typename, color, simgrid::instr::Container::getRoot()->type_);
+  recursiveNewVariableType(new_typename, color, simgrid::instr::Container::get_root()->type_);
 }
 
 static void recursiveNewUserVariableType(std::string father_type, std::string new_typename, std::string color,
@@ -414,7 +414,7 @@ static void recursiveNewUserVariableType(std::string father_type, std::string ne
 
 void instr_new_user_variable_type(std::string father_type, std::string new_typename, std::string color)
 {
-  recursiveNewUserVariableType(father_type, new_typename, color, simgrid::instr::Container::getRoot()->type_);
+  recursiveNewUserVariableType(father_type, new_typename, color, simgrid::instr::Container::get_root()->type_);
 }
 
 static void recursiveNewUserStateType(std::string father_type, std::string new_typename, simgrid::instr::Type* root)
@@ -428,14 +428,14 @@ static void recursiveNewUserStateType(std::string father_type, std::string new_t
 
 void instr_new_user_state_type(std::string father_type, std::string new_typename)
 {
-  recursiveNewUserStateType(father_type, new_typename, simgrid::instr::Container::getRoot()->type_);
+  recursiveNewUserStateType(father_type, new_typename, simgrid::instr::Container::get_root()->type_);
 }
 
 static void recursiveNewValueForUserStateType(std::string type_name, const char* val, std::string color,
                                               simgrid::instr::Type* root)
 {
   if (root->get_name() == type_name)
-    static_cast<simgrid::instr::StateType*>(root)->addEntityValue(val, color);
+    static_cast<simgrid::instr::StateType*>(root)->add_entity_value(val, color);
 
   for (auto elm : root->children_)
     recursiveNewValueForUserStateType(type_name, val, color, elm.second);
@@ -443,7 +443,7 @@ static void recursiveNewValueForUserStateType(std::string type_name, const char*
 
 void instr_new_value_for_user_state_type(std::string type_name, const char* value, std::string color)
 {
-  recursiveNewValueForUserStateType(type_name, value, color, simgrid::instr::Container::getRoot()->type_);
+  recursiveNewValueForUserStateType(type_name, value, color, simgrid::instr::Container::get_root()->type_);
 }
 
 #define GRAPHICATOR_SUPPORT_FUNCTIONS
@@ -469,7 +469,7 @@ xbt_graph_t instr_routing_platform_graph()
   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()->get_netzone_root(),
-                              simgrid::instr::Container::getRoot());
+                              simgrid::instr::Container::get_root());
   delete nodes;
   delete edges;
   return ret;

diff --git a/src/instr/instr_resource_utilization.cpp b/src/instr/instr_resource_utilization.cpp
index 120de2d..699541d 100644 (file)
--- a/src/instr/instr_resource_utilization.cpp
+++ b/src/instr/instr_resource_utilization.cpp
@@ -13,21 +13,21 @@ void TRACE_surf_resource_set_utilization(const char* type, const char* name, con
                                          double value, double now, double delta)
 {
   // only trace resource utilization if resource is known by tracing mechanism
-  container_t container = simgrid::instr::Container::byNameOrNull(resource);
+  container_t container = simgrid::instr::Container::by_name_or_null(resource);
   if (not container || not value)
     return;
 
   // trace uncategorized resource utilization
   if (TRACE_uncategorized()){
     XBT_DEBUG("UNCAT %s [%f - %f] %s %s %f", type, now, now + delta, resource, name, value);
-    container->getVariable(name)->instr_event(now, delta, resource, value);
+    container->get_variable(name)->instr_event(now, delta, resource, value);
   }
 
   // trace categorized resource utilization
   if (TRACE_categorized() && category) {
     std::string category_type = name[0] + std::string(category);
     XBT_DEBUG("CAT %s [%f - %f] %s %s %f", type, now, now + delta, resource, category_type.c_str(), value);
-    container->getVariable(name)->instr_event(now, delta, resource, value);
+    container->get_variable(name)->instr_event(now, delta, resource, value);
   }
 }
 

diff --git a/src/msg/instr_msg_process.cpp b/src/msg/instr_msg_process.cpp
index e2d7cb1..a0aa212 100644 (file)
--- a/src/msg/instr_msg_process.cpp
+++ b/src/msg/instr_msg_process.cpp
@@ -19,6 +19,6 @@ void TRACE_msg_process_kill(smx_process_exit_status_t status, msg_process_t proc
 {
   if (TRACE_actor_is_enabled() && status == SMX_EXIT_FAILURE) {
     //kill means that this process no longer exists, let's destroy it
-    simgrid::instr::Container::byName(instr_pid(process))->removeFromParent();
+    simgrid::instr::Container::by_name(instr_pid(process))->remove_from_parent();
   }
 }

diff --git a/src/msg/instr_msg_task.cpp b/src/msg/instr_msg_task.cpp
index 9291f93..e455118 100644 (file)
--- a/src/msg/instr_msg_task.cpp
+++ b/src/msg/instr_msg_task.cpp
@@ -49,9 +49,9 @@ void TRACE_msg_task_execute_start(msg_task_t task)
   XBT_DEBUG("EXEC,in %p, %lld, %s", task, task->counter, task->category);
 
   if (TRACE_actor_is_enabled())
-    simgrid::instr::Container::byName(instr_pid(MSG_process_self()))
-        ->getState("ACTOR_STATE")
-        ->pushEvent("task_execute");
+    simgrid::instr::Container::by_name(instr_pid(MSG_process_self()))
+        ->get_state("ACTOR_STATE")
+        ->push_event("task_execute");
 }
 
 void TRACE_msg_task_execute_end(msg_task_t task)
@@ -59,7 +59,7 @@ void TRACE_msg_task_execute_end(msg_task_t task)
   XBT_DEBUG("EXEC,out %p, %lld, %s", task, task->counter, task->category);
 
   if (TRACE_actor_is_enabled())
-    simgrid::instr::Container::byName(instr_pid(MSG_process_self()))->getState("ACTOR_STATE")->popEvent();
+    simgrid::instr::Container::by_name(instr_pid(MSG_process_self()))->get_state("ACTOR_STATE")->pop_event();
 }
 
 /* MSG_task_destroy related functions */
@@ -78,7 +78,7 @@ void TRACE_msg_task_get_start()
   XBT_DEBUG("GET,in");
 
   if (TRACE_actor_is_enabled())
-    simgrid::instr::Container::byName(instr_pid(MSG_process_self()))->getState("ACTOR_STATE")->pushEvent("receive");
+    simgrid::instr::Container::by_name(instr_pid(MSG_process_self()))->get_state("ACTOR_STATE")->push_event("receive");
 }
 
 void TRACE_msg_task_get_end(msg_task_t task)
@@ -86,11 +86,11 @@ void TRACE_msg_task_get_end(msg_task_t task)
   XBT_DEBUG("GET,out %p, %lld, %s", task, task->counter, task->category);
 
   if (TRACE_actor_is_enabled()) {
-    container_t process_container = simgrid::instr::Container::byName(instr_pid(MSG_process_self()));
-    process_container->getState("ACTOR_STATE")->popEvent();
+    container_t process_container = simgrid::instr::Container::by_name(instr_pid(MSG_process_self()));
+    process_container->get_state("ACTOR_STATE")->pop_event();
 
     std::string key = std::string("p") + std::to_string(task->counter);
-    simgrid::instr::Container::getRoot()->getLink("ACTOR_TASK_LINK")->endEvent(process_container, "SR", key);
+    simgrid::instr::Container::get_root()->get_link("ACTOR_TASK_LINK")->end_event(process_container, "SR", key);
   }
 }
 
@@ -100,11 +100,11 @@ void TRACE_msg_task_put_start(msg_task_t task)
   XBT_DEBUG("PUT,in %p, %lld, %s", task, task->counter, task->category);
 
   if (TRACE_actor_is_enabled()) {
-    container_t process_container = simgrid::instr::Container::byName(instr_pid(MSG_process_self()));
-    process_container->getState("ACTOR_STATE")->pushEvent("send");
+    container_t process_container = simgrid::instr::Container::by_name(instr_pid(MSG_process_self()));
+    process_container->get_state("ACTOR_STATE")->push_event("send");
 
     std::string key = std::string("p") + std::to_string(task->counter);
-    simgrid::instr::Container::getRoot()->getLink("ACTOR_TASK_LINK")->startEvent(process_container, "SR", key);
+    simgrid::instr::Container::get_root()->get_link("ACTOR_TASK_LINK")->start_event(process_container, "SR", key);
   }
 }
 
@@ -113,5 +113,5 @@ void TRACE_msg_task_put_end()
   XBT_DEBUG("PUT,out");
 
   if (TRACE_actor_is_enabled())
-    simgrid::instr::Container::byName(instr_pid(MSG_process_self()))->getState("ACTOR_STATE")->popEvent();
+    simgrid::instr::Container::by_name(instr_pid(MSG_process_self()))->get_state("ACTOR_STATE")->pop_event();
 }

diff --git a/src/msg/msg_gos.cpp b/src/msg/msg_gos.cpp
index 5415b72..0769959 100644 (file)
--- a/src/msg/msg_gos.cpp
+++ b/src/msg/msg_gos.cpp
@@ -113,7 +113,7 @@ msg_error_t MSG_process_sleep(double nb_sec)
   msg_error_t status = MSG_OK;
 
   if (TRACE_actor_is_enabled())
-    simgrid::instr::Container::byName(instr_pid(MSG_process_self()))->getState("ACTOR_STATE")->pushEvent("sleep");
+    simgrid::instr::Container::by_name(instr_pid(MSG_process_self()))->get_state("ACTOR_STATE")->push_event("sleep");
 
   try {
     simcall_process_sleep(nb_sec);
@@ -133,7 +133,7 @@ msg_error_t MSG_process_sleep(double nb_sec)
   }
 
   if (TRACE_actor_is_enabled())
-    simgrid::instr::Container::byName(instr_pid(MSG_process_self()))->getState("ACTOR_STATE")->popEvent();
+    simgrid::instr::Container::by_name(instr_pid(MSG_process_self()))->get_state("ACTOR_STATE")->pop_event();
 
   return status;
 }

diff --git a/src/msg/msg_process.cpp b/src/msg/msg_process.cpp
index 3a82a9a..581d75c 100644 (file)
--- a/src/msg/msg_process.cpp
+++ b/src/msg/msg_process.cpp
@@ -40,7 +40,7 @@ void MSG_process_cleanup_from_SIMIX(smx_actor_t smx_actor)
   }
 
   if (TRACE_actor_is_enabled())
-    simgrid::instr::Container::byName(instr_pid(smx_actor->ciface()))->removeFromParent();
+    simgrid::instr::Container::by_name(instr_pid(smx_actor->ciface()))->remove_from_parent();
 
   // free the data if a function was provided
   if (msg_actor && msg_actor->data && msg_global->process_data_cleanup) {

diff --git a/src/plugins/vm/VmLiveMigration.cpp b/src/plugins/vm/VmLiveMigration.cpp
index 0c1f792..a6cfe1f 100644 (file)
--- a/src/plugins/vm/VmLiveMigration.cpp
+++ b/src/plugins/vm/VmLiveMigration.cpp
@@ -59,18 +59,18 @@ void MigrationRx::operator()()
     counter++;
 
     // start link
-    container_t msg = simgrid::instr::Container::byName(vm_->get_name());
-    simgrid::instr::Container::getRoot()->getLink("VM_LINK")->startEvent(msg, "M", key);
+    container_t msg = simgrid::instr::Container::by_name(vm_->get_name());
+    simgrid::instr::Container::get_root()->get_link("VM_LINK")->start_event(msg, "M", key);
 
     // destroy existing container of this vm
-    simgrid::instr::Container::byName(vm_->get_name())->removeFromParent();
+    simgrid::instr::Container::by_name(vm_->get_name())->remove_from_parent();
 
     // create new container on the new_host location
-    new simgrid::instr::Container(vm_->get_cname(), "VM", simgrid::instr::Container::byName(dst_pm_->get_name()));
+    new simgrid::instr::Container(vm_->get_cname(), "VM", simgrid::instr::Container::by_name(dst_pm_->get_name()));
 
     // end link
-    msg = simgrid::instr::Container::byName(vm_->get_name());
-    simgrid::instr::Container::getRoot()->getLink("VM_LINK")->endEvent(msg, "M", key);
+    msg = simgrid::instr::Container::by_name(vm_->get_name());
+    simgrid::instr::Container::get_root()->get_link("VM_LINK")->end_event(msg, "M", key);
   }
   // Inform the SRC that the migration has been correctly performed
   std::string* payload = new std::string("__mig_stage4:");

diff --git a/src/smpi/colls/smpi_automatic_selector.cpp b/src/smpi/colls/smpi_automatic_selector.cpp
index c01b6d3..8c90b96 100644 (file)
--- a/src/smpi/colls/smpi_automatic_selector.cpp
+++ b/src/smpi/colls/smpi_automatic_selector.cpp
@@ -14,12 +14,12 @@
 #define TRACE_AUTO_COLL(cat)                                                                                           \
   if (TRACE_is_enabled()) {                                                                                            \
     simgrid::instr::EventType* type =                                                                                  \
-        simgrid::instr::Container::getRoot()->type_->by_name_or_create<simgrid::instr::EventType>(#cat);               \
+        simgrid::instr::Container::get_root()->type_->by_name_or_create<simgrid::instr::EventType>(#cat);              \
                                                                                                                        \
     std::string cont_name = std::string("rank-" + std::to_string(simgrid::s4u::this_actor::get_pid()));                \
-    type->addEntityValue(Colls::mpi_coll_##cat##_description[i].name, "1.0 1.0 1.0");                                  \
-    new simgrid::instr::NewEvent(SIMIX_get_clock(), simgrid::instr::Container::byName(cont_name), type,                \
-                                 type->getEntityValue(Colls::mpi_coll_##cat##_description[i].name));                   \
+    type->add_entity_value(Colls::mpi_coll_##cat##_description[i].name, "1.0 1.0 1.0");                                \
+    new simgrid::instr::NewEvent(SIMIX_get_clock(), simgrid::instr::Container::by_name(cont_name), type,               \
+                                 type->get_entity_value(Colls::mpi_coll_##cat##_description[i].name));                 \
   }
 
 #define AUTOMATIC_COLL_BENCH(cat, ret, args, args2)                                                                    \

diff --git a/src/smpi/internals/instr_smpi.cpp b/src/smpi/internals/instr_smpi.cpp
index b267dbb..f2cd092 100644 (file)
--- a/src/smpi/internals/instr_smpi.cpp
+++ b/src/smpi/internals/instr_smpi.cpp
@@ -155,7 +155,7 @@ XBT_PRIVATE std::string smpi_container_key(int rank)
 
 XBT_PRIVATE container_t smpi_container(int rank)
 {
-  return simgrid::instr::Container::byName(smpi_container_key(rank));
+  return simgrid::instr::Container::by_name(smpi_container_key(rank));
 }
 
 static std::string TRACE_smpi_put_key(int src, int dst, int tag, int send)
@@ -235,12 +235,12 @@ void TRACE_smpi_setup_container(int rank, sg_host_t host)
 
   container_t father;
   if (TRACE_smpi_is_grouped()){
-    father = simgrid::instr::Container::byNameOrNull(host->get_name());
+    father = simgrid::instr::Container::by_name_or_null(host->get_name());
   }else{
-    father = simgrid::instr::Container::getRoot();
+    father = simgrid::instr::Container::get_root();
   }
   xbt_assert(father != nullptr, "Could not find a parent for mpi rank %s at function %s", str.c_str(), __func__);
-  father->createChild(str, "MPI"); // This container is of type MPI
+  father->create_child(str, "MPI"); // This container is of type MPI
 }
 
 void TRACE_smpi_init(int rank)
@@ -250,7 +250,7 @@ void TRACE_smpi_init(int rank)
 
   TRACE_smpi_setup_container(rank, sg_host_self());
 #if HAVE_PAPI
-  container_t container   = simgrid::instr::Container::byName(str);
+  container_t container   = simgrid::instr::Container::by_name(str);
   papi_counter_t counters = smpi_process()->papi_counters();
 
   for (auto const& it : counters) {
@@ -270,42 +270,42 @@ void TRACE_smpi_finalize(int rank)
   if (not TRACE_smpi_is_enabled())
     return;
 
-  smpi_container(rank)->removeFromParent();
+  smpi_container(rank)->remove_from_parent();
 }
 
 void TRACE_smpi_computing_init(int rank)
 {
  //first use, initialize the color in the trace
  if (TRACE_smpi_is_enabled() && TRACE_smpi_is_computing())
-   smpi_container(rank)->getState("MPI_STATE")->addEntityValue("computing", instr_find_color("computing"));
+   smpi_container(rank)->get_state("MPI_STATE")->add_entity_value("computing", instr_find_color("computing"));
 }
 
 void TRACE_smpi_computing_in(int rank, double amount)
 {
   if (TRACE_smpi_is_enabled() && TRACE_smpi_is_computing())
     smpi_container(rank)
-        ->getState("MPI_STATE")
-        ->pushEvent("computing", new simgrid::instr::CpuTIData("compute", amount));
+        ->get_state("MPI_STATE")
+        ->push_event("computing", new simgrid::instr::CpuTIData("compute", amount));
 }
 
 void TRACE_smpi_computing_out(int rank)
 {
   if (TRACE_smpi_is_enabled() && TRACE_smpi_is_computing())
-    smpi_container(rank)->getState("MPI_STATE")->popEvent();
+    smpi_container(rank)->get_state("MPI_STATE")->pop_event();
 }
 
 void TRACE_smpi_sleeping_in(int rank, double duration)
 {
   if (TRACE_smpi_is_enabled() && TRACE_smpi_is_sleeping())
     smpi_container(rank)
-        ->getState("MPI_STATE")
-        ->pushEvent("sleeping", new simgrid::instr::CpuTIData("sleep", duration));
+        ->get_state("MPI_STATE")
+        ->push_event("sleeping", new simgrid::instr::CpuTIData("sleep", duration));
 }
 
 void TRACE_smpi_sleeping_out(int rank)
 {
   if (TRACE_smpi_is_enabled() && not TRACE_smpi_is_sleeping())
-    smpi_container(rank)->getState("MPI_STATE")->popEvent();
+    smpi_container(rank)->get_state("MPI_STATE")->pop_event();
 }
 
 void TRACE_smpi_testing_in(int rank)
@@ -314,15 +314,15 @@ void TRACE_smpi_testing_in(int rank)
   if (not TRACE_smpi_is_enabled())
     return;
 
-  simgrid::instr::StateType* state = smpi_container(rank)->getState("MPI_STATE");
-  state->addEntityValue("test");
-  state->pushEvent("test", new simgrid::instr::NoOpTIData("test"));
+  simgrid::instr::StateType* state = smpi_container(rank)->get_state("MPI_STATE");
+  state->add_entity_value("test");
+  state->push_event("test", new simgrid::instr::NoOpTIData("test"));
 }
 
 void TRACE_smpi_testing_out(int rank)
 {
   if (TRACE_smpi_is_enabled())
-    smpi_container(rank)->getState("MPI_STATE")->popEvent();
+    smpi_container(rank)->get_state("MPI_STATE")->pop_event();
 }
 
 void TRACE_smpi_comm_in(int rank, const char* operation, simgrid::instr::TIData* extra)
@@ -332,15 +332,15 @@ void TRACE_smpi_comm_in(int rank, const char* operation, simgrid::instr::TIData*
     return;
   }
 
-  simgrid::instr::StateType* state = smpi_container(rank)->getState("MPI_STATE");
-  state->addEntityValue(operation, instr_find_color(operation));
-  state->pushEvent(operation, extra);
+  simgrid::instr::StateType* state = smpi_container(rank)->get_state("MPI_STATE");
+  state->add_entity_value(operation, instr_find_color(operation));
+  state->push_event(operation, extra);
 }
 
 void TRACE_smpi_comm_out(int rank)
 {
   if (TRACE_smpi_is_enabled())
-    smpi_container(rank)->getState("MPI_STATE")->popEvent();
+    smpi_container(rank)->get_state("MPI_STATE")->pop_event();
 }
 
 void TRACE_smpi_send(int rank, int src, int dst, int tag, int size)
@@ -351,7 +351,7 @@ void TRACE_smpi_send(int rank, int src, int dst, int tag, int size)
   std::string key = TRACE_smpi_get_key(src, dst, tag, 1);
 
   XBT_DEBUG("Send tracing from %d to %d, tag %d, with key %s", src, dst, tag, key.c_str());
-  simgrid::instr::Container::getRoot()->getLink("MPI_LINK")->startEvent(smpi_container(rank), "PTP", key, size);
+  simgrid::instr::Container::get_root()->get_link("MPI_LINK")->start_event(smpi_container(rank), "PTP", key, size);
 }
 
 void TRACE_smpi_recv(int src, int dst, int tag)
@@ -362,7 +362,7 @@ void TRACE_smpi_recv(int src, int dst, int tag)
   std::string key = TRACE_smpi_get_key(src, dst, tag, 0);
 
   XBT_DEBUG("Recv tracing from %d to %d, tag %d, with key %s", src, dst, tag, key.c_str());
-  simgrid::instr::Container::getRoot()->getLink("MPI_LINK")->endEvent(smpi_container(dst), "PTP", key);
+  simgrid::instr::Container::get_root()->get_link("MPI_LINK")->end_event(smpi_container(dst), "PTP", key);
 }
 
 /**************** Functions to trace the migration of tasks. *****************/
@@ -370,8 +370,8 @@ void TRACE_smpi_send_process_data_in(int rank)
 {
   if (!TRACE_smpi_is_enabled()) return;
 
-  smpi_container(rank)->getState("MIGRATE_STATE")->addEntityValue("migration", instr_find_color("migration"));
-  smpi_container(rank)->getState("MIGRATE_STATE")->pushEvent("migration");
+  smpi_container(rank)->get_state("MIGRATE_STATE")->add_entity_value("migration", instr_find_color("migration"));
+  smpi_container(rank)->get_state("MIGRATE_STATE")->push_event("migration");
 }
 
 void TRACE_smpi_send_process_data_out(int rank)
@@ -379,7 +379,7 @@ void TRACE_smpi_send_process_data_out(int rank)
   if (!TRACE_smpi_is_enabled()) return; 
 
   /* Clean the process state. */
-  smpi_container(rank)->getState("MIGRATE_STATE")->popEvent();
+  smpi_container(rank)->get_state("MIGRATE_STATE")->pop_event();
 }
 
 void TRACE_smpi_process_change_host(int rank, sg_host_t new_host)
@@ -393,15 +393,15 @@ void TRACE_smpi_process_change_host(int rank, sg_host_t new_host)
 
   // start link (= tell the trace that this rank moves from A to B)
   container_t cont = smpi_container(rank);
-  simgrid::instr::Container::getRoot()->getLink("MIGRATE_LINK")->startEvent(cont, "M", key);
+  simgrid::instr::Container::get_root()->get_link("MIGRATE_LINK")->start_event(cont, "M", key);
 
   // Destroy container of this rank on this host
-  cont->removeFromParent();
+  cont->remove_from_parent();
 
   // Setup container on new host
   TRACE_smpi_setup_container(rank, new_host);
 
   // end link
   cont = smpi_container(rank); // This points to the newly created container
-  simgrid::instr::Container::getRoot()->getLink("MIGRATE_LINK")->endEvent(cont, "M", key);
+  simgrid::instr::Container::get_root()->get_link("MIGRATE_LINK")->end_event(cont, "M", key);
 }

diff --git a/src/surf/cpu_interface.cpp b/src/surf/cpu_interface.cpp
index bd2a534..ebe52e9 100644 (file)
--- a/src/surf/cpu_interface.cpp
+++ b/src/surf/cpu_interface.cpp
@@ -134,9 +134,9 @@ double Cpu::get_available_speed()
 
 void Cpu::onSpeedChange() {
   if (TRACE_categorized() || TRACE_uncategorized() || TRACE_platform())
-    instr::Container::byName(get_cname())
-        ->getVariable("power")
-        ->setEvent(surf_get_clock(), coresAmount_ * speed_.scale * speed_.peak);
+    instr::Container::by_name(get_cname())
+        ->get_variable("power")
+        ->set_event(surf_get_clock(), coresAmount_ * speed_.scale * speed_.peak);
   s4u::Host::onSpeedChange(*host_);
 }
 

diff --git a/src/surf/network_interface.cpp b/src/surf/network_interface.cpp
index 2e3bc1e..2ccae96 100644 (file)
--- a/src/surf/network_interface.cpp
+++ b/src/surf/network_interface.cpp
@@ -188,9 +188,9 @@ void LinkImpl::turn_off()
 void LinkImpl::on_bandwidth_change()
 {
   if (TRACE_categorized() || TRACE_uncategorized() || TRACE_platform())
-    instr::Container::byName(get_cname())
-        ->getVariable("bandwidth")
-        ->setEvent(surf_get_clock(), sg_bandwidth_factor * bandwidth_.scale * bandwidth_.peak);
+    instr::Container::by_name(get_cname())
+        ->get_variable("bandwidth")
+        ->set_event(surf_get_clock(), sg_bandwidth_factor * bandwidth_.scale * bandwidth_.peak);
   s4u::Link::on_bandwidth_change(this->piface_);
 }