Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
move ContextFactory::self() into Context::self() and tidy it up
[simgrid.git] / src / kernel / context / ContextRaw.cpp
1 /* Copyright (c) 2009-2018. 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 "ContextRaw.hpp"
7 #include "context_private.hpp"
8 #include "mc/mc.h"
9 #include "simgrid/Exception.hpp"
10 #include "src/simix/smx_private.hpp"
11
12 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(simix_context);
13
14 // Raw context routines
15
16 typedef void (*rawctx_entry_point_t)(void *);
17
18 typedef void* raw_stack_t;
19 extern "C" raw_stack_t raw_makecontext(void* malloced_stack, int stack_size,
20                                    rawctx_entry_point_t entry_point, void* arg);
21 extern "C" void raw_swapcontext(raw_stack_t* old, raw_stack_t new_context);
22
23 // TODO, we should handle FP, MMX and the x87 control-word (for x86 and x86_64)
24
25 #if SIMGRID_PROCESSOR_x86_64
26 __asm__ (
27 #if defined(__APPLE__)
28    ".text\n"
29    ".globl _raw_makecontext\n"
30    "_raw_makecontext:\n"
31 #elif defined(_WIN32)
32    ".text\n"
33    ".globl raw_makecontext\n"
34    "raw_makecontext:\n"
35 #else
36    ".text\n"
37    ".globl raw_makecontext\n"
38    ".type raw_makecontext,@function\n"
39    "raw_makecontext:\n"/* Calling convention sets the arguments in rdi, rsi, rdx and rcx, respectively */
40 #endif
41    "   mov %rdi,%rax\n"      /* stack */
42    "   add %rsi,%rax\n"      /* size  */
43    "   andq $-16, %rax\n"    /* align stack */
44    "   movq $0,   -8(%rax)\n" /* @return for func */
45    "   mov %rdx,-16(%rax)\n" /* func */
46    "   mov %rcx,-24(%rax)\n" /* arg/rdi */
47    "   movq $0,  -32(%rax)\n" /* rsi */
48    "   movq $0,  -40(%rax)\n" /* rdx */
49    "   movq $0,  -48(%rax)\n" /* rcx */
50    "   movq $0,  -56(%rax)\n" /* r8  */
51    "   movq $0,  -64(%rax)\n" /* r9  */
52    "   movq $0,  -72(%rax)\n" /* rbp */
53    "   movq $0,  -80(%rax)\n" /* rbx */
54    "   movq $0,  -88(%rax)\n" /* r12 */
55    "   movq $0,  -96(%rax)\n" /* r13 */
56    "   movq $0, -104(%rax)\n" /* r14 */
57    "   movq $0, -112(%rax)\n" /* r15 */
58    "   sub $112,%rax\n"
59    "   ret\n"
60 );
61
62 __asm__ (
63 #if defined(__APPLE__)
64    ".text\n"
65    ".globl _raw_swapcontext\n"
66    "_raw_swapcontext:\n"
67 #elif defined(_WIN32)
68    ".text\n"
69    ".globl raw_swapcontext\n"
70    "raw_swapcontext:\n"
71 #else
72    ".text\n"
73    ".globl raw_swapcontext\n"
74    ".type raw_swapcontext,@function\n"
75    "raw_swapcontext:\n" /* Calling convention sets the arguments in rdi and rsi, respectively */
76 #endif
77    "   push %rdi\n"
78    "   push %rsi\n"
79    "   push %rdx\n"
80    "   push %rcx\n"
81    "   push %r8\n"
82    "   push %r9\n"
83    "   push %rbp\n"
84    "   push %rbx\n"
85    "   push %r12\n"
86    "   push %r13\n"
87    "   push %r14\n"
88    "   push %r15\n"
89    "   mov %rsp,(%rdi)\n" /* old */
90    "   mov %rsi,%rsp\n" /* new */
91    "   pop %r15\n"
92    "   pop %r14\n"
93    "   pop %r13\n"
94    "   pop %r12\n"
95    "   pop %rbx\n"
96    "   pop %rbp\n"
97    "   pop %r9\n"
98    "   pop %r8\n"
99    "   pop %rcx\n"
100    "   pop %rdx\n"
101    "   pop %rsi\n"
102    "   pop %rdi\n"
103    "   ret\n"
104 );
105 #elif SIMGRID_PROCESSOR_i686
106 __asm__ (
107 #if defined(__APPLE__) || defined(_WIN32)
108    ".text\n"
109    ".globl _raw_makecontext\n"
110    "_raw_makecontext:\n"
111 #else
112    ".text\n"
113    ".globl raw_makecontext\n"
114    ".type raw_makecontext,@function\n"
115    "raw_makecontext:\n"
116 #endif
117    "   movl 4(%esp),%eax\n"   /* stack */
118    "   addl 8(%esp),%eax\n"   /* size  */
119    "   andl $-16, %eax\n"     /* align stack */
120    "   movl 12(%esp),%ecx\n"  /* func  */
121    "   movl 16(%esp),%edx\n"  /* arg   */
122    "   movl %edx, -4(%eax)\n"
123    "   movl $0,   -8(%eax)\n" /* @return for func */
124    "   movl %ecx,-12(%eax)\n"
125    "   movl $0,  -16(%eax)\n" /* ebp */
126    "   movl $0,  -20(%eax)\n" /* ebx */
127    "   movl $0,  -24(%eax)\n" /* esi */
128    "   movl $0,  -28(%eax)\n" /* edi */
129    "   subl $28,%eax\n"
130    "   retl\n"
131 );
132
133 __asm__ (
134 #if defined(__APPLE__) || defined(_WIN32)
135    ".text\n"
136    ".globl _raw_swapcontext\n"
137    "_raw_swapcontext:\n"
138 #else
139    ".text\n"
140    ".globl raw_swapcontext\n"
141    ".type raw_swapcontext,@function\n"
142    "raw_swapcontext:\n"
143 #endif
144    // Fetch the parameters:
145    "   movl 4(%esp),%eax\n" /* old (raw_stack_t*) */
146    "   movl 8(%esp),%edx\n" /* new (raw_stack_t)  */
147    // Save registers of the current context on the stack:
148    "   pushl %ebp\n"
149    "   pushl %ebx\n"
150    "   pushl %esi\n"
151    "   pushl %edi\n"
152    // Save the current context (stack pointer) in *old:
153    "   movl %esp,(%eax)\n"
154    // Switch to the stack of the new context:
155    "   movl %edx,%esp\n"
156    // Pop the values of the new context:
157    "   popl %edi\n"
158    "   popl %esi\n"
159    "   popl %ebx\n"
160    "   popl %ebp\n"
161    // Return using the return address of the new context:
162    "   retl\n"
163 );
164 #else
165
166
167 /* If you implement raw contexts for other processors, don't forget to
168    update the definition of HAVE_RAW_CONTEXTS in tools/cmake/CompleteInFiles.cmake */
169
170 raw_stack_t raw_makecontext(void* malloced_stack, int stack_size,
171                             rawctx_entry_point_t entry_point, void* arg) {
172    THROW_UNIMPLEMENTED;
173 }
174
175 void raw_swapcontext(raw_stack_t* old, raw_stack_t new_context) {
176    THROW_UNIMPLEMENTED;
177 }
178
179 #endif
180
181 // ***** Method definitions
182
183 namespace simgrid {
184 namespace kernel {
185 namespace context {
186
187 // RawContextFactory
188
189 RawContextFactory::RawContextFactory() : ContextFactory("RawContextFactory"), parallel_(SIMIX_context_is_parallel())
190 {
191   RawContext::set_maestro(nullptr);
192   if (parallel_) {
193     // TODO: choose dynamically when SIMIX_context_get_parallel_threshold() > 1
194     ParallelRawContext::initialize();
195   }
196 }
197
198 RawContextFactory::~RawContextFactory()
199 {
200   if (parallel_)
201     ParallelRawContext::finalize();
202 }
203
204 Context* RawContextFactory::create_context(std::function<void()> code, void_pfn_smxprocess_t cleanup_func,
205                                            smx_actor_t process)
206 {
207   if (parallel_)
208     return this->new_context<ParallelRawContext>(std::move(code), cleanup_func, process);
209   return this->new_context<SerialRawContext>(std::move(code), cleanup_func, process);
210 }
211
212 void RawContextFactory::run_all()
213 {
214   if (parallel_)
215     ParallelRawContext::run_all();
216   else
217     SerialRawContext::run_all();
218 }
219
220 // RawContext
221
222 RawContext* RawContext::maestro_context_ = nullptr;
223
224 RawContext::RawContext(std::function<void()> code, void_pfn_smxprocess_t cleanup, smx_actor_t process)
225     : Context(std::move(code), cleanup, process)
226 {
227    if (has_code()) {
228      this->stack_ = SIMIX_context_stack_new();
229 #if PTH_STACKGROWTH == -1
230      ASAN_ONLY(this->asan_stack_ = static_cast<char*>(this->stack_) + smx_context_usable_stack_size);
231 #else
232      ASAN_ONLY(this->asan_stack_ = this->stack_);
233 #endif
234      this->stack_top_ = raw_makecontext(this->stack_, smx_context_usable_stack_size, RawContext::wrapper, this);
235    } else {
236      if (process != nullptr && maestro_context_ == nullptr)
237        maestro_context_ = this;
238      if (MC_is_active())
239        MC_ignore_heap(&maestro_context_->stack_top_, sizeof(maestro_context_->stack_top_));
240    }
241 }
242
243 RawContext::~RawContext()
244 {
245   SIMIX_context_stack_delete(this->stack_);
246 }
247
248 void RawContext::wrapper(void* arg)
249 {
250   RawContext* context = static_cast<RawContext*>(arg);
251   ASAN_FINISH_SWITCH(nullptr, &context->asan_ctx_->asan_stack_, &context->asan_ctx_->asan_stack_size_);
252   try {
253     (*context)();
254   } catch (StopRequest const&) {
255     XBT_DEBUG("Caught a StopRequest");
256   } catch (simgrid::Exception const& e) {
257     XBT_INFO("Actor killed by an uncatched exception %s", simgrid::xbt::demangle(typeid(e).name()).get());
258     throw;
259   }
260   context->Context::stop();
261
262   ASAN_ONLY(context->asan_stop_ = true);
263   context->suspend();
264 }
265
266 inline void RawContext::swap(RawContext* from, RawContext* to)
267 {
268   ASAN_ONLY(void* fake_stack = nullptr);
269   ASAN_ONLY(to->asan_ctx_ = from);
270   ASAN_START_SWITCH(from->asan_stop_ ? nullptr : &fake_stack, to->asan_stack_, to->asan_stack_size_);
271   raw_swapcontext(&from->stack_top_, to->stack_top_);
272   ASAN_FINISH_SWITCH(fake_stack, &from->asan_ctx_->asan_stack_, &from->asan_ctx_->asan_stack_size_);
273 }
274
275 void RawContext::stop()
276 {
277   Context::stop();
278   throw StopRequest();
279 }
280
281 // SerialRawContext
282
283 unsigned long SerialRawContext::process_index_; /* index of the next process to run in the list of runnable processes */
284
285 void SerialRawContext::suspend()
286 {
287   /* determine the next context */
288   SerialRawContext* next_context;
289   unsigned long int i = process_index_;
290   process_index_++;
291   if (i < simix_global->process_to_run.size()) {
292     /* execute the next process */
293     XBT_DEBUG("Run next process");
294     next_context = static_cast<SerialRawContext*>(simix_global->process_to_run[i]->context_);
295   } else {
296     /* all processes were run, return to maestro */
297     XBT_DEBUG("No more process to run");
298     next_context = static_cast<SerialRawContext*>(RawContext::get_maestro());
299   }
300   Context::set_current(next_context);
301   RawContext::swap(this, next_context);
302 }
303
304 void SerialRawContext::resume()
305 {
306   Context::set_current(this);
307   RawContext::swap(RawContext::get_maestro(), this);
308 }
309
310 void SerialRawContext::run_all()
311 {
312   if (simix_global->process_to_run.empty())
313     return;
314   smx_actor_t first_process = simix_global->process_to_run.front();
315   process_index_            = 1;
316   static_cast<SerialRawContext*>(first_process->context_)->resume();
317 }
318
319 // ParallelRawContext
320
321 simgrid::xbt::Parmap<smx_actor_t>* ParallelRawContext::parmap_;
322 std::atomic<uintptr_t> ParallelRawContext::threads_working_; /* number of threads that have started their work */
323 uintptr_t thread_local ParallelRawContext::worker_id_;       /* thread-specific storage for the thread id */
324 std::vector<ParallelRawContext*> ParallelRawContext::workers_context_; /* space to save the worker context
325                                                                           in each thread */
326
327 void ParallelRawContext::initialize()
328 {
329   parmap_ = nullptr;
330   workers_context_.clear();
331   workers_context_.resize(SIMIX_context_get_nthreads(), nullptr);
332 }
333
334 void ParallelRawContext::finalize()
335 {
336   delete parmap_;
337   parmap_ = nullptr;
338   workers_context_.clear();
339 }
340
341 void ParallelRawContext::run_all()
342 {
343   threads_working_ = 0;
344   if (parmap_ == nullptr)
345     parmap_ = new simgrid::xbt::Parmap<smx_actor_t>(SIMIX_context_get_nthreads(), SIMIX_context_get_parallel_mode());
346   parmap_->apply(
347       [](smx_actor_t process) {
348         ParallelRawContext* context = static_cast<ParallelRawContext*>(process->context_);
349         context->resume();
350       },
351       simix_global->process_to_run);
352 }
353
354 void ParallelRawContext::suspend()
355 {
356   /* determine the next context */
357   boost::optional<smx_actor_t> next_work = parmap_->next();
358   ParallelRawContext* next_context;
359   if (next_work) {
360     /* there is a next process to resume */
361     XBT_DEBUG("Run next process");
362     next_context = static_cast<ParallelRawContext*>(next_work.get()->context_);
363   } else {
364     /* all processes were run, go to the barrier */
365     XBT_DEBUG("No more processes to run");
366     next_context = workers_context_[worker_id_];
367     XBT_DEBUG("Restoring worker stack %zu (working threads = %zu)", worker_id_, threads_working_.load());
368   }
369
370   Context::set_current(next_context);
371   RawContext::swap(this, next_context);
372 }
373
374 void ParallelRawContext::resume()
375 {
376   worker_id_                         = threads_working_.fetch_add(1, std::memory_order_relaxed);
377   ParallelRawContext* worker_context = static_cast<ParallelRawContext*>(SIMIX_context_self());
378   workers_context_[worker_id_]       = worker_context;
379   XBT_DEBUG("Saving worker stack %zu", worker_id_);
380   Context::set_current(this);
381   RawContext::swap(worker_context, this);
382 }
383
384 ContextFactory* raw_factory()
385 {
386   XBT_VERB("Using raw contexts. Because the glibc is just not good enough for us.");
387   return new RawContextFactory();
388 }
389 }}}