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<void()> code,
- void_pfn_smxprocess_t cleanup, smx_actor_t process)
+ThreadContext* ThreadContextFactory::create_context(std::function<void()> code, void_pfn_smxprocess_t cleanup,
+ smx_actor_t process, bool maestro)
{
- return this->new_context<ThreadContext>(std::move(code), cleanup, process, not code);
+ if (parallel_)
+ return this->new_context<ParallelThreadContext>(std::move(code), cleanup, process, maestro);
+ else
+ return this->new_context<SerialThreadContext>(std::move(code), cleanup, process, maestro);
}
void ThreadContextFactory::run_all()
{
- if (smx_ctx_thread_sem == nullptr) {
- // Serial execution
- for (smx_actor_t const& process : simix_global->process_to_run) {
- XBT_DEBUG("Handling %p",process);
- ThreadContext* context = static_cast<ThreadContext*>(process->context);
- xbt_os_sem_release(context->begin_);
- xbt_os_sem_acquire(context->end_);
- }
- } else {
+ if (parallel_) {
// Parallel execution
- for (smx_actor_t const& process : simix_global->process_to_run)
- xbt_os_sem_release(static_cast<ThreadContext*>(process->context)->begin_);
- for (smx_actor_t const& process : simix_global->process_to_run)
- xbt_os_sem_acquire(static_cast<ThreadContext*>(process->context)->end_);
+ ParallelThreadContext::run_all();
+ } else {
+ // Serial execution
+ SerialThreadContext::run_all();
}
}
-ThreadContext* ThreadContextFactory::self()
-{
- return static_cast<ThreadContext*>(xbt_os_thread_get_extra_data());
-}
-
-ThreadContext* ThreadContextFactory::attach(void_pfn_smxprocess_t cleanup_func, smx_actor_t process)
-{
- return this->new_context<ThreadContext>(
- std::function<void()>(), cleanup_func, process, false);
-}
-
-ThreadContext* ThreadContextFactory::create_maestro(std::function<void()> code, smx_actor_t process)
-{
- return this->new_context<ThreadContext>(std::move(code), nullptr, process, true);
-}
+// ThreadContext
-ThreadContext::ThreadContext(std::function<void()> code,
- void_pfn_smxprocess_t cleanup, smx_actor_t process, bool maestro)
- : AttachContext(std::move(code), cleanup, process)
+ThreadContext::ThreadContext(std::function<void()> code, void_pfn_smxprocess_t cleanup, smx_actor_t process,
+ bool maestro)
+ : AttachContext(std::move(code), cleanup, process), is_maestro_(maestro)
{
// We do not need the semaphores when maestro is in main,
// but creating them anyway simplifies things when maestro is externalized
/* 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_);
}
stack.ss_flags = 0;
sigaltstack(&stack, nullptr);
#endif
- /* Tell the maestro we are starting, and wait for its green light */
+ // Tell the caller (normally 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->start();
try {
(*context)();
- context->Context::stop();
+ if (not context->isMaestro()) // really?
+ context->Context::stop();
} catch (StopRequest const&) {
XBT_DEBUG("Caught a StopRequest");
+ xbt_assert(not context->isMaestro(), "I'm not supposed to be maestro here.");
}
- 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(context->end_);
+ // Signal to the caller (normally the maestro) that we have finished:
+ context->yield();
#ifndef WIN32
stack.ss_flags = SS_DISABLE;
return nullptr;
}
-void *ThreadContext::maestro_wrapper(void *param)
+void ThreadContext::release()
{
- ThreadContext* context = static_cast<ThreadContext*>(param);
-
-#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;
- 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)();
-
- // Tell main that we have finished:
- xbt_os_sem_release(context->end_);
+ xbt_os_sem_release(this->begin_);
+}
-#ifndef WIN32
- stack.ss_flags = SS_DISABLE;
- sigaltstack(&stack, nullptr);
-#endif
- return nullptr;
+void ThreadContext::wait()
+{
+ xbt_os_sem_acquire(this->end_);
}
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->start_hook();
+}
+
+void ThreadContext::yield()
+{
+ this->yield_hook();
+ xbt_os_sem_release(this->end_);
}
void ThreadContext::stop()
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_);
+ xbt_assert(not this->isMaestro());
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->isMaestro());
+ this->yield();
ThreadContext* maestro = (ThreadContext*) simix_global->maestro_process->context;
xbt_os_sem_acquire(maestro->end_);
xbt_os_thread_set_extra_data(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<ThreadContext*>(process->context);
+ context->release();
+ context->wait();
+ }
+}
+
+// ParallelThreadContext
+
+xbt_os_sem_t ParallelThreadContext::thread_sem_ = nullptr;
+
+void ParallelThreadContext::initialize()
+{
+ thread_sem_ = xbt_os_sem_init(SIMIX_context_get_nthreads());
+}
+
+void ParallelThreadContext::finalize()
+{
+ xbt_os_sem_destroy(thread_sem_);
+ thread_sem_ = nullptr;
+}
+
+void ParallelThreadContext::run_all()
+{
+ for (smx_actor_t const& process : simix_global->process_to_run)
+ static_cast<ThreadContext*>(process->context)->release();
+ for (smx_actor_t const& process : simix_global->process_to_run)
+ static_cast<ThreadContext*>(process->context)->wait();
+}
+
+void ParallelThreadContext::start_hook()
+{
+ if (not isMaestro()) /* parallel run */
+ xbt_os_sem_acquire(thread_sem_);
+}
+
+void ParallelThreadContext::yield_hook()
+{
+ if (not isMaestro()) /* parallel run */
+ xbt_os_sem_release(thread_sem_);
+}
+
+XBT_PRIVATE ContextFactory* thread_factory()
+{
+ XBT_VERB("Activating thread context factory");
+ return new ThreadContextFactory();
+}
}}} // namespace