X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/c0a4a200c90b3384121aa4b6e30acaed9e3bd0ac..a5da20e6d4fc6ad5b4a96b72d979a48b999838b2:/src/kernel/context/Context.cpp diff --git a/src/kernel/context/Context.cpp b/src/kernel/context/Context.cpp index 97b19857dc..9d66f8c649 100644 --- a/src/kernel/context/Context.cpp +++ b/src/kernel/context/Context.cpp @@ -1,26 +1,29 @@ -/* Copyright (c) 2007-2017. The SimGrid Team. All rights reserved. */ +/* Copyright (c) 2007-2019. 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. */ #include "mc/mc.h" +#include "simgrid/s4u/Host.hpp" +#include "src/kernel/activity/CommImpl.hpp" #include "src/kernel/context/Context.hpp" -#include "src/simix/smx_private.h" -#include "src/mc/mc_ignore.h" +#include "src/simix/smx_private.hpp" +#include "src/surf/surf_interface.hpp" +XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(simix_context); /** * @brief creates a new context for a user level process * @param code a main function * @param cleanup_func the function to call when the context stops + * @param simix_process */ smx_context_t SIMIX_context_new( std::function code, void_pfn_smxprocess_t cleanup_func, smx_actor_t simix_process) { - xbt_assert(simix_global, "simix is not initialized, please call MSG_init first"); return simix_global->context_factory->create_context( std::move(code), cleanup_func, simix_process); } @@ -33,74 +36,121 @@ ContextFactoryInitializer factory_initializer = nullptr; ContextFactory::~ContextFactory() = default; -Context* ContextFactory::self() +static thread_local smx_context_t smx_current_context = nullptr; +Context* Context::self() { - return SIMIX_context_get_current(); + return smx_current_context; +} +void Context::set_current(Context* self) +{ + smx_current_context = self; } -void ContextFactory::declare_context(void* context, std::size_t size) +void Context::declare_context(std::size_t size) { #if SIMGRID_HAVE_MC /* Store the address of the stack in heap to compare it apart of heap comparison */ if(MC_is_active()) - MC_ignore_heap(context, size); + MC_ignore_heap(this, size); #endif } -Context* ContextFactory::attach(void_pfn_smxprocess_t cleanup_func, smx_actor_t process) +Context* ContextFactory::attach(void_pfn_smxprocess_t, smx_actor_t) { xbt_die("Cannot attach with this ContextFactory.\n" "Try using --cfg=contexts/factory:thread instead.\n"); } -Context* ContextFactory::create_maestro(std::function code, smx_actor_t process) +Context* ContextFactory::create_maestro(std::function, smx_actor_t) { xbt_die("Cannot create_maestro with this ContextFactory.\n" "Try using --cfg=contexts/factory:thread instead.\n"); } -Context::Context(std::function code, - void_pfn_smxprocess_t cleanup_func, smx_actor_t process) - : code_(std::move(code)), process_(process), iwannadie(false) +Context::Context(std::function code, void_pfn_smxprocess_t cleanup_func, smx_actor_t actor) + : code_(std::move(code)), cleanup_func_(cleanup_func), actor_(actor) { - /* If the user provided a function for the process then use it. - Otherwise, it is the context for maestro and we should set it as the - current context */ - if (has_code()) - this->cleanup_func_ = cleanup_func; - else - SIMIX_context_set_current(this); + /* If no function was provided, this is the context for maestro + * and we should set it as the current context */ + if (not has_code()) + set_current(this); } -Context::~Context() = default; +Context::~Context() +{ + if (self() == this) + set_current(nullptr); +} void Context::stop() { + actor_->finished_ = true; + + if (actor_->auto_restart_ && actor_->host_->is_off()) { + XBT_DEBUG("Insert host %s to watched_hosts because it's off and %s needs to restart", actor_->host_->get_cname(), + actor_->get_cname()); + watched_hosts.insert(actor_->host_->get_cname()); + } + + // Execute the termination callbacks + smx_process_exit_status_t exit_status = (actor_->context_->iwannadie) ? SMX_EXIT_FAILURE : SMX_EXIT_SUCCESS; + while (not actor_->on_exit.empty()) { + s_smx_process_exit_fun_t exit_fun = actor_->on_exit.back(); + actor_->on_exit.pop_back(); + (exit_fun.fun)(exit_status, exit_fun.arg); + } + + /* cancel non-blocking activities */ + for (auto activity : actor_->comms) + boost::static_pointer_cast(activity)->cancel(); + actor_->comms.clear(); + + XBT_DEBUG("%s@%s(%ld) should not run anymore", actor_->get_cname(), actor_->iface()->get_host()->get_cname(), + actor_->pid_); + if (this->cleanup_func_) - this->cleanup_func_(this->process_); - this->process_->suspended = 0; + this->cleanup_func_(this->actor_); - this->iwannadie = false; - simcall_process_cleanup(this->process_); + this->iwannadie = false; // don't let the simcall's yield() do a Context::stop(), because that's me + simgrid::simix::simcall([this] { + simgrid::s4u::Actor::on_destruction(actor_->iface()); + + /* Unregister from the kill timer if any */ + if (actor_->kill_timer != nullptr) { + SIMIX_timer_remove(actor_->kill_timer); + actor_->kill_timer = nullptr; + } + + SIMIX_process_cleanup(actor_); + }); this->iwannadie = true; } AttachContext::~AttachContext() = default; -}}} +StopRequest::~StopRequest() = default; -/** @brief Executes all the processes to run (in parallel if possible). */ -void SIMIX_context_runall() +void StopRequest::do_throw() { - simix_global->context_factory->run_all(); + throw StopRequest(); } -/** @brief returns the current running context */ -smx_context_t SIMIX_context_self() +bool StopRequest::try_n_catch(std::function try_block) { - if (simix_global && simix_global->context_factory) - return simix_global->context_factory->self(); - else - return nullptr; + bool res; + try { + try_block(); + res = true; + } catch (StopRequest const&) { + XBT_DEBUG("Caught a StopRequest"); + res = false; + } + return res; } +}}} +/** @brief Executes all the processes to run (in parallel if possible). */ +void SIMIX_context_runall() +{ + simix_global->context_factory->run_all(); +}