X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/9c92907fc7a130fd6abc60b98791daa320742ba2..ca9a033421bed9944ee0412aa1341e584a0d9010:/src/kernel/context/Context.cpp diff --git a/src/kernel/context/Context.cpp b/src/kernel/context/Context.cpp index d650e2085a..44f2383bbd 100644 --- a/src/kernel/context/Context.cpp +++ b/src/kernel/context/Context.cpp @@ -1,36 +1,18 @@ -/* Copyright (c) 2007-2010, 2012-2015. 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 - -#include -#include -#include - -#include - #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" - -/** - * @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 - */ -smx_context_t SIMIX_context_new( - std::function code, - void_pfn_smxprocess_t cleanup_func, - smx_process_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); -} +#include "src/simix/smx_private.hpp" +#include "src/surf/surf_interface.hpp" + +XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(simix_context); + namespace simgrid { namespace kernel { @@ -38,66 +20,117 @@ namespace context { ContextFactoryInitializer factory_initializer = nullptr; -ContextFactory::~ContextFactory() {} +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) { - return SIMIX_context_get_current(); + smx_current_context = self; } -void ContextFactory::declare_context(void* context, std::size_t size) +void Context::declare_context(std::size_t size) { -#if HAVE_MC +#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_process_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_process_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_process_t process) - : code_(std::move(code)), process_(process), iwannadie(false) +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() { + if (self() == this) + set_current(nullptr); } void Context::stop() { - if (this->cleanup_func_) - this->cleanup_func_(this->process_); - this->process_->suspended = 0; - - this->iwannadie = false; - simcall_process_cleanup(this->process_); + 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() +AttachContext::~AttachContext() = default; + +StopRequest::~StopRequest() = default; + +void StopRequest::do_throw() { + throw StopRequest(); } +bool StopRequest::try_n_catch(std::function try_block) +{ + 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). */ @@ -105,13 +138,3 @@ void SIMIX_context_runall() { simix_global->context_factory->run_all(); } - -/** @brief returns the current running context */ -smx_context_t SIMIX_context_self() -{ - if (simix_global && simix_global->context_factory) - return simix_global->context_factory->self(); - else - return nullptr; -} -