Logo AND Algorithmique Numérique Distribuée

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