double date = 0.0;
simgrid::xbt::Task<void()> callback;
- s_smx_timer() {}
- s_smx_timer(double date, simgrid::xbt::Task<void()> callback)
- : date(date), callback(std::move(callback)) {}
+ s_smx_timer()=default;
+ s_smx_timer(double date, simgrid::xbt::Task<void()> callback) : date(date), callback(std::move(callback)) {}
} s_smx_timer_t;
void (*SMPI_switch_data_segment)(int) = nullptr;
"Try to increase stack size with --cfg=contexts/stack_size (current size is %d KiB).\n",
smx_context_stack_size / 1024);
if (XBT_LOG_ISENABLED(simix_kernel, xbt_log_priority_debug)) {
- fprintf(stderr,
- "siginfo = {si_signo = %d, si_errno = %d, si_code = %d, si_addr = %p}\n",
+ fprintf(stderr, "siginfo = {si_signo = %d, si_errno = %d, si_code = %d, si_addr = %p}\n",
siginfo->si_signo, siginfo->si_errno, siginfo->si_code, siginfo->si_addr);
}
} else if (siginfo->si_signo == SIGSEGV) {
#if HAVE_SMPI
if (smpi_enabled() && !smpi_privatize_global_variables) {
#if HAVE_PRIVATIZATION
- fprintf(stderr,
- "Try to enable SMPI variable privatization with --cfg=smpi/privatize-global-variables:yes.\n");
+ fprintf(stderr, "Try to enable SMPI variable privatization with --cfg=smpi/privatize-global-variables:yes.\n");
#else
- fprintf(stderr,
- "Sadly, your system does not support --cfg=smpi/privatize-global-variables:yes (yet).\n");
+ fprintf(stderr, "Sadly, your system does not support --cfg=smpi/privatize-global-variables:yes (yet).\n");
#endif /* HAVE_PRIVATIZATION */
}
#endif /* HAVE_SMPI */
* Install signal handler for SIGSEGV. Check that nobody has already installed
* its own handler. For example, the Java VM does this.
*/
-static void install_segvhandler(void)
+static void install_segvhandler()
{
stack_t stack, old_stack;
stack.ss_sp = sigsegv_stack;
}
if ((old_action.sa_flags & SA_SIGINFO) || old_action.sa_handler != SIG_DFL) {
XBT_DEBUG("A signal handler was already installed for SIGSEGV (%p). Restore it.",
- (old_action.sa_flags & SA_SIGINFO) ?
- (void*)old_action.sa_sigaction : (void*)old_action.sa_handler);
+ (old_action.sa_flags & SA_SIGINFO) ? (void*)old_action.sa_sigaction : (void*)old_action.sa_handler);
sigaction(SIGSEGV, &old_action, nullptr);
}
}
#endif /* _WIN32 */
/********************************* SIMIX **************************************/
-double SIMIX_timer_next(void)
+double SIMIX_timer_next()
{
return xbt_heap_size(simix_timers) > 0 ? xbt_heap_maxkey(simix_timers) : -1.0;
}
-static void kill_process(smx_process_t process)
+static void kill_process(smx_actor_t process)
{
SIMIX_process_kill(process, nullptr);
}
namespace simgrid {
namespace simix {
+simgrid::xbt::signal<void(void)> onDeadlock;
+
XBT_PUBLIC(void) set_maestro(std::function<void()> code)
{
maestro_code = std::move(code);
simix_global = std::unique_ptr<simgrid::simix::Global>(new simgrid::simix::Global());
simgrid::simix::ActorImpl proc;
- simix_global->process_to_run = xbt_dynar_new(sizeof(smx_process_t), nullptr);
- simix_global->process_that_ran = xbt_dynar_new(sizeof(smx_process_t), nullptr);
+ simix_global->process_to_run = xbt_dynar_new(sizeof(smx_actor_t), nullptr);
+ simix_global->process_that_ran = xbt_dynar_new(sizeof(smx_actor_t), nullptr);
simix_global->process_list = xbt_swag_new(xbt_swag_offset(proc, process_hookup));
simix_global->process_to_destroy = xbt_swag_new(xbt_swag_offset(proc, destroy_hookup));
simix_global->maestro_process = nullptr;
*
* This functions remove the memory used by SIMIX
*/
-void SIMIX_clean(void)
+void SIMIX_clean()
{
- if (smx_cleaned) return; // to avoid double cleaning by java and C
+ if (smx_cleaned)
+ return; // to avoid double cleaning by java and C
#if HAVE_SMPI
if (SIMIX_process_count()>0){
smx_cleaned = 1;
XBT_DEBUG("SIMIX_clean called. Simulation's over.");
- if (!xbt_dynar_is_empty(simix_global->process_to_run) && SIMIX_get_clock() == 0.0) {
+ if (!xbt_dynar_is_empty(simix_global->process_to_run) && SIMIX_get_clock() <= 0.0) {
XBT_CRITICAL(" ");
XBT_CRITICAL("The time is still 0, and you still have processes ready to run.");
XBT_CRITICAL("It seems that you forgot to run the simulation that you setup.");
*
* \return Return the clock.
*/
-double SIMIX_get_clock(void)
+double SIMIX_get_clock()
{
if(MC_is_active() || MC_record_replay_is_active()){
return MC_process_clock_get(SIMIX_process_self());
static int process_syscall_color(void *p)
{
- switch ((*(smx_process_t *)p)->simcall.call) {
+ switch ((*(smx_actor_t *)p)->simcall.call) {
case SIMCALL_NONE:
case SIMCALL_PROCESS_KILL:
return 2;
/** Wake up all processes waiting for a Surf action to finish */
static void SIMIX_wake_processes()
{
- unsigned int iter;
- surf_model_t model;
surf_action_t action;
- xbt_dynar_foreach(all_existing_models, iter, model) {
+ for(auto model : *all_existing_models) {
XBT_DEBUG("Handling the processes whose action failed (if any)");
while ((action = surf_model_extract_failed_action_set(model))) {
XBT_DEBUG(" Handling Action %p",action);
- SIMIX_simcall_exit((smx_synchro_t) action->getData());
+ SIMIX_simcall_exit((smx_activity_t) action->getData());
}
XBT_DEBUG("Handling the processes whose action terminated normally (if any)");
while ((action = surf_model_extract_done_action_set(model))) {
if (action->getData() == nullptr)
XBT_DEBUG("probably vcpu's action %p, skip", action);
else
- SIMIX_simcall_exit((smx_synchro_t) action->getData());
+ SIMIX_simcall_exit((smx_activity_t) action->getData());
}
}
}
* \ingroup SIMIX_API
* \brief Run the main simulation loop.
*/
-void SIMIX_run(void)
+void SIMIX_run()
{
if (MC_record_path) {
simgrid::mc::replay(MC_record_path);
}
double time = 0;
- smx_process_t process;
+ smx_actor_t process;
do {
- XBT_DEBUG("New Schedule Round; size(queue)=%lu",
- xbt_dynar_length(simix_global->process_to_run));
+ XBT_DEBUG("New Schedule Round; size(queue)=%lu", xbt_dynar_length(simix_global->process_to_run));
SIMIX_execute_tasks();
while (!xbt_dynar_is_empty(simix_global->process_to_run)) {
- XBT_DEBUG("New Sub-Schedule Round; size(queue)=%lu",
- xbt_dynar_length(simix_global->process_to_run));
+ XBT_DEBUG("New Sub-Schedule Round; size(queue)=%lu", xbt_dynar_length(simix_global->process_to_run));
/* Run all processes that are ready to run, possibly in parallel */
SIMIX_process_runall();
}
time = SIMIX_timer_next();
- if (time != -1.0 || xbt_swag_size(simix_global->process_list) != 0) {
+ if (time > -1.0 || xbt_swag_size(simix_global->process_list) != 0) {
XBT_DEBUG("Calling surf_solve");
time = surf_solve(time);
XBT_DEBUG("Moving time ahead : %g", time);
} while (again);
/* Autorestart all process */
- char *hostname = nullptr;
- unsigned int iter;
- xbt_dynar_foreach(host_that_restart,iter,hostname) {
- XBT_INFO("Restart processes on host: %s",hostname);
- SIMIX_host_autorestart(sg_host_by_name(hostname));
+ for (auto host: host_that_restart) {
+ XBT_INFO("Restart processes on host: %s", sg_host_get_name(host));
+ SIMIX_host_autorestart(host);
}
- xbt_dynar_reset(host_that_restart);
+ host_that_restart.clear();
/* Clean processes to destroy */
SIMIX_process_empty_trash();
XBT_DEBUG("### time %f, empty %d", time, xbt_dynar_is_empty(simix_global->process_to_run));
- } while (time != -1.0 || !xbt_dynar_is_empty(simix_global->process_to_run));
+ if (xbt_dynar_is_empty(simix_global->process_to_run) &&
+ xbt_swag_size(simix_global->process_list) != 0)
+ simgrid::simix::onDeadlock();
+
+ } while (time > -1.0 || !xbt_dynar_is_empty(simix_global->process_to_run));
if (xbt_swag_size(simix_global->process_list) != 0) {
- TRACE_end();
+ TRACE_end();
XBT_CRITICAL("Oops ! Deadlock or code not perfectly clean.");
SIMIX_display_process_status();
/**
* \brief Registers a function to kill a process.
*
- * This function registers a function to be called when a
- * process is killed. The function has to call the SIMIX_process_kill().
+ * This function registers a function to be called when a process is killed. The function has to call the
+ * SIMIX_process_kill().
*
* \param function Kill process function
*/
-void SIMIX_function_register_process_kill(void_pfn_smxprocess_t
- function)
+void SIMIX_function_register_process_kill(void_pfn_smxprocess_t function)
{
simix_global->kill_process_function = function;
}
/**
* \brief Registers a function to cleanup a process.
*
- * This function registers a user function to be called when
- * a process ends properly.
+ * This function registers a user function to be called when a process ends properly.
*
* \param function cleanup process function
*/
-void SIMIX_function_register_process_cleanup(void_pfn_smxprocess_t
- function)
+void SIMIX_function_register_process_cleanup(void_pfn_smxprocess_t function)
{
simix_global->cleanup_process_function = function;
}
-void SIMIX_display_process_status(void)
+void SIMIX_display_process_status()
{
if (simix_global->process_list == nullptr) {
return;
}
- smx_process_t process = nullptr;
+ smx_actor_t process = nullptr;
int nbprocess = xbt_swag_size(simix_global->process_list);
XBT_INFO("%d processes are still running, waiting for something.", nbprocess);
/* List the process and their state */
- XBT_INFO
- ("Legend of the following listing: \"Process <pid> (<name>@<host>): <status>\"");
+ XBT_INFO("Legend of the following listing: \"Process <pid> (<name>@<host>): <status>\"");
xbt_swag_foreach(process, simix_global->process_list) {
if (process->waiting_synchro) {
}
xbt_dict_t SIMIX_asr_get_properties(const char *name)
{
- return (xbt_dict_t) xbt_lib_get_or_null(as_router_lib, name, ROUTING_PROP_ASR_LEVEL);
+ return static_cast<xbt_dict_t>(xbt_lib_get_or_null(as_router_lib, name, ROUTING_PROP_ASR_LEVEL));
}
int SIMIX_is_maestro()
