2 * Copyright © 2008 Ryan Lortie
3 * Copyright © 2010 Codethink Limited
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the licence, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the
17 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 * Boston, MA 02111-1307, USA.
20 * Author: Ryan Lortie <desrt@desrt.ca>
27 #include <glib/gmessages.h>
28 #include <glib/gatomic.h>
29 #include <glib/gslist.h>
30 #include <glib/gthread.h>
31 #include <glib/gslice.h>
33 #include "gthreadprivate.h"
36 #ifdef G_BIT_LOCK_FORCE_FUTEX_EMULATION
40 static GMutex g_futex_mutex
;
41 static GSList
*g_futex_address_list
= NULL
;
46 * We have headers for futex(2) on the build machine. This does not
47 * imply that every system that ever runs the resulting glib will have
48 * kernel support for futex, but you'd have to have a pretty old
49 * kernel in order for that not to be the case.
51 * If anyone actually gets bit by this, please file a bug. :)
53 #include <linux/futex.h>
54 #include <sys/syscall.h>
59 * @address: a pointer to an integer
60 * @value: the value that should be at @address
62 * Atomically checks that the value stored at @address is equal to
63 * @value and then blocks. If the value stored at @address is not
64 * equal to @value then this function returns immediately.
66 * To unblock, call g_futex_wake() on @address.
68 * This call may spuriously unblock (for example, in response to the
69 * process receiving a signal) but this is not guaranteed. Unlike the
70 * Linux system call of a similar name, there is no guarantee that a
71 * waiting process will unblock due to a g_futex_wake() call in a
75 g_futex_wait (const volatile gint
*address
,
78 syscall (__NR_futex
, address
, (gsize
) FUTEX_WAIT
, (gsize
) value
, NULL
);
83 * @address: a pointer to an integer
85 * Nominally, wakes one thread that is blocked in g_futex_wait() on
86 * @address (if any thread is currently waiting).
88 * As mentioned in the documention for g_futex_wait(), spurious
89 * wakeups may occur. As such, this call may result in more than one
90 * thread being woken up.
93 g_futex_wake (const volatile gint
*address
)
95 syscall (__NR_futex
, address
, (gsize
) FUTEX_WAKE
, (gsize
) 1, NULL
);
100 /* emulate futex(2) */
103 const volatile gint
*address
;
109 g_futex_find_address (const volatile gint
*address
)
113 for (node
= g_futex_address_list
; node
; node
= node
->next
)
115 WaitAddress
*waiter
= node
->data
;
117 if (waiter
->address
== address
)
125 g_futex_wait (const volatile gint
*address
,
128 g_mutex_lock (&g_futex_mutex
);
129 if G_LIKELY (g_atomic_int_get (address
) == value
)
133 if ((waiter
= g_futex_find_address (address
)) == NULL
)
135 waiter
= g_slice_new (WaitAddress
);
136 waiter
->address
= address
;
137 g_cond_init (&waiter
->wait_queue
);
138 waiter
->ref_count
= 0;
139 g_futex_address_list
=
140 g_slist_prepend (g_futex_address_list
, waiter
);
144 g_cond_wait (&waiter
->wait_queue
, &g_futex_mutex
);
146 if (!--waiter
->ref_count
)
148 g_futex_address_list
=
149 g_slist_remove (g_futex_address_list
, waiter
);
150 g_cond_clear (&waiter
->wait_queue
);
151 g_slice_free (WaitAddress
, waiter
);
154 g_mutex_unlock (&g_futex_mutex
);
158 g_futex_wake (const volatile gint
*address
)
162 /* need to lock here for two reasons:
163 * 1) need to acquire/release lock to ensure waiter is not in
164 * the process of registering a wait
165 * 2) need to -stay- locked until the end to ensure a wake()
166 * in another thread doesn't cause 'waiter' to stop existing
168 g_mutex_lock (&g_futex_mutex
);
169 if ((waiter
= g_futex_find_address (address
)))
170 g_cond_signal (&waiter
->wait_queue
);
171 g_mutex_unlock (&g_futex_mutex
);
175 #define CONTENTION_CLASSES 11
176 static volatile gint g_bit_lock_contended
[CONTENTION_CLASSES
];
178 #if (defined (i386) || defined (__amd64__))
179 #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)
180 #define USE_ASM_GOTO 1
186 * @address: a pointer to an integer
187 * @lock_bit: a bit value between 0 and 31
189 * Sets the indicated @lock_bit in @address. If the bit is already
190 * set, this call will block until g_bit_unlock() unsets the
193 * Attempting to lock on two different bits within the same integer is
194 * not supported and will very probably cause deadlocks.
196 * The value of the bit that is set is (1u << @bit). If @bit is not
197 * between 0 and 31 then the result is undefined.
199 * This function accesses @address atomically. All other accesses to
200 * @address must be atomic in order for this function to work
206 g_bit_lock (volatile gint
*address
,
211 asm volatile goto ("lock bts %1, (%0)\n"
214 : "r" (address
), "r" (lock_bit
)
221 guint mask
= 1u << lock_bit
;
224 v
= g_atomic_int_get (address
);
227 guint
class = ((gsize
) address
) % G_N_ELEMENTS (g_bit_lock_contended
);
229 g_atomic_int_add (&g_bit_lock_contended
[class], +1);
230 g_futex_wait (address
, v
);
231 g_atomic_int_add (&g_bit_lock_contended
[class], -1);
236 guint mask
= 1u << lock_bit
;
240 v
= g_atomic_int_or (address
, mask
);
244 guint
class = ((gsize
) address
) % G_N_ELEMENTS (g_bit_lock_contended
);
246 g_atomic_int_add (&g_bit_lock_contended
[class], +1);
247 g_futex_wait (address
, v
);
248 g_atomic_int_add (&g_bit_lock_contended
[class], -1);
257 * @address: a pointer to an integer
258 * @lock_bit: a bit value between 0 and 31
260 * Sets the indicated @lock_bit in @address, returning %TRUE if
261 * successful. If the bit is already set, returns %FALSE immediately.
263 * Attempting to lock on two different bits within the same integer is
266 * The value of the bit that is set is (1u << @bit). If @bit is not
267 * between 0 and 31 then the result is undefined.
269 * This function accesses @address atomically. All other accesses to
270 * @address must be atomic in order for this function to work
273 * Returns: %TRUE if the lock was acquired
278 g_bit_trylock (volatile gint
*address
,
284 asm volatile ("lock bts %2, (%1)\n"
288 : "r" (address
), "r" (lock_bit
)
293 guint mask
= 1u << lock_bit
;
296 v
= g_atomic_int_or (address
, mask
);
304 * @address: a pointer to an integer
305 * @lock_bit: a bit value between 0 and 31
307 * Clears the indicated @lock_bit in @address. If another thread is
308 * currently blocked in g_bit_lock() on this same bit then it will be
311 * This function accesses @address atomically. All other accesses to
312 * @address must be atomic in order for this function to work
318 g_bit_unlock (volatile gint
*address
,
322 asm volatile ("lock btr %1, (%0)"
324 : "r" (address
), "r" (lock_bit
)
327 guint mask
= 1u << lock_bit
;
329 g_atomic_int_and (address
, ~mask
);
333 guint
class = ((gsize
) address
) % G_N_ELEMENTS (g_bit_lock_contended
);
335 if (g_atomic_int_get (&g_bit_lock_contended
[class]))
336 g_futex_wake (address
);
341 /* We emulate pointer-sized futex(2) because the kernel API only
344 * We assume that the 'interesting' part is always the lower order bits.
345 * This assumption holds because pointer bitlocks are restricted to
346 * using the low order bits of the pointer as the lock.
348 * On 32 bits, there is nothing to do since the pointer size is equal to
349 * the integer size. On little endian the lower-order bits don't move,
350 * so do nothing. Only on 64bit big endian do we need to do a bit of
351 * pointer arithmetic: the low order bits are shifted by 4 bytes. We
352 * have a helper function that always does the right thing here.
354 * Since we always consider the low-order bits of the integer value, a
355 * simple cast from (gsize) to (guint) always takes care of that.
357 * After that, pointer-sized futex becomes as simple as:
359 * g_futex_wait (g_futex_int_address (address), (guint) value);
363 * g_futex_wake (g_futex_int_address (int_address));
365 static const volatile gint
*
366 g_futex_int_address (const volatile void *address
)
368 const volatile gint
*int_address
= address
;
370 /* this implementation makes these (reasonable) assumptions: */
371 G_STATIC_ASSERT (G_BYTE_ORDER
== G_LITTLE_ENDIAN
||
372 (G_BYTE_ORDER
== G_BIG_ENDIAN
&&
374 (sizeof (gpointer
) == 4 || sizeof (gpointer
) == 8)));
376 #if G_BYTE_ORDER == G_BIG_ENDIAN && GLIB_SIZEOF_VOID_P == 8
384 * g_pointer_bit_lock:
385 * @address: a pointer to a #gpointer-sized value
386 * @lock_bit: a bit value between 0 and 31
388 * This is equivalent to g_bit_lock, but working on pointers (or other
389 * pointer-sized values).
391 * For portability reasons, you may only lock on the bottom 32 bits of
397 (g_pointer_bit_lock
) (volatile void *address
,
400 g_return_if_fail (lock_bit
< 32);
405 asm volatile goto ("lock bts %1, (%0)\n"
408 : "r" (address
), "r" ((gsize
) lock_bit
)
415 volatile gsize
*pointer_address
= address
;
416 gsize mask
= 1u << lock_bit
;
419 v
= (gsize
) g_atomic_pointer_get (pointer_address
);
422 guint
class = ((gsize
) address
) % G_N_ELEMENTS (g_bit_lock_contended
);
424 g_atomic_int_add (&g_bit_lock_contended
[class], +1);
425 g_futex_wait (g_futex_int_address (address
), v
);
426 g_atomic_int_add (&g_bit_lock_contended
[class], -1);
431 volatile gsize
*pointer_address
= address
;
432 gsize mask
= 1u << lock_bit
;
436 v
= g_atomic_pointer_or (pointer_address
, mask
);
440 guint
class = ((gsize
) address
) % G_N_ELEMENTS (g_bit_lock_contended
);
442 g_atomic_int_add (&g_bit_lock_contended
[class], +1);
443 g_futex_wait (g_futex_int_address (address
), (guint
) v
);
444 g_atomic_int_add (&g_bit_lock_contended
[class], -1);
453 * g_pointer_bit_trylock:
454 * @address: a pointer to a #gpointer-sized value
455 * @lock_bit: a bit value between 0 and 31
457 * This is equivalent to g_bit_trylock, but working on pointers (or
458 * other pointer-sized values).
460 * For portability reasons, you may only lock on the bottom 32 bits of
463 * Returns: %TRUE if the lock was acquired
468 (g_pointer_bit_trylock
) (volatile void *address
,
471 g_return_val_if_fail (lock_bit
< 32, FALSE
);
477 asm volatile ("lock bts %2, (%1)\n"
481 : "r" (address
), "r" ((gsize
) lock_bit
)
486 volatile gsize
*pointer_address
= address
;
487 gsize mask
= 1u << lock_bit
;
490 g_return_val_if_fail (lock_bit
< 32, FALSE
);
492 v
= g_atomic_pointer_or (pointer_address
, mask
);
500 * g_pointer_bit_unlock:
501 * @address: a pointer to a #gpointer-sized value
502 * @lock_bit: a bit value between 0 and 31
504 * This is equivalent to g_bit_unlock, but working on pointers (or other
505 * pointer-sized values).
507 * For portability reasons, you may only lock on the bottom 32 bits of
513 (g_pointer_bit_unlock
) (volatile void *address
,
516 g_return_if_fail (lock_bit
< 32);
520 asm volatile ("lock btr %1, (%0)"
522 : "r" (address
), "r" ((gsize
) lock_bit
)
525 volatile gsize
*pointer_address
= address
;
526 gsize mask
= 1u << lock_bit
;
528 g_atomic_pointer_and (pointer_address
, ~mask
);
532 guint
class = ((gsize
) address
) % G_N_ELEMENTS (g_bit_lock_contended
);
533 if (g_atomic_int_get (&g_bit_lock_contended
[class]))
534 g_futex_wake (g_futex_int_address (address
));