X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/207e186001374b77093f4064a2a25a9c626a989d..ca9a033421bed9944ee0412aa1341e584a0d9010:/src/kernel/context/Context.cpp diff --git a/src/kernel/context/Context.cpp b/src/kernel/context/Context.cpp index 0aead0c913..44f2383bbd 100644 --- a/src/kernel/context/Context.cpp +++ b/src/kernel/context/Context.cpp @@ -1,44 +1,36 @@ -/* Copyright (c) 2007-2018. 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.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); -} namespace simgrid { namespace kernel { namespace context { -static thread_local smx_context_t smx_current_context; ContextFactoryInitializer factory_initializer = nullptr; ContextFactory::~ContextFactory() = default; -Context* ContextFactory::self() +static thread_local smx_context_t smx_current_context = nullptr; +Context* Context::self() { return smx_current_context; } +void Context::set_current(Context* self) +{ + smx_current_context = self; +} void Context::declare_context(std::size_t size) { @@ -49,67 +41,100 @@ void Context::declare_context(std::size_t size) #endif } -Context* ContextFactory::attach(void_pfn_smxprocess_t cleanup_func, smx_actor_t process) +Context* ContextFactory::attach(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 actor) - : code_(std::move(code)), actor_(actor) +Context::Context(std::function code, smx_actor_t actor) : code_(std::move(code)), 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() { - if (this->cleanup_func_) - this->cleanup_func_(this->actor_); - this->actor_->suspended_ = 0; - - this->iwannadie = false; - simgrid::simix::simcall([this] { SIMIX_process_cleanup(this->actor_); }); + actor_->finished_ = true; + + if (actor_->has_to_auto_restart() && not actor_->get_host()->is_on()) { + XBT_DEBUG("Insert host %s to watched_hosts because it's off and %s needs to restart", + actor_->get_host()->get_cname(), actor_->get_cname()); + watched_hosts.insert(actor_->get_host()->get_name()); + } + + // 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_->get_pid()); + + this->actor_->cleanup(); + + 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; + } + + actor_->cleanup(); + }); 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 Sets the current context of this thread. - * @param context the context to set - */ -void SIMIX_context_set_current(smx_context_t context) +/** @brief Executes all the processes to run (in parallel if possible). */ +void SIMIX_context_runall() { - simgrid::kernel::context::smx_current_context = context; + simix_global->context_factory->run_all(); }