From: Frederic Suter Date: Fri, 11 May 2018 13:25:12 +0000 (+0200) Subject: snake_case in instr X-Git-Tag: v3.20~252 X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/commitdiff_plain/f36bb244f8e4874b90572ecb44ed6e2f3fa9592b snake_case in instr --- diff --git a/src/instr/instr_config.cpp b/src/instr/instr_config.cpp index 20f4014f42..b271e71aff 100644 --- 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 75b55ab10c..4b9c0f129e 100644 --- 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(mark_type); + simgrid::instr::Container::get_root()->type_->by_name_or_create(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::Container::getRoot()->type_->by_name(mark_type)); + static_cast(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::Container::getRoot()->type_->by_name(mark_type)); + static_cast(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 f5428d8a31..52994b4a5b 100644 --- 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(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(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(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(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(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 0106898bf0..0498243a56 100644 --- a/src/instr/instr_paje_containers.hpp +++ b/src/instr/instr_paje_containers.hpp @@ -28,20 +28,20 @@ public: std::map 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 92e53e1484..45fafcae81 100644 --- 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 bf82373dc2..eb4041ef48 100644 --- 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 f37c0e1ee7..04445d25e8 100644 --- a/src/instr/instr_paje_trace.cpp +++ b/src/instr/instr_paje_trace.cpp @@ -85,7 +85,7 @@ static void buffer_debug(std::vector* 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 6a1556d576..141c330aba 100644 --- 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(it->second); diff --git a/src/instr/instr_paje_types.hpp b/src/instr/instr_paje_types.hpp index 4ac25a5f84..7784cfa881 100644 --- 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(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 23a502c393..53626d54ea 100644 --- 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 329dedde58..bb7827e939 100644 --- 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::settype_->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::setstartEvent(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(netzone)->get_graph(graph, nodes, edges); for (auto elm : *edges) { xbt_edge_t edge = elm.second; - linkContainers(simgrid::instr::Container::byName(static_cast(edge->src->data)), - simgrid::instr::Container::byName(static_cast(edge->dst->data)), filter); + linkContainers(simgrid::instr::Container::by_name(static_cast(edge->src->data)), + simgrid::instr::Container::by_name(static_cast(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* filter = new std::set; 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("ACTOR"); simgrid::instr::StateType* state = actor_type->by_name_or_create("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("VM"); simgrid::instr::StateType* state = vm->by_name_or_create("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(root)->addEntityValue(val, color); + static_cast(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* nodes = new std::map; std::map* edges = new std::map; 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 120de2d352..699541dea9 100644 --- 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 e2d7cb1bfa..a0aa2123eb 100644 --- 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 9291f931ec..e4551189b7 100644 --- 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 5415b72404..0769959348 100644 --- 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 3a82a9add1..581d75c100 100644 --- 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 0c1f7928a2..a6cfe1f7ab 100644 --- 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 c01b6d3a24..8c90b96415 100644 --- 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(#cat); \ + simgrid::instr::Container::get_root()->type_->by_name_or_create(#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 b267dbb91f..f2cd092522 100644 --- 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 bd2a534913..ebe52e9cb8 100644 --- 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 2e3bc1ec0f..2ccae96bc1 100644 --- 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_); }