+2004-02-26 Sebastian Wilhelmi <seppi@seppi.de>
+
+ * glib/gatomic.c, glib/gatomic.h: New files to implement atomic
+ operations for different platforms. Fixes bug #63621.
+
+ * glib/glib.h: Include gatomic.h.
+
+ * configure.in: Add test for assembler routines for atomic operations.
+
+ * glib/Makefile.am: Add gatomic.c, gatomic.h.
+
+ * tests/Makefile.am, tests/atomic-test.c: Unit test for atomic
+ operations.
+
2003-02-26 Hans Breuer <hans@breuer.org>
* glib/glib.def : added g_hash_table_find and a
+2004-02-26 Sebastian Wilhelmi <seppi@seppi.de>
+
+ * glib/gatomic.c, glib/gatomic.h: New files to implement atomic
+ operations for different platforms. Fixes bug #63621.
+
+ * glib/glib.h: Include gatomic.h.
+
+ * configure.in: Add test for assembler routines for atomic operations.
+
+ * glib/Makefile.am: Add gatomic.c, gatomic.h.
+
+ * tests/Makefile.am, tests/atomic-test.c: Unit test for atomic
+ operations.
+
2003-02-26 Hans Breuer <hans@breuer.org>
* glib/glib.def : added g_hash_table_find and a
+2004-02-26 Sebastian Wilhelmi <seppi@seppi.de>
+
+ * glib/gatomic.c, glib/gatomic.h: New files to implement atomic
+ operations for different platforms. Fixes bug #63621.
+
+ * glib/glib.h: Include gatomic.h.
+
+ * configure.in: Add test for assembler routines for atomic operations.
+
+ * glib/Makefile.am: Add gatomic.c, gatomic.h.
+
+ * tests/Makefile.am, tests/atomic-test.c: Unit test for atomic
+ operations.
+
2003-02-26 Hans Breuer <hans@breuer.org>
* glib/glib.def : added g_hash_table_find and a
+2004-02-26 Sebastian Wilhelmi <seppi@seppi.de>
+
+ * glib/gatomic.c, glib/gatomic.h: New files to implement atomic
+ operations for different platforms. Fixes bug #63621.
+
+ * glib/glib.h: Include gatomic.h.
+
+ * configure.in: Add test for assembler routines for atomic operations.
+
+ * glib/Makefile.am: Add gatomic.c, gatomic.h.
+
+ * tests/Makefile.am, tests/atomic-test.c: Unit test for atomic
+ operations.
+
2003-02-26 Hans Breuer <hans@breuer.org>
* glib/glib.def : added g_hash_table_find and a
+2004-02-26 Sebastian Wilhelmi <seppi@seppi.de>
+
+ * glib/gatomic.c, glib/gatomic.h: New files to implement atomic
+ operations for different platforms. Fixes bug #63621.
+
+ * glib/glib.h: Include gatomic.h.
+
+ * configure.in: Add test for assembler routines for atomic operations.
+
+ * glib/Makefile.am: Add gatomic.c, gatomic.h.
+
+ * tests/Makefile.am, tests/atomic-test.c: Unit test for atomic
+ operations.
+
2003-02-26 Hans Breuer <hans@breuer.org>
* glib/glib.def : added g_hash_table_find and a
+2004-02-26 Sebastian Wilhelmi <seppi@seppi.de>
+
+ * glib/gatomic.c, glib/gatomic.h: New files to implement atomic
+ operations for different platforms. Fixes bug #63621.
+
+ * glib/glib.h: Include gatomic.h.
+
+ * configure.in: Add test for assembler routines for atomic operations.
+
+ * glib/Makefile.am: Add gatomic.c, gatomic.h.
+
+ * tests/Makefile.am, tests/atomic-test.c: Unit test for atomic
+ operations.
+
2003-02-26 Hans Breuer <hans@breuer.org>
* glib/glib.def : added g_hash_table_find and a
LIBS="$glib_save_LIBS"
fi
+dnl *****************************
+dnl *** GAtomic tests for gcc ***
+dnl *****************************
+
+AC_MSG_CHECKING([whether to use inline assembler routines for atomic integers])
+
+if test x"$GCC" = xyes; then
+ case $host_cpu in
+ i386)
+ AC_MSG_RESULT([no])
+ ;;
+ i?86)
+ AC_MSG_RESULT([i486])
+ glib_atomic_inlined_implementation=I486
+ ;;
+ sparc*)
+ SPARCV9_WARNING="Try to rerun configure with CFLAGS='-mcpu=v9',
+ when you are using a sparc with v9 instruction set (most
+ sparcs nowadays). This will make the code for atomic
+ operations much faster. The resulting code will not run
+ on very old sparcs though."
+
+ AC_LINK_IFELSE([[
+ main ()
+ {
+ int tmp1, tmp2, tmp3;
+ __asm__ __volatile__("casx [%2], %0, %1"
+ : "=&r" (tmp1), "=&r" (tmp2) : "r" (&tmp3));
+ }]],
+ AC_MSG_RESULT([sparcv9])
+ glib_atomic_inlined_implementation=SPARCV9,
+ AC_MSG_RESULT([no])
+ AC_MSG_WARN([[$SPARCV9_WARNING]]))
+ ;;
+ alpha)
+ AC_MSG_RESULT([alpha])
+ glib_atomic_inlined_implementation=ALPHA
+ ;;
+ x86_64)
+ AC_MSG_RESULT([x86_64])
+ glib_atomic_inlined_implementation=X86_64
+ ;;
+ powerpc*)
+ AC_MSG_RESULT([powerpc])
+ glib_atomic_inlined_implementation=POWERPC
+ ;;
+ ia64)
+ AC_MSG_RESULT([ia64])
+ glib_atomic_inlined_implementation=IA64
+ ;;
+ *)
+ AC_MSG_RESULT([none])
+ glib_atomic_inlined_implementation=NONE
+ ;;
+ esac
+fi
+
dnl ****************************************
dnl *** GLib POLL* compatibility defines ***
dnl ****************************************
long dummy_long;
};
_______EOF
+ if test x"$g_atomic_inlined_implementation" != x; then
+ echo >>$outfile
+ echo "#define G_ATOMIC_INLINED_IMPLEMENTATION_$g_atomic_inlined_implementation" >>$outfile
+ fi
echo >>$outfile
g_bit_sizes="16 32 64"
g_system_thread_sizeof="$glib_cv_sizeof_system_thread"
g_mutex_contents="$glib_cv_byte_contents_gmutex"
+g_atomic_inlined_implementation="$glib_atomic_inlined_implementation"
+
g_module_suffix="$glib_gmodule_suffix"
g_pid_type="$glib_pid_type"
+2004-02-26 Sebastian Wilhelmi <seppi@seppi.de>
+
+ * glib/glib-overrides.txt, glib/glib-sections.txt,
+ glib/glib-docs.sgml, glib/tmpl/atomic_operations.sgml: Add docs
+ for atomic operations.
+
Tue Feb 24 14:09:21 2004 Owen Taylor <otaylor@redhat.com>
* === Released 2.3.3 ===
<!ENTITY glib-Byte-Order-Macros SYSTEM "xml/byte_order.xml">
<!ENTITY glib-Numerical-Definitions SYSTEM "xml/numerical.xml">
<!ENTITY glib-Miscellaneous-Macros SYSTEM "xml/macros_misc.xml">
+<!ENTITY glib-Atomic-Operations SYSTEM "xml/atomic_operations.xml">
<!ENTITY glib-Memory-Allocation SYSTEM "xml/memory.xml">
<!ENTITY glib-Error-Reporting SYSTEM "xml/error_reporting.xml">
<!ENTITY glib-Warnings-and-Assertions SYSTEM "xml/warnings.xml">
&glib-Byte-Order-Macros;
&glib-Numerical-Definitions;
&glib-Miscellaneous-Macros;
+ &glib-Atomic-Operations;
</chapter>
<chapter id="glib-core">
gchar c
</FUNCTION>
+# g_atomic
+
+<FUNCTION>
+<NAME>g_atomic_int_get</NAME>
+<RETURNS>gint32</RETURNS>
+gint32 *atomic
+</FUNCTION>
+
+<FUNCTION>
+<NAME>g_atomic_int_exchange_and_add</NAME>
+<RETURNS>gint32</RETURNS>
+gint32 *atomic
+gint32 val
+</FUNCTION>
+
+<FUNCTION>
+<NAME>g_atomic_int_add</NAME>
+<RETURNS>void</RETURNS>
+gint32 *atomic
+gint32 val
+</FUNCTION>
+
+<FUNCTION>
+<NAME>g_atomic_int_compare_and_exchange</NAME>
+<RETURNS>gboolean</RETURNS>
+gint32 *atomic
+gint32 oldval
+gint32 newval
+</FUNCTION>
+
+<FUNCTION>
+<NAME>g_atomic_pointer_get</NAME>
+<RETURNS>gpointer</RETURNS>
+gpointer *atomic
+</FUNCTION>
+
+<FUNCTION>
+<NAME>g_atomic_pointer_compare_and_exchange</NAME>
+<RETURNS>gboolean</RETURNS>
+gpointer *atomic
+gpointer oldval
+gpointer newval
+</FUNCTION>
+
+<FUNCTION>
+<NAME>g_atomic_int_inc</NAME>
+<RETURNS>void</RETURNS>
+gint32 *atomic
+</FUNCTION>
+
+<FUNCTION>
+<NAME>g_atomic_int_dec_and_test</NAME>
+<RETURNS>gboolean</RETURNS>
+gint32 *atomic
+</FUNCTION>
+
<STRUCT>
<NAME>GIConv</NAME>
</STRUCT>
</SECTION>
<SECTION>
+<TITLE>Atomic Operations</TITLE>
+<FILE>atomic_operations</FILE>
+g_atomic_int_get
+g_atomic_int_add
+g_atomic_int_exchange_and_add
+g_atomic_int_compare_and_exchange
+g_atomic_pointer_get
+g_atomic_pointer_compare_and_exchange
+g_atomic_int_inc
+g_atomic_int_dec_and_test
+</SECTION>
+
+<SUBSECTION Private>
+g_atomic_int_add_fallback
+g_atomic_int_exchange_and_add_fallback
+g_atomic_int_compare_and_exchange_fallback
+g_atomic_pointer_compare_and_exchange_fallback
+
+<SECTION>
<TITLE>IO Channels</TITLE>
<FILE>iochannels</FILE>
GIOChannel
--- /dev/null
+<!-- ##### SECTION Title ##### -->
+Atomic Operations
+
+<!-- ##### SECTION Short_Description ##### -->
+basic atomic integer and pointer operations
+
+<!-- ##### SECTION Long_Description ##### -->
+<para>
+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.
+</para>
+
+<para>
+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.
+</para>
+
+<note>
+<para>
+You must not directly read integers or pointers concurrently accessed
+by other threads with with the following functions directly. Always use
+g_atomic_int_get() and g_atomic_pointer_get() respectively. They are
+acting as a memory barrier.
+</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>
+
+<!-- ##### SECTION See_Also ##### -->
+<para>
+<variablelist>
+
+<varlistentry>
+<term>#GMutex</term>
+<listitem><para>GLib mutual exclusions.</para></listitem>
+</varlistentry>
+
+</variablelist>
+</para>
+
+<!-- ##### FUNCTION g_atomic_int_get ##### -->
+<para>
+Reads the value of the integer pointed to by @atomic. Also acts as
+a memory barrier.
+</para>
+
+@atomic: a pointer to a 32-bit integer.
+@Returns: the value of *@atomic.
+@Since: 2.4
+
+
+<!-- ##### FUNCTION g_atomic_int_add ##### -->
+<para>
+Atomically adds @val to the integer pointed to by @atomic.
+Also acts as a memory barrier.
+</para>
+
+@atomic: a pointer to a 32-bit integer.
+@val: the value to add to *@atomic.
+@Since: 2.4
+
+
+<!-- ##### FUNCTION g_atomic_int_exchange_and_add ##### -->
+<para>
+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.
+</para>
+
+@atomic: a pointer to a 32-bit integer.
+@val: the value to add to *@atomic.
+@Returns: the value of *@atomic before the addition.
+@Since: 2.4
+
+
+<!-- ##### FUNCTION g_atomic_int_compare_and_exchange ##### -->
+<para>
+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.
+</para>
+
+@atomic: a pointer to a 32-bit integer.
+@oldval: the assumed old value of *@atomic.
+@newval: the new value of *@atomic.
+@Returns: %TRUE, if *@atomic was equal @oldval. %FALSE otherwise.
+@Since: 2.4
+
+
+<!-- ##### FUNCTION g_atomic_pointer_get ##### -->
+<para>
+Reads the value of the pointer pointed to by @atomic. Also acts as
+a memory barrier.
+</para>
+
+@atomic: a pointer to a #gpointer.
+@Returns: the value to add to *@atomic.
+@Since: 2.4
+
+
+<!-- ##### FUNCTION g_atomic_pointer_compare_and_exchange ##### -->
+<para>
+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.
+</para>
+
+@atomic: a pointer to a #gpointer.
+@oldval: the assumed old value of *@atomic.
+@newval: the new value of *@atomic.
+@Returns: %TRUE, if *@atomic was equal @oldval. %FALSE otherwise.
+@Since: 2.4
+
+
+<!-- ##### FUNCTION g_atomic_int_inc ##### -->
+<para>
+Atomically increments the integer pointed to by @atomic by 1.
+</para>
+
+@atomic: a pointer to a 32-bit integer.
+@Since: 2.4
+
+
+<!-- ##### FUNCTION g_atomic_int_dec_and_test ##### -->
+<para>
+Atomically decrements the integer pointed to by @atomic by 1.
+</para>
+
+@atomic: a pointer to a 32-bit integer.
+@Returns: %TRUE, if the integer pointed to by @atomic is 0 after
+decrementing it.
+@Since: 2.4
+
+
libglib_2_0_la_SOURCES = \
garray.c \
gasyncqueue.c \
+ gatomic.c \
gbacktrace.c \
gbsearcharray.h \
gcache.c \
galloca.h \
garray.h \
gasyncqueue.h \
+ gatomic.h \
gbacktrace.h \
gcache.h \
gcompletion.h \
--- /dev/null
+/* GLIB - Library of useful routines for C programming
+ * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * GAtomic: atomic integer operation.
+ * Copyright (C) 2003 Sebastian Wilhelmi
+ *
+ * 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
+ * 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.
+ */
+
+#include <glib.h>
+
+#ifdef G_THREADS_ENABLED
+# if !defined (G_ATOMIC_USE_FALLBACK_IMPLEMENTATION)
+/* We have an inline implementation, which we can now use for the
+ * fallback implementation. This fallback implementation is only used by
+ * modules, which are not compliled with gcc
+ */
+
+gint32
+g_atomic_int_exchange_and_add_fallback (gint32 *atomic,
+ gint32 val)
+{
+ return g_atomic_int_exchange_and_add (atomic, val);
+}
+
+
+void
+g_atomic_int_add_fallback (gint32 *atomic,
+ gint32 val)
+{
+ g_atomic_int_add (atomic, val);
+}
+
+gboolean
+g_atomic_int_compare_and_exchange_fallback (gint32 *atomic,
+ gint32 oldval,
+ gint32 newval)
+{
+ return g_atomic_int_compare_and_exchange (atomic, oldval, newval);
+}
+
+gboolean
+g_atomic_pointer_compare_and_exchange_fallback (gpointer *atomic,
+ gpointer oldval,
+ gpointer newval)
+{
+ return g_atomic_pointer_compare_and_exchange (atomic, oldval, newval);
+}
+
+gint32
+g_atomic_int_get_fallback (gint32 *atomic)
+{
+ return g_atomic_int_get (atomic);
+}
+
+gint32
+g_atomic_pointer_get_fallback (gpointer *atomic)
+{
+ return g_atomic_int_get (atomic);
+}
+
+# else /* !G_ATOMIC_USE_FALLBACK_IMPLEMENTATION */
+/* We have to use the slow, but safe locking method */
+G_LOCK_DEFINE_STATIC (g_atomic_lock);
+
+gint32
+g_atomic_int_exchange_and_add_fallback (gint32 *atomic,
+ gint32 val)
+{
+ gint32 result;
+
+ G_LOCK (g_atomic_lock);
+ result = *atomic;
+ *atomic += val;
+ G_UNLOCK (g_atomic_lock);
+
+ return result;
+}
+
+
+void
+g_atomic_int_add_fallback (gint32 *atomic,
+ gint32 val)
+{
+ G_LOCK (g_atomic_lock);
+ *atomic += val;
+ G_UNLOCK (g_atomic_lock);
+}
+
+gboolean
+g_atomic_int_compare_and_exchange_fallback (gint32 *atomic,
+ gint32 oldval,
+ gint32 newval)
+{
+ gboolean result;
+
+ G_LOCK (g_atomic_lock);
+ if (*atomic == oldval)
+ {
+ result = TRUE;
+ *atomic = newval;
+ }
+ else
+ result = FALSE;
+ G_UNLOCK (g_atomic_lock);
+
+ return result;
+}
+
+gboolean
+g_atomic_pointer_compare_and_exchange_fallback (gpointer *atomic,
+ gpointer oldval,
+ gpointer newval)
+{
+ gboolean result;
+
+ G_LOCK (g_atomic_lock);
+ if (*atomic == oldval)
+ {
+ result = TRUE;
+ *atomic = newval;
+ }
+ else
+ result = FALSE;
+ G_UNLOCK (g_atomic_lock);
+
+ return result;
+}
+
+static inline gint32
+g_atomic_int_get_fallback (gint32 *atomic)
+{
+ gint32 result;
+
+ G_LOCK (g_atomic_lock);
+ result = *atomic;
+ G_UNLOCK (g_atomic_lock);
+
+ return result;
+}
+
+static inline gpointer
+g_atomic_pointer_get_fallback (gpointer *atomic)
+{
+ gpointer result;
+
+ G_LOCK (g_atomic_lock);
+ result = *atomic;
+ G_UNLOCK (g_atomic_lock);
+
+ return result;
+}
+
+
+# endif /* G_ATOMIC_USE_FALLBACK_IMPLEMENTATION */
+#else /* !G_THREADS_ENABLED */
+gint32 g_atomic_int_exchange_and_add (gint32 *atomic,
+ gint32 val)
+{
+ gint32 result = *atomic;
+ *atomic += val;
+ return result;
+}
+#endif /* G_THREADS_ENABLED */
+
--- /dev/null
+/* GLIB - Library of useful routines for C programming
+ * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * GAtomic: atomic integer operation.
+ * Copyright (C) 2003 Sebastian Wilhelmi
+ *
+ * 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
+ * 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.
+ */
+
+/*
+ * Modified by the GLib Team and others 1997-2000. See the AUTHORS
+ * file for a list of people on the GLib Team. See the ChangeLog
+ * files for a list of changes. These files are distributed with
+ * GLib at ftp://ftp.gtk.org/pub/gtk/.
+ */
+
+#ifndef __G_ATOMIC_H__
+#define __G_ATOMIC_H__
+
+#include <glib/gtypes.h>
+
+G_BEGIN_DECLS
+
+#ifdef G_THREADS_ENABLED
+
+gint32 g_atomic_int_exchange_and_add_fallback (gint32 *atomic,
+ gint32 val);
+void g_atomic_int_add_fallback (gint32 *atomic,
+ gint32 val);
+gboolean g_atomic_int_compare_and_exchange_fallback (gint32 *atomic,
+ gint32 oldval,
+ gint32 newval);
+gboolean g_atomic_pointer_compare_and_exchange_fallback (gpointer *atomic,
+ gpointer oldval,
+ gpointer newval);
+
+# if defined (__GNUC__)
+# if defined (G_ATOMIC_INLINED_IMPLEMENTATION_I486)
+/* Adapted from CVS version 1.10 of glibc's sysdeps/i386/i486/bits/atomic.h
+ */
+static inline gint32
+g_atomic_int_exchange_and_add (gint32 *atomic,
+ gint32 val)
+{
+ gint32 result;
+
+ __asm__ __volatile__ ("lock; xaddl %0,%1"
+ : "=r" (result), "=m" (*atomic)
+ : "0" (val), "m" (*atomic));
+ return result;
+}
+
+static inline void
+g_atomic_int_add (gint32 *atomic,
+ gint32 val)
+{
+ __asm__ __volatile__ ("lock; addl %1,%0"
+ : "=m" (*atomic)
+ : "ir" (val), "m" (*atomic));
+}
+
+static inline gboolean
+g_atomic_int_compare_and_exchange (gint32 *atomic,
+ gint32 oldval,
+ gint32 newval)
+{
+ gint32 result;
+
+ __asm __volatile ("lock; cmpxchgl %2, %1"
+ : "=a" (result), "=m" (*atomic)
+ : "r" (newval), "m" (*atomic), "0" (oldval));
+
+ return result == oldval;
+}
+
+/* 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 */
+
+static inline gboolean
+g_atomic_pointer_compare_and_exchange (gpointer *atomic,
+ gpointer oldval,
+ gpointer newval)
+{
+ gpointer result;
+
+ __asm __volatile ("lock; cmpxchgl %2, %1"
+ : "=a" (result), "=m" (*atomic)
+ : "r" (newval), "m" (*atomic), "0" (oldval));
+
+ return result == oldval;
+}
+
+# define G_ATOMIC_MEMORY_BARRIER() /* Not needed */
+
+# elif defined(G_ATOMIC_INLINED_IMPLEMENTATION_SPARCV9) \
+ && (defined(__sparcv8) || defined(__sparcv9) || defined(__sparc_v9__))
+/* Adapted from CVS version 1.3 of glibc's sysdeps/sparc/sparc64/bits/atomic.h
+ */
+/* Why the test for __sparcv8, wheras really the sparcv9 architecture
+ * is required for the folowing assembler instructions? On
+ * sparc-solaris the only difference detectable at compile time
+ * between no -m and -mcpu=v9 is __sparcv8.
+ *
+ * However, in case -mcpu=v8 is set, the assembler will fail. This
+ * should be rare however, as there are only very few v8-not-v9
+ * machines still out there (and we can't do better).
+ */
+static inline gboolean
+g_atomic_int_compare_and_exchange (gint32 *atomic,
+ gint32 oldval,
+ gint32 newval)
+{
+ gint32 result;
+ __asm __volatile ("cas [%4], %2, %0"
+ : "=r" (result), "=m" (*atomic)
+ : "r" (oldval), "m" (*atomic), "r" (atomic),
+ "0" (newval));
+ return result != 0;
+}
+
+# if GLIB_SIZEOF_VOID_P == 4 /* 32-bit system */
+static inline gboolean
+g_atomic_pointer_compare_and_exchange (gpointer *atomic,
+ gpointer oldval,
+ gpointer newval)
+{
+ gpointer result;
+ __asm __volatile ("cas [%4], %2, %0"
+ : "=r" (result), "=m" (*atomic)
+ : "r" (oldval), "m" (*atomic), "r" (atomic),
+ "0" (newval));
+ return result != 0;
+}
+# elif GLIB_SIZEOF_VOID_P == 8 /* 64-bit system */
+static inline gboolean
+g_atomic_pointer_compare_and_exchange (gpointer *atomic,
+ gpointer oldval,
+ gpointer newval)
+{
+ 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 != 0;
+}
+# else /* What's that */
+# error "Your system has an unsupported pointer size"
+# endif /* GLIB_SIZEOF_VOID_P */
+static inline gint32
+g_atomic_int_exchange_and_add (gint32 *atomic,
+ gint32 val)
+{
+ gint32 result;
+ do
+ result = *atomic;
+ while (!g_atomic_int_compare_and_exchange (atomic, result, result + val));
+
+ return result;
+}
+
+static inline void
+g_atomic_int_add (gint32 *atomic,
+ gint32 val)
+{
+ g_atomic_int_exchange_and_add (atomic, val);
+}
+
+# define G_ATOMIC_MEMORY_BARRIER() \
+ __asm __volatile ("membar #LoadLoad | #LoadStore" \
+ " | #StoreLoad | #StoreStore" : : : "memory")
+
+# elif defined(G_ATOMIC_INLINED_IMPLEMENTATION_ALPHA)
+/* Adapted from CVS version 1.3 of glibc's sysdeps/alpha/bits/atomic.h
+ */
+static inline gboolean
+g_atomic_int_compare_and_exchange (gint32 *atomic,
+ gint32 oldval,
+ gint32 newval)
+{
+ gint32 result;
+ gint32 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" ((gint64)oldval),
+ "Ir" (newval)
+ : "memory");
+ return result != 0;
+}
+# if GLIB_SIZEOF_VOID_P == 4 /* 32-bit system */
+static inline gboolean
+g_atomic_pointer_compare_and_exchange (gpointer *atomic,
+ gpointer oldval,
+ gpointer newval)
+{
+ gint32 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" ((gint64)oldval),
+ "Ir" (newval)
+ : "memory");
+ return result != 0;
+}
+# elif GLIB_SIZEOF_VOID_P == 8 /* 64-bit system */
+static inline gboolean
+g_atomic_pointer_compare_and_exchange (gpointer *atomic,
+ gpointer oldval,
+ gpointer newval)
+{
+ gint32 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" ((gint64)oldval),
+ "Ir" (newval)
+ : "memory");
+ return result != 0;
+}
+# else /* What's that */
+# error "Your system has an unsupported pointer size"
+# endif /* GLIB_SIZEOF_VOID_P */
+static inline gint32
+g_atomic_int_exchange_and_add (gint32 *atomic,
+ gint32 val)
+{
+ gint32 result;
+ do
+ result = *atomic;
+ while (!g_atomic_int_compare_and_exchange (atomic, result, result + val));
+
+ return result;
+}
+
+static inline void
+g_atomic_int_add (gint32 *atomic,
+ gint32 val)
+{
+ g_atomic_int_exchange_and_add (atomic, val);
+}
+
+# define G_ATOMIC_MEMORY_BARRIER() __asm ("mb" : : : "memory")
+
+# elif defined(G_ATOMIC_INLINED_IMPLEMENTATION_X86_64)
+/* Adapted from CVS version 1.9 of glibc's sysdeps/x86_64/bits/atomic.h
+ */
+static inline gint32
+g_atomic_int_exchange_and_add (gint32 *atomic,
+ gint32 val)
+{
+ gint32 result;
+
+ __asm__ __volatile__ ("lock; xaddl %0,%1"
+ : "=r" (result), "=m" (*atomic)
+ : "0" (val), "m" (*atomic));
+ return result;
+}
+
+static inline void
+g_atomic_int_add (gint32 *atomic,
+ gint32 val)
+{
+ __asm__ __volatile__ ("lock; addl %1,%0"
+ : "=m" (*atomic)
+ : "ir" (val), "m" (*atomic));
+}
+
+static inline gboolean
+g_atomic_int_compare_and_exchange (gint32 *atomic,
+ gint32 oldval,
+ gint32 newval)
+{
+ gint32 result;
+
+ __asm __volatile ("lock; cmpxchgl %2, %1"
+ : "=a" (result), "=m" (*atomic)
+ : "r" (newval), "m" (*atomic), "0" (oldval));
+
+ return result == oldval;
+}
+
+static inline gboolean
+g_atomic_pointer_compare_and_exchange (gpointer *atomic,
+ gpointer oldval,
+ gpointer newval)
+{
+ gpointer result;
+
+ __asm __volatile ("lock; cmpxchgq %q2, %1"
+ : "=a" (result), "=m" (*atomic)
+ : "r" (newval), "m" (*atomic), "0" (oldval));
+
+ return result == oldval;
+}
+
+# define G_ATOMIC_MEMORY_BARRIER() /* Not needed */
+
+# elif defined(G_ATOMIC_INLINED_IMPLEMENTATION_POWERPC)
+/* Adapted from CVS version 1.12 of glibc's sysdeps/powerpc/bits/atomic.h
+ * and CVS version 1.3 of glibc's sysdeps/powerpc/powerpc32/bits/atomic.h
+ * and CVS version 1.2 of glibc's sysdeps/powerpc/powerpc64/bits/atomic.h
+ */
+static inline gint32
+g_atomic_int_exchange_and_add (gint32 *atomic,
+ gint32 val)
+{
+ gint32 result, temp;
+ __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), "2" (*atomic)
+ : "cr0", "memory");
+ return result;
+}
+
+static inline void
+g_atomic_int_add (gint32 *atomic,
+ gint32 val)
+{
+ g_atomic_int_exchange_and_add (atomic, val);
+}
+
+# if GLIB_SIZEOF_VOID_P == 4 /* 32-bit system */
+static inline gboolean
+g_atomic_int_compare_and_exchange (gint32 *atomic,
+ gint32 oldval,
+ gint32 newval)
+{
+ gint32 result;
+ __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");
+ return result == 0;
+}
+
+static inline gboolean
+g_atomic_pointer_compare_and_exchange (gpointer *atomic,
+ gpointer oldval,
+ gpointer newval)
+{
+ gpointer result;
+ __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");
+ return result == 0;
+}
+# elif GLIB_SIZEOF_VOID_P == 8 /* 64-bit system */
+static inline gboolean
+g_atomic_int_compare_and_exchange (gint32 *atomic,
+ gint32 oldval,
+ gint32 newval)
+{
+ __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");
+ return result == 0;
+}
+
+static inline gboolean
+g_atomic_pointer_compare_and_exchange (gpointer *atomic,
+ gpointer oldval,
+ gpointer newval)
+{
+ gpointer result;
+ __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");
+ return result == 0;
+}
+# else /* What's that */
+# error "Your system has an unsupported pointer size"
+# endif /* GLIB_SIZEOF_VOID_P */
+
+# define G_ATOMIC_MEMORY_BARRIER() __asm ("sync" : : : "memory")
+
+# elif defined(G_ATOMIC_INLINED_IMPLEMENTATION_IA64)
+/* Adapted from CVS version 1.8 of glibc's sysdeps/ia64/bits/atomic.h
+ */
+static inline gint32
+g_atomic_int_exchange_and_add (gint32 *atomic,
+ gint32 val)
+{
+ return __sync_fetch_and_add_si (atomic, val);
+}
+
+static inline void
+g_atomic_int_add (gint32 *atomic,
+ gint32 val)
+{
+ __sync_fetch_and_add_si (atomic, val);
+}
+
+static inline gboolean
+g_atomic_int_compare_and_exchange (gint32 *atomic,
+ gint32 oldval,
+ gint32 newval)
+{
+ return __sync_bool_compare_and_exchange_si (atomic, oldval, newval);
+}
+
+static inline gboolean
+g_atomic_pointer_compare_and_exchange (gpointer *atomic,
+ gpointer oldval,
+ gpointer newval)
+{
+ return __sync_bool_compare_and_exchange_di ((long *)atomic,
+ (long)oldval, (long)newval);
+}
+
+# define G_ATOMIC_MEMORY_BARRIER() __sync_synchronize ()
+
+# else /* !G_ATOMIC_INLINED_IMPLEMENTATION_... */
+# define G_ATOMIC_USE_FALLBACK_IMPLEMENTATION
+# endif /* G_ATOMIC_INLINED_IMPLEMENTATION_... */
+# else /* !__GNU__ */
+# define G_ATOMIC_USE_FALLBACK_IMPLEMENTATION
+# endif /* __GNUC__ */
+#else /* !G_THREADS_ENABLED */
+gint32 g_atomic_int_exchange_and_add (gint32 *atomic, gint32 val);
+# define g_atomic_int_add(atomic, val) (void)(*(atomic) += (val))
+# define g_atomic_int_compare_and_exchange(atomic, oldval, newval) \
+ (*(atomic) == (oldval) ? (*(atomic) = (newval), TRUE) : FALSE)
+# define g_atomic_pointer_compare_and_exchange(atomic, oldval, newval) \
+ (*(atomic) == (oldval) ? (*(atomic) = (newval), TRUE) : FALSE)
+# define g_atomic_int_get(atomic) (*(atomic))
+# define g_atomic_pointer_get(atomic) (*(atomic))
+#endif /* G_THREADS_ENABLED */
+
+#ifdef G_ATOMIC_USE_FALLBACK_IMPLEMENTATION
+# define g_atomic_int_exchange_and_add \
+ g_atomic_int_exchange_and_add_fallback
+# define g_atomic_int_add \
+ g_atomic_int_add_fallback
+# define g_atomic_int_compare_and_exchange \
+ g_atomic_int_compare_and_exchange_fallback
+# define g_atomic_pointer_compare_and_exchange \
+ g_atomic_pointer_compare_and_exchange_fallback
+# define g_atomic_int_get \
+ g_atomic_int_get_fallback
+# define g_atomic_pointer_get \
+ g_atomic_pointer_get_fallback
+#else /* !G_ATOMIC_USE_FALLBACK_IMPLEMENTATION */
+static inline gint32
+g_atomic_int_get (gint32 *atomic)
+{
+ gint32 result = *atomic;
+ G_ATOMIC_MEMORY_BARRIER ();
+ return result;
+}
+
+static inline gpointer
+g_atomic_pointer_get (gpointer *atomic)
+{
+ gpointer result = *atomic;
+ G_ATOMIC_MEMORY_BARRIER ();
+ return result;
+}
+#endif /* G_ATOMIC_USE_FALLBACK_IMPLEMENTATION */
+
+#define g_atomic_int_inc(atomic) (g_atomic_int_add ((atomic), 1))
+#define g_atomic_int_dec_and_test(atomic) \
+ (g_atomic_int_exchange_and_add ((atomic), -1) == 1)
+
+G_END_DECLS
+
+#endif /* __G_ATOMIC_H__ */
#include <glib/galloca.h>
#include <glib/garray.h>
#include <glib/gasyncqueue.h>
+#include <glib/gatomic.h>
#include <glib/gbacktrace.h>
#include <glib/gcache.h>
#include <glib/gcompletion.h>
endif
test_programs = \
+ atomic-test \
array-test \
$(CXX_TEST) \
child-test \
thread_ldadd = $(libgthread) $(G_THREAD_LIBS) $(progs_ldadd)
module_ldadd = $(libgmodule) $(G_MODULE_LIBS) $(progs_ldadd)
+atomic_test_LDADD = $(progs_ldadd)
array_test_LDADD = $(progs_ldadd)
child_test_LDADD = $(thread_ldadd)
completion_test_LDADD = $(progs_ldadd)
--- /dev/null
+#undef G_DISABLE_ASSERT
+#undef G_LOG_DOMAIN
+
+#include <glib.h>
+
+/* Obviously we can't test that the operations are atomic, but we can
+ * at least test, that they do, what they ought to do */
+
+int
+main (int argc,
+ char *argv[])
+{
+ gint i;
+ gint32 atomic = -5;
+ gpointer atomic_pointer = NULL;
+ gpointer biggest_pointer = atomic_pointer - 1;
+
+ for (i = 0; i < 15; i++)
+ g_atomic_int_inc (&atomic);
+ g_assert (atomic == 10);
+ for (i = 0; i < 9; i++)
+ g_assert (!g_atomic_int_dec_and_test (&atomic));
+ g_assert (g_atomic_int_dec_and_test (&atomic));
+ g_assert (atomic == 0);
+
+ g_assert (g_atomic_int_exchange_and_add (&atomic, 5) == 0);
+ g_assert (atomic == 5);
+
+ g_assert (g_atomic_int_exchange_and_add (&atomic, -10) == 5);
+ g_assert (atomic == -5);
+
+ g_atomic_int_add (&atomic, 20);
+ g_assert (atomic == 15);
+
+ g_atomic_int_add (&atomic, -35);
+ g_assert (atomic == -20);
+
+ g_assert (atomic == g_atomic_int_get (&atomic));
+
+ g_assert (g_atomic_int_compare_and_exchange (&atomic, -20, 20));
+ g_assert (atomic == 20);
+
+ g_assert (!g_atomic_int_compare_and_exchange (&atomic, 42, 12));
+ g_assert (atomic == 20);
+
+ g_assert (g_atomic_pointer_compare_and_exchange (&atomic_pointer,
+ NULL, biggest_pointer));
+ g_assert (atomic_pointer == biggest_pointer);
+
+ g_assert (atomic_pointer == g_atomic_pointer_get (&atomic_pointer));
+
+ g_assert (g_atomic_pointer_compare_and_exchange (&atomic_pointer,
+ biggest_pointer, NULL));
+ g_assert (atomic_pointer == NULL);
+
+ return 0;
+}
projects / platform / upstream / glib.git / commitdiff