1 /* Unit tests for GMutex
2 * Copyright (C) 2011 Red Hat, Inc
3 * Author: Matthias Clasen
4 *
5 * SPDX-License-Identifier: LicenseRef-old-glib-tests
6 *
7 * This work is provided "as is"; redistribution and modification
8 * in whole or in part, in any medium, physical or electronic is
9 * permitted without restriction.
10 *
11 * This work 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.
14 *
15 * In no event shall the authors or contributors be liable for any
16 * direct, indirect, incidental, special, exemplary, or consequential
17 * damages (including, but not limited to, procurement of substitute
18 * goods or services; loss of use, data, or profits; or business
19 * interruption) however caused and on any theory of liability, whether
20 * in contract, strict liability, or tort (including negligence or
21 * otherwise) arising in any way out of the use of this software, even
22 * if advised of the possibility of such damage.
23 */
24
25 /* We are testing some deprecated APIs here */
26 #ifndef GLIB_DISABLE_DEPRECATION_WARNINGS
27 #define GLIB_DISABLE_DEPRECATION_WARNINGS
28 #endif
29
30 #include <glib.h>
31
32 #include <stdio.h>
33
34 static void
35 test_mutex1 (void)
36 {
37 GMutex mutex;
38
39 g_mutex_init (&mutex);
40 g_mutex_lock (&mutex);
41 g_mutex_unlock (&mutex);
42 g_mutex_lock (&mutex);
43 g_mutex_unlock (&mutex);
44 g_mutex_clear (&mutex);
45 }
46
47 static void
48 test_mutex2 (void)
49 {
50 static GMutex mutex;
51
52 g_mutex_lock (&mutex);
53 g_mutex_unlock (&mutex);
54 g_mutex_lock (&mutex);
55 g_mutex_unlock (&mutex);
56 }
57
58 static void
59 test_mutex3 (void)
60 {
61 GMutex *mutex;
62
63 mutex = g_mutex_new ();
64 g_mutex_lock (mutex);
65 g_mutex_unlock (mutex);
66 g_mutex_lock (mutex);
67 g_mutex_unlock (mutex);
68 g_mutex_free (mutex);
69 }
70
71 static void
72 test_mutex4 (void)
73 {
74 static GMutex mutex;
75 gboolean ret;
76
77 ret = g_mutex_trylock (&mutex);
78 g_assert (ret);
79
80 /* no guarantees that mutex is recursive, so could return 0 or 1 */
81 if (g_mutex_trylock (&mutex))
82 g_mutex_unlock (&mutex);
83
84 g_mutex_unlock (&mutex);
85 }
86
87 #define LOCKS 48
88 #define ITERATIONS 10000
89 #define THREADS 100
90
91
92 GThread *owners[LOCKS];
93 GMutex locks[LOCKS];
94
95 static void
96 acquire (gint nr)
97 {
98 GThread *self;
99
100 self = g_thread_self ();
101
102 if (!g_mutex_trylock (&locks[nr]))
103 {
104 if (g_test_verbose ())
105 g_printerr ("thread %p going to block on lock %d\n", self, nr);
106
107 g_mutex_lock (&locks[nr]);
108 }
109
110 g_assert (owners[nr] == NULL); /* hopefully nobody else is here */
111 owners[nr] = self;
112
113 /* let some other threads try to ruin our day */
114 g_thread_yield ();
115 g_thread_yield ();
116 g_thread_yield ();
117
118 g_assert (owners[nr] == self); /* hopefully this is still us... */
119 owners[nr] = NULL; /* make way for the next guy */
120
121 g_mutex_unlock (&locks[nr]);
122 }
123
124 static gpointer
125 thread_func (gpointer data)
126 {
127 gint i;
128 GRand *rand;
129
130 rand = g_rand_new ();
131
132 for (i = 0; i < ITERATIONS; i++)
133 acquire (g_rand_int_range (rand, 0, LOCKS));
134
135 g_rand_free (rand);
136
137 return NULL;
138 }
139
140 static void
141 test_mutex5 (void)
142 {
143 gint i;
144 GThread *threads[THREADS];
145
146 for (i = 0; i < LOCKS; i++)
147 g_mutex_init (&locks[i]);
148
149 for (i = 0; i < THREADS; i++)
150 threads[i] = g_thread_create (thread_func, NULL, TRUE, NULL);
151
152 for (i = 0; i < THREADS; i++)
153 g_thread_join (threads[i]);
154
155 for (i = 0; i < LOCKS; i++)
156 g_mutex_clear (&locks[i]);
157
158 for (i = 0; i < LOCKS; i++)
159 g_assert (owners[i] == NULL);
160 }
161
162 static gpointer
163 test_mutex_errno_func (gpointer data)
164 {
165 GMutex *m = data;
166
167 g_test_summary ("Validates that errno is not touched upon return");
168 g_test_bug ("https://gitlab.gnome.org/GNOME/glib/-/issues/3034");
169
170 for (unsigned int i = 0; i < 1000; i++)
171 {
172 errno = 0;
173 g_mutex_lock (m);
174 g_assert_cmpint (errno, ==, 0);
175
176 g_thread_yield ();
177
178 errno = 0;
179 g_mutex_unlock (m);
180 g_assert_cmpint (errno, ==, 0);
181
182 errno = 0;
183 if (g_mutex_trylock (m))
184 {
185 g_assert_cmpint (errno, ==, 0);
186
187 g_thread_yield ();
188
189 errno = 0;
190 g_mutex_unlock (m);
191 g_assert_cmpint (errno, ==, 0);
192 }
193 }
194
195 return NULL;
196 }
197
198 static void
199 test_mutex_errno (void)
200 {
201 gsize i;
202 GThread *threads[THREADS];
203 GMutex m;
204
205 g_mutex_init (&m);
206
207 for (i = 0; i < G_N_ELEMENTS (threads); i++)
208 {
209 threads[i] = g_thread_new ("test_mutex_errno",
210 test_mutex_errno_func, &m);
211 }
212
213 for (i = 0; i < G_N_ELEMENTS (threads); i++)
214 {
215 g_thread_join (threads[i]);
216 }
217 }
218
219 static gint count_to = 0;
220
221 static gboolean
222 do_addition (gint *value)
223 {
224 static GMutex lock;
225 gboolean more;
226
227 /* test performance of "good" cases (ie: short critical sections) */
228 g_mutex_lock (&lock);
229 if ((more = *value != count_to))
230 if (*value != -1)
231 (*value)++;
232 g_mutex_unlock (&lock);
233
234 return more;
235 }
236
237 static gpointer
238 addition_thread (gpointer value)
239 {
240 while (do_addition (value));
241
242 return NULL;
243 }
244
245 static void
246 test_mutex_perf (gconstpointer data)
247 {
248 const guint n_threads = GPOINTER_TO_UINT (data);
249 GThread *threads[THREADS];
250 gint64 start_time;
251 gdouble rate;
252 gint x = -1;
253 guint i;
254
255 count_to = g_test_perf () ? 100000000 : n_threads + 1;
256
257 g_assert (n_threads <= G_N_ELEMENTS (threads));
258
259 for (i = 0; n_threads > 0 && i < n_threads - 1; i++)
260 threads[i] = g_thread_create (addition_thread, &x, TRUE, NULL);
261
262 /* avoid measuring thread setup/teardown time */
263 start_time = g_get_monotonic_time ();
264 g_atomic_int_set (&x, 0);
265 addition_thread (&x);
266 g_assert_cmpint (g_atomic_int_get (&x), ==, count_to);
267 rate = g_get_monotonic_time () - start_time;
268 rate = x / rate;
269
270 for (i = 0; n_threads > 0 && i < n_threads - 1; i++)
271 g_thread_join (threads[i]);
272
273 g_test_maximized_result (rate, "%f mips", rate);
274 }
275
276 int
277 main (int argc, char *argv[])
278 {
279 g_test_init (&argc, &argv, NULL);
280
281 g_test_add_func ("/thread/mutex1", test_mutex1);
282 g_test_add_func ("/thread/mutex2", test_mutex2);
283 g_test_add_func ("/thread/mutex3", test_mutex3);
284 g_test_add_func ("/thread/mutex4", test_mutex4);
285 g_test_add_func ("/thread/mutex5", test_mutex5);
286 g_test_add_func ("/thread/mutex/errno", test_mutex_errno);
287
288 {
289 guint i;
290
291 g_test_add_data_func ("/thread/mutex/perf/uncontended", GUINT_TO_POINTER (0), test_mutex_perf);
292
293 for (i = 1; i <= 10; i++)
294 {
295 gchar name[80];
296 sprintf (name, "/thread/mutex/perf/contended/%u", i);
297 g_test_add_data_func (name, GUINT_TO_POINTER (i), test_mutex_perf);
298 }
299 }
300
301 return g_test_run ();
302 }