Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
kill a useless accessor
[simgrid.git] / src / simix / ThreadContext.cpp
1 /* Copyright (c) 2009-2015. The SimGrid Team.
2  * All rights reserved.                                                     */
3
4 /* This program is free software; you can redistribute it and/or modify it
5  * under the terms of the license (GNU LGPL) which comes with this package. */
6
7 #include <utility>
8 #include <functional>
9
10 #include "xbt/function_types.h"
11 #include "smx_private.h"
12 #include "src/internal_config.h"           /* loads context system definitions */
13 #include "xbt/swag.h"
14 #include "xbt/xbt_os_thread.h"
15 #include "src/xbt_modinter.h"       /* prototype of os thread module's init/exit in XBT */
16
17 #include "src/simix/smx_private.hpp"
18 #include "src/simix/ThreadContext.hpp"
19
20 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(simix_context);
21
22 static xbt_os_sem_t smx_ctx_thread_sem = nullptr;
23
24 namespace simgrid {
25 namespace simix {
26
27 XBT_PRIVATE ContextFactory* thread_factory()
28 {
29   XBT_VERB("Activating thread context factory");
30   return new ThreadContextFactory();
31 }
32
33 ThreadContextFactory::ThreadContextFactory()
34   : ContextFactory("ThreadContextFactory")
35 {
36   if (SIMIX_context_is_parallel()) {
37     smx_ctx_thread_sem = xbt_os_sem_init(SIMIX_context_get_nthreads());
38   } else {
39     smx_ctx_thread_sem = nullptr;
40   }
41 }
42
43 ThreadContextFactory::~ThreadContextFactory()
44 {
45   if (smx_ctx_thread_sem) {
46     xbt_os_sem_destroy(smx_ctx_thread_sem);
47     smx_ctx_thread_sem = nullptr;
48   }
49 }
50
51 ThreadContext* ThreadContextFactory::create_context(
52     std::function<void()> code,
53     void_pfn_smxprocess_t cleanup, smx_process_t process)
54 {
55   return this->new_context<ThreadContext>(std::move(code), cleanup, process, !code);
56 }
57
58 void ThreadContextFactory::run_all()
59 {
60   if (smx_ctx_thread_sem == nullptr) {
61     // Serial execution
62     smx_process_t process;
63     unsigned int cursor;
64     xbt_dynar_foreach(simix_global->process_to_run, cursor, process) {
65       XBT_DEBUG("Handling %p",process);
66       ThreadContext* context = static_cast<ThreadContext*>(process->context);
67       xbt_os_sem_release(context->begin_);
68       xbt_os_sem_acquire(context->end_);
69     }
70   } else {
71     // Parallel execution
72     unsigned int index;
73     smx_process_t process;
74     xbt_dynar_foreach(simix_global->process_to_run, index, process)
75       xbt_os_sem_release(static_cast<ThreadContext*>(process->context)->begin_);
76     xbt_dynar_foreach(simix_global->process_to_run, index, process)
77        xbt_os_sem_acquire(static_cast<ThreadContext*>(process->context)->end_);
78   }
79 }
80
81 ThreadContext* ThreadContextFactory::self()
82 {
83   return static_cast<ThreadContext*>(xbt_os_thread_get_extra_data());
84 }
85
86 ThreadContext* ThreadContextFactory::attach(void_pfn_smxprocess_t cleanup_func, smx_process_t process)
87 {
88   return this->new_context<ThreadContext>(
89     std::function<void()>(), cleanup_func, process, false);
90 }
91
92 ThreadContext* ThreadContextFactory::create_maestro(std::function<void()> code, smx_process_t process)
93 {
94     return this->new_context<ThreadContext>(std::move(code), nullptr, process, true);
95 }
96
97 ThreadContext::ThreadContext(std::function<void()> code,
98     void_pfn_smxprocess_t cleanup, smx_process_t process, bool maestro)
99   : AttachContext(std::move(code), cleanup, process)
100 {
101   // We do not need the semaphores when maestro is in main, but we create them anyway for simplicity wrt the case where maestro is externalized
102   this->begin_ = xbt_os_sem_init(0);
103   this->end_ = xbt_os_sem_init(0);
104
105   /* If the user provided a function for the process then use it */
106   if (has_code()) {
107     if (smx_context_stack_size_was_set)
108       xbt_os_thread_setstacksize(smx_context_stack_size);
109     if (smx_context_guard_size_was_set)
110       xbt_os_thread_setguardsize(smx_context_guard_size);
111
112     /* create and start the process */
113     /* NOTE: The first argument to xbt_os_thread_create used to be the process *
114     * name, but now the name is stored at SIMIX level, so we pass a null  */
115     this->thread_ =
116       xbt_os_thread_create(NULL,
117         maestro ? ThreadContext::maestro_wrapper : ThreadContext::wrapper,
118         this, this);
119     /* wait the starting of the newly created process */
120     xbt_os_sem_acquire(this->end_);
121   }
122
123   /* Otherwise, we attach to the current thread */
124   else {
125     xbt_os_thread_set_extra_data(this);
126   }
127 }
128
129 ThreadContext::~ThreadContext()
130 {
131   if (this->thread_) /* If there is a thread (maestro don't have any), wait for its termination */
132     xbt_os_thread_join(this->thread_, nullptr);
133
134   /* destroy the synchronization objects */
135   xbt_os_sem_destroy(this->begin_);
136   xbt_os_sem_destroy(this->end_);
137 }
138
139 void *ThreadContext::wrapper(void *param)
140 {
141   ThreadContext* context = static_cast<ThreadContext*>(param);
142
143 #ifndef WIN32
144   /* Install alternate signal stack, for SIGSEGV handler. */
145   stack_t stack;
146   stack.ss_sp = sigsegv_stack;
147   stack.ss_size = sizeof sigsegv_stack;
148   stack.ss_flags = 0;
149   sigaltstack(&stack, nullptr);
150 #endif
151   /* Tell the maestro we are starting, and wait for its green light */
152   xbt_os_sem_release(context->end_);
153
154   xbt_os_sem_acquire(context->begin_);
155   if (smx_ctx_thread_sem)       /* parallel run */
156     xbt_os_sem_acquire(smx_ctx_thread_sem);
157
158   (*context)();
159   context->stop();
160
161   return nullptr;
162 }
163
164 void *ThreadContext::maestro_wrapper(void *param)
165 {
166   ThreadContext* context = static_cast<ThreadContext*>(param);
167
168 #ifndef WIN32
169   /* Install alternate signal stack, for SIGSEGV handler. */
170   stack_t stack;
171   stack.ss_sp = sigsegv_stack;
172   stack.ss_size = sizeof sigsegv_stack;
173   stack.ss_flags = 0;
174   sigaltstack(&stack, nullptr);
175 #endif
176   /* Tell the caller we are starting */
177   xbt_os_sem_release(context->end_);
178
179   // Wait for the caller to give control back to us:
180   xbt_os_sem_acquire(context->begin_);
181   (*context)();
182
183   // Tell main that we have finished:
184   xbt_os_sem_release(context->end_);
185
186   return nullptr;
187 }
188
189 void ThreadContext::start()
190 {
191   xbt_os_sem_acquire(this->begin_);
192   if (smx_ctx_thread_sem)       /* parallel run */
193     xbt_os_sem_acquire(smx_ctx_thread_sem);
194 }
195
196 void ThreadContext::stop()
197 {
198   Context::stop();
199   if (smx_ctx_thread_sem)
200     xbt_os_sem_release(smx_ctx_thread_sem);
201
202   // Signal to the maestro that it has finished:
203   xbt_os_sem_release(this->end_);
204
205   xbt_os_thread_exit(NULL);
206 }
207
208 void ThreadContext::suspend()
209 {
210   if (smx_ctx_thread_sem)
211     xbt_os_sem_release(smx_ctx_thread_sem);
212   xbt_os_sem_release(this->end_);
213   xbt_os_sem_acquire(this->begin_);
214   if (smx_ctx_thread_sem)
215     xbt_os_sem_acquire(smx_ctx_thread_sem);
216 }
217
218 void ThreadContext::attach_start()
219 {
220   // We're breaking the layers here by depending on the upper layer:
221   ThreadContext* maestro = (ThreadContext*) simix_global->maestro_process->context;
222   xbt_os_sem_release(maestro->begin_);
223   this->start();
224 }
225
226 void ThreadContext::attach_stop()
227 {
228   if (smx_ctx_thread_sem)
229     xbt_os_sem_release(smx_ctx_thread_sem);
230   xbt_os_sem_release(this->end_);
231
232   ThreadContext* maestro = (ThreadContext*) simix_global->maestro_process->context;
233   xbt_os_sem_acquire(maestro->end_);
234
235   xbt_os_thread_set_extra_data(nullptr);
236 }
237
238 }
239 }