1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
/* Fl_Lock.cxx
I would prefer that fltk contain the minimal amount of extra stuff
for doing threads. There are other portable thread wrapper libraries
out there and fltk should not be providing another. This file
is an attempt to make minimal additions and make them self-contained
in this source file.
Fl::lock() - recursive lock. Plus you must call this before the
first call to Fl::wait()/run() to initialize the thread system.
The lock is locked all the time except when Fl::wait() is waiting
for events.
Fl::unlock() - release the recursive lock.
Fl::awake(void*) - Causes Fl::wait() to return (with the lock locked)
even if there are no events ready.
Fl::thread_message() - returns an argument sent to an Fl::awake call,
or returns null if none. Warning: the current implementation only
has a one-entry queue and only returns the most recent value!
See also the Fl_Threads.h header file, which provides convienence
functions so you can create your own threads and mutexes.
*/
#include <fltk/Fl.h>
#include <config.h>
////////////////////////////////////////////////////////////////
#if defined(_WIN32)
#include <windows.h>
#include <process.h>
// these pointers are in Fl_win32.cxx:
extern void (*fl_lock_function)();
extern void (*fl_unlock_function)();
static DWORD main_thread;
CRITICAL_SECTION cs;
static void unlock_function() {
LeaveCriticalSection(&cs);
}
static void lock_function() {
EnterCriticalSection(&cs);
}
void Fl::lock() {
if (!main_thread)
InitializeCriticalSection(&cs);
lock_function();
if (!main_thread) {
fl_lock_function = lock_function;
fl_unlock_function = unlock_function;
main_thread = GetCurrentThreadId();
}
}
void Fl::unlock() {
unlock_function();
}
// when called from a thread, it causes FLTK to awake from Fl::wait()
void Fl::awake(void* msg) {
PostThreadMessage( main_thread, WM_USER, (WPARAM)msg, 0);
}
////////////////////////////////////////////////////////////////
#elif HAVE_PTHREAD
#include <unistd.h>
#include <pthread.h>
#ifdef PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
// Linux supports recursive locks, use them directly:
static pthread_mutex_t fltk_mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
static void lock_function() {
pthread_mutex_lock(&fltk_mutex);
}
void Fl::unlock() {
pthread_mutex_unlock(&fltk_mutex);
}
// this is needed for the Fl_Mutex constructor:
pthread_mutexattr_t Fl_Mutex_attrib = {PTHREAD_MUTEX_RECURSIVE_NP};
#else
// Make a recursive lock out of the pthread mutex:
static pthread_mutex_t fltk_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_t owner;
static int counter;
static void lock_function() {
if (!counter || owner != pthread_self()) {
pthread_mutex_lock(&fltk_mutex); owner = pthread_self();
}
counter++;
}
void Fl::unlock() {
if (!--counter) pthread_mutex_unlock(&fltk_mutex);
}
#endif
static int thread_filedes[2];
// these pointers are in Fl_x.cxx:
extern void (*fl_lock_function)();
extern void (*fl_unlock_function)();
static void* thread_message_;
void* Fl::thread_message() {
void* r = thread_message_;
thread_message_ = 0;
return r;
}
static void thread_awake_cb(int fd, void*) {
read(fd, &thread_message_, sizeof(void*));
}
void Fl::lock() {
lock_function();
if (!thread_filedes[1]) { // initialize the mt support
// Init threads communication pipe to let threads awake FLTK from wait
pipe(thread_filedes);
Fl::add_fd(thread_filedes[0], FL_READ, thread_awake_cb);
fl_lock_function = lock_function;
fl_unlock_function = Fl::unlock;
}
}
void Fl::awake(void* msg) {
write(thread_filedes[1], &msg, sizeof(void*));
}
#endif
|
