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
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
|
dnl Defines the macro CAIRO_CONFIGURE_PTHREAD to find a suitable
dnl pthread implementation. There are two levels of pthread conformance
dnl we are looking for:
dnl
dnl a) A minimal level denoted by -DCAIRO_HAS_PTHREAD=1: This level
dnl requires mutex and recursive mutexattr support. If possible we try
dnl to use weakly linked stubs from libc over the real pthread library.
dnl This level is required by the cairo library proper. If the user
dnl invokes configure with --enable-pthread=yes or
dnl --enable-pthread=always then we avoid trying to use weak stubs.
dnl
dnl b) A full level denoted by -DCAIRO_HAS_REAL_PTHREAD=1: This level
dnl requires full support from a real pthread library, including thread
dnl creation, joins, thread attribtues, etc. This level is required by
dnl multithreaded applications using cairo, such as the test suite
dnl binaries and cairo utilities.
dnl
dnl Usage:
dnl CAIRO_ENABLE(pthread, pthread, <default yes|no|auto|always>,
dnl [CAIRO_CONFIGURE_PTHREAD])
dnl
dnl This should be invoked near the end of configure.ac so that
dnl the pthread specific CFLAGS and LIBS end up at the front
dnl of CAIRO_CFLAGS and CAIRO_LIBS -- this helps ensure that we
dnl really do get non-weak symbols from the actual pthread library
dnl rather than possible stubs in other libraries.
dnl
dnl The user can override the choices made by
dnl CAIRO_CONFIGURE_PTHREAD by using --enable-pthread=yes and
dnl giving PTHREAD_CFLAGS and PTHREAD_LIBS to configure.
dnl
dnl Sets environment variables:
dnl use_pthread="yes" | "no (<errmsg>)"
dnl have_pthread="yes" | "no (<errmsg)"
dnl have_real_pthread="yes" | "no (<errmsg)"
dnl pthread_{CFLAGS,LIBS,REQUIRES}
dnl real_pthread_{CFLAGS,LIBS}
dnl
dnl Autoconfigured defines in config.h (conditional):
dnl CAIRO_HAS_PTHREAD
dnl CAIRO_HAS_REAL_PTHREAD
dnl
dnl -----------------------------------------------------------------------
dnl A program to test all the pthread features we need to be able to
dnl compile libcairo itself. We could test the features independently,
dnl but we need all of them anyway.
m4_define([libcairo_pthread_program],[dnl
#ifndef _GNU_SOURCE
#define _GNU_SOURCE /* for PTHREAD_MUTEX_INITIALIZER under linux */
#endif
#include <pthread.h>
pthread_mutex_t test_mutex_initializer = PTHREAD_MUTEX_INITIALIZER;
int test_mutex (void)
{
int x = 0;
pthread_mutex_t mutex;
x |= pthread_mutex_init (&mutex, NULL);
x |= pthread_mutex_lock (&mutex);
x |= pthread_mutex_unlock (&mutex);
x |= pthread_mutex_destroy (&mutex);
return 0;
}
int test_mutex_attr (void)
{
int x = 0;
pthread_mutexattr_t attr;
pthread_mutex_t mutex;
x |= pthread_mutexattr_init (&attr);
x |= pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_RECURSIVE);
x |= pthread_mutex_init (&mutex, &attr);
x |= pthread_mutex_lock (&mutex);
x |= pthread_mutex_unlock (&mutex);
x |= pthread_mutex_destroy (&mutex);
x |= pthread_mutexattr_destroy (&attr);
return x;
}])
dnl -----------------------------------------------------------------------
dnl A program to test all the features we want to be able to run the test
dnl suite or other thready cairo applications that want real threads.
m4_define([testsuite_pthread_program],[dnl
libcairo_pthread_program
pthread_once_t once_control = PTHREAD_ONCE_INIT;
void test_once_init (void) {}
int test_once (void)
{
return pthread_once (&once_control, test_once_init);
}
pthread_key_t test_specific_key;
int test_specific (void)
{
int x = 0;
x |= pthread_key_create (&test_specific_key, NULL);
x |= pthread_setspecific (test_specific_key, NULL);
x |= pthread_getspecific (test_specific_key) != NULL;
return x;
}
void cleaner (void *arg) { (void)arg; }
void *
test_thread_main (void *arg)
{
pthread_cleanup_push (cleaner, arg);
pthread_exit (arg);
pthread_cleanup_pop (1);
return arg;
}
int
test_threads (void)
{
int x = 0;
pthread_t thread;
pthread_attr_t attr;
void *arg = NULL;
x |= pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
x |= pthread_create (&thread, &attr, test_thread_main, arg);
x |= pthread_equal (pthread_self(), thread);
x |= pthread_join (thread, &arg);
x |= pthread_attr_destroy (&attr);
return x;
}])
dnl -----------------------------------------------------------------------
dnl CAIRO_CHECK_PTHREAD(tag, cflags, libs, program, true-action, false-action)
dnl Set <tag>_{CFLAGS,LIBS} to {<cflags>,<libs>} if we can compile and link
dnl <program> with the given flags and libs. Execute <true-action> on
dnl success and <false-action> on failure.
AC_DEFUN([CAIRO_CHECK_PTHREAD],[dnl
CAIRO_CC_TRY_LINK_WITH_ENV_SILENT(
[CFLAGS="$2";
LIBS="$3"],
[$4],
[$1_CFLAGS="$CFLAGS";
$1_LIBS="$LIBS";
$5],
[$1_CFLAGS="";
$1_LIBS="";
$6])
])
dnl CAIRO_CONFIGURE_PTHREADS(): Look for pthreads.
dnl
dnl If the user specifies PTHREAD_CFLAGS and PTHREAD_LIBS then we use
dnl those. Otherwise we try CFLAGS=-D_REENTRANT and LIBS=-lpthread for
dnl full pthread support, and look for stubs in libc for the minimal
dnl pthread support.
dnl
dnl CFLAGS=-D_REENTRANT LIBS=-lpthread has been tested to work on:
dnl
dnl Solaris 9 (5.9) Sun C 5.8 Patch 121015-04 2007/01/10
dnl OpenSolaris (5.11) Sun C 5.9 Patch 124868-08 2008/11/25
dnl OpenSolaris (5.11) clang version 1.1 (trunk 90017)
dnl Tru64/OSF1 V5.1 Compaq C V6.5-003
dnl Mac OS X 10.5.5 gcc 4.0.1 (Apple Inc. build 5465)
dnl Mac OS X 10.6 gcc 4.2.1 (Apple Inc. build 5659)
dnl FreeBSD 7.2 gcc 4.2
dnl OpenBSD 4.5 gcc 3.3.5 (propolice)
dnl Debian Linux (Etch) gcc 4.3
dnl
dnl Thread support is also in various libcs directly, so often using no
dnl flags at all works as well, but unfortunately Solaris 9 has
dnl practically _all_ of libpthread stubbed out in libc, so we cannot
dnl distinguish between a working libpthread and a stubbed out one by a
dnl link-only test.
dnl
dnl We also explicitly do not link to pthread-stubs or whatever other
dnl third-party stubs library, since that forces cairo clients to be
dnl extra careful when giving both libcairo and libpthread on the
dnl command line: the user would have to use "-lpthread -lcairo" rather
dnl than the more common "-lcairo -lpthread" to not accidentally use
dnl stubs pulled in by libcairo everywhere in the application. We
dnl might also need to have a way to teach pkg-config about library
dnl ordering constraints which aren't actual dependencies, and at this
dnl point it just starts doing my head in.
dnl
dnl If your unix-like doesn't work with the secret handshake
dnl -D_REENTRANT -lpthread and you can actually compile the rest of
dnl cairo just fine otherwise, please take a moment complain loudly
dnl to the cairo mailing list!
dnl
AC_DEFUN([CAIRO_CONFIGURE_PTHREAD],[dnl
dnl Try to use the user's PTHREAD_LIBS/CFLAGS
dnl if they're available.
if test "x$PTHREAD_CFLAGS" = "x"; then
PTHREAD_CFLAGS="-D_REENTRANT"
fi
if test "x$PTHREAD_LIBS" = "x"; then
PTHREAD_LIBS="-lpthread"
fi
dnl First try to find the real pthreads.
CAIRO_CHECK_PTHREAD(
[real_pthread], [$PTHREAD_CFLAGS], [$PTHREAD_LIBS],
[testsuite_pthread_program],
[have_real_pthread=yes],
[have_real_pthread=no])
if test "x$have_real_pthread" != "xyes"; then
dnl Give -pthread a go.
CAIRO_CHECK_PTHREAD(
[real_pthread], [-pthread], [],
[testsuite_pthread_program],
[have_real_pthread=yes],
[have_real_pthread="no (can't link with -lpthread or -pthread)"])
fi
PTHREAD_CFLAGS=
PTHREAD_LIBS=
dnl Check if we can use libc's stubs in libcairo.
dnl Only do this if the user hasn't explicitly enabled
dnl pthreads, but is relying on automatic configuration.
have_pthread="no"
if test "x$enable_pthread" != "xyes"; then
CAIRO_CHECK_PTHREAD(
[pthread], [-D_REENTRANT], [],
[libcairo_pthread_program],
[have_pthread=yes],
[])
fi
dnl Default to using the real pthreads for libcairo.
if test "x$have_pthread" != "xyes"; then
have_pthread="$have_real_pthread";
pthread_CFLAGS="$real_pthread_CFLAGS";
pthread_LIBS="$real_pthread_LIBS";
fi
dnl Tell autoconf about the results.
if test "x$have_real_pthread" = "xyes"; then
AC_DEFINE([CAIRO_HAS_REAL_PTHREAD], 1,
[Define to 1 if we have full pthread support])
fi
if test "x$have_pthread" = "xyes"; then
AC_DEFINE([CAIRO_HAS_PTHREAD], 1,
[Define to 1 f we have minimal pthread support])
fi
dnl Make sure we scored some pthreads.
if test "x$enable_pthread" = "xyes" -a "x$have_pthread" != "xyes"; then
AC_MSG_ERROR([pthread requested but not found])
fi
dnl Set the output variables for CAIRO_ENABLE.
use_pthread="$have_pthread"
pthread_REQUIRES=""
])
|
