/* 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,
* 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 {
-simgrid::surf::signal<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 */
{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 -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)
{
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);
}
}
{
XBT_DEBUG("Create all Libs");
host_list = xbt_dict_new_homogeneous([](void*p) {
- delete static_cast<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::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);
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_model(NULL)
-{THROW_DEADCODE;} // FIXME: DEADCODE?
-
Resource::Resource(Model *model, const char *name)
: Resource(model, name, 1/*ON*/)
{}
lmm_update_variable_weight(getModel()->getMaxminSystem(), getVariable(), priority);
if (getModel()->getUpdateMechanism() == UM_LAZY)
- heapRemove(getModel()->getActionHeap());
+ heapRemove(getModel()->getActionHeap());
XBT_OUT();
}