X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=glib%2Fgatomic.c;h=30a5c5d51f22af55eeb107a2d7ebd15eecb24695;hb=2a53b4d0e2c98a14aedf31e38f0ad1fb2e8fe26f;hp=845c8668658dcc1fc0bde7d690ac37a6105f6023;hpb=631d0c3534661e549f7df18fbb9832bdf19c5eaf;p=platform%2Fupstream%2Fglib.git diff --git a/glib/gatomic.c b/glib/gatomic.c index 845c866..30a5c5d 100644 --- a/glib/gatomic.c +++ b/glib/gatomic.c @@ -1,34 +1,25 @@ -/* GLIB - Library of useful routines for C programming - * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald +/* + * Copyright © 2011 Ryan Lortie * - * g_atomic_*: atomic operations. - * Copyright (C) 2003 Sebastian Wilhelmi - * Copyright (C) 2007 Nokia Corporation + * This library is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2 of the + * licence, or (at your option) any later version. * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of + * This library is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the - * Free Software Foundation, Inc., 59 Temple Place - Suite 330, - * Boston, MA 02111-1307, USA. + * License along with this library; if not, see . + * + * Author: Ryan Lortie */ #include "config.h" -#if defined (G_ATOMIC_ARM) -#include -#endif - #include "gatomic.h" -#include "gthreadprivate.h" /** * SECTION:atomic_operations @@ -36,1150 +27,891 @@ * @short_description: basic atomic integer and pointer operations * @see_also: #GMutex * - * The following functions can be used to atomically access integers and - * pointers. They are implemented as inline assembler function on most - * platforms and use slower fall-backs otherwise. Using them can sometimes - * save you from using a performance-expensive #GMutex to protect the - * integer or pointer. - * - * The most important usage is reference counting. Using - * g_atomic_int_inc() and g_atomic_int_dec_and_test() makes reference - * counting a very fast operation. - * - * You must not directly read integers or pointers concurrently - * accessed by multiple threads, but use the atomic accessor functions - * instead. That is, always use g_atomic_int_get() and g_atomic_pointer_get() - * for read outs. They provide the neccessary synchonization mechanisms - * like memory barriers to access memory locations concurrently. - * - * - * If you are using those functions for anything apart from - * simple reference counting, you should really be aware of the implications - * of doing that. There are literally thousands of ways to shoot yourself - * in the foot. So if in doubt, use a #GMutex. If you don't know, what - * memory barriers are, do not use anything but g_atomic_int_inc() and - * g_atomic_int_dec_and_test(). - * - * - * It is not safe to set an integer or pointer just by assigning - * to it, when it is concurrently accessed by other threads with the following - * functions. Use g_atomic_int_compare_and_exchange() or - * g_atomic_pointer_compare_and_exchange() respectively. - * + * The following is a collection of compiler macros to provide atomic + * access to integer and pointer-sized values. + * + * The macros that have 'int' in the name will operate on pointers to + * #gint and #guint. The macros with 'pointer' in the name will operate + * on pointers to any pointer-sized value, including #gsize. There is + * no support for 64bit operations on platforms with 32bit pointers + * because it is not generally possible to perform these operations + * atomically. + * + * The get, set and exchange operations for integers and pointers + * nominally operate on #gint and #gpointer, respectively. Of the + * arithmetic operations, the 'add' operation operates on (and returns) + * signed integer values (#gint and #gssize) and the 'and', 'or', and + * 'xor' operations operate on (and return) unsigned integer values + * (#guint and #gsize). + * + * All of the operations act as a full compiler and (where appropriate) + * hardware memory barrier. Acquire and release or producer and + * consumer barrier semantics are not available through this API. + * + * It is very important that all accesses to a particular integer or + * pointer be performed using only this API and that different sizes of + * operation are not mixed or used on overlapping memory regions. Never + * read or assign directly from or to a value -- always use this API. + * + * For simple reference counting purposes you should use + * g_atomic_int_inc() and g_atomic_int_dec_and_test(). Other uses that + * fall outside of simple reference counting patterns are prone to + * subtle bugs and occasionally undefined behaviour. It is also worth + * noting that since all of these operations require global + * synchronisation of the entire machine, they can be quite slow. In * the case of performing multiple atomic operations it can often be + * faster to simply acquire a mutex lock around the critical area, + * perform the operations normally and then release the lock. + **/ + +/** + * G_ATOMIC_LOCK_FREE: + * + * This macro is defined if the atomic operations of GLib are + * implemented using real hardware atomic operations. This means that + * the GLib atomic API can be used between processes and safely mixed + * with other (hardware) atomic APIs. + * + * If this macro is not defined, the atomic operations may be + * emulated using a mutex. In that case, the GLib atomic operations are + * only atomic relative to themselves and within a single process. + **/ + +/* NOTE CAREFULLY: + * + * This file is the lowest-level part of GLib. + * + * Other lowlevel parts of GLib (threads, slice allocator, g_malloc, + * messages, etc) call into these functions and macros to get work done. + * + * As such, these functions can not call back into any part of GLib + * without risking recursion. */ -#if defined (__GNUC__) -# if defined (G_ATOMIC_I486) -/* Adapted from CVS version 1.10 of glibc's sysdeps/i386/i486/bits/atomic.h +#ifdef G_ATOMIC_LOCK_FREE + +/* if G_ATOMIC_LOCK_FREE was defined by ./configure then we MUST + * implement the atomic operations in a lock-free manner. */ + +#if defined (__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4) +/** + * g_atomic_int_get: + * @atomic: a pointer to a #gint or #guint + * + * Gets the current value of @atomic. + * + * This call acts as a full compiler and hardware + * memory barrier (before the get). + * + * Returns: the value of the integer + * + * Since: 2.4 + **/ gint -g_atomic_int_exchange_and_add (volatile gint G_GNUC_MAY_ALIAS *atomic, - gint val) +(g_atomic_int_get) (const volatile gint *atomic) { - gint result; - - __asm__ __volatile__ ("lock; xaddl %0,%1" - : "=r" (result), "=m" (*atomic) - : "0" (val), "m" (*atomic)); - return result; + return g_atomic_int_get (atomic); } - + +/** + * g_atomic_int_set: + * @atomic: a pointer to a #gint or #guint + * @newval: a new value to store + * + * Sets the value of @atomic to @newval. + * + * This call acts as a full compiler and hardware + * memory barrier (after the set). + * + * Since: 2.4 + */ void -g_atomic_int_add (volatile gint G_GNUC_MAY_ALIAS *atomic, - gint val) +(g_atomic_int_set) (volatile gint *atomic, + gint newval) { - __asm__ __volatile__ ("lock; addl %1,%0" - : "=m" (*atomic) - : "ir" (val), "m" (*atomic)); + g_atomic_int_set (atomic, newval); } -gboolean -g_atomic_int_compare_and_exchange (volatile gint G_GNUC_MAY_ALIAS *atomic, - gint oldval, - gint newval) +/** + * g_atomic_int_inc: + * @atomic: a pointer to a #gint or #guint + * + * Increments the value of @atomic by 1. + * + * Think of this operation as an atomic version of `{ *atomic += 1; }`. + * + * This call acts as a full compiler and hardware memory barrier. + * + * Since: 2.4 + **/ +void +(g_atomic_int_inc) (volatile gint *atomic) { - gint result; - - __asm__ __volatile__ ("lock; cmpxchgl %2, %1" - : "=a" (result), "=m" (*atomic) - : "r" (newval), "m" (*atomic), "0" (oldval)); - - return result == oldval; + g_atomic_int_inc (atomic); } -/* The same code as above, as on i386 gpointer is 32 bit as well. - * Duplicating the code here seems more natural than casting the - * arguments and calling the former function */ - +/** + * g_atomic_int_dec_and_test: + * @atomic: a pointer to a #gint or #guint + * + * Decrements the value of @atomic by 1. + * + * Think of this operation as an atomic version of + * `{ *atomic -= 1; return (*atomic == 0); }`. + * + * This call acts as a full compiler and hardware memory barrier. + * + * Returns: %TRUE if the resultant value is zero + * + * Since: 2.4 + **/ gboolean -g_atomic_pointer_compare_and_exchange (volatile gpointer G_GNUC_MAY_ALIAS *atomic, - gpointer oldval, - gpointer newval) +(g_atomic_int_dec_and_test) (volatile gint *atomic) { - gpointer result; - - __asm__ __volatile__ ("lock; cmpxchgl %2, %1" - : "=a" (result), "=m" (*atomic) - : "r" (newval), "m" (*atomic), "0" (oldval)); - - return result == oldval; + return g_atomic_int_dec_and_test (atomic); } -# elif defined (G_ATOMIC_SPARCV9) -/* Adapted from CVS version 1.3 of glibc's sysdeps/sparc/sparc64/bits/atomic.h - */ -# define ATOMIC_INT_CMP_XCHG(atomic, oldval, newval) \ - ({ \ - gint __result; \ - __asm__ __volatile__ ("cas [%4], %2, %0" \ - : "=r" (__result), "=m" (*(atomic)) \ - : "r" (oldval), "m" (*(atomic)), "r" (atomic),\ - "0" (newval)); \ - __result == oldval; \ - }) - -# if GLIB_SIZEOF_VOID_P == 4 /* 32-bit system */ +/** + * g_atomic_int_compare_and_exchange: + * @atomic: a pointer to a #gint or #guint + * @oldval: the value to compare with + * @newval: the value to conditionally replace with + * + * Compares @atomic to @oldval and, if equal, sets it to @newval. + * If @atomic was not equal to @oldval then no change occurs. + * + * This compare and exchange is done atomically. + * + * Think of this operation as an atomic version of + * `{ if (*atomic == oldval) { *atomic = newval; return TRUE; } else return FALSE; }`. + * + * This call acts as a full compiler and hardware memory barrier. + * + * Returns: %TRUE if the exchange took place + * + * Since: 2.4 + **/ gboolean -g_atomic_pointer_compare_and_exchange (volatile gpointer G_GNUC_MAY_ALIAS *atomic, - gpointer oldval, - gpointer newval) +(g_atomic_int_compare_and_exchange) (volatile gint *atomic, + gint oldval, + gint newval) { - gpointer result; - __asm__ __volatile__ ("cas [%4], %2, %0" - : "=r" (result), "=m" (*atomic) - : "r" (oldval), "m" (*atomic), "r" (atomic), - "0" (newval)); - return result == oldval; + return g_atomic_int_compare_and_exchange (atomic, oldval, newval); } -# elif GLIB_SIZEOF_VOID_P == 8 /* 64-bit system */ -gboolean -g_atomic_pointer_compare_and_exchange (volatile gpointer G_GNUC_MAY_ALIAS *atomic, - gpointer oldval, - gpointer newval) + +/** + * g_atomic_int_add: + * @atomic: a pointer to a #gint or #guint + * @val: the value to add + * + * Atomically adds @val to the value of @atomic. + * + * Think of this operation as an atomic version of + * `{ tmp = *atomic; *atomic += val; return tmp; }`. + * + * This call acts as a full compiler and hardware memory barrier. + * + * Before version 2.30, this function did not return a value + * (but g_atomic_int_exchange_and_add() did, and had the same meaning). + * + * Returns: the value of @atomic before the add, signed + * + * Since: 2.4 + **/ +gint +(g_atomic_int_add) (volatile gint *atomic, + gint val) { - gpointer result; - gpointer *a = atomic; - __asm__ __volatile__ ("casx [%4], %2, %0" - : "=r" (result), "=m" (*a) - : "r" (oldval), "m" (*a), "r" (a), - "0" (newval)); - return result == oldval; + return g_atomic_int_add (atomic, val); } -# else /* What's that */ -# error "Your system has an unsupported pointer size" -# endif /* GLIB_SIZEOF_VOID_P */ -# define G_ATOMIC_MEMORY_BARRIER \ - __asm__ __volatile__ ("membar #LoadLoad | #LoadStore" \ - " | #StoreLoad | #StoreStore" : : : "memory") - -# elif defined (G_ATOMIC_ALPHA) -/* Adapted from CVS version 1.3 of glibc's sysdeps/alpha/bits/atomic.h - */ -# define ATOMIC_INT_CMP_XCHG(atomic, oldval, newval) \ - ({ \ - gint __result; \ - gint __prev; \ - __asm__ __volatile__ ( \ - " mb\n" \ - "1: ldl_l %0,%2\n" \ - " cmpeq %0,%3,%1\n" \ - " beq %1,2f\n" \ - " mov %4,%1\n" \ - " stl_c %1,%2\n" \ - " beq %1,1b\n" \ - " mb\n" \ - "2:" \ - : "=&r" (__prev), \ - "=&r" (__result) \ - : "m" (*(atomic)), \ - "Ir" (oldval), \ - "Ir" (newval) \ - : "memory"); \ - __result != 0; \ - }) -# if GLIB_SIZEOF_VOID_P == 4 /* 32-bit system */ -gboolean -g_atomic_pointer_compare_and_exchange (volatile gpointer G_GNUC_MAY_ALIAS *atomic, - gpointer oldval, - gpointer newval) + +/** + * g_atomic_int_and: + * @atomic: a pointer to a #gint or #guint + * @val: the value to 'and' + * + * Performs an atomic bitwise 'and' of the value of @atomic and @val, + * storing the result back in @atomic. + * + * This call acts as a full compiler and hardware memory barrier. + * + * Think of this operation as an atomic version of + * `{ tmp = *atomic; *atomic &= val; return tmp; }`. + * + * Returns: the value of @atomic before the operation, unsigned + * + * Since: 2.30 + **/ +guint +(g_atomic_int_and) (volatile guint *atomic, + guint val) { - gint result; - gpointer prev; - __asm__ __volatile__ ( - " mb\n" - "1: ldl_l %0,%2\n" - " cmpeq %0,%3,%1\n" - " beq %1,2f\n" - " mov %4,%1\n" - " stl_c %1,%2\n" - " beq %1,1b\n" - " mb\n" - "2:" - : "=&r" (prev), - "=&r" (result) - : "m" (*atomic), - "Ir" (oldval), - "Ir" (newval) - : "memory"); - return result != 0; + return g_atomic_int_and (atomic, val); } -# elif GLIB_SIZEOF_VOID_P == 8 /* 64-bit system */ -gboolean -g_atomic_pointer_compare_and_exchange (volatile gpointer G_GNUC_MAY_ALIAS *atomic, - gpointer oldval, - gpointer newval) + +/** + * g_atomic_int_or: + * @atomic: a pointer to a #gint or #guint + * @val: the value to 'or' + * + * Performs an atomic bitwise 'or' of the value of @atomic and @val, + * storing the result back in @atomic. + * + * Think of this operation as an atomic version of + * `{ tmp = *atomic; *atomic |= val; return tmp; }`. + * + * This call acts as a full compiler and hardware memory barrier. + * + * Returns: the value of @atomic before the operation, unsigned + * + * Since: 2.30 + **/ +guint +(g_atomic_int_or) (volatile guint *atomic, + guint val) { - gint result; - gpointer prev; - __asm__ __volatile__ ( - " mb\n" - "1: ldq_l %0,%2\n" - " cmpeq %0,%3,%1\n" - " beq %1,2f\n" - " mov %4,%1\n" - " stq_c %1,%2\n" - " beq %1,1b\n" - " mb\n" - "2:" - : "=&r" (prev), - "=&r" (result) - : "m" (*atomic), - "Ir" (oldval), - "Ir" (newval) - : "memory"); - return result != 0; + return g_atomic_int_or (atomic, val); } -# else /* What's that */ -# error "Your system has an unsupported pointer size" -# endif /* GLIB_SIZEOF_VOID_P */ -# define G_ATOMIC_MEMORY_BARRIER __asm__ ("mb" : : : "memory") -# elif defined (G_ATOMIC_X86_64) -/* Adapted from CVS version 1.9 of glibc's sysdeps/x86_64/bits/atomic.h - */ -gint -g_atomic_int_exchange_and_add (volatile gint G_GNUC_MAY_ALIAS *atomic, - gint val) + +/** + * g_atomic_int_xor: + * @atomic: a pointer to a #gint or #guint + * @val: the value to 'xor' + * + * Performs an atomic bitwise 'xor' of the value of @atomic and @val, + * storing the result back in @atomic. + * + * Think of this operation as an atomic version of + * `{ tmp = *atomic; *atomic ^= val; return tmp; }`. + * + * This call acts as a full compiler and hardware memory barrier. + * + * Returns: the value of @atomic before the operation, unsigned + * + * Since: 2.30 + **/ +guint +(g_atomic_int_xor) (volatile guint *atomic, + guint val) { - gint result; + return g_atomic_int_xor (atomic, val); +} + - __asm__ __volatile__ ("lock; xaddl %0,%1" - : "=r" (result), "=m" (*atomic) - : "0" (val), "m" (*atomic)); - return result; +/** + * g_atomic_pointer_get: + * @atomic: a pointer to a #gpointer-sized value + * + * Gets the current value of @atomic. + * + * This call acts as a full compiler and hardware + * memory barrier (before the get). + * + * Returns: the value of the pointer + * + * Since: 2.4 + **/ +gpointer +(g_atomic_pointer_get) (const volatile void *atomic) +{ + return g_atomic_pointer_get ((const volatile gpointer *) atomic); } - + +/** + * g_atomic_pointer_set: + * @atomic: a pointer to a #gpointer-sized value + * @newval: a new value to store + * + * Sets the value of @atomic to @newval. + * + * This call acts as a full compiler and hardware + * memory barrier (after the set). + * + * Since: 2.4 + **/ void -g_atomic_int_add (volatile gint G_GNUC_MAY_ALIAS *atomic, - gint val) +(g_atomic_pointer_set) (volatile void *atomic, + gpointer newval) { - __asm__ __volatile__ ("lock; addl %1,%0" - : "=m" (*atomic) - : "ir" (val), "m" (*atomic)); + g_atomic_pointer_set ((volatile gpointer *) atomic, newval); } +/** + * g_atomic_pointer_compare_and_exchange: + * @atomic: a pointer to a #gpointer-sized value + * @oldval: the value to compare with + * @newval: the value to conditionally replace with + * + * Compares @atomic to @oldval and, if equal, sets it to @newval. + * If @atomic was not equal to @oldval then no change occurs. + * + * This compare and exchange is done atomically. + * + * Think of this operation as an atomic version of + * `{ if (*atomic == oldval) { *atomic = newval; return TRUE; } else return FALSE; }`. + * + * This call acts as a full compiler and hardware memory barrier. + * + * Returns: %TRUE if the exchange took place + * + * Since: 2.4 + **/ gboolean -g_atomic_int_compare_and_exchange (volatile gint G_GNUC_MAY_ALIAS *atomic, - gint oldval, - gint newval) +(g_atomic_pointer_compare_and_exchange) (volatile void *atomic, + gpointer oldval, + gpointer newval) { - gint result; - - __asm__ __volatile__ ("lock; cmpxchgl %2, %1" - : "=a" (result), "=m" (*atomic) - : "r" (newval), "m" (*atomic), "0" (oldval)); - - return result == oldval; + return g_atomic_pointer_compare_and_exchange ((volatile gpointer *) atomic, + oldval, newval); } -gboolean -g_atomic_pointer_compare_and_exchange (volatile gpointer G_GNUC_MAY_ALIAS *atomic, - gpointer oldval, - gpointer newval) +/** + * g_atomic_pointer_add: + * @atomic: a pointer to a #gpointer-sized value + * @val: the value to add + * + * Atomically adds @val to the value of @atomic. + * + * Think of this operation as an atomic version of + * `{ tmp = *atomic; *atomic += val; return tmp; }`. + * + * This call acts as a full compiler and hardware memory barrier. + * + * Returns: the value of @atomic before the add, signed + * + * Since: 2.30 + **/ +gssize +(g_atomic_pointer_add) (volatile void *atomic, + gssize val) { - gpointer result; - - __asm__ __volatile__ ("lock; cmpxchgq %q2, %1" - : "=a" (result), "=m" (*atomic) - : "r" (newval), "m" (*atomic), "0" (oldval)); - - return result == oldval; + return g_atomic_pointer_add ((volatile gpointer *) atomic, val); } -# elif defined (G_ATOMIC_POWERPC) -/* Adapted from CVS version 1.16 of glibc's sysdeps/powerpc/bits/atomic.h - * and CVS version 1.4 of glibc's sysdeps/powerpc/powerpc32/bits/atomic.h - * and CVS version 1.7 of glibc's sysdeps/powerpc/powerpc64/bits/atomic.h - */ -# ifdef __OPTIMIZE__ -/* Non-optimizing compile bails on the following two asm statements - * for reasons unknown to the author */ -gint -g_atomic_int_exchange_and_add (volatile gint G_GNUC_MAY_ALIAS *atomic, - gint val) +/** + * g_atomic_pointer_and: + * @atomic: a pointer to a #gpointer-sized value + * @val: the value to 'and' + * + * Performs an atomic bitwise 'and' of the value of @atomic and @val, + * storing the result back in @atomic. + * + * Think of this operation as an atomic version of + * `{ tmp = *atomic; *atomic &= val; return tmp; }`. + * + * This call acts as a full compiler and hardware memory barrier. + * + * Returns: the value of @atomic before the operation, unsigned + * + * Since: 2.30 + **/ +gsize +(g_atomic_pointer_and) (volatile void *atomic, + gsize val) { - gint result, temp; -#if ASM_NUMERIC_LABELS - __asm__ __volatile__ ("1: lwarx %0,0,%3\n" - " add %1,%0,%4\n" - " stwcx. %1,0,%3\n" - " bne- 1b" - : "=&b" (result), "=&r" (temp), "=m" (*atomic) - : "b" (atomic), "r" (val), "m" (*atomic) - : "cr0", "memory"); -#else - __asm__ __volatile__ (".Lieaa%=: lwarx %0,0,%3\n" - " add %1,%0,%4\n" - " stwcx. %1,0,%3\n" - " bne- .Lieaa%=" - : "=&b" (result), "=&r" (temp), "=m" (*atomic) - : "b" (atomic), "r" (val), "m" (*atomic) - : "cr0", "memory"); -#endif - return result; + return g_atomic_pointer_and ((volatile gpointer *) atomic, val); } - -/* The same as above, to save a function call repeated here */ -void -g_atomic_int_add (volatile gint G_GNUC_MAY_ALIAS *atomic, - gint val) + +/** + * g_atomic_pointer_or: + * @atomic: a pointer to a #gpointer-sized value + * @val: the value to 'or' + * + * Performs an atomic bitwise 'or' of the value of @atomic and @val, + * storing the result back in @atomic. + * + * Think of this operation as an atomic version of + * `{ tmp = *atomic; *atomic |= val; return tmp; }`. + * + * This call acts as a full compiler and hardware memory barrier. + * + * Returns: the value of @atomic before the operation, unsigned + * + * Since: 2.30 + **/ +gsize +(g_atomic_pointer_or) (volatile void *atomic, + gsize val) { - gint result, temp; -#if ASM_NUMERIC_LABELS - __asm__ __volatile__ ("1: lwarx %0,0,%3\n" - " add %1,%0,%4\n" - " stwcx. %1,0,%3\n" - " bne- 1b" - : "=&b" (result), "=&r" (temp), "=m" (*atomic) - : "b" (atomic), "r" (val), "m" (*atomic) - : "cr0", "memory"); -#else - __asm__ __volatile__ (".Lia%=: lwarx %0,0,%3\n" - " add %1,%0,%4\n" - " stwcx. %1,0,%3\n" - " bne- .Lia%=" - : "=&b" (result), "=&r" (temp), "=m" (*atomic) - : "b" (atomic), "r" (val), "m" (*atomic) - : "cr0", "memory"); -#endif + return g_atomic_pointer_or ((volatile gpointer *) atomic, val); } -# else /* !__OPTIMIZE__ */ -gint -g_atomic_int_exchange_and_add (volatile gint G_GNUC_MAY_ALIAS *atomic, - gint val) -{ - gint result; - do - result = *atomic; - while (!g_atomic_int_compare_and_exchange (atomic, result, result + val)); - return result; -} - -void -g_atomic_int_add (volatile gint G_GNUC_MAY_ALIAS *atomic, - gint val) +/** + * g_atomic_pointer_xor: + * @atomic: a pointer to a #gpointer-sized value + * @val: the value to 'xor' + * + * Performs an atomic bitwise 'xor' of the value of @atomic and @val, + * storing the result back in @atomic. + * + * Think of this operation as an atomic version of + * `{ tmp = *atomic; *atomic ^= val; return tmp; }`. + * + * This call acts as a full compiler and hardware memory barrier. + * + * Returns: the value of @atomic before the operation, unsigned + * + * Since: 2.30 + **/ +gsize +(g_atomic_pointer_xor) (volatile void *atomic, + gsize val) { - gint result; - do - result = *atomic; - while (!g_atomic_int_compare_and_exchange (atomic, result, result + val)); + return g_atomic_pointer_xor ((volatile gpointer *) atomic, val); } -# endif /* !__OPTIMIZE__ */ -# if GLIB_SIZEOF_VOID_P == 4 /* 32-bit system */ -gboolean -g_atomic_int_compare_and_exchange (volatile gint G_GNUC_MAY_ALIAS *atomic, - gint oldval, - gint newval) -{ - gint result; -#if ASM_NUMERIC_LABELS - __asm__ __volatile__ ("sync\n" - "1: lwarx %0,0,%1\n" - " subf. %0,%2,%0\n" - " bne 2f\n" - " stwcx. %3,0,%1\n" - " bne- 1b\n" - "2: isync" - : "=&r" (result) - : "b" (atomic), "r" (oldval), "r" (newval) - : "cr0", "memory"); -#else - __asm__ __volatile__ ("sync\n" - ".L1icae%=: lwarx %0,0,%1\n" - " subf. %0,%2,%0\n" - " bne .L2icae%=\n" - " stwcx. %3,0,%1\n" - " bne- .L1icae%=\n" - ".L2icae%=: isync" - : "=&r" (result) - : "b" (atomic), "r" (oldval), "r" (newval) - : "cr0", "memory"); +#elif defined (G_PLATFORM_WIN32) + +#include +#if !defined(_M_AMD64) && !defined (_M_IA64) && !defined(_M_X64) && !(defined _MSC_VER && _MSC_VER <= 1200) +#define InterlockedAnd _InterlockedAnd +#define InterlockedOr _InterlockedOr +#define InterlockedXor _InterlockedXor #endif - return result == 0; -} -gboolean -g_atomic_pointer_compare_and_exchange (volatile gpointer G_GNUC_MAY_ALIAS *atomic, - gpointer oldval, - gpointer newval) +#if !defined (_MSC_VER) || _MSC_VER <= 1200 +#include "gmessages.h" +/* Inlined versions for older compiler */ +static LONG +_gInterlockedAnd (volatile guint *atomic, + guint val) { - gpointer result; -#if ASM_NUMERIC_LABELS - __asm__ __volatile__ ("sync\n" - "1: lwarx %0,0,%1\n" - " subf. %0,%2,%0\n" - " bne 2f\n" - " stwcx. %3,0,%1\n" - " bne- 1b\n" - "2: isync" - : "=&r" (result) - : "b" (atomic), "r" (oldval), "r" (newval) - : "cr0", "memory"); -#else - __asm__ __volatile__ ("sync\n" - ".L1pcae%=: lwarx %0,0,%1\n" - " subf. %0,%2,%0\n" - " bne .L2pcae%=\n" - " stwcx. %3,0,%1\n" - " bne- .L1pcae%=\n" - ".L2pcae%=: isync" - : "=&r" (result) - : "b" (atomic), "r" (oldval), "r" (newval) - : "cr0", "memory"); -#endif - return result == 0; + LONG i, j; + + j = *atomic; + do { + i = j; + j = InterlockedCompareExchange(atomic, i & val, i); + } while (i != j); + + return j; } -# elif GLIB_SIZEOF_VOID_P == 8 /* 64-bit system */ -gboolean -g_atomic_int_compare_and_exchange (volatile gint G_GNUC_MAY_ALIAS *atomic, - gint oldval, - gint newval) +#define InterlockedAnd(a,b) _gInterlockedAnd(a,b) +static LONG +_gInterlockedOr (volatile guint *atomic, + guint val) { - gpointer result; -#if ASM_NUMERIC_LABELS - __asm__ __volatile__ ("sync\n" - "1: lwarx %0,0,%1\n" - " extsw %0,%0\n" - " subf. %0,%2,%0\n" - " bne 2f\n" - " stwcx. %3,0,%1\n" - " bne- 1b\n" - "2: isync" - : "=&r" (result) - : "b" (atomic), "r" (oldval), "r" (newval) - : "cr0", "memory"); -#else - __asm__ __volatile__ ("sync\n" - ".L1icae%=: lwarx %0,0,%1\n" - " extsw %0,%0\n" - " subf. %0,%2,%0\n" - " bne .L2icae%=\n" - " stwcx. %3,0,%1\n" - " bne- .L1icae%=\n" - ".L2icae%=: isync" - : "=&r" (result) - : "b" (atomic), "r" (oldval), "r" (newval) - : "cr0", "memory"); -#endif - return result == 0; -} + LONG i, j; -gboolean -g_atomic_pointer_compare_and_exchange (volatile gpointer G_GNUC_MAY_ALIAS *atomic, - gpointer oldval, - gpointer newval) -{ - gpointer result; -#if ASM_NUMERIC_LABELS - __asm__ __volatile__ ("sync\n" - "1: ldarx %0,0,%1\n" - " subf. %0,%2,%0\n" - " bne 2f\n" - " stdcx. %3,0,%1\n" - " bne- 1b\n" - "2: isync" - : "=&r" (result) - : "b" (atomic), "r" (oldval), "r" (newval) - : "cr0", "memory"); -#else - __asm__ __volatile__ ("sync\n" - ".L1pcae%=: ldarx %0,0,%1\n" - " subf. %0,%2,%0\n" - " bne .L2pcae%=\n" - " stdcx. %3,0,%1\n" - " bne- .L1pcae%=\n" - ".L2pcae%=: isync" - : "=&r" (result) - : "b" (atomic), "r" (oldval), "r" (newval) - : "cr0", "memory"); -#endif - return result == 0; + j = *atomic; + do { + i = j; + j = InterlockedCompareExchange(atomic, i | val, i); + } while (i != j); + + return j; } -# else /* What's that */ -# error "Your system has an unsupported pointer size" -# endif /* GLIB_SIZEOF_VOID_P */ +#define InterlockedOr(a,b) _gInterlockedOr(a,b) +static LONG +_gInterlockedXor (volatile guint *atomic, + guint val) +{ + LONG i, j; -# define G_ATOMIC_MEMORY_BARRIER __asm__ ("sync" : : : "memory") + j = *atomic; + do { + i = j; + j = InterlockedCompareExchange(atomic, i ^ val, i); + } while (i != j); -# elif defined (G_ATOMIC_IA64) -/* Adapted from CVS version 1.8 of glibc's sysdeps/ia64/bits/atomic.h + return j; +} +#define InterlockedXor(a,b) _gInterlockedXor(a,b) +#endif + +/* + * http://msdn.microsoft.com/en-us/library/ms684122(v=vs.85).aspx */ gint -g_atomic_int_exchange_and_add (volatile gint G_GNUC_MAY_ALIAS *atomic, - gint val) +(g_atomic_int_get) (const volatile gint *atomic) { - return __sync_fetch_and_add (atomic, val); + MemoryBarrier (); + return *atomic; } - + void -g_atomic_int_add (volatile gint G_GNUC_MAY_ALIAS *atomic, - gint val) +(g_atomic_int_set) (volatile gint *atomic, + gint newval) { - __sync_fetch_and_add (atomic, val); + *atomic = newval; + MemoryBarrier (); } -gboolean -g_atomic_int_compare_and_exchange (volatile gint G_GNUC_MAY_ALIAS *atomic, - gint oldval, - gint newval) +void +(g_atomic_int_inc) (volatile gint *atomic) { - return __sync_bool_compare_and_swap (atomic, oldval, newval); + InterlockedIncrement (atomic); } gboolean -g_atomic_pointer_compare_and_exchange (volatile gpointer G_GNUC_MAY_ALIAS *atomic, - gpointer oldval, - gpointer newval) +(g_atomic_int_dec_and_test) (volatile gint *atomic) { - return __sync_bool_compare_and_swap ((long *)atomic, - (long)oldval, (long)newval); + return InterlockedDecrement (atomic) == 0; } -# define G_ATOMIC_MEMORY_BARRIER __sync_synchronize () -# elif defined (G_ATOMIC_S390) -/* Adapted from glibc's sysdeps/s390/bits/atomic.h - */ -# define ATOMIC_INT_CMP_XCHG(atomic, oldval, newval) \ - ({ \ - gint __result = oldval; \ - __asm__ __volatile__ ("cs %0, %2, %1" \ - : "+d" (__result), "=Q" (*(atomic)) \ - : "d" (newval), "m" (*(atomic)) : "cc" ); \ - __result == oldval; \ - }) - -# if GLIB_SIZEOF_VOID_P == 4 /* 32-bit system */ gboolean -g_atomic_pointer_compare_and_exchange (volatile gpointer G_GNUC_MAY_ALIAS *atomic, - gpointer oldval, - gpointer newval) +(g_atomic_int_compare_and_exchange) (volatile gint *atomic, + gint oldval, + gint newval) { - gpointer result = oldval; - __asm__ __volatile__ ("cs %0, %2, %1" - : "+d" (result), "=Q" (*(atomic)) - : "d" (newval), "m" (*(atomic)) : "cc" ); - return result == oldval; + return InterlockedCompareExchange (atomic, newval, oldval) == oldval; } -# elif GLIB_SIZEOF_VOID_P == 8 /* 64-bit system */ -gboolean -g_atomic_pointer_compare_and_exchange (volatile gpointer G_GNUC_MAY_ALIAS *atomic, - gpointer oldval, - gpointer newval) + +gint +(g_atomic_int_add) (volatile gint *atomic, + gint val) { - gpointer result = oldval; - gpointer *a = atomic; - __asm__ __volatile__ ("csg %0, %2, %1" - : "+d" (result), "=Q" (*a) - : "d" ((long)(newval)), "m" (*a) : "cc" ); - return result == oldval; + return InterlockedExchangeAdd (atomic, val); } -# else /* What's that */ -# error "Your system has an unsupported pointer size" -# endif /* GLIB_SIZEOF_VOID_P */ -# elif defined (G_ATOMIC_ARM) -static volatile int atomic_spin = 0; -static int atomic_spin_trylock (void) +guint +(g_atomic_int_and) (volatile guint *atomic, + guint val) { - int result; - - asm volatile ( - "swp %0, %1, [%2]\n" - : "=&r,&r" (result) - : "r,0" (1), "r,r" (&atomic_spin) - : "memory"); - if (result == 0) - return 0; - else - return -1; + return InterlockedAnd (atomic, val); } -static void atomic_spin_lock (void) +guint +(g_atomic_int_or) (volatile guint *atomic, + guint val) { - while (atomic_spin_trylock()) - sched_yield(); + return InterlockedOr (atomic, val); } -static void atomic_spin_unlock (void) +guint +(g_atomic_int_xor) (volatile guint *atomic, + guint val) { - atomic_spin = 0; + return InterlockedXor (atomic, val); } -gint -g_atomic_int_exchange_and_add (volatile gint G_GNUC_MAY_ALIAS *atomic, - gint val) + +gpointer +(g_atomic_pointer_get) (const volatile void *atomic) { - gint result; - - atomic_spin_lock(); - result = *atomic; - *atomic += val; - atomic_spin_unlock(); - - return result; + const volatile gpointer *ptr = atomic; + + MemoryBarrier (); + return *ptr; } void -g_atomic_int_add (volatile gint G_GNUC_MAY_ALIAS *atomic, - gint val) +(g_atomic_pointer_set) (volatile void *atomic, + gpointer newval) { - atomic_spin_lock(); - *atomic += val; - atomic_spin_unlock(); + volatile gpointer *ptr = atomic; + + *ptr = newval; + MemoryBarrier (); } gboolean -g_atomic_int_compare_and_exchange (volatile gint G_GNUC_MAY_ALIAS *atomic, - gint oldval, - gint newval) +(g_atomic_pointer_compare_and_exchange) (volatile void *atomic, + gpointer oldval, + gpointer newval) { - gboolean result; - - atomic_spin_lock(); - if (*atomic == oldval) - { - result = TRUE; - *atomic = newval; - } - else - result = FALSE; - atomic_spin_unlock(); - - return result; + return InterlockedCompareExchangePointer (atomic, newval, oldval) == oldval; } -gboolean -g_atomic_pointer_compare_and_exchange (volatile gpointer G_GNUC_MAY_ALIAS *atomic, - gpointer oldval, - gpointer newval) +gssize +(g_atomic_pointer_add) (volatile void *atomic, + gssize val) { - gboolean result; - - atomic_spin_lock(); - if (*atomic == oldval) - { - result = TRUE; - *atomic = newval; - } - else - result = FALSE; - atomic_spin_unlock(); - - return result; +#if GLIB_SIZEOF_VOID_P == 8 + return InterlockedExchangeAdd64 (atomic, val); +#else + return InterlockedExchangeAdd (atomic, val); +#endif } -# elif defined (G_ATOMIC_CRIS) || defined (G_ATOMIC_CRISV32) -# ifdef G_ATOMIC_CRIS -# define CRIS_ATOMIC_INT_CMP_XCHG(atomic, oldval, newval) \ - ({ \ - gboolean __result; \ - __asm__ __volatile__ ("\n" \ - "0:\tclearf\n\t" \ - "cmp.d [%[Atomic]], %[OldVal]\n\t" \ - "bne 1f\n\t" \ - "ax\n\t" \ - "move.d %[NewVal], [%[Atomic]]\n\t" \ - "bwf 0b\n" \ - "1:\tseq %[Result]" \ - : [Result] "=&r" (__result), \ - "=m" (*(atomic)) \ - : [Atomic] "r" (atomic), \ - [OldVal] "r" (oldval), \ - [NewVal] "r" (newval), \ - "g" (*(gpointer*) (atomic)) \ - : "memory"); \ - __result; \ - }) -# else -# define CRIS_ATOMIC_INT_CMP_XCHG(atomic, oldval, newval) \ - ({ \ - gboolean __result; \ - __asm__ __volatile__ ("\n" \ - "0:\tclearf p\n\t" \ - "cmp.d [%[Atomic]], %[OldVal]\n\t" \ - "bne 1f\n\t" \ - "ax\n\t" \ - "move.d %[NewVal], [%[Atomic]]\n\t" \ - "bcs 0b\n" \ - "1:\tseq %[Result]" \ - : [Result] "=&r" (__result), \ - "=m" (*(atomic)) \ - : [Atomic] "r" (atomic), \ - [OldVal] "r" (oldval), \ - [NewVal] "r" (newval), \ - "g" (*(gpointer*) (atomic)) \ - : "memory"); \ - __result; \ - }) -# endif - -#define CRIS_CACHELINE_SIZE 32 -#define CRIS_ATOMIC_BREAKS_CACHELINE(atomic) \ - (((gulong)(atomic) & (CRIS_CACHELINE_SIZE - 1)) > (CRIS_CACHELINE_SIZE - sizeof (atomic))) - -gint __g_atomic_int_exchange_and_add (volatile gint G_GNUC_MAY_ALIAS *atomic, - gint val); -void __g_atomic_int_add (volatile gint G_GNUC_MAY_ALIAS *atomic, - gint val); -gboolean __g_atomic_int_compare_and_exchange (volatile gint G_GNUC_MAY_ALIAS *atomic, - gint oldval, - gint newval); -gboolean __g_atomic_pointer_compare_and_exchange (volatile gpointer G_GNUC_MAY_ALIAS *atomic, - gpointer oldval, - gpointer newval); -gboolean -g_atomic_pointer_compare_and_exchange (volatile gpointer G_GNUC_MAY_ALIAS *atomic, - gpointer oldval, - gpointer newval) +gsize +(g_atomic_pointer_and) (volatile void *atomic, + gsize val) { - if (G_UNLIKELY (CRIS_ATOMIC_BREAKS_CACHELINE (atomic))) - return __g_atomic_pointer_compare_and_exchange (atomic, oldval, newval); - - return CRIS_ATOMIC_INT_CMP_XCHG (atomic, oldval, newval); +#if GLIB_SIZEOF_VOID_P == 8 + return InterlockedAnd64 (atomic, val); +#else + return InterlockedAnd (atomic, val); +#endif } -gboolean -g_atomic_int_compare_and_exchange (volatile gint G_GNUC_MAY_ALIAS *atomic, - gint oldval, - gint newval) +gsize +(g_atomic_pointer_or) (volatile void *atomic, + gsize val) { - if (G_UNLIKELY (CRIS_ATOMIC_BREAKS_CACHELINE (atomic))) - return __g_atomic_int_compare_and_exchange (atomic, oldval, newval); - - return CRIS_ATOMIC_INT_CMP_XCHG (atomic, oldval, newval); +#if GLIB_SIZEOF_VOID_P == 8 + return InterlockedOr64 (atomic, val); +#else + return InterlockedOr (atomic, val); +#endif } -gint -g_atomic_int_exchange_and_add (volatile gint G_GNUC_MAY_ALIAS *atomic, - gint val) +gsize +(g_atomic_pointer_xor) (volatile void *atomic, + gsize val) { - gint result; - - if (G_UNLIKELY (CRIS_ATOMIC_BREAKS_CACHELINE (atomic))) - return __g_atomic_int_exchange_and_add (atomic, val); - - do - result = *atomic; - while (!CRIS_ATOMIC_INT_CMP_XCHG (atomic, result, result + val)); - - return result; +#if GLIB_SIZEOF_VOID_P == 8 + return InterlockedXor64 (atomic, val); +#else + return InterlockedXor (atomic, val); +#endif } +#else -void -g_atomic_int_add (volatile gint G_GNUC_MAY_ALIAS *atomic, - gint val) -{ - gint result; +/* This error occurs when ./configure decided that we should be capable + * of lock-free atomics but we find at compile-time that we are not. + */ +#error G_ATOMIC_LOCK_FREE defined, but incapable of lock-free atomics. - if (G_UNLIKELY (CRIS_ATOMIC_BREAKS_CACHELINE (atomic))) - return __g_atomic_int_add (atomic, val); +#endif /* defined (__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4) */ - do - result = *atomic; - while (!CRIS_ATOMIC_INT_CMP_XCHG (atomic, result, result + val)); -} +#else /* G_ATOMIC_LOCK_FREE */ -/* We need the atomic mutex for atomic operations where the atomic variable - * breaks the 32 byte cache line since the CRIS architecture does not support - * atomic operations on such variables. Fortunately this should be rare. - */ -# define DEFINE_WITH_MUTEXES -# define g_atomic_int_exchange_and_add __g_atomic_int_exchange_and_add -# define g_atomic_int_add __g_atomic_int_add -# define g_atomic_int_compare_and_exchange __g_atomic_int_compare_and_exchange -# define g_atomic_pointer_compare_and_exchange __g_atomic_pointer_compare_and_exchange - -# else /* !G_ATOMIC_* */ -# define DEFINE_WITH_MUTEXES -# endif /* G_ATOMIC_* */ -#else /* !__GNUC__ */ -# ifdef G_PLATFORM_WIN32 -# define DEFINE_WITH_WIN32_INTERLOCKED -# else -# define DEFINE_WITH_MUTEXES -# endif -#endif /* __GNUC__ */ - -#ifdef DEFINE_WITH_WIN32_INTERLOCKED -# include -/* Following indicates that InterlockedCompareExchangePointer is - * declared in winbase.h (included by windows.h) and needs to be - * commented out if not true. It is defined iff WINVER > 0x0400, - * which is usually correct but can be wrong if WINVER is set before - * windows.h is included. +/* We are not permitted to call into any GLib functions from here, so we + * can not use GMutex. + * + * Fortunately, we already take care of the Windows case above, and all + * non-Windows platforms on which glib runs have pthreads. Use those. */ -# if WINVER > 0x0400 -# define HAVE_INTERLOCKED_COMPARE_EXCHANGE_POINTER -# endif +#include -gint32 -g_atomic_int_exchange_and_add (volatile gint32 G_GNUC_MAY_ALIAS *atomic, - gint32 val) -{ - return InterlockedExchangeAdd (atomic, val); -} +static pthread_mutex_t g_atomic_lock = PTHREAD_MUTEX_INITIALIZER; -void -g_atomic_int_add (volatile gint32 G_GNUC_MAY_ALIAS *atomic, - gint32 val) +gint +(g_atomic_int_get) (const volatile gint *atomic) { - InterlockedExchangeAdd (atomic, val); -} + gint value; -gboolean -g_atomic_int_compare_and_exchange (volatile gint32 G_GNUC_MAY_ALIAS *atomic, - gint32 oldval, - gint32 newval) -{ -#ifndef HAVE_INTERLOCKED_COMPARE_EXCHANGE_POINTER - return (guint32) InterlockedCompareExchange ((PVOID*)atomic, - (PVOID)newval, - (PVOID)oldval) == oldval; -#else - return InterlockedCompareExchange (atomic, - newval, - oldval) == oldval; -#endif -} + pthread_mutex_lock (&g_atomic_lock); + value = *atomic; + pthread_mutex_unlock (&g_atomic_lock); -gboolean -g_atomic_pointer_compare_and_exchange (volatile gpointer G_GNUC_MAY_ALIAS *atomic, - gpointer oldval, - gpointer newval) -{ -# ifdef HAVE_INTERLOCKED_COMPARE_EXCHANGE_POINTER - return InterlockedCompareExchangePointer (atomic, newval, oldval) == oldval; -# else -# if GLIB_SIZEOF_VOID_P != 4 /* no 32-bit system */ -# error "InterlockedCompareExchangePointer needed" -# else - return InterlockedCompareExchange (atomic, newval, oldval) == oldval; -# endif -# endif + return value; } -#endif /* DEFINE_WITH_WIN32_INTERLOCKED */ - -#ifdef DEFINE_WITH_MUTEXES -/* We have to use the slow, but safe locking method */ -static GMutex *g_atomic_mutex; -/** - * g_atomic_int_exchange_and_add: - * @atomic: a pointer to an integer - * @val: the value to add to *@atomic - * - * Atomically adds @val to the integer pointed to by @atomic. - * It returns the value of *@atomic just before the addition - * took place. Also acts as a memory barrier. - * - * Returns: the value of *@atomic before the addition. - * - * Since: 2.4 - */ -gint -g_atomic_int_exchange_and_add (volatile gint G_GNUC_MAY_ALIAS *atomic, - gint val) +void +(g_atomic_int_set) (volatile gint *atomic, + gint value) { - gint result; - - g_mutex_lock (g_atomic_mutex); - result = *atomic; - *atomic += val; - g_mutex_unlock (g_atomic_mutex); - - return result; + pthread_mutex_lock (&g_atomic_lock); + *atomic = value; + pthread_mutex_unlock (&g_atomic_lock); } -/** - * g_atomic_int_add: - * @atomic: a pointer to an integer - * @val: the value to add to *@atomic - * - * Atomically adds @val to the integer pointed to by @atomic. - * Also acts as a memory barrier. - * - * Since: 2.4 - */ void -g_atomic_int_add (volatile gint G_GNUC_MAY_ALIAS *atomic, - gint val) +(g_atomic_int_inc) (volatile gint *atomic) { - g_mutex_lock (g_atomic_mutex); - *atomic += val; - g_mutex_unlock (g_atomic_mutex); + pthread_mutex_lock (&g_atomic_lock); + (*atomic)++; + pthread_mutex_unlock (&g_atomic_lock); } -/** - * g_atomic_int_compare_and_exchange: - * @atomic: a pointer to an integer - * @oldval: the assumed old value of *@atomic - * @newval: the new value of *@atomic - * - * Compares @oldval with the integer pointed to by @atomic and - * if they are equal, atomically exchanges *@atomic with @newval. - * Also acts as a memory barrier. - * - * Returns: %TRUE, if *@atomic was equal @oldval. %FALSE otherwise. - * - * Since: 2.4 - */ gboolean -g_atomic_int_compare_and_exchange (volatile gint G_GNUC_MAY_ALIAS *atomic, - gint oldval, - gint newval) +(g_atomic_int_dec_and_test) (volatile gint *atomic) { - gboolean result; - - g_mutex_lock (g_atomic_mutex); - if (*atomic == oldval) - { - result = TRUE; - *atomic = newval; - } - else - result = FALSE; - g_mutex_unlock (g_atomic_mutex); - - return result; + gboolean is_zero; + + pthread_mutex_lock (&g_atomic_lock); + is_zero = --(*atomic) == 0; + pthread_mutex_unlock (&g_atomic_lock); + + return is_zero; } -/** - * g_atomic_pointer_compare_and_exchange: - * @atomic: a pointer to a #gpointer - * @oldval: the assumed old value of *@atomic - * @newval: the new value of *@atomic - * - * Compares @oldval with the pointer pointed to by @atomic and - * if they are equal, atomically exchanges *@atomic with @newval. - * Also acts as a memory barrier. - * - * Returns: %TRUE, if *@atomic was equal @oldval. %FALSE otherwise. - * - * Since: 2.4 - */ gboolean -g_atomic_pointer_compare_and_exchange (volatile gpointer G_GNUC_MAY_ALIAS *atomic, - gpointer oldval, - gpointer newval) +(g_atomic_int_compare_and_exchange) (volatile gint *atomic, + gint oldval, + gint newval) { - gboolean result; - - g_mutex_lock (g_atomic_mutex); - if (*atomic == oldval) - { - result = TRUE; - *atomic = newval; - } - else - result = FALSE; - g_mutex_unlock (g_atomic_mutex); - - return result; -} + gboolean success; -#ifdef G_ATOMIC_OP_MEMORY_BARRIER_NEEDED + pthread_mutex_lock (&g_atomic_lock); -/** - * g_atomic_int_get: - * @atomic: a pointer to an integer - * - * Reads the value of the integer pointed to by @atomic. - * Also acts as a memory barrier. - * - * Returns: the value of *@atomic - * - * Since: 2.4 - */ -gint -(g_atomic_int_get) (volatile gint G_GNUC_MAY_ALIAS *atomic) -{ - gint result; + if ((success = (*atomic == oldval))) + *atomic = newval; - g_mutex_lock (g_atomic_mutex); - result = *atomic; - g_mutex_unlock (g_atomic_mutex); + pthread_mutex_unlock (&g_atomic_lock); - return result; + return success; } -/** - * g_atomic_int_set: - * @atomic: a pointer to an integer - * @newval: the new value - * - * Sets the value of the integer pointed to by @atomic. - * Also acts as a memory barrier. - * - * Since: 2.10 - */ -void -(g_atomic_int_set) (volatile gint G_GNUC_MAY_ALIAS *atomic, - gint newval) +gint +(g_atomic_int_add) (volatile gint *atomic, + gint val) { - g_mutex_lock (g_atomic_mutex); - *atomic = newval; - g_mutex_unlock (g_atomic_mutex); + gint oldval; + + pthread_mutex_lock (&g_atomic_lock); + oldval = *atomic; + *atomic = oldval + val; + pthread_mutex_unlock (&g_atomic_lock); + + return oldval; } -/** - * g_atomic_pointer_get: - * @atomic: a pointer to a #gpointer. - * - * Reads the value of the pointer pointed to by @atomic. - * Also acts as a memory barrier. - * - * Returns: the value to add to *@atomic. - * - * Since: 2.4 - */ -gpointer -(g_atomic_pointer_get) (volatile gpointer G_GNUC_MAY_ALIAS *atomic) +guint +(g_atomic_int_and) (volatile guint *atomic, + guint val) { - gpointer result; + guint oldval; - g_mutex_lock (g_atomic_mutex); - result = *atomic; - g_mutex_unlock (g_atomic_mutex); + pthread_mutex_lock (&g_atomic_lock); + oldval = *atomic; + *atomic = oldval & val; + pthread_mutex_unlock (&g_atomic_lock); - return result; + return oldval; } -/** - * g_atomic_pointer_set: - * @atomic: a pointer to a #gpointer - * @newval: the new value - * - * Sets the value of the pointer pointed to by @atomic. - * Also acts as a memory barrier. - * - * Since: 2.10 - */ -void -(g_atomic_pointer_set) (volatile gpointer G_GNUC_MAY_ALIAS *atomic, - gpointer newval) -{ - g_mutex_lock (g_atomic_mutex); - *atomic = newval; - g_mutex_unlock (g_atomic_mutex); -} -#endif /* G_ATOMIC_OP_MEMORY_BARRIER_NEEDED */ -#elif defined (G_ATOMIC_OP_MEMORY_BARRIER_NEEDED) -gint -(g_atomic_int_get) (volatile gint G_GNUC_MAY_ALIAS *atomic) +guint +(g_atomic_int_or) (volatile guint *atomic, + guint val) { - G_ATOMIC_MEMORY_BARRIER; - return *atomic; + guint oldval; + + pthread_mutex_lock (&g_atomic_lock); + oldval = *atomic; + *atomic = oldval | val; + pthread_mutex_unlock (&g_atomic_lock); + + return oldval; } -void -(g_atomic_int_set) (volatile gint G_GNUC_MAY_ALIAS *atomic, - gint newval) +guint +(g_atomic_int_xor) (volatile guint *atomic, + guint val) { - *atomic = newval; - G_ATOMIC_MEMORY_BARRIER; + guint oldval; + + pthread_mutex_lock (&g_atomic_lock); + oldval = *atomic; + *atomic = oldval ^ val; + pthread_mutex_unlock (&g_atomic_lock); + + return oldval; } + gpointer -(g_atomic_pointer_get) (volatile gpointer G_GNUC_MAY_ALIAS *atomic) +(g_atomic_pointer_get) (const volatile void *atomic) { - G_ATOMIC_MEMORY_BARRIER; - return *atomic; -} + const volatile gpointer *ptr = atomic; + gpointer value; + + pthread_mutex_lock (&g_atomic_lock); + value = *ptr; + pthread_mutex_unlock (&g_atomic_lock); + + return value; +} void -(g_atomic_pointer_set) (volatile gpointer G_GNUC_MAY_ALIAS *atomic, - gpointer newval) +(g_atomic_pointer_set) (volatile void *atomic, + gpointer newval) { - *atomic = newval; - G_ATOMIC_MEMORY_BARRIER; + volatile gpointer *ptr = atomic; + + pthread_mutex_lock (&g_atomic_lock); + *ptr = newval; + pthread_mutex_unlock (&g_atomic_lock); } -#endif /* DEFINE_WITH_MUTEXES || G_ATOMIC_OP_MEMORY_BARRIER_NEEDED */ -#ifdef ATOMIC_INT_CMP_XCHG gboolean -g_atomic_int_compare_and_exchange (volatile gint G_GNUC_MAY_ALIAS *atomic, - gint oldval, - gint newval) +(g_atomic_pointer_compare_and_exchange) (volatile void *atomic, + gpointer oldval, + gpointer newval) { - return ATOMIC_INT_CMP_XCHG (atomic, oldval, newval); -} + volatile gpointer *ptr = atomic; + gboolean success; -gint -g_atomic_int_exchange_and_add (volatile gint G_GNUC_MAY_ALIAS *atomic, - gint val) -{ - gint result; - do - result = *atomic; - while (!ATOMIC_INT_CMP_XCHG (atomic, result, result + val)); + pthread_mutex_lock (&g_atomic_lock); - return result; -} - -void -g_atomic_int_add (volatile gint G_GNUC_MAY_ALIAS *atomic, - gint val) -{ - gint result; - do - result = *atomic; - while (!ATOMIC_INT_CMP_XCHG (atomic, result, result + val)); + if ((success = (*ptr == oldval))) + *ptr = newval; + + pthread_mutex_unlock (&g_atomic_lock); + + return success; } -#endif /* ATOMIC_INT_CMP_XCHG */ -void -_g_atomic_thread_init (void) +gssize +(g_atomic_pointer_add) (volatile void *atomic, + gssize val) { -#ifdef DEFINE_WITH_MUTEXES - g_atomic_mutex = g_mutex_new (); -#endif /* DEFINE_WITH_MUTEXES */ + volatile gssize *ptr = atomic; + gssize oldval; + + pthread_mutex_lock (&g_atomic_lock); + oldval = *ptr; + *ptr = oldval + val; + pthread_mutex_unlock (&g_atomic_lock); + + return oldval; } -#ifndef G_ATOMIC_OP_MEMORY_BARRIER_NEEDED -gint -(g_atomic_int_get) (volatile gint G_GNUC_MAY_ALIAS *atomic) +gsize +(g_atomic_pointer_and) (volatile void *atomic, + gsize val) { - return g_atomic_int_get (atomic); + volatile gsize *ptr = atomic; + gsize oldval; + + pthread_mutex_lock (&g_atomic_lock); + oldval = *ptr; + *ptr = oldval & val; + pthread_mutex_unlock (&g_atomic_lock); + + return oldval; } -void -(g_atomic_int_set) (volatile gint G_GNUC_MAY_ALIAS *atomic, - gint newval) +gsize +(g_atomic_pointer_or) (volatile void *atomic, + gsize val) { - g_atomic_int_set (atomic, newval); + volatile gsize *ptr = atomic; + gsize oldval; + + pthread_mutex_lock (&g_atomic_lock); + oldval = *ptr; + *ptr = oldval | val; + pthread_mutex_unlock (&g_atomic_lock); + + return oldval; } -gpointer -(g_atomic_pointer_get) (volatile gpointer G_GNUC_MAY_ALIAS *atomic) +gsize +(g_atomic_pointer_xor) (volatile void *atomic, + gsize val) { - return g_atomic_pointer_get (atomic); + volatile gsize *ptr = atomic; + gsize oldval; + + pthread_mutex_lock (&g_atomic_lock); + oldval = *ptr; + *ptr = oldval ^ val; + pthread_mutex_unlock (&g_atomic_lock); + + return oldval; } -void -(g_atomic_pointer_set) (volatile gpointer G_GNUC_MAY_ALIAS *atomic, - gpointer newval) +#endif + +/** + * g_atomic_int_exchange_and_add: + * @atomic: a pointer to a #gint + * @val: the value to add + * + * This function existed before g_atomic_int_add() returned the prior + * value of the integer (which it now does). It is retained only for + * compatibility reasons. Don't use this function in new code. + * + * Returns: the value of @atomic before the add, signed + * Since: 2.4 + * Deprecated: 2.30: Use g_atomic_int_add() instead. + **/ +gint +g_atomic_int_exchange_and_add (volatile gint *atomic, + gint val) { - g_atomic_pointer_set (atomic, newval); + return (g_atomic_int_add) (atomic, val); } -#endif /* G_ATOMIC_OP_MEMORY_BARRIER_NEEDED */