1 /* System thread definitions
2 Copyright (C) 2012-2019 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>. */
27 #ifndef THREADS_ENABLED
30 sys_mutex_init (sys_mutex_t
*m
)
36 sys_mutex_lock (sys_mutex_t
*m
)
41 sys_mutex_unlock (sys_mutex_t
*m
)
46 sys_cond_init (sys_cond_t
*c
)
52 sys_cond_wait (sys_cond_t
*c
, sys_mutex_t
*m
)
57 sys_cond_signal (sys_cond_t
*c
)
62 sys_cond_broadcast (sys_cond_t
*c
)
67 sys_cond_destroy (sys_cond_t
*c
)
72 sys_thread_self (void)
78 sys_thread_create (sys_thread_t
*t
, const char *name
,
79 thread_creation_function
*func
, void *datum
)
85 sys_thread_yield (void)
89 #elif defined (HAVE_PTHREAD)
93 #ifdef HAVE_SYS_PRCTL_H
94 #include <sys/prctl.h>
98 sys_mutex_init (sys_mutex_t
*mutex
)
100 pthread_mutex_init (mutex
, NULL
);
104 sys_mutex_lock (sys_mutex_t
*mutex
)
106 pthread_mutex_lock (mutex
);
110 sys_mutex_unlock (sys_mutex_t
*mutex
)
112 pthread_mutex_unlock (mutex
);
116 sys_cond_init (sys_cond_t
*cond
)
118 pthread_cond_init (cond
, NULL
);
122 sys_cond_wait (sys_cond_t
*cond
, sys_mutex_t
*mutex
)
124 pthread_cond_wait (cond
, mutex
);
128 sys_cond_signal (sys_cond_t
*cond
)
130 pthread_cond_signal (cond
);
134 sys_cond_broadcast (sys_cond_t
*cond
)
136 pthread_cond_broadcast (cond
);
138 /* Send an app defined event to break out of the NS run loop.
139 It seems that if ns_select is running the NS run loop, this
140 broadcast has no effect until the loop is done, breaking a couple
141 of tests in thread-tests.el. */
142 ns_run_loop_break ();
147 sys_cond_destroy (sys_cond_t
*cond
)
149 pthread_cond_destroy (cond
);
153 sys_thread_self (void)
155 return pthread_self ();
159 sys_thread_create (sys_thread_t
*thread_ptr
, const char *name
,
160 thread_creation_function
*func
, void *arg
)
165 if (pthread_attr_init (&attr
))
169 /* Avoid crash on macOS with deeply nested GC (Bug#30364). */
171 size_t required_stack_size
= sizeof (void *) * 1024 * 1024;
172 if (pthread_attr_getstacksize (&attr
, &stack_size
) == 0
173 && stack_size
< required_stack_size
)
174 pthread_attr_setstacksize (&attr
, required_stack_size
);
177 if (!pthread_attr_setdetachstate (&attr
, PTHREAD_CREATE_DETACHED
))
179 result
= pthread_create (thread_ptr
, &attr
, func
, arg
) == 0;
180 #if defined (HAVE_SYS_PRCTL_H) && defined (HAVE_PRCTL) && defined (PR_SET_NAME)
181 if (result
&& name
!= NULL
)
182 prctl (PR_SET_NAME
, name
);
186 pthread_attr_destroy (&attr
);
192 sys_thread_yield (void)
197 #elif defined (WINDOWSNT)
201 /* Cannot include <process.h> because of the local header by the same
203 uintptr_t _beginthread (void (__cdecl
*)(void *), unsigned, void *);
205 /* Mutexes are implemented as critical sections, because they are
206 faster than Windows mutex objects (implemented in userspace), and
207 satisfy the requirements, since we only need to synchronize within a
210 sys_mutex_init (sys_mutex_t
*mutex
)
212 InitializeCriticalSection ((LPCRITICAL_SECTION
)mutex
);
216 sys_mutex_lock (sys_mutex_t
*mutex
)
218 /* FIXME: What happens if the owning thread exits without releasing
219 the mutex? According to MSDN, the result is undefined behavior. */
220 EnterCriticalSection ((LPCRITICAL_SECTION
)mutex
);
224 sys_mutex_unlock (sys_mutex_t
*mutex
)
226 LeaveCriticalSection ((LPCRITICAL_SECTION
)mutex
);
230 sys_cond_init (sys_cond_t
*cond
)
232 cond
->initialized
= false;
233 cond
->wait_count
= 0;
234 /* Auto-reset event for signal. */
235 cond
->events
[CONDV_SIGNAL
] = CreateEvent (NULL
, FALSE
, FALSE
, NULL
);
236 /* Manual-reset event for broadcast. */
237 cond
->events
[CONDV_BROADCAST
] = CreateEvent (NULL
, TRUE
, FALSE
, NULL
);
238 if (!cond
->events
[CONDV_SIGNAL
] || !cond
->events
[CONDV_BROADCAST
])
240 InitializeCriticalSection ((LPCRITICAL_SECTION
)&cond
->wait_count_lock
);
241 cond
->initialized
= true;
245 sys_cond_wait (sys_cond_t
*cond
, sys_mutex_t
*mutex
)
248 bool last_thread_waiting
;
250 if (!cond
->initialized
)
253 /* Increment the wait count avoiding race conditions. */
254 EnterCriticalSection ((LPCRITICAL_SECTION
)&cond
->wait_count_lock
);
256 LeaveCriticalSection ((LPCRITICAL_SECTION
)&cond
->wait_count_lock
);
258 /* Release the mutex and wait for either the signal or the broadcast
260 LeaveCriticalSection ((LPCRITICAL_SECTION
)mutex
);
261 wait_result
= WaitForMultipleObjects (2, cond
->events
, FALSE
, INFINITE
);
263 /* Decrement the wait count and see if we are the last thread
264 waiting on the condition variable. */
265 EnterCriticalSection ((LPCRITICAL_SECTION
)&cond
->wait_count_lock
);
267 last_thread_waiting
=
268 wait_result
== WAIT_OBJECT_0
+ CONDV_BROADCAST
269 && cond
->wait_count
== 0;
270 LeaveCriticalSection ((LPCRITICAL_SECTION
)&cond
->wait_count_lock
);
272 /* Broadcast uses a manual-reset event, so when the last thread is
273 released, we must manually reset that event. */
274 if (last_thread_waiting
)
275 ResetEvent (cond
->events
[CONDV_BROADCAST
]);
277 /* Per the API, re-acquire the mutex. */
278 EnterCriticalSection ((LPCRITICAL_SECTION
)mutex
);
282 sys_cond_signal (sys_cond_t
*cond
)
284 bool threads_waiting
;
286 if (!cond
->initialized
)
289 EnterCriticalSection ((LPCRITICAL_SECTION
)&cond
->wait_count_lock
);
290 threads_waiting
= cond
->wait_count
> 0;
291 LeaveCriticalSection ((LPCRITICAL_SECTION
)&cond
->wait_count_lock
);
294 SetEvent (cond
->events
[CONDV_SIGNAL
]);
298 sys_cond_broadcast (sys_cond_t
*cond
)
300 bool threads_waiting
;
302 if (!cond
->initialized
)
305 EnterCriticalSection ((LPCRITICAL_SECTION
)&cond
->wait_count_lock
);
306 threads_waiting
= cond
->wait_count
> 0;
307 LeaveCriticalSection ((LPCRITICAL_SECTION
)&cond
->wait_count_lock
);
310 SetEvent (cond
->events
[CONDV_BROADCAST
]);
314 sys_cond_destroy (sys_cond_t
*cond
)
316 if (cond
->events
[CONDV_SIGNAL
])
317 CloseHandle (cond
->events
[CONDV_SIGNAL
]);
318 if (cond
->events
[CONDV_BROADCAST
])
319 CloseHandle (cond
->events
[CONDV_BROADCAST
]);
321 if (!cond
->initialized
)
324 /* FIXME: What if wait_count is non-zero, i.e. there are still
325 threads waiting on this condition variable? */
326 DeleteCriticalSection ((LPCRITICAL_SECTION
)&cond
->wait_count_lock
);
330 sys_thread_self (void)
332 return (sys_thread_t
) GetCurrentThreadId ();
335 static thread_creation_function
*thread_start_address
;
337 /* _beginthread wants a void function, while we are passed a function
338 that returns a pointer. So we use a wrapper. See the command in
339 w32term.h about the need for ALIGN_STACK attribute. */
340 static void ALIGN_STACK
341 w32_beginthread_wrapper (void *arg
)
343 (void)thread_start_address (arg
);
347 sys_thread_create (sys_thread_t
*thread_ptr
, const char *name
,
348 thread_creation_function
*func
, void *arg
)
350 /* FIXME: Do threads that run Lisp require some minimum amount of
351 stack? Zero here means each thread will get the same amount as
352 the main program. On GNU/Linux, it seems like the stack is 2MB
353 by default, overridden by RLIMIT_STACK at program start time.
354 Not sure what to do with this. See also the comment in
355 w32proc.c:new_child. */
356 const unsigned stack_size
= 0;
359 thread_start_address
= func
;
361 /* We use _beginthread rather than CreateThread because the former
362 arranges for the thread handle to be automatically closed when
363 the thread exits, thus preventing handle leaks and/or the need to
364 track all the threads and close their handles when they exit.
365 Also, MSDN seems to imply that code which uses CRT _must_ call
366 _beginthread, although if that is true, we already violate that
367 rule in many places... */
368 thandle
= _beginthread (w32_beginthread_wrapper
, stack_size
, arg
);
369 if (thandle
== (uintptr_t)-1L)
372 /* Kludge alert! We use the Windows thread ID, an unsigned 32-bit
373 number, as the sys_thread_t type, because that ID is the only
374 unique identifier of a thread on Windows. But _beginthread
375 returns a handle of the thread, and there's no easy way of
376 getting the thread ID given a handle (GetThreadId is available
377 only since Vista, so we cannot use it portably). Fortunately,
378 the value returned by sys_thread_create is not used by its
379 callers; instead, run_thread, which runs in the context of the
380 new thread, calls sys_thread_self and uses its return value;
381 sys_thread_self in this implementation calls GetCurrentThreadId.
382 Therefore, we return some more or less arbitrary value of the
383 thread ID from this function. */
384 *thread_ptr
= thandle
& 0xFFFFFFFF;
389 sys_thread_yield (void)