Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
a3c60882e0f49fe89fdf440f923f91894e548a7a
[simgrid.git] / src / kernel / context / ContextThread.cpp
1 /* Copyright (c) 2009-2019. The SimGrid Team. All rights reserved.          */
2
3 /* This program is free software; you can redistribute it and/or modify it
4  * under the terms of the license (GNU LGPL) which comes with this package. */
5
6 #include "src/kernel/context/ContextThread.hpp"
7
8 #include "simgrid/Exception.hpp"
9 #include "src/internal_config.h" /* loads context system definitions */
10 #include "src/simix/smx_private.hpp"
11 #include "src/xbt_modinter.h" /* prototype of os thread module's init/exit in XBT */
12 #include "xbt/function_types.h"
13
14 #include <functional>
15 #include <utility>
16
17 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(simix_context);
18
19 namespace simgrid {
20 namespace kernel {
21 namespace context {
22
23 // ThreadContextFactory
24
25 ThreadContextFactory::ThreadContextFactory()
26     : ContextFactory("ThreadContextFactory"), parallel_(SIMIX_context_is_parallel())
27 {
28   if (parallel_)
29     ParallelThreadContext::initialize();
30 }
31
32 ThreadContextFactory::~ThreadContextFactory()
33 {
34   if (parallel_)
35     ParallelThreadContext::finalize();
36 }
37
38 ThreadContext* ThreadContextFactory::create_context(std::function<void()> code, void_pfn_smxprocess_t cleanup,
39                                                     smx_actor_t process, bool maestro)
40 {
41   if (parallel_)
42     return this->new_context<ParallelThreadContext>(std::move(code), cleanup, process, maestro);
43   else
44     return this->new_context<SerialThreadContext>(std::move(code), cleanup, process, maestro);
45 }
46
47 void ThreadContextFactory::run_all()
48 {
49   if (parallel_) {
50     // Parallel execution
51     ParallelThreadContext::run_all();
52   } else {
53     // Serial execution
54     SerialThreadContext::run_all();
55   }
56 }
57
58 // ThreadContext
59
60 ThreadContext::ThreadContext(std::function<void()> code, void_pfn_smxprocess_t cleanup, smx_actor_t actor, bool maestro)
61     : AttachContext(std::move(code), cleanup, actor), is_maestro_(maestro)
62 {
63   /* If the user provided a function for the process then use it */
64   if (has_code()) {
65     /* create and start the process */
66     this->thread_ = new std::thread(ThreadContext::wrapper, this);
67     /* wait the starting of the newly created process */
68     this->end_.acquire();
69   }
70
71   /* Otherwise, we attach to the current thread */
72   else {
73     Context::set_current(this);
74   }
75 }
76
77 ThreadContext::~ThreadContext()
78 {
79   if (this->thread_) /* If there is a thread (maestro don't have any), wait for its termination */
80     thread_->join();
81   delete thread_;
82 }
83
84 void *ThreadContext::wrapper(void *param)
85 {
86   ThreadContext* context = static_cast<ThreadContext*>(param);
87   Context::set_current(context);
88
89 #ifndef WIN32
90   /* Install alternate signal stack, for SIGSEGV handler. */
91   stack_t stack;
92   stack.ss_sp = sigsegv_stack;
93   stack.ss_size = sizeof sigsegv_stack;
94   stack.ss_flags = 0;
95   sigaltstack(&stack, nullptr);
96 #endif
97   // Tell the caller (normally the maestro) we are starting, and wait for its green light
98   context->end_.release();
99   context->start();
100
101   try {
102     (*context)();
103   } catch (StopRequest const&) {
104     XBT_DEBUG("Caught a StopRequest");
105     xbt_assert(not context->is_maestro(), "Maestro shall not receive StopRequests, even when detached.");
106   } catch (simgrid::Exception const& e) {
107     XBT_INFO("Actor killed by an uncatched exception %s", simgrid::xbt::demangle(typeid(e).name()).get());
108     throw;
109   }
110   if (not context->is_maestro()) // Just in case somebody detached maestro
111     context->Context::stop();
112
113   // Signal to the caller (normally the maestro) that we have finished:
114   context->yield();
115
116 #ifndef WIN32
117   stack.ss_flags = SS_DISABLE;
118   sigaltstack(&stack, nullptr);
119 #endif
120   return nullptr;
121 }
122
123 void ThreadContext::release()
124 {
125   this->begin_.release();
126 }
127
128 void ThreadContext::wait()
129 {
130   this->end_.acquire();
131 }
132
133 void ThreadContext::start()
134 {
135   this->begin_.acquire();
136   this->start_hook();
137 }
138
139 void ThreadContext::yield()
140 {
141   this->yield_hook();
142   this->end_.release();
143 }
144
145 void ThreadContext::stop()
146 {
147   Context::stop();
148   throw StopRequest();
149 }
150
151 void ThreadContext::suspend()
152 {
153   this->yield();
154   this->start();
155 }
156
157 void ThreadContext::attach_start()
158 {
159   // We're breaking the layers here by depending on the upper layer:
160   ThreadContext* maestro = (ThreadContext*)simix_global->maestro_process->context_;
161   maestro->begin_.release();
162   xbt_assert(not this->is_maestro());
163   this->start();
164 }
165
166 void ThreadContext::attach_stop()
167 {
168   xbt_assert(not this->is_maestro());
169   this->yield();
170
171   ThreadContext* maestro = (ThreadContext*)simix_global->maestro_process->context_;
172   maestro->end_.acquire();
173
174   Context::set_current(nullptr);
175 }
176
177 // SerialThreadContext
178
179 void SerialThreadContext::run_all()
180 {
181   for (smx_actor_t const& process : simix_global->process_to_run) {
182     XBT_DEBUG("Handling %p", process);
183     ThreadContext* context = static_cast<ThreadContext*>(process->context_);
184     context->release();
185     context->wait();
186   }
187 }
188
189 // ParallelThreadContext
190
191 xbt::OsSemaphore* ParallelThreadContext::thread_sem_ = nullptr;
192
193 void ParallelThreadContext::initialize()
194 {
195   thread_sem_ = new xbt::OsSemaphore(SIMIX_context_get_nthreads());
196 }
197
198 void ParallelThreadContext::finalize()
199 {
200   delete thread_sem_;
201   thread_sem_ = nullptr;
202 }
203
204 void ParallelThreadContext::run_all()
205 {
206   for (smx_actor_t const& process : simix_global->process_to_run)
207     static_cast<ThreadContext*>(process->context_)->release();
208   for (smx_actor_t const& process : simix_global->process_to_run)
209     static_cast<ThreadContext*>(process->context_)->wait();
210 }
211
212 void ParallelThreadContext::start_hook()
213 {
214   if (not is_maestro()) /* parallel run */
215     thread_sem_->acquire();
216 }
217
218 void ParallelThreadContext::yield_hook()
219 {
220   if (not is_maestro()) /* parallel run */
221     thread_sem_->release();
222 }
223
224 XBT_PRIVATE ContextFactory* thread_factory()
225 {
226   XBT_VERB("Activating thread context factory");
227   return new ThreadContextFactory();
228 }
229 }}} // namespace