-/* 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 <http://www.gnu.org/licenses/>.
+ *
+ * Author: Ryan Lortie <desrt@desrt.ca>
*/
#include "config.h"
-#if defined (G_ATOMIC_ARM)
-#include <sched.h>
-#endif
-
#include "gatomic.h"
-#include "gthreadprivate.h"
/**
* SECTION:atomic_operations
* @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.
- *
- * <note><para>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.
- * </para></note>
- *
- * <note><para>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().
- * </para></note>
- *
- * <note><para>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.
- * </para></note>
+ * 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 <windows.h>
+#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 <windows.h>
-/* 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 <pthread.h>
-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 */
projects / platform / upstream / glib.git / blobdiff