From f0c8eebff675af6278ff663ff0fc47126c9193cc Mon Sep 17 00:00:00 2001 From: Takishipp Date: Fri, 18 Aug 2017 16:41:12 +0200 Subject: [PATCH] normalize s_type class part 2 --- src/instr/instr_interface.cpp | 2 +- src/instr/instr_paje_containers.cpp | 10 ++-- src/instr/instr_paje_types.cpp | 28 ++++----- src/instr/instr_private.h | 10 ++-- src/smpi/colls/smpi_automatic_selector.cpp | 4 +- src/smpi/internals/instr_smpi.cpp | 2 +- src/surf/instr_routing.cpp | 68 +++++++++++----------- 7 files changed, 62 insertions(+), 62 deletions(-) diff --git a/src/instr/instr_interface.cpp b/src/instr/instr_interface.cpp index 204d359442..b75c053a1a 100644 --- a/src/instr/instr_interface.cpp +++ b/src/instr/instr_interface.cpp @@ -153,7 +153,7 @@ void TRACE_declare_mark(const char *mark_type) } XBT_DEBUG("MARK,declare %s", mark_type); - s_type::eventNew(mark_type, PJ_type_get_root()); + Type::eventNew(mark_type, PJ_type_get_root()); declared_marks.insert(mark_type); } diff --git a/src/instr/instr_paje_containers.cpp b/src/instr/instr_paje_containers.cpp index a76ed9ae64..d92944f118 100644 --- a/src/instr/instr_paje_containers.cpp +++ b/src/instr/instr_paje_containers.cpp @@ -88,12 +88,12 @@ container_t PJ_container_new (const char *name, e_container_types kind, containe char as_typename[INSTR_DEFAULT_STR_SIZE]; snprintf (as_typename, INSTR_DEFAULT_STR_SIZE, "L%d", newContainer->level); if (newContainer->father){ - newContainer->type = s_type::getOrNull (as_typename, newContainer->father->type); + newContainer->type = Type::getOrNull (as_typename, newContainer->father->type); if (newContainer->type == nullptr){ - newContainer->type = s_type::containerNew (as_typename, newContainer->father->type); + newContainer->type = Type::containerNew (as_typename, newContainer->father->type); } }else{ - newContainer->type = s_type::containerNew ("0", nullptr); + newContainer->type = Type::containerNew ("0", nullptr); } }else{ //otherwise, the name is its kind @@ -124,9 +124,9 @@ container_t PJ_container_new (const char *name, e_container_types kind, containe THROWF (tracing_error, 0, "new container kind is unknown."); break; } - type_t type = s_type::getOrNull (typeNameBuff, newContainer->father->type); + type_t type = Type::getOrNull (typeNameBuff, newContainer->father->type); if (type == nullptr){ - newContainer->type = s_type::containerNew (typeNameBuff, newContainer->father->type); + newContainer->type = Type::containerNew (typeNameBuff, newContainer->father->type); }else{ newContainer->type = type; } diff --git a/src/instr/instr_paje_types.cpp b/src/instr/instr_paje_types.cpp index abcc6e55a1..aa29a390f2 100644 --- a/src/instr/instr_paje_types.cpp +++ b/src/instr/instr_paje_types.cpp @@ -20,7 +20,7 @@ type_t PJ_type_get_root () return rootType; } -s_type::s_type (const char *typeNameBuff, const char *key, const char *color, e_entity_types kind, type_t father) +Type::Type (const char *typeNameBuff, const char *key, const char *color, e_entity_types kind, type_t father) { if (typeNameBuff == nullptr || key == nullptr){ THROWF(tracing_error, 0, "can't create a new type with name or key equal nullptr"); @@ -75,14 +75,14 @@ void recursiveDestroyType (type_t type) type_t PJ_type_get (const char *name, type_t father) { - type_t ret = s_type::getOrNull (name, father); + type_t ret = Type::getOrNull (name, father); if (ret == nullptr){ THROWF (tracing_error, 2, "type with name (%s) not found in father type (%s)", name, father->name); } return ret; } -type_t s_type::getOrNull (const char *name, type_t father) +type_t Type::getOrNull (const char *name, type_t father) { if (name == nullptr || father == nullptr){ THROWF (tracing_error, 0, "can't get type with a nullptr name or from a nullptr father"); @@ -104,13 +104,13 @@ type_t s_type::getOrNull (const char *name, type_t father) return ret; } -type_t s_type::containerNew (const char *name, type_t father) +type_t Type::containerNew (const char *name, type_t father) { if (name == nullptr){ THROWF (tracing_error, 0, "can't create a container type with a nullptr name"); } - type_t ret = new s_type (name, name, nullptr, TYPE_CONTAINER, father); + type_t ret = new Type (name, name, nullptr, TYPE_CONTAINER, father); if (father == nullptr) { rootType = ret; } else { @@ -120,19 +120,19 @@ type_t s_type::containerNew (const char *name, type_t father) return ret; } -type_t s_type::eventNew (const char *name, type_t father) +type_t Type::eventNew (const char *name, type_t father) { if (name == nullptr){ THROWF (tracing_error, 0, "can't create an event type with a nullptr name"); } - type_t ret = new s_type (name, name, nullptr, TYPE_EVENT, father); + type_t ret = new Type (name, name, nullptr, TYPE_EVENT, father); XBT_DEBUG("EventType %s(%s), child of %s(%s)", ret->name, ret->id, father->name, father->id); LogDefineEventType(ret); return ret; } -type_t s_type::variableNew (const char *name, const char *color, type_t father) +type_t Type::variableNew (const char *name, const char *color, type_t father) { if (name == nullptr){ THROWF (tracing_error, 0, "can't create a variable type with a nullptr name"); @@ -142,16 +142,16 @@ type_t s_type::variableNew (const char *name, const char *color, type_t father) if (not color) { char white[INSTR_DEFAULT_STR_SIZE] = "1 1 1"; - ret = new s_type (name, name, white, TYPE_VARIABLE, father); + ret = new Type (name, name, white, TYPE_VARIABLE, father); }else{ - ret = new s_type (name, name, color, TYPE_VARIABLE, father); + ret = new Type (name, name, color, TYPE_VARIABLE, father); } XBT_DEBUG("VariableType %s(%s), child of %s(%s)", ret->name, ret->id, father->name, father->id); LogVariableTypeDefinition (ret); return ret; } -type_t s_type::linkNew (const char *name, type_t father, type_t source, type_t dest) +type_t Type::linkNew (const char *name, type_t father, type_t source, type_t dest) { if (name == nullptr){ THROWF (tracing_error, 0, "can't create a link type with a nullptr name"); @@ -161,14 +161,14 @@ type_t s_type::linkNew (const char *name, type_t father, type_t source, type_t d char key[INSTR_DEFAULT_STR_SIZE]; snprintf (key, INSTR_DEFAULT_STR_SIZE, "%s-%s-%s", name, source->id, dest->id); - ret = new s_type (name, key, nullptr, TYPE_LINK, father); + ret = new Type (name, key, nullptr, TYPE_LINK, father); XBT_DEBUG("LinkType %s(%s), child of %s(%s) %s(%s)->%s(%s)", ret->name, ret->id, father->name, father->id, source->name, source->id, dest->name, dest->id); LogLinkTypeDefinition(ret, source, dest); return ret; } -type_t s_type::stateNew (const char *name, type_t father) +type_t Type::stateNew (const char *name, type_t father) { if (name == nullptr){ THROWF (tracing_error, 0, "can't create a state type with a nullptr name"); @@ -176,7 +176,7 @@ type_t s_type::stateNew (const char *name, type_t father) type_t ret = nullptr; - ret = new s_type (name, name, nullptr, TYPE_STATE, father); + ret = new Type (name, name, nullptr, TYPE_STATE, father); XBT_DEBUG("StateType %s(%s), child of %s(%s)", ret->name, ret->id, father->name, father->id); LogStateTypeDefinition(ret); return ret; diff --git a/src/instr/instr_private.h b/src/instr/instr_private.h index b0ea0eda1e..e9ce033c94 100644 --- a/src/instr/instr_private.h +++ b/src/instr/instr_private.h @@ -65,15 +65,15 @@ class ess_type { char *color; }; -class s_type; -typedef s_type *type_t; -class s_type : public ess_type { +class Type; +typedef Type *type_t; +class Type : public ess_type { public: e_entity_types kind; - s_type *father; + Type *father; xbt_dict_t children; xbt_dict_t values; //valid for all types except variable and container - s_type (const char *typeNameBuff, const char *key, const char *color, e_entity_types kind, type_t father); + Type (const char *typeNameBuff, const char *key, const char *color, e_entity_types kind, type_t father); static type_t getOrNull (const char *name, type_t father); static type_t containerNew (const char *name, type_t father); static type_t eventNew (const char *name, type_t father); diff --git a/src/smpi/colls/smpi_automatic_selector.cpp b/src/smpi/colls/smpi_automatic_selector.cpp index b1a272ff65..e4ed65a6b2 100644 --- a/src/smpi/colls/smpi_automatic_selector.cpp +++ b/src/smpi/colls/smpi_automatic_selector.cpp @@ -16,9 +16,9 @@ #define TRACE_AUTO_COLL(cat) \ if (TRACE_is_enabled()) { \ - type_t type = s_type::getOrNull(#cat, PJ_type_get_root()); \ + type_t type = Type::getOrNull(#cat, PJ_type_get_root()); \ if (not type) { \ - type = s_type::eventNew(#cat, PJ_type_get_root()); \ + type = Type::eventNew(#cat, PJ_type_get_root()); \ } \ char cont_name[25]; \ snprintf(cont_name, 25, "rank-%d", smpi_process()->index()); \ diff --git a/src/smpi/internals/instr_smpi.cpp b/src/smpi/internals/instr_smpi.cpp index 5c25d7c652..52133ebca5 100644 --- a/src/smpi/internals/instr_smpi.cpp +++ b/src/smpi/internals/instr_smpi.cpp @@ -209,7 +209,7 @@ void TRACE_smpi_init(int rank) * multiple times but only the last one would be used... */ if (s_type::getOrNull(it.first.c_str(), container->type) == nullptr) { - s_type::variableNew(it.first.c_str(), nullptr, container->type); + Type::variableNew(it.first.c_str(), nullptr, container->type); } } #endif diff --git a/src/surf/instr_routing.cpp b/src/surf/instr_routing.cpp index e8e5b87918..185bb86778 100644 --- a/src/surf/instr_routing.cpp +++ b/src/surf/instr_routing.cpp @@ -105,9 +105,9 @@ static void linkContainers (container_t src, container_t dst, xbt_dict_t filter) father->type->name, src->type->name, src->type->id, dst->type->name, dst->type->id); - type_t link_type = s_type::getOrNull (link_typename, father->type); + type_t link_type = Type::getOrNull (link_typename, father->type); if (link_type == nullptr){ - link_type = s_type::linkNew (link_typename, father->type, src->type, dst->type); + link_type = Type::linkNew (link_typename, father->type, src->type, dst->type); } //register EDGE types for triva configuration @@ -173,12 +173,12 @@ static void sg_instr_AS_begin(simgrid::s4u::NetZone& netzone) PJ_container_set_root (root); if (TRACE_smpi_is_enabled()) { - type_t mpi = s_type::getOrNull ("MPI", root->type); + type_t mpi = Type::getOrNull ("MPI", root->type); if (mpi == nullptr){ - mpi = s_type::containerNew("MPI", root->type); + mpi = Type::containerNew("MPI", root->type); if (not TRACE_smpi_is_grouped()) - s_type::stateNew ("MPI_STATE", mpi); - s_type::linkNew ("MPI_LINK", PJ_type_get_root(), mpi, mpi); + Type::stateNew ("MPI_STATE", mpi); + Type::linkNew ("MPI_LINK", PJ_type_get_root(), mpi, mpi); } } @@ -214,21 +214,21 @@ static void instr_routing_parse_start_link(simgrid::s4u::Link& link) container_t container = PJ_container_new(link.name(), INSTR_LINK, father); if ((TRACE_categorized() || TRACE_uncategorized() || TRACE_platform()) && (not TRACE_disable_link())) { - type_t bandwidth = s_type::getOrNull("bandwidth", container->type); + type_t bandwidth = Type::getOrNull("bandwidth", container->type); if (bandwidth == nullptr) { - bandwidth = s_type::variableNew("bandwidth", nullptr, container->type); + bandwidth = Type::variableNew("bandwidth", nullptr, container->type); } - type_t latency = s_type::getOrNull("latency", container->type); + type_t latency = Type::getOrNull("latency", container->type); if (latency == nullptr) { - latency = s_type::variableNew("latency", nullptr, container->type); + latency = Type::variableNew("latency", nullptr, container->type); } new SetVariableEvent(0, container, bandwidth, bandwidth_value); new SetVariableEvent(0, container, latency, latency_value); } if (TRACE_uncategorized()) { - type_t bandwidth_used = s_type::getOrNull("bandwidth_used", container->type); + type_t bandwidth_used = Type::getOrNull("bandwidth_used", container->type); if (bandwidth_used == nullptr) { - s_type::variableNew("bandwidth_used", "0.5 0.5 0.5", container->type); + Type::variableNew("bandwidth_used", "0.5 0.5 0.5", container->type); } } } @@ -239,56 +239,56 @@ static void sg_instr_new_host(simgrid::s4u::Host& host) container_t container = PJ_container_new(host.getCname(), INSTR_HOST, father); if ((TRACE_categorized() || TRACE_uncategorized() || TRACE_platform()) && (not TRACE_disable_speed())) { - type_t speed = s_type::getOrNull ("power", container->type); + type_t speed = Type::getOrNull ("power", container->type); if (speed == nullptr){ - speed = s_type::variableNew ("power", nullptr, container->type); + speed = Type::variableNew ("power", nullptr, container->type); } double current_speed_state = host.getSpeed(); new SetVariableEvent (0, container, speed, current_speed_state); } if (TRACE_uncategorized()){ - type_t speed_used = s_type::getOrNull ("power_used", container->type); + type_t speed_used = Type::getOrNull ("power_used", container->type); if (speed_used == nullptr){ - s_type::variableNew ("power_used", "0.5 0.5 0.5", container->type); + Type::variableNew ("power_used", "0.5 0.5 0.5", container->type); } } if (TRACE_smpi_is_enabled() && TRACE_smpi_is_grouped()){ - type_t mpi = s_type::getOrNull ("MPI", container->type); + type_t mpi = Type::getOrNull ("MPI", container->type); if (mpi == nullptr){ - mpi = s_type::containerNew("MPI", container->type); - s_type::stateNew ("MPI_STATE", mpi); + mpi = Type::containerNew("MPI", container->type); + Type::stateNew ("MPI_STATE", mpi); } } if (TRACE_msg_process_is_enabled()) { - type_t msg_process = s_type::getOrNull ("MSG_PROCESS", container->type); + type_t msg_process = Type::getOrNull ("MSG_PROCESS", container->type); if (msg_process == nullptr){ - msg_process = s_type::containerNew("MSG_PROCESS", container->type); - type_t state = s_type::stateNew ("MSG_PROCESS_STATE", msg_process); + msg_process = Type::containerNew("MSG_PROCESS", container->type); + type_t state = Type::stateNew ("MSG_PROCESS_STATE", msg_process); value PJ_value("suspend", "1 0 1", state); value::get_or_new("sleep", "1 1 0", state); value::get_or_new("receive", "1 0 0", state); value::get_or_new("send", "0 0 1", state); value::get_or_new("task_execute", "0 1 1", state); - s_type::linkNew ("MSG_PROCESS_LINK", PJ_type_get_root(), msg_process, msg_process); - s_type::linkNew ("MSG_PROCESS_TASK_LINK", PJ_type_get_root(), msg_process, msg_process); + Type::linkNew ("MSG_PROCESS_LINK", PJ_type_get_root(), msg_process, msg_process); + Type::linkNew ("MSG_PROCESS_TASK_LINK", PJ_type_get_root(), msg_process, msg_process); } } if (TRACE_msg_vm_is_enabled()) { - type_t msg_vm = s_type::getOrNull ("MSG_VM", container->type); + type_t msg_vm = Type::getOrNull ("MSG_VM", container->type); if (msg_vm == nullptr){ - msg_vm = s_type::containerNew("MSG_VM", container->type); - type_t state = s_type::stateNew ("MSG_VM_STATE", msg_vm); + msg_vm = Type::containerNew("MSG_VM", container->type); + type_t state = Type::stateNew ("MSG_VM_STATE", msg_vm); value PJ_value("suspend", "1 0 1", state); value::get_or_new("sleep", "1 1 0", state); value::get_or_new("receive", "1 0 0", state); value::get_or_new("send", "0 0 1", state); value::get_or_new("task_execute", "0 1 1", state); - s_type::linkNew ("MSG_VM_LINK", PJ_type_get_root(), msg_vm, msg_vm); - s_type::linkNew ("MSG_VM_PROCESS_LINK", PJ_type_get_root(), msg_vm, msg_vm); + Type::linkNew ("MSG_VM_LINK", PJ_type_get_root(), msg_vm, msg_vm); + Type::linkNew ("MSG_VM_PROCESS_LINK", PJ_type_get_root(), msg_vm, msg_vm); } } @@ -339,17 +339,17 @@ static void recursiveNewVariableType (const char *new_typename, const char *colo if (not strcmp(root->name, "HOST")) { char tnstr[INSTR_DEFAULT_STR_SIZE]; snprintf (tnstr, INSTR_DEFAULT_STR_SIZE, "p%s", new_typename); - s_type::variableNew (tnstr, color, root); + Type::variableNew (tnstr, color, root); } if (not strcmp(root->name, "MSG_VM")) { char tnstr[INSTR_DEFAULT_STR_SIZE]; snprintf (tnstr, INSTR_DEFAULT_STR_SIZE, "p%s", new_typename); - s_type::variableNew (tnstr, color, root); + Type::variableNew (tnstr, color, root); } if (not strcmp(root->name, "LINK")) { char tnstr[INSTR_DEFAULT_STR_SIZE]; snprintf (tnstr, INSTR_DEFAULT_STR_SIZE, "b%s", new_typename); - s_type::variableNew (tnstr, color, root); + Type::variableNew (tnstr, color, root); } xbt_dict_cursor_t cursor = nullptr; type_t child_type; @@ -367,7 +367,7 @@ void instr_new_variable_type (const char *new_typename, const char *color) static void recursiveNewUserVariableType (const char *father_type, const char *new_typename, const char *color, type_t root) { if (not strcmp(root->name, father_type)) { - s_type::variableNew (new_typename, color, root); + Type::variableNew (new_typename, color, root); } xbt_dict_cursor_t cursor = nullptr; type_t child_type; @@ -385,7 +385,7 @@ void instr_new_user_variable_type (const char *father_type, const char *new_typ static void recursiveNewUserStateType (const char *father_type, const char *new_typename, type_t root) { if (not strcmp(root->name, father_type)) { - s_type::stateNew (new_typename, root); + Type::stateNew (new_typename, root); } xbt_dict_cursor_t cursor = nullptr; type_t child_type; -- 2.20.1