X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/5b6023822fdeec6470f9da22aa35be032e6b9ae0..465dac153770a28f3a334705a06a1ee7a457c965:/src/kernel/context/ContextThread.cpp diff --git a/src/kernel/context/ContextThread.cpp b/src/kernel/context/ContextThread.cpp index 15a9ef7fc0..64188a62f8 100644 --- a/src/kernel/context/ContextThread.cpp +++ b/src/kernel/context/ContextThread.cpp @@ -1,4 +1,4 @@ -/* Copyright (c) 2009-2018. The SimGrid Team. All rights reserved. */ +/* Copyright (c) 2009-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. */ @@ -10,7 +10,6 @@ #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 "xbt/xbt_os_thread.h" #include #include @@ -37,12 +36,12 @@ ThreadContextFactory::~ThreadContextFactory() } ThreadContext* ThreadContextFactory::create_context(std::function code, void_pfn_smxprocess_t cleanup, - smx_actor_t process, bool maestro) + smx_actor_t actor, bool maestro) { if (parallel_) - return this->new_context(std::move(code), cleanup, process, maestro); + return this->new_context(std::move(code), cleanup, actor, maestro); else - return this->new_context(std::move(code), cleanup, process, maestro); + return this->new_context(std::move(code), cleanup, actor, maestro); } void ThreadContextFactory::run_all() @@ -58,49 +57,34 @@ void ThreadContextFactory::run_all() // ThreadContext -ThreadContext::ThreadContext(std::function code, void_pfn_smxprocess_t cleanup, smx_actor_t process, - bool maestro) - : AttachContext(std::move(code), cleanup, process), is_maestro_(maestro) +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) { - // 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 the user provided a function for the actor then use it */ if (has_code()) { - if (smx_context_stack_size_was_set) - xbt_os_thread_setstacksize(smx_context_stack_size); - if (smx_context_guard_size_was_set) - xbt_os_thread_setguardsize(smx_context_guard_size); - - /* 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, ThreadContext::wrapper, this, this); - /* wait the starting of the newly created process */ - xbt_os_sem_acquire(this->end_); + /* create and start the actor */ + this->thread_ = new std::thread(ThreadContext::wrapper, this); + /* wait the starting of the newly created actor */ + this->end_.acquire(); } /* Otherwise, we attach to the current thread */ else { - xbt_os_thread_set_extra_data(this); + Context::set_current(this); } } 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_); + thread_->join(); + delete thread_; } void *ThreadContext::wrapper(void *param) { ThreadContext* context = static_cast(param); + Context::set_current(context); #ifndef WIN32 /* Install alternate signal stack, for SIGSEGV handler. */ @@ -111,7 +95,7 @@ void *ThreadContext::wrapper(void *param) sigaltstack(&stack, nullptr); #endif // Tell the caller (normally the maestro) we are starting, and wait for its green light - xbt_os_sem_release(context->end_); + context->end_.release(); context->start(); try { @@ -138,24 +122,24 @@ void *ThreadContext::wrapper(void *param) void ThreadContext::release() { - xbt_os_sem_release(this->begin_); + this->begin_.release(); } void ThreadContext::wait() { - xbt_os_sem_acquire(this->end_); + this->end_.acquire(); } void ThreadContext::start() { - xbt_os_sem_acquire(this->begin_); + this->begin_.acquire(); this->start_hook(); } void ThreadContext::yield() { this->yield_hook(); - xbt_os_sem_release(this->end_); + this->end_.release(); } void ThreadContext::stop() @@ -174,7 +158,7 @@ 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_); + maestro->begin_.release(); xbt_assert(not this->is_maestro()); this->start(); } @@ -185,18 +169,18 @@ void ThreadContext::attach_stop() this->yield(); ThreadContext* maestro = (ThreadContext*)simix_global->maestro_process->context_; - xbt_os_sem_acquire(maestro->end_); + maestro->end_.acquire(); - xbt_os_thread_set_extra_data(nullptr); + Context::set_current(nullptr); } // SerialThreadContext 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_); + for (smx_actor_t const& actor : simix_global->process_to_run) { + XBT_DEBUG("Handling %p", actor); + ThreadContext* context = static_cast(actor->context_); context->release(); context->wait(); } @@ -204,37 +188,37 @@ void SerialThreadContext::run_all() // ParallelThreadContext -xbt_os_sem_t ParallelThreadContext::thread_sem_ = nullptr; +xbt::OsSemaphore* ParallelThreadContext::thread_sem_ = nullptr; void ParallelThreadContext::initialize() { - thread_sem_ = xbt_os_sem_init(SIMIX_context_get_nthreads()); + thread_sem_ = new xbt::OsSemaphore(SIMIX_context_get_nthreads()); } void ParallelThreadContext::finalize() { - xbt_os_sem_destroy(thread_sem_); + 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(); + for (smx_actor_t const& actor : simix_global->process_to_run) + static_cast(actor->context_)->release(); + for (smx_actor_t const& actor : simix_global->process_to_run) + static_cast(actor->context_)->wait(); } void ParallelThreadContext::start_hook() { if (not is_maestro()) /* parallel run */ - xbt_os_sem_acquire(thread_sem_); + thread_sem_->acquire(); } void ParallelThreadContext::yield_hook() { if (not is_maestro()) /* parallel run */ - xbt_os_sem_release(thread_sem_); + thread_sem_->release(); } XBT_PRIVATE ContextFactory* thread_factory()