/** Callback fired when the platform is created (ie, the xml file parsed),
* right before the actual simulation starts. */
-extern XBT_PUBLIC xbt::signal<void()> onPlatformCreated;
+extern XBT_PUBLIC xbt::signal<void()> on_platform_created;
+
+/** Callback fired when the platform is about to be created (ie, just before the xml file is parsed) */
+extern XBT_PUBLIC xbt::signal<void()> on_platform_creation;
/** Callback fired when the main simulation loop ends, just before the end of Engine::run() */
extern XBT_PUBLIC xbt::signal<void()> onSimulationEnd;
InputStream in = NativeLib.class.getClassLoader().getResourceAsStream(path+filename);
OutputStream out = new FileOutputStream(fileOut);
) {
- if (in == null)
- continue; // Try the next name: no such file found
-
- /* copy the library in position */
- byte[] buffer = new byte[4096];
- int bytesRead;
- while ((bytesRead = in.read(buffer)) != -1) // Read until EOF
- out.write(buffer, 0, bytesRead);
-
- done = true;
+ if (in != null) {
+ /* copy the library in position */
+ byte[] buffer = new byte[4096];
+ int bytesRead;
+ while ((bytesRead = in.read(buffer)) != -1) // Read until EOF
+ out.write(buffer, 0, bytesRead);
+ done = true;
+ }
}
if (done) {
- /* load that shit */
+ /* load that library */
System.load(fileOut.getAbsolutePath());
-
+
/* It loaded! we're good */
return true;
}
int console_open(lua_State *L) {
sg_platf_init();
- sg_platf_begin();
+ simgrid::s4u::on_platform_creation();
return 0;
}
int console_close(lua_State *L) {
- sg_platf_end();
+ simgrid::s4u::on_platform_created();
sg_platf_exit();
return 0;
}
+++ /dev/null
-/* Copyright (c) 2012-2018. The SimGrid Team. All rights reserved. */
-
-/* This program is free software; you can redistribute it and/or modify it
- * under the terms of the license (GNU LGPL) which comes with this package. */
-
-#ifndef SIMGRID_INSTR_INTERFACE_HPP
-#define SIMGRID_INSTR_INTERFACE_HPP
-
-#include "xbt.h"
-
-XBT_PUBLIC int TRACE_start();
-XBT_PUBLIC int TRACE_end();
-XBT_PUBLIC void TRACE_global_init();
-XBT_PUBLIC void TRACE_help(int detailed);
-
-#endif
#include "src/internal_config.h" // HAVE_FUTEX_H
#include "src/kernel/context/Context.hpp"
+#include "xbt/xbt_os_thread.h"
#include <boost/optional.hpp>
simgrid::instr::TraceFormat simgrid::instr::trace_format = simgrid::instr::TraceFormat::Paje;
-int TRACE_start()
+void TRACE_start()
{
+ if (trace_active)
+ return;
+
// tracing system must be:
// - enabled (with --cfg=tracing:yes)
// - already configured (TRACE_global_init already called)
if (TRACE_is_enabled()) {
- instr_routing_define_callbacks();
+ instr_define_callbacks();
XBT_DEBUG("Tracing starts");
/* init the tracing module to generate the right output */
/* open the trace file(s) */
std::string format = simgrid::config::get_value<std::string>(OPT_TRACING_FORMAT);
- XBT_DEBUG("Tracing format %s\n", format.c_str());
+ XBT_DEBUG("Tracing format %s", format.c_str());
if (format == "Paje") {
TRACE_paje_start();
} else if (format == "TI") {
xbt_die("Unknown trace format :%s ", format.c_str());
}
- /* activate trace */
- if (trace_active) {
- THROWF(tracing_error, 0, "Tracing is already active");
- }
trace_active = true;
XBT_DEBUG("Tracing is on");
}
- return 0;
}
-int TRACE_end()
+void TRACE_end()
{
- int retval;
- if (not trace_active) {
- retval = 1;
- } else {
- retval = 0;
-
- /* dump trace buffer */
- TRACE_last_timestamp_to_dump = surf_get_clock();
- TRACE_paje_dump_buffer(true);
-
- simgrid::instr::Type* root_type = simgrid::instr::Container::getRoot()->type_;
- /* destroy all data structures of tracing (and free) */
- delete simgrid::instr::Container::getRoot();
- delete root_type;
-
- /* close the trace files */
- std::string format = simgrid::config::get_value<std::string>(OPT_TRACING_FORMAT);
- XBT_DEBUG("Tracing format %s\n", format.c_str());
- if (format == "Paje") {
- TRACE_paje_end();
- } else if (format == "TI") {
- TRACE_TI_end();
- }else{
- xbt_die("Unknown trace format :%s ", format.c_str());
- }
+ if (not trace_active)
+ return;
- /* de-activate trace */
- trace_active = false;
- XBT_DEBUG("Tracing is off");
- XBT_DEBUG("Tracing system is shutdown");
+ /* dump trace buffer */
+ TRACE_last_timestamp_to_dump = surf_get_clock();
+ TRACE_paje_dump_buffer(true);
+
+ simgrid::instr::Type* root_type = simgrid::instr::Container::getRoot()->type_;
+ /* destroy all data structures of tracing (and free) */
+ delete simgrid::instr::Container::getRoot();
+ delete root_type;
+
+ /* close the trace files */
+ std::string format = simgrid::config::get_value<std::string>(OPT_TRACING_FORMAT);
+ XBT_DEBUG("Tracing format %s\n", format.c_str());
+ if (format == "Paje") {
+ TRACE_paje_end();
+ } else if (format == "TI") {
+ TRACE_TI_end();
+ } else {
+ xbt_die("Unknown trace format :%s ", format.c_str());
}
- return retval;
+
+ /* de-activate trace */
+ trace_active = false;
+ XBT_DEBUG("Tracing is off");
+ XBT_DEBUG("Tracing system is shutdown");
}
bool TRACE_needs_platform ()
events_.push_back(new StateEvent(issuer_, this, PAJE_PopState, nullptr, nullptr));
}
+void StateType::popEvent(TIData* extra)
+{
+ events_.push_back(new StateEvent(issuer_, this, PAJE_PopState, nullptr, 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());
void pushEvent(std::string value_name);
void pushEvent(std::string value_name, TIData* extra);
void popEvent();
+ void popEvent(TIData* extra);
};
}
}
#include "surf/surf.hpp"
#include "xbt/graph.h"
-XBT_LOG_NEW_DEFAULT_SUBCATEGORY (instr_routing, instr, "Tracing platform hierarchy");
+XBT_LOG_NEW_DEFAULT_SUBCATEGORY(instr_routing, instr, "Tracing platform hierarchy");
static std::vector<simgrid::instr::NetZoneContainer*> currentContainer; /* push and pop, used only in creation */
-static const char *instr_node_name (xbt_node_t node)
+static const char* instr_node_name(xbt_node_t node)
{
- void *data = xbt_graph_node_get_data(node);
- return static_cast<char*>(data);
+ return static_cast<char*>(xbt_graph_node_get_data(node));
}
-static container_t lowestCommonAncestor (container_t a1, container_t a2)
+static container_t lowestCommonAncestor(container_t a1, container_t a2)
{
- //this is only an optimization (since most of a1 and a2 share the same parent)
+ // this is only an optimization (since most of a1 and a2 share the same parent)
if (a1->father_ == a2->father_)
return a1->father_;
- //create an array with all ancestors of a1
+ // create an array with all ancestors of a1
std::vector<container_t> ancestors_a1;
container_t p = a1->father_;
- while (p){
+ while (p) {
ancestors_a1.push_back(p);
p = p->father_;
}
- //create an array with all ancestors of a2
+ // create an array with all ancestors of a2
std::vector<container_t> ancestors_a2;
p = a2->father_;
- while (p){
+ while (p) {
ancestors_a2.push_back(p);
p = p->father_;
}
- //find the lowest ancestor
- p = nullptr;
+ // find the lowest ancestor
+ p = nullptr;
int i = ancestors_a1.size() - 1;
int j = ancestors_a2.size() - 1;
- while (i >= 0 && j >= 0){
+ while (i >= 0 && j >= 0) {
container_t a1p = ancestors_a1.at(i);
container_t a2p = ancestors_a2.at(j);
- if (a1p == a2p){
+ if (a1p == a2p) {
p = a1p;
- }else{
+ } else {
break;
}
i--;
static void linkContainers(container_t src, container_t dst, std::set<std::string>* filter)
{
- //ignore loopback
+ // ignore loopback
if (src->get_name() == "__loopback__" || dst->get_name() == "__loopback__") {
- XBT_DEBUG (" linkContainers: ignoring loopback link");
+ XBT_DEBUG(" linkContainers: ignoring loopback link");
return;
}
- //find common father
- container_t father = lowestCommonAncestor (src, dst);
+ // find common father
+ container_t father = lowestCommonAncestor(src, dst);
if (not father) {
- xbt_die ("common father unknown, this is a tracing problem");
+ xbt_die("common father unknown, this is a tracing problem");
}
// check if we already register this pair (we only need one direction)
filter->insert(aux1);
filter->insert(aux2);
- //declare type
+ // declare type
std::string link_typename = father->type_->get_name() + "-" + src->type_->get_name() +
std::to_string(src->type_->get_id()) + "-" + dst->type_->get_name() +
std::to_string(dst->type_->get_id());
simgrid::instr::LinkType* link = father->type_->getOrCreateLinkType(link_typename, src->type_, dst->type_);
link->setCallingContainer(father);
- //register EDGE types for triva configuration
+ // register EDGE types for triva configuration
trivaEdgeTypes.insert(link->get_name());
- //create the link
+ // create the link
static long long counter = 0;
std::string key = std::to_string(counter);
}
XBT_DEBUG("Graph extraction for NetZone = %s", netzone->get_cname());
if (not netzone->getChildren()->empty()) {
- //bottom-up recursion
+ // bottom-up recursion
for (auto const& nz_son : *netzone->getChildren()) {
container_t child_container = container->children_.at(nz_son->get_cname());
recursiveGraphExtraction(nz_son, child_container, filter);
}
}
- xbt_graph_t graph = xbt_graph_new_graph (0, nullptr);
+ xbt_graph_t graph = xbt_graph_new_graph(0, nullptr);
std::map<std::string, xbt_node_t>* nodes = new std::map<std::string, xbt_node_t>;
std::map<std::string, xbt_edge_t>* edges = new std::map<std::string, xbt_edge_t>;
static void instr_netzone_on_creation(simgrid::s4u::NetZone& netzone)
{
std::string id = netzone.get_name();
-
if (simgrid::instr::Container::getRoot() == nullptr) {
simgrid::instr::NetZoneContainer* root = new simgrid::instr::NetZoneContainer(id, 0, nullptr);
mpi->getOrCreateStateType("MIGRATE_STATE");
}
- if (TRACE_needs_platform()){
+ if (TRACE_needs_platform()) {
currentContainer.push_back(root);
}
return;
}
- if (TRACE_needs_platform()){
+ if (TRACE_needs_platform()) {
simgrid::instr::NetZoneContainer* container =
new simgrid::instr::NetZoneContainer(id, currentContainer.size(), currentContainer.back());
currentContainer.push_back(container);
static void instr_netzone_on_seal(simgrid::s4u::NetZone& /*netzone*/)
{
- if (TRACE_needs_platform()){
+ if (TRACE_needs_platform()) {
currentContainer.pop_back();
}
}
static void instr_netpoint_on_creation(simgrid::kernel::routing::NetPoint* netpoint)
{
- if (netpoint->is_router() && TRACE_is_enabled() && TRACE_needs_platform())
+ if (netpoint->is_router() && TRACE_needs_platform() && TRACE_is_enabled())
new simgrid::instr::RouterContainer(netpoint->get_cname(), currentContainer.back());
}
{
currentContainer.clear();
std::set<std::string>* filter = new std::set<std::string>;
- XBT_DEBUG ("Starting graph extraction.");
+ XBT_DEBUG("Starting graph extraction.");
recursiveGraphExtraction(simgrid::s4u::Engine::get_instance()->getNetRoot(), simgrid::instr::Container::getRoot(),
filter);
- XBT_DEBUG ("Graph extraction finished.");
+ XBT_DEBUG("Graph extraction finished.");
delete filter;
TRACE_paje_dump_buffer(true);
}
-void instr_routing_define_callbacks()
+void instr_define_callbacks()
{
// always need the callbacks to zones (we need only the root zone), to create the rootContainer and the rootType
// properly
if (TRACE_needs_platform()) {
+ simgrid::s4u::on_platform_created.connect(instr_on_platform_created);
simgrid::s4u::Host::onCreation.connect(instr_host_on_creation);
simgrid::s4u::Link::onCreation.connect(instr_link_on_creation);
- simgrid::s4u::onPlatformCreated.connect(instr_on_platform_created);
}
simgrid::s4u::NetZone::onCreation.connect(instr_netzone_on_creation);
simgrid::s4u::NetZone::onSeal.connect(instr_netzone_on_seal);
container_t container)
{
if (not netzone->getChildren()->empty()) {
- //bottom-up recursion
+ // bottom-up recursion
for (auto const& netzone_child : *netzone->getChildren()) {
container_t child_container = container->children_.at(netzone_child->get_cname());
recursiveXBTGraphExtraction(graph, nodes, edges, netzone_child, child_container);
static_cast<simgrid::kernel::routing::NetZoneImpl*>(netzone)->get_graph(graph, nodes, edges);
}
-xbt_graph_t instr_routing_platform_graph ()
+xbt_graph_t instr_routing_platform_graph()
{
- xbt_graph_t ret = xbt_graph_new_graph (0, nullptr);
+ xbt_graph_t ret = xbt_graph_new_graph(0, nullptr);
std::map<std::string, xbt_node_t>* nodes = new std::map<std::string, xbt_node_t>;
std::map<std::string, xbt_edge_t>* edges = new std::map<std::string, xbt_edge_t>;
recursiveXBTGraphExtraction(ret, nodes, edges, simgrid::s4u::Engine::get_instance()->getNetRoot(),
return ret;
}
-void instr_routing_platform_graph_export_graphviz (xbt_graph_t g, const char *filename)
+void instr_routing_platform_graph_export_graphviz(xbt_graph_t g, const char* filename)
{
unsigned int cursor = 0;
- xbt_node_t node = nullptr;
- xbt_edge_t edge = nullptr;
+ xbt_node_t node = nullptr;
+ xbt_edge_t edge = nullptr;
- FILE *file = fopen(filename, "w");
+ FILE* file = fopen(filename, "w");
xbt_assert(file, "Failed to open %s \n", filename);
if (g->directed)
fprintf(file, " node [shape=box, style=filled]\n");
fprintf(file, " node [width=.3, height=.3, style=filled, color=skyblue]\n\n");
- xbt_dynar_foreach(g->nodes, cursor, node) {
+ xbt_dynar_foreach (g->nodes, cursor, node) {
fprintf(file, " \"%s\";\n", instr_node_name(node));
}
- xbt_dynar_foreach(g->edges, cursor, edge) {
- const char *src_s = instr_node_name (edge->src);
- const char *dst_s = instr_node_name (edge->dst);
+ xbt_dynar_foreach (g->edges, cursor, edge) {
+ const char* src_s = instr_node_name(edge->src);
+ const char* dst_s = instr_node_name(edge->dst);
if (g->directed)
fprintf(file, " \"%s\" -> \"%s\";\n", src_s, dst_s);
else
#include <xbt/base.h>
-#include "instr/instr_interface.hpp"
#include "simgrid/instr.h"
#include "simgrid_config.h"
#include "src/instr/instr_paje_containers.hpp"
extern XBT_PRIVATE std::set<std::string> trivaNodeTypes;
extern XBT_PRIVATE std::set<std::string> trivaEdgeTypes;
XBT_PRIVATE long long int instr_new_paje_id();
-XBT_PRIVATE void instr_routing_define_callbacks();
+XBT_PRIVATE void instr_define_callbacks();
void instr_new_variable_type(std::string new_typename, std::string color);
void instr_new_user_variable_type(std::string father_type, std::string new_typename, std::string color);
void instr_new_user_state_type(std::string father_type, std::string new_typename);
void instr_new_value_for_user_state_type(std::string new_typename, const char* value, std::string color);
/* instr_config.c */
+XBT_PRIVATE void TRACE_start();
XBT_PRIVATE void TRACE_TI_start();
XBT_PRIVATE void TRACE_TI_end();
+XBT_PRIVATE void TRACE_end();
+XBT_PRIVATE void TRACE_global_init();
+XBT_PRIVATE void TRACE_help(int detailed);
XBT_PRIVATE void TRACE_paje_dump_buffer(bool force);
XBT_PRIVATE void dump_comment_file(std::string filename);
#ifndef SIMGRID_KERNEL_CONTEXT_CONTEXT_HPP
#define SIMGRID_KERNEL_CONTEXT_CONTEXT_HPP
-#include "instr/instr_interface.hpp"
#include "src/internal_config.h"
#include "src/simix/smx_network_private.hpp"
#include "simgrid/s4u/Engine.hpp"
#include "simgrid/s4u/Host.hpp"
-#include "instr/instr_interface.hpp"
#include "mc/mc.h"
+#include "src/instr/instr_private.hpp"
#include "src/msg/msg_private.hpp"
#include <xbt/config.hpp>
/* This program is free software; you can redistribute it and/or modify it
* under the terms of the license (GNU LGPL) which comes with this package. */
-#include "instr/instr_interface.hpp"
#include "mc/mc.h"
#include "simgrid/kernel/routing/NetPoint.hpp"
#include "simgrid/kernel/routing/NetZoneImpl.hpp"
#include "simgrid/s4u/NetZone.hpp"
#include "simgrid/s4u/Storage.hpp"
#include "simgrid/simix.h"
+#include "src/instr/instr_private.hpp"
#include "src/kernel/EngineImpl.hpp"
#include "src/surf/network_interface.hpp"
#include "surf/surf.hpp" // routing_platf. FIXME:KILLME. SOON
namespace simgrid {
namespace s4u {
-xbt::signal<void()> onPlatformCreated;
+xbt::signal<void()> on_platform_creation;
+xbt::signal<void()> on_platform_created;
xbt::signal<void()> onSimulationEnd;
xbt::signal<void(double)> onTimeAdvance;
xbt::signal<void(void)> onDeadlock;
#include "simgrid/kernel/resource/Action.hpp"
#include "simgrid/s4u/Engine.hpp"
#include "simgrid/sg_config.hpp"
-#include "src/include/instr/instr_interface.hpp"
+#include "src/instr/instr_private.hpp"
#include "src/surf/surf_interface.hpp"
XBT_LOG_NEW_CATEGORY(sd, "Logging specific to SimDag");
/* sg_config: configuration infrastructure for the simulation world */
#include "simgrid/sg_config.hpp"
-#include "instr/instr_interface.hpp"
#include "simgrid/instr.h"
+#include "src/instr/instr_private.hpp"
#include "src/internal_config.h"
#include "src/kernel/lmm/maxmin.hpp"
#include "src/mc/mc_config.hpp"
#endif
/* register a function to be called by SURF after the environment creation */
sg_platf_init();
- simgrid::s4u::onPlatformCreated.connect(SIMIX_post_create_environment);
+ simgrid::s4u::on_platform_created.connect(SIMIX_post_create_environment);
simgrid::s4u::Host::onCreation.connect([](simgrid::s4u::Host& host) {
if (host.extension<simgrid::simix::Host>() == nullptr) // another callback to the same signal may have created it
host.extension_set<simgrid::simix::Host>(new simgrid::simix::Host());
#include "simgrid/s4u/Actor.hpp"
#include "src/kernel/context/Context.hpp"
+#include <xbt/xbt_os_thread.h>
#include <unordered_map>
#include <vector>
});
simgrid::surf::on_cluster.connect(&clusterCreation_cb);
- simgrid::s4u::onPlatformCreated.connect(&postparse_cb);
+ simgrid::s4u::on_platform_created.connect(&postparse_cb);
simgrid::s4u::NetZone::onRouteCreation.connect(&routeCreation_cb);
}
#include "simgrid/kernel/routing/VivaldiZone.hpp"
#include "simgrid/s4u/Engine.hpp"
#include "src/include/simgrid/sg_config.hpp"
+#include "src/instr/instr_private.hpp"
#include "src/kernel/EngineImpl.hpp"
#include "src/simix/smx_host_private.hpp"
#include "src/simix/smx_private.hpp"
/** Module management function: creates all internal data structures */
void sg_platf_init()
{
- simgrid::s4u::onPlatformCreated.connect(check_disk_attachment);
+ simgrid::s4u::on_platform_creation.connect(TRACE_start);
+ simgrid::s4u::on_platform_created.connect(check_disk_attachment);
}
/** Module management function: frees all internal data structures */
void sg_platf_exit() {
simgrid::surf::on_cluster.disconnectSlots();
- simgrid::s4u::onPlatformCreated.disconnectSlots();
+ simgrid::s4u::on_platform_created.disconnectSlots();
/* make sure that we will reinit the models while loading the platf once reinited */
surf_parse_models_setup_already_called = 0;
host->pimpl_cpu->set_speed_trace(peer->speed_trace);
}
-void sg_platf_begin() { /* Do nothing: just for symmetry of user code */ }
-
-void sg_platf_end() {
- simgrid::s4u::onPlatformCreated();
-}
-
/* Pick the right models for CPU, net and host, and call their model_init_preparse */
static void surf_config_models_setup()
{
/* set the new current component of the tree */
current_routing = new_zone;
-
simgrid::s4u::NetZone::onCreation(*new_zone); // notify the signal
return new_zone;
* under the terms of the license (GNU LGPL) which comes with this package. */
#include "surf_interface.hpp"
-#include "instr/instr_interface.hpp" // TRACE_is_enabled(). FIXME: remove by subscribing tracing to the surf signals
#include "mc/mc.h"
#include "simgrid/s4u/Engine.hpp"
#include "simgrid/sg_config.hpp"
+#include "src/instr/instr_private.hpp" // TRACE_end(). FIXME: remove by subscribing tracing to the surf signals
#include "src/internal_config.h"
#include "src/surf/HostImpl.hpp"
#include "src/surf/xml/platf.hpp"
XBT_PRIVATE int __surf_is_absolute_file_path(const char* file_path);
XBT_PRIVATE void check_disk_attachment();
-XBT_PRIVATE void parse_after_config();
#endif
void routing_cluster_add_backbone(simgrid::kernel::resource::LinkImpl* bb);
/*** END of the parsing cruft ***/
-XBT_PUBLIC void sg_platf_begin(); // Start a new platform
-XBT_PUBLIC void sg_platf_end(); // Finish the creation of the platform
-
XBT_PUBLIC simgrid::s4u::NetZone* sg_platf_new_Zone_begin(simgrid::kernel::routing::ZoneCreationArgs* zone); // Begin description of new Zone
XBT_PUBLIC void sg_platf_new_Zone_seal(); // That Zone is fully described
* under the terms of the license (GNU LGPL) which comes with this package. */
#include "surf/surf.hpp"
-#include "instr/instr_interface.hpp" // TRACE_start(). FIXME: remove by subscribing tracing to the surf signals
#include "src/surf/cpu_interface.hpp"
#include "src/surf/network_interface.hpp"
#include "src/surf/surf_interface.hpp"
}
}
-static int after_config_done;
-void parse_after_config() {
- if (not after_config_done) {
- TRACE_start();
-
- after_config_done = 1;
- }
-}
-
/* This function acts as a main in the parsing area. */
void parse_platform_file(const char *file)
{
int parse_status;
/* init the flex parser */
- after_config_done = 0;
surf_parse_open(file);
/* Do the actual parsing */
#include "simgrid/kernel/routing/NetPoint.hpp"
#include "simgrid/s4u/Engine.hpp"
#include "simgrid/sg_config.hpp"
+#include "src/instr/instr_private.hpp"
#include "src/surf/network_interface.hpp"
#include "src/surf/surf_interface.hpp"
#include "src/surf/xml/platf_private.hpp"
"Please update your code, or use another, more adapted, file.",
surf_parsed_filename, version);
- sg_platf_begin();
+ simgrid::s4u::on_platform_creation();
}
void ETag_surfxml_platform(){
- sg_platf_end();
+ simgrid::s4u::on_platform_created();
}
void STag_surfxml_host(){
void STag_surfxml_cluster(){
ZONE_TAG = 0;
- parse_after_config();
xbt_assert(current_property_set == nullptr, "Someone forgot to reset the property set to nullptr in its closing tag (or XML malformed)");
}
void STag_surfxml_cabinet(){
- parse_after_config();
simgrid::kernel::routing::CabinetCreationArgs cabinet;
cabinet.id = A_surfxml_cabinet_id;
cabinet.prefix = A_surfxml_cabinet_prefix;
}
void STag_surfxml_peer(){
- parse_after_config();
simgrid::kernel::routing::PeerCreationArgs peer;
peer.id = std::string(A_surfxml_peer_id);
void STag_surfxml_trace___connect()
{
- parse_after_config();
simgrid::kernel::routing::TraceConnectCreationArgs trace_connect;
trace_connect.element = A_surfxml_trace___connect_element;
void STag_surfxml_zone()
{
- parse_after_config();
ZONE_TAG = 1;
simgrid::kernel::routing::ZoneCreationArgs zone;
zone.id = A_surfxml_zone_id;
XBT_INFO("The custom configuration '%s' is already defined by user!", elm.first.c_str());
}
XBT_DEBUG("End configuration name = %s",A_surfxml_config_id);
+ if (TRACE_is_enabled())
+ TRACE_start();
delete current_property_set;
current_property_set = nullptr;
void STag_surfxml_random(){/* Nothing to do */}
void ETag_surfxml_random(){/* Nothing to do */}
void ETag_surfxml_trace___connect(){/* Nothing to do */}
-void STag_surfxml_trace(){parse_after_config();}
+void STag_surfxml_trace()
+{ /* Nothing to do */
+}
void ETag_surfxml_router(){/*Nothing to do*/}
void ETag_surfxml_host___link(){/* Nothing to do */}
void ETag_surfxml_cabinet(){/* Nothing to do */}
set(EXTRA_DIST
src/bindings/java/MANIFEST.in
- src/include/instr/instr_interface.hpp
src/include/mc/datatypes.h
src/include/mc/mc.h
src/include/simgrid/sg_config.hpp
src/surf/cpu_cas01.cpp
src/surf/cpu_interface.cpp
src/surf/cpu_ti.cpp
- src/surf/instr_routing.cpp
src/surf/network_cm02.cpp
src/surf/network_constant.cpp
src/surf/network_interface.cpp
src/instr/instr_paje_types.hpp
src/instr/instr_paje_values.cpp
src/instr/instr_paje_values.hpp
+ src/instr/instr_platform.cpp
src/instr/instr_private.hpp
src/instr/instr_smpi.hpp
src/instr/instr_resource_utilization.cpp
