X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/b87fc0829538ec066fd077e6c30ee6270b8abd78..c68caf0f27b0fdde9df0a39857e5a162fc196d85:/src/kernel/context/ContextThread.cpp diff --git a/src/kernel/context/ContextThread.cpp b/src/kernel/context/ContextThread.cpp index 4ed2f29012..c93e361daf 100644 --- a/src/kernel/context/ContextThread.cpp +++ b/src/kernel/context/ContextThread.cpp @@ -1,103 +1,66 @@ -/* Copyright (c) 2009-2017. The SimGrid Team. All rights reserved. */ +/* Copyright (c) 2009-2018. 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 "src/kernel/context/ContextThread.hpp" +#include "simgrid/Exception.hpp" +#include "src/internal_config.h" /* loads context system definitions */ +#include "src/simix/smx_private.hpp" +#include "src/xbt_modinter.h" /* prototype of os thread module's init/exit in XBT */ #include "xbt/function_types.h" -#include "src/simix/smx_private.h" -#include "src/internal_config.h" /* loads context system definitions */ -#include "xbt/swag.h" #include "xbt/xbt_os_thread.h" -#include "src/xbt_modinter.h" /* prototype of os thread module's init/exit in XBT */ -#include "src/kernel/context/ContextThread.hpp" +#include +#include XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(simix_context); -static xbt_os_sem_t smx_ctx_thread_sem = nullptr; - namespace simgrid { namespace kernel { namespace context { -XBT_PRIVATE ContextFactory* thread_factory() -{ - XBT_VERB("Activating thread context factory"); - return new ThreadContextFactory(); -} +// ThreadContextFactory ThreadContextFactory::ThreadContextFactory() - : ContextFactory("ThreadContextFactory") + : ContextFactory("ThreadContextFactory"), parallel_(SIMIX_context_is_parallel()) { - if (SIMIX_context_is_parallel()) { - smx_ctx_thread_sem = xbt_os_sem_init(SIMIX_context_get_nthreads()); - } else { - smx_ctx_thread_sem = nullptr; - } + if (parallel_) + ParallelThreadContext::initialize(); } ThreadContextFactory::~ThreadContextFactory() { - if (smx_ctx_thread_sem) { - xbt_os_sem_destroy(smx_ctx_thread_sem); - smx_ctx_thread_sem = nullptr; - } + if (parallel_) + ParallelThreadContext::finalize(); } -ThreadContext* ThreadContextFactory::create_context( - std::function code, - void_pfn_smxprocess_t cleanup, smx_actor_t process) +ThreadContext* ThreadContextFactory::create_context(std::function code, void_pfn_smxprocess_t cleanup, + smx_actor_t process, bool maestro) { - return this->new_context(std::move(code), cleanup, process, not code); + if (parallel_) + return this->new_context(std::move(code), cleanup, process, maestro); + else + return this->new_context(std::move(code), cleanup, process, maestro); } void ThreadContextFactory::run_all() { - if (smx_ctx_thread_sem == nullptr) { - // Serial execution - for (smx_actor_t process : simix_global->process_to_run) { - XBT_DEBUG("Handling %p",process); - ThreadContext* context = static_cast(process->context); - xbt_os_sem_release(context->begin_); - xbt_os_sem_acquire(context->end_); - } - } else { + if (parallel_) { // Parallel execution - for (smx_actor_t process : simix_global->process_to_run) - xbt_os_sem_release(static_cast(process->context)->begin_); - for (smx_actor_t process : simix_global->process_to_run) - xbt_os_sem_acquire(static_cast(process->context)->end_); + ParallelThreadContext::run_all(); + } else { + // Serial execution + SerialThreadContext::run_all(); } } -ThreadContext* ThreadContextFactory::self() -{ - return static_cast(xbt_os_thread_get_extra_data()); -} +// ThreadContext -ThreadContext* ThreadContextFactory::attach(void_pfn_smxprocess_t cleanup_func, smx_actor_t process) +ThreadContext::ThreadContext(std::function code, void_pfn_smxprocess_t cleanup, smx_actor_t actor, bool maestro) + : AttachContext(std::move(code), cleanup, actor), is_maestro_(maestro) { - return this->new_context( - std::function(), cleanup_func, process, false); -} - -ThreadContext* ThreadContextFactory::create_maestro(std::function code, smx_actor_t process) -{ - return this->new_context(std::move(code), nullptr, process, true); -} - -ThreadContext::ThreadContext(std::function code, - void_pfn_smxprocess_t cleanup, smx_actor_t process, bool maestro) - : AttachContext(std::move(code), cleanup, process) -{ - // We do not need the semaphores when maestro is in main, - // but creating them anyway simplifies things when maestro is externalized - this->begin_ = xbt_os_sem_init(0); - this->end_ = xbt_os_sem_init(0); - /* If the user provided a function for the process then use it */ if (has_code()) { if (smx_context_stack_size_was_set) @@ -108,17 +71,14 @@ ThreadContext::ThreadContext(std::function code, /* create and start the process */ /* NOTE: The first argument to xbt_os_thread_create used to be the process * * name, but now the name is stored at SIMIX level, so we pass a null */ - this->thread_ = - xbt_os_thread_create(nullptr, - maestro ? &ThreadContext::maestro_wrapper : &ThreadContext::wrapper, - this, this); + this->thread_ = xbt_os_thread_create(nullptr, ThreadContext::wrapper, this, this); /* wait the starting of the newly created process */ - xbt_os_sem_acquire(this->end_); + this->end_.acquire(); } /* Otherwise, we attach to the current thread */ else { - xbt_os_thread_set_extra_data(this); + SIMIX_context_set_current(this); } } @@ -126,15 +86,12 @@ ThreadContext::~ThreadContext() { if (this->thread_) /* If there is a thread (maestro don't have any), wait for its termination */ xbt_os_thread_join(this->thread_, nullptr); - - /* destroy the synchronization objects */ - xbt_os_sem_destroy(this->begin_); - xbt_os_sem_destroy(this->end_); } void *ThreadContext::wrapper(void *param) { ThreadContext* context = static_cast(param); + SIMIX_context_set_current(context); #ifndef WIN32 /* Install alternate signal stack, for SIGSEGV handler. */ @@ -144,91 +101,136 @@ void *ThreadContext::wrapper(void *param) stack.ss_flags = 0; sigaltstack(&stack, nullptr); #endif - /* Tell the maestro we are starting, and wait for its green light */ - xbt_os_sem_release(context->end_); - - xbt_os_sem_acquire(context->begin_); - if (smx_ctx_thread_sem) /* parallel run */ - xbt_os_sem_acquire(smx_ctx_thread_sem); - - (*context)(); - context->stop(); - - return nullptr; -} + // Tell the caller (normally the maestro) we are starting, and wait for its green light + context->end_.release(); + context->start(); + + try { + (*context)(); + } catch (StopRequest const&) { + XBT_DEBUG("Caught a StopRequest"); + xbt_assert(not context->is_maestro(), "Maestro shall not receive StopRequests, even when detached."); + } catch (simgrid::Exception const& e) { + XBT_INFO("Actor killed by an uncatched exception %s", simgrid::xbt::demangle(typeid(e).name()).get()); + throw; + } + if (not context->is_maestro()) // Just in case somebody detached maestro + context->Context::stop(); -void *ThreadContext::maestro_wrapper(void *param) -{ - ThreadContext* context = static_cast(param); + // Signal to the caller (normally the maestro) that we have finished: + context->yield(); #ifndef WIN32 - /* Install alternate signal stack, for SIGSEGV handler. */ - stack_t stack; - stack.ss_sp = sigsegv_stack; - stack.ss_size = sizeof sigsegv_stack; - stack.ss_flags = 0; + stack.ss_flags = SS_DISABLE; sigaltstack(&stack, nullptr); #endif - /* Tell the caller we are starting */ - xbt_os_sem_release(context->end_); - - // Wait for the caller to give control back to us: - xbt_os_sem_acquire(context->begin_); - (*context)(); + return nullptr; +} - // Tell main that we have finished: - xbt_os_sem_release(context->end_); +void ThreadContext::release() +{ + this->begin_.release(); +} - return nullptr; +void ThreadContext::wait() +{ + this->end_.acquire(); } void ThreadContext::start() { - xbt_os_sem_acquire(this->begin_); - if (smx_ctx_thread_sem) /* parallel run */ - xbt_os_sem_acquire(smx_ctx_thread_sem); + this->begin_.acquire(); + this->start_hook(); +} + +void ThreadContext::yield() +{ + this->yield_hook(); + this->end_.release(); } void ThreadContext::stop() { Context::stop(); - if (smx_ctx_thread_sem) - xbt_os_sem_release(smx_ctx_thread_sem); - - // Signal to the maestro that it has finished: - xbt_os_sem_release(this->end_); - - xbt_os_thread_exit(nullptr); + throw StopRequest(); } void ThreadContext::suspend() { - if (smx_ctx_thread_sem) - xbt_os_sem_release(smx_ctx_thread_sem); - xbt_os_sem_release(this->end_); - xbt_os_sem_acquire(this->begin_); - if (smx_ctx_thread_sem) - xbt_os_sem_acquire(smx_ctx_thread_sem); + this->yield(); + this->start(); } void ThreadContext::attach_start() { // We're breaking the layers here by depending on the upper layer: - ThreadContext* maestro = (ThreadContext*) simix_global->maestro_process->context; - xbt_os_sem_release(maestro->begin_); + ThreadContext* maestro = (ThreadContext*)simix_global->maestro_process->context_; + maestro->begin_.release(); + xbt_assert(not this->is_maestro()); this->start(); } void ThreadContext::attach_stop() { - if (smx_ctx_thread_sem) - xbt_os_sem_release(smx_ctx_thread_sem); - xbt_os_sem_release(this->end_); + xbt_assert(not this->is_maestro()); + this->yield(); + + ThreadContext* maestro = (ThreadContext*)simix_global->maestro_process->context_; + maestro->end_.acquire(); + + SIMIX_context_set_current(nullptr); +} - ThreadContext* maestro = (ThreadContext*) simix_global->maestro_process->context; - xbt_os_sem_acquire(maestro->end_); +// SerialThreadContext - xbt_os_thread_set_extra_data(nullptr); +void SerialThreadContext::run_all() +{ + for (smx_actor_t const& process : simix_global->process_to_run) { + XBT_DEBUG("Handling %p", process); + ThreadContext* context = static_cast(process->context_); + context->release(); + context->wait(); + } } +// ParallelThreadContext + +xbt::OsSemaphore* ParallelThreadContext::thread_sem_ = nullptr; + +void ParallelThreadContext::initialize() +{ + thread_sem_ = new xbt::OsSemaphore(SIMIX_context_get_nthreads()); +} + +void ParallelThreadContext::finalize() +{ + delete thread_sem_; + thread_sem_ = nullptr; +} + +void ParallelThreadContext::run_all() +{ + for (smx_actor_t const& process : simix_global->process_to_run) + static_cast(process->context_)->release(); + for (smx_actor_t const& process : simix_global->process_to_run) + static_cast(process->context_)->wait(); +} + +void ParallelThreadContext::start_hook() +{ + if (not is_maestro()) /* parallel run */ + thread_sem_->acquire(); +} + +void ParallelThreadContext::yield_hook() +{ + if (not is_maestro()) /* parallel run */ + thread_sem_->release(); +} + +XBT_PRIVATE ContextFactory* thread_factory() +{ + XBT_VERB("Activating thread context factory"); + return new ThreadContextFactory(); +} }}} // namespace