#include "src/kernel/activity/SynchroRaw.hpp"
#include "src/mc/mc_record.hpp"
#include "src/mc/mc_replay.hpp"
-#include "src/simix/smx_host_private.hpp"
#include "src/simix/smx_private.hpp"
#include "src/surf/StorageImpl.hpp"
#include "src/surf/xml/platf.hpp"
#include "src/mc/remote/Client.hpp"
#endif
-#include <boost/heap/fibonacci_heap.hpp>
XBT_LOG_NEW_CATEGORY(simix, "All SIMIX categories");
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_kernel, simix, "Logging specific to SIMIX (kernel)");
std::unique_ptr<simgrid::simix::Global> simix_global;
-namespace {
-typedef std::pair<double, smx_timer_t> TimerQelt;
-boost::heap::fibonacci_heap<TimerQelt, boost::heap::compare<simgrid::xbt::HeapComparator<TimerQelt>>> simix_timers;
-}
-
-/** @brief Timer datatype */
-class s_smx_timer_t {
- double date = 0.0;
-
-public:
- decltype(simix_timers)::handle_type handle_;
- simgrid::xbt::Task<void()> callback;
- double getDate() { return date; }
- s_smx_timer_t(double date, simgrid::xbt::Task<void()> callback) : date(date), callback(std::move(callback)) {}
-};
-
void (*SMPI_switch_data_segment)(simgrid::s4u::ActorPtr) = nullptr;
bool _sg_do_verbose_exit = true;
std::raise(signum);
}
-char sigsegv_stack[SIGSTKSZ]; /* alternate stack for SIGSEGV handler */
+unsigned char sigsegv_stack[SIGSTKSZ]; /* alternate stack for SIGSEGV handler */
/**
* Install signal handler for SIGSEGV. Check that nobody has already installed
#endif /* _WIN32 */
/********************************* SIMIX **************************************/
-double SIMIX_timer_next()
+namespace simgrid {
+namespace simix {
+
+Timer* Timer::set(double date, simgrid::xbt::Task<void()>&& callback)
{
- return simix_timers.empty() ? -1.0 : simix_timers.top().first;
+ Timer* timer = new Timer(date, std::move(callback));
+ timer->handle_ = simix_timers.emplace(std::make_pair(date, timer));
+ return timer;
}
-namespace simgrid {
-namespace simix {
+/** @brief cancels a timer that was added earlier */
+void Timer::remove()
+{
+ simgrid::simix::simix_timers.erase(handle_);
+ delete this;
+}
void Global::empty_trash()
{
#endif
if (simix_global == nullptr) {
- simix_global = std::unique_ptr<simgrid::simix::Global>(new simgrid::simix::Global());
- simix_global->maestro_process = nullptr;
+ surf_init(argc, argv); /* Initialize SURF structures */
- surf_init(argc, argv); /* Initialize SURF structures */
+ simix_global.reset(new simgrid::simix::Global());
+ simix_global->maestro_process = nullptr;
SIMIX_context_mod_init();
// Either create a new context with maestro or create
sg_platf_init();
simgrid::s4u::on_platform_created.connect(surf_presolve);
- simgrid::s4u::Storage::on_creation.connect([](simgrid::s4u::Storage& storage) {
+ simgrid::s4u::Storage::on_creation.connect([](simgrid::s4u::Storage const& storage) {
sg_storage_t s = simgrid::s4u::Storage::by_name(storage.get_name());
xbt_assert(s != nullptr, "Storage not found for name %s", storage.get_cname());
});
if (simgrid::config::get_value<bool>("clean-atexit"))
atexit(SIMIX_clean);
-
- if (_sg_cfg_exit_asap)
- exit(0);
}
int smx_cleaned = 0;
/* Exit the SIMIX network module */
SIMIX_mailbox_exit();
- while (not simix_timers.empty()) {
- delete simix_timers.top().second;
- simix_timers.pop();
+ while (not simgrid::simix::simix_timers.empty()) {
+ delete simgrid::simix::simix_timers.top().second;
+ simgrid::simix::simix_timers.pop();
}
/* Free the remaining data structures */
simix_global->actors_to_run.clear();
#endif
/* Let's free maestro now */
- delete simix_global->maestro_process->context_;
- simix_global->maestro_process->context_ = nullptr;
delete simix_global->maestro_process;
simix_global->maestro_process = nullptr;
static bool SIMIX_execute_timers()
{
bool result = false;
- while (not simix_timers.empty() && SIMIX_get_clock() >= simix_timers.top().first) {
+ while (not simgrid::simix::simix_timers.empty() && SIMIX_get_clock() >= simgrid::simix::simix_timers.top().first) {
result = true;
// FIXME: make the timers being real callbacks (i.e. provide dispatchers that read and expand the args)
- smx_timer_t timer = simix_timers.top().second;
- simix_timers.pop();
+ smx_timer_t timer = simgrid::simix::simix_timers.top().second;
+ simgrid::simix::simix_timers.pop();
try {
timer->callback();
} catch (...) {
if (simix_global->tasks.empty())
return false;
- using std::swap;
do {
// We don't want the callbacks to modify the vector we are iterating over:
- swap(simix_global->tasks, simix_global->tasksTemp);
+ simix_global->tasks.swap(simix_global->tasksTemp);
// Execute all the queued tasks:
for (auto& task : simix_global->tasksTemp)
}
}
- time = SIMIX_timer_next();
+ time = simgrid::simix::Timer::next();
if (time > -1.0 || not simix_global->process_list.empty()) {
XBT_DEBUG("Calling surf_solve");
time = surf_solve(time);
simgrid::s4u::on_simulation_end();
}
-/**
- * @brief Set the date to execute a function
- *
- * Set the date to execute the function on the surf.
- * @param date Date to execute function
- * @param callback Function to be executed
- * @param arg Parameters of the function
- *
- */
+double SIMIX_timer_next()
+{
+ return simgrid::simix::Timer::next();
+}
+
smx_timer_t SIMIX_timer_set(double date, void (*callback)(void*), void *arg)
{
- smx_timer_t timer = new s_smx_timer_t(date, simgrid::xbt::make_task([callback, arg]() { callback(arg); }));
- timer->handle_ = simix_timers.emplace(std::make_pair(date, timer));
- return timer;
+ return simgrid::simix::Timer::set(date, std::bind(callback, arg));
}
-smx_timer_t SIMIX_timer_set(double date, simgrid::xbt::Task<void()> callback)
+smx_timer_t SIMIX_timer_set(double date, simgrid::xbt::Task<void()>&& callback) // deprecated
{
- smx_timer_t timer = new s_smx_timer_t(date, std::move(callback));
- timer->handle_ = simix_timers.emplace(std::make_pair(date, timer));
- return timer;
+ return simgrid::simix::Timer::set(date, std::move(callback));
}
/** @brief cancels a timer that was added earlier */
void SIMIX_timer_remove(smx_timer_t timer) {
- simix_timers.erase(timer->handle_);
- delete timer;
+ timer->remove();
}
/** @brief Returns the date at which the timer will trigger (or 0 if nullptr timer) */
double SIMIX_timer_get_date(smx_timer_t timer) {
- return timer ? timer->getDate() : 0;
+ return timer ? timer->get_date() : 0;
}
void SIMIX_display_process_status()
if (process->waiting_synchro) {
const char* synchro_description = "unknown";
+ // we don't care about the Activity type to get its name, use RawImpl
+ const char* name =
+ boost::static_pointer_cast<simgrid::kernel::activity::ActivityImpl_T<simgrid::kernel::activity::RawImpl>>(
+ process->waiting_synchro)
+ ->get_cname();
if (boost::dynamic_pointer_cast<simgrid::kernel::activity::ExecImpl>(process->waiting_synchro) != nullptr)
synchro_description = "execution";
if (boost::dynamic_pointer_cast<simgrid::kernel::activity::IoImpl>(process->waiting_synchro) != nullptr)
synchro_description = "I/O";
- XBT_INFO("Process %ld (%s@%s): waiting for %s synchro %p (%s) in state %d to finish", process->pid_,
- process->get_cname(), process->host_->get_cname(), synchro_description, process->waiting_synchro.get(),
- process->waiting_synchro->get_cname(), (int)process->waiting_synchro->state_);
+ XBT_INFO("Process %ld (%s@%s): waiting for %s synchro %p (%s) in state %d to finish", process->get_pid(),
+ process->get_cname(), process->get_host()->get_cname(), synchro_description,
+ process->waiting_synchro.get(), name, (int)process->waiting_synchro->state_);
}
else {
- XBT_INFO("Process %ld (%s@%s)", process->pid_, process->get_cname(), process->host_->get_cname());
+ XBT_INFO("Process %ld (%s@%s)", process->get_pid(), process->get_cname(), process->get_host()->get_cname());
}
}
}
