Logo AND Algorithmique Numérique Distribuée

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