/* 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 "src/portable.h"
#include "surf_private.h"
#include "surf_interface.hpp"
#include "network_interface.hpp"
#include "cpu_interface.hpp"
-#include "host_interface.hpp"
+#include "src/surf/HostImpl.hpp"
#include "src/simix/smx_host_private.h"
#include "surf_routing.hpp"
#include "simgrid/sg_config.h"
#include "mc/mc.h"
#include "virtual_machine.hpp"
+#include "src/instr/instr_private.h" // TRACE_is_enabled(). FIXME: remove by subscribing tracing to the surf signals
XBT_LOG_NEW_CATEGORY(surf, "All SURF categories");
-XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_kernel, surf,
- "Logging specific to SURF (kernel)");
+XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_kernel, surf, "Logging specific to SURF (kernel)");
/*********
* Utils *
*********/
/* model_list_invoke contains only surf_host and surf_vm.
- * The callback functions of cpu_model and network_model will be called from
- * those of these host models. */
+ * The callback functions of cpu_model and network_model will be called from those of these host models. */
xbt_dynar_t all_existing_models = NULL; /* to destroy models correctly */
-xbt_dynar_t model_list_invoke = NULL; /* for invoking callbacks */
+xbt_dynar_t model_list_invoke = NULL; /* to invoke callbacks */
-tmgr_history_t history = NULL;
-lmm_system_t maxmin_system = NULL;
+simgrid::trace_mgr::future_evt_set *future_evt_set = nullptr;
xbt_dynar_t surf_path = NULL;
-xbt_dynar_t host_that_restart = NULL;
+xbt_dynar_t host_that_restart = xbt_dynar_new(sizeof(char*), NULL);
xbt_dict_t watched_hosts_lib;
namespace simgrid {
namespace surf {
-surf_callback(void, void) surfExitCallbacks;
+simgrid::xbt::signal<void(void)> surfExitCallbacks;
}
}
+#include <simgrid/plugins/energy.h> // FIXME: this plugin should not be linked to the core
+
s_surf_model_description_t surf_plugin_description[] = {
{"Energy", "Cpu energy consumption.", sg_energy_plugin_init},
{NULL, NULL, NULL} /* this array must be NULL terminated */
};
-/* Don't forget to update the option description in smx_config when you change
- this */
+/* Don't forget to update the option description in smx_config when you change this */
s_surf_model_description_t surf_network_model_description[] = {
- {"LV08",
- "Realistic network analytic model (slow-start modeled by multiplying latency by 10.4, bandwidth by .92; bottleneck sharing uses a payload of S=8775 for evaluating RTT). ",
+ {"LV08", "Realistic network analytic model (slow-start modeled by multiplying latency by 10.4, bandwidth by .92; bottleneck sharing uses a payload of S=8775 for evaluating RTT). ",
surf_network_model_init_LegrandVelho},
{"Constant",
"Simplistic network model where all communication take a constant time (one second). This model provides the lowest realism, but is (marginally) faster.",
surf_network_model_init_Constant},
- {"SMPI",
- "Realistic network model specifically tailored for HPC settings (accurate modeling of slow start with correction factors on three intervals: < 1KiB, < 64 KiB, >= 64 KiB)",
+ {"SMPI", "Realistic network model specifically tailored for HPC settings (accurate modeling of slow start with correction factors on three intervals: < 1KiB, < 64 KiB, >= 64 KiB)",
surf_network_model_init_SMPI},
- {"IB",
- "Realistic network model specifically tailored for HPC settings, with Infiniband contention model",
+ {"IB", "Realistic network model specifically tailored for HPC settings, with Infiniband contention model",
surf_network_model_init_IB},
- {"CM02",
- "Legacy network analytic model (Very similar to LV08, but without corrective factors. The timings of small messages are thus poorly modeled).",
+ {"CM02", "Legacy network analytic model (Very similar to LV08, but without corrective factors. The timings of small messages are thus poorly modeled).",
surf_network_model_init_CM02},
#ifdef HAVE_NS3
- {"NS3",
- "Network pseudo-model using the NS3 tcp model instead of an analytic model",
- surf_network_model_init_NS3},
+ {"NS3", "Network pseudo-model using the NS3 tcp model instead of an analytic model", surf_network_model_init_NS3},
#endif
- {"Reno",
- "Model from Steven H. Low using lagrange_solve instead of lmm_solve (experts only; check the code for more info).",
+ {"Reno", "Model from Steven H. Low using lagrange_solve instead of lmm_solve (experts only; check the code for more info).",
surf_network_model_init_Reno},
- {"Reno2",
- "Model from Steven H. Low using lagrange_solve instead of lmm_solve (experts only; check the code for more info).",
+ {"Reno2", "Model from Steven H. Low using lagrange_solve instead of lmm_solve (experts only; check the code for more info).",
surf_network_model_init_Reno2},
- {"Vegas",
- "Model from Steven H. Low using lagrange_solve instead of lmm_solve (experts only; check the code for more info).",
+ {"Vegas", "Model from Steven H. Low using lagrange_solve instead of lmm_solve (experts only; check the code for more info).",
surf_network_model_init_Vegas},
{NULL, NULL, NULL} /* this array must be NULL terminated */
};
s_surf_model_description_t surf_cpu_model_description[] = {
- {"Cas01",
- "Simplistic CPU model (time=size/power).",
- surf_cpu_model_init_Cas01},
+ {"Cas01", "Simplistic CPU model (time=size/power).", surf_cpu_model_init_Cas01},
{NULL, NULL, NULL} /* this array must be NULL terminated */
};
s_surf_model_description_t surf_host_model_description[] = {
- {"default",
- "Default host model. Currently, CPU:Cas01 and network:LV08 (with cross traffic enabled)",
- surf_host_model_init_current_default},
- {"compound",
- "Host model that is automatically chosen if you change the network and CPU models",
- surf_host_model_init_compound},
- {"ptask_L07", "Host model somehow similar to Cas01+CM02 but allowing parallel tasks",
- surf_host_model_init_ptask_L07},
+ {"default", "Default host model. Currently, CPU:Cas01 and network:LV08 (with cross traffic enabled)", surf_host_model_init_current_default},
+ {"compound", "Host model that is automatically chosen if you change the network and CPU models", surf_host_model_init_compound},
+ {"ptask_L07", "Host model somehow similar to Cas01+CM02 but allowing parallel tasks", surf_host_model_init_ptask_L07},
{NULL, NULL, NULL} /* this array must be NULL terminated */
};
s_surf_model_description_t surf_vm_model_description[] = {
- {"default",
- "Default vm model.",
- surf_vm_model_init_HL13},
+ {"default", "Default vm model.", surf_vm_model_init_HL13},
{NULL, NULL, NULL} /* this array must be NULL terminated */
};
s_surf_model_description_t surf_optimization_mode_description[] = {
- {"Lazy",
- "Lazy action management (partial invalidation in lmm + heap in action remaining).",
- NULL},
- {"TI",
- "Trace integration. Highly optimized mode when using availability traces (only available for the Cas01 CPU model for now).",
- NULL},
- {"Full",
- "Full update of remaining and variables. Slow but may be useful when debugging.",
- NULL},
+ {"Lazy", "Lazy action management (partial invalidation in lmm + heap in action remaining).", NULL},
+ {"TI", "Trace integration. Highly optimized mode when using availability traces (only available for the Cas01 CPU model for now).", NULL},
+ {"Full", "Full update of remaining and variables. Slow but may be useful when debugging.", NULL},
{NULL, NULL, NULL} /* this array must be NULL terminated */
};
s_surf_model_description_t surf_storage_model_description[] = {
- {"default",
- "Simplistic storage model.",
- surf_storage_model_init_default},
+ {"default", "Simplistic storage model.", surf_storage_model_init_default},
{NULL, NULL, NULL} /* this array must be NULL terminated */
};
-#ifdef CONTEXT_THREADS
+#ifdef HAVE_THREAD_CONTEXTS
static xbt_parmap_t surf_parmap = NULL; /* parallel map on models */
#endif
return NOW;
}
-#ifdef _XBT_WIN32
+#ifdef _WIN32
# define FILE_DELIM "\\"
#else
# define FILE_DELIM "/" /* FIXME: move to better location */
return NULL;
}
-#ifdef _XBT_WIN32
+#ifdef _WIN32
#include <windows.h>
#define MAX_DRIVE 26
static const char *disk_drives_letter_table[MAX_DRIVE] = {
const char *__surf_get_initial_path(void)
{
-#ifdef _XBT_WIN32
+#ifdef _WIN32
unsigned i;
char current_directory[MAX_PATH + 1] = { 0 };
unsigned int len = GetCurrentDirectory(MAX_PATH + 1, current_directory);
*/
int __surf_is_absolute_file_path(const char *file_path)
{
-#ifdef _XBT_WIN32
+#ifdef _WIN32
WIN32_FIND_DATA wfd = { 0 };
HANDLE hFile = FindFirstFile(file_path, &wfd);
/** Displays the long description of all registered models, and quit */
void model_help(const char *category, s_surf_model_description_t * table)
{
- int i;
- printf("Long description of the %s models accepted by this simulator:\n",
- category);
- for (i = 0; table[i].name; i++)
+ printf("Long description of the %s models accepted by this simulator:\n", category);
+ for (int i = 0; table[i].name; i++)
printf(" %s: %s\n", table[i].name, table[i].description);
}
return -1;
}
-static XBT_INLINE void routing_asr_prop_free(void *p)
-{
- //xbt_dict_t elm = (xbt_dict_t) p;
- //xbt_dict_free(&elm); FIXME: leaking in some case? That's a sometimes double-free with AsCluster::~AsCluster
-}
-
-static XBT_INLINE void surf_storage_free(void *r)
+static inline void surf_storage_free(void *r)
{
delete static_cast<simgrid::surf::Storage*>(r);
}
void sg_version_check(int lib_version_major,int lib_version_minor,int lib_version_patch) {
if ((lib_version_major != SIMGRID_VERSION_MAJOR) || (lib_version_minor != SIMGRID_VERSION_MINOR)) {
fprintf(stderr,
- "FATAL ERROR: Your program was compiled with SimGrid version %d.%d.%d, "
- "and then linked against SimGrid %d.%d.%d. Please fix this.\n",
+ "FATAL ERROR: Your program was compiled with SimGrid version %d.%d.%d, "
+ "and then linked against SimGrid %d.%d.%d. Please fix this.\n",
SIMGRID_VERSION_MAJOR,SIMGRID_VERSION_MINOR,SIMGRID_VERSION_PATCH,
- lib_version_major,lib_version_minor,lib_version_patch);
+ lib_version_major,lib_version_minor,lib_version_patch);
abort();
}
if (lib_version_patch != SIMGRID_VERSION_PATCH) {
fprintf(stderr,
- "Warning: Your program was compiled with SimGrid version %d.%d.%d, "
- "and then linked against SimGrid %d.%d.%d. Proceeding anyway.\n",
+ "Warning: Your program was compiled with SimGrid version %d.%d.%d, "
+ "and then linked against SimGrid %d.%d.%d. Proceeding anyway.\n",
SIMGRID_VERSION_MAJOR,SIMGRID_VERSION_MINOR,SIMGRID_VERSION_PATCH,
- lib_version_major,lib_version_minor,lib_version_patch);
+ lib_version_major,lib_version_minor,lib_version_patch);
}
}
void surf_init(int *argc, char **argv)
{
+ if (host_list != nullptr) // Already initialized
+ return;
+
XBT_DEBUG("Create all Libs");
host_list = xbt_dict_new_homogeneous([](void*p) {
- delete (simgrid::Host*)p;
+ simgrid::s4u::Host* host = static_cast<simgrid::s4u::Host*>(p);
+ simgrid::s4u::Host::onDestruction(*host);
+ delete host;
});
+ USER_HOST_LEVEL = simgrid::s4u::Host::extension_create(NULL);
+
as_router_lib = xbt_lib_new();
storage_lib = xbt_lib_new();
storage_type_lib = xbt_lib_new();
file_lib = xbt_lib_new();
watched_hosts_lib = xbt_dict_new_homogeneous(NULL);
- sg_host_init();
XBT_DEBUG("Add routing levels");
- ROUTING_PROP_ASR_LEVEL = xbt_lib_add_level(as_router_lib,routing_asr_prop_free);
+ ROUTING_PROP_ASR_LEVEL = xbt_lib_add_level(as_router_lib, NULL);
XBT_DEBUG("Add SURF levels");
- simgrid::surf::Host::init();
+ simgrid::surf::HostImpl::classInit();
SURF_STORAGE_LEVEL = xbt_lib_add_level(storage_lib,surf_storage_free);
xbt_init(argc, argv);
all_existing_models = xbt_dynar_new(sizeof(simgrid::surf::Model*), NULL);
if (!model_list_invoke)
model_list_invoke = xbt_dynar_new(sizeof(simgrid::surf::Model*), NULL);
- if (!history)
- history = tmgr_history_new();
+ if (!future_evt_set)
+ future_evt_set = new simgrid::trace_mgr::future_evt_set();
TRACE_add_start_function(TRACE_surf_alloc);
TRACE_add_end_function(TRACE_surf_release);
xbt_dynar_free(&model_list_invoke);
routing_exit();
- surf_callback_emit(simgrid::surf::surfExitCallbacks);
+ simgrid::surf::surfExitCallbacks();
- if (maxmin_system) {
- lmm_system_free(maxmin_system);
- maxmin_system = NULL;
- }
- if (history) {
- tmgr_history_free(history);
- history = NULL;
+ if (future_evt_set) {
+ delete future_evt_set;
+ future_evt_set = nullptr;
}
-#ifdef CONTEXT_THREADS
+#ifdef HAVE_THREAD_CONTEXTS
xbt_parmap_destroy(surf_parmap);
#endif
tmgr_finalize();
- surf_parse_lex_destroy();
- surf_parse_free_callbacks();
+ sg_platf_exit();
NOW = 0; /* Just in case the user plans to restart the simulation afterward */
}
delete p_doneActionSet;
}
-double Model::shareResources(double now)
+double Model::next_occuring_event(double now)
{
//FIXME: set the good function once and for all
if (p_updateMechanism == UM_LAZY)
- return shareResourcesLazy(now);
+ return next_occuring_event_lazy(now);
else if (p_updateMechanism == UM_FULL)
- return shareResourcesFull(now);
+ return next_occuring_event_full(now);
else
xbt_die("Invalid cpu update mechanism!");
}
-double Model::shareResourcesLazy(double now)
+double Model::next_occuring_event_lazy(double now)
{
Action *action = NULL;
double min = -1;
return min;
}
-double Model::shareResourcesFull(double /*now*/) {
+double Model::next_occuring_event_full(double /*now*/) {
THROW_UNIMPLEMENTED;
}
for (++it; it != itend; ++it) {
- action = &*it;
+ action = &*it;
value = lmm_variable_getvalue(action->getVariable());
if (value > 0) {
if (action->getRemains() > 0)
void Model::updateActionsState(double now, double delta)
{
if (p_updateMechanism == UM_FULL)
- updateActionsStateFull(now, delta);
+ updateActionsStateFull(now, delta);
else if (p_updateMechanism == UM_LAZY)
- updateActionsStateLazy(now, delta);
+ updateActionsStateLazy(now, delta);
else
- xbt_die("Invalid cpu update mechanism!");
+ xbt_die("Invalid cpu update mechanism!");
}
void Model::updateActionsStateLazy(double /*now*/, double /*delta*/)
namespace simgrid {
namespace surf {
-Resource::Resource()
-: p_name(NULL), p_properties(NULL), p_model(NULL)
-{}
-
-Resource::Resource(Model *model, const char *name, xbt_dict_t props)
- : Resource(model, name, props, SURF_RESOURCE_ON)
+Resource::Resource(Model *model, const char *name)
+ : Resource(model, name, 1/*ON*/)
{}
-Resource::Resource(Model *model, const char *name, xbt_dict_t props, lmm_constraint_t constraint)
- : Resource(model, name, props, constraint, SURF_RESOURCE_ON)
+Resource::Resource(Model *model, const char *name, lmm_constraint_t constraint)
+ : Resource(model, name, constraint, 1/*ON*/)
{}
-Resource::Resource(
- Model *model, const char *name, xbt_dict_t props,
- lmm_constraint_t constraint, e_surf_resource_state_t stateInit)
- : p_name(xbt_strdup(name)), p_properties(props), p_model(model)
- , m_running(true), m_stateCurrent(stateInit), p_constraint(constraint)
+Resource::Resource(Model *model, const char *name, lmm_constraint_t constraint, int initiallyOn)
+ : p_name(xbt_strdup(name))
+ , p_model(model)
+ , m_isOn(initiallyOn)
+ , p_constraint(constraint)
{}
-Resource::Resource(Model *model, const char *name, xbt_dict_t props, e_surf_resource_state_t stateInit)
- : p_name(xbt_strdup(name)), p_properties(props), p_model(model)
- , m_running(true), m_stateCurrent(stateInit)
+Resource::Resource(Model *model, const char *name, int initiallyOn)
+ : p_name(xbt_strdup(name))
+ , p_model(model)
+ , m_isOn(initiallyOn)
{}
+
Resource::~Resource() {
xbt_free((void*)p_name);
- xbt_dict_free(&p_properties);
}
-e_surf_resource_state_t Resource::getState()
-{
- return m_stateCurrent;
+bool Resource::isOn() {
+ return m_isOn;
}
-
-void Resource::setState(e_surf_resource_state_t state)
-{
- m_stateCurrent = state;
-}
-
-bool Resource::isOn()
-{
- return m_running;
+bool Resource::isOff() {
+ return ! m_isOn;
}
void Resource::turnOn()
{
- if (!m_running) {
- m_running = true;
+ if (!m_isOn) {
+ m_isOn = true;
}
}
void Resource::turnOff()
{
- if (m_running) {
- m_running = false;
+ if (m_isOn) {
+ m_isOn = false;
}
}
return p_name;
}
-xbt_dict_t Resource::getProperties() {
- if (p_properties==NULL)
- p_properties = xbt_dict_new();
- return p_properties;
-}
-
lmm_constraint_t Resource::getConstraint() {
return p_constraint;
}
void Action::initialize(simgrid::surf::Model *model, double cost, bool failed,
lmm_variable_t var)
{
- m_priority = 1.0;
- m_refcount = 1;
m_remains = cost;
- m_maxDuration = NO_MAX_DURATION;
- m_finish = -1.0;
m_start = surf_get_clock();
m_cost = cost;
p_model = model;
- p_data = NULL;
p_variable = var;
- m_lastValue = 0;
- m_lastUpdate = 0;
- m_suspended = false;
- m_hat = NOTSET;
- p_category = NULL;
- p_stateHookup.prev = 0;
- p_stateHookup.next = 0;
if (failed)
p_stateSet = getModel()->getFailedActionSet();
else
lmm_update_variable_weight(getModel()->getMaxminSystem(), getVariable(), priority);
if (getModel()->getUpdateMechanism() == UM_LAZY)
- heapRemove(getModel()->getActionHeap());
+ heapRemove(getModel()->getActionHeap());
XBT_OUT();
}