rewrite atomic using a global mutex

Author: Philippe Simons

CMakeLists.txt

@@ -49,6 +49,16 @@ set ( LIB_VERSION_REVISION 1 )
 set ( LIB_VERSION_INFO
       "${LIB_VERSION_CURRENT}.${LIB_VERSION_AGE}.${LIB_VERSION_REVISION}" )
 
+# the default C standard to use for all targets
+set(CMAKE_C_STANDARD 90)
+
+# the default C++ standard to use for all targets
+set(CMAKE_CXX_STANDARD 98)
+
+# whether to use gnu extensions
+set(CMAKE_C_EXTENSIONS ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
 include_directories (
     android
     ${CMAKE_BINARY_DIR}
@@ -185,7 +195,6 @@ endif()
 
 target_compile_options(libfluidsynth-OBJ
                             PRIVATE
-                            -std=gnu11
                             -Wall
                             -DHAVE_CONFIG_H
                             -Wno-unused-variable

src/utils/fluid_atomic.h

@@ -34,6 +34,81 @@
 // Do not include pthread on windows. It includes winsock.h, which collides with ws2tcpip.h from fluid_sys.h
 // It isn't need on Windows anyway.
 #include <pthread.h>
+
+static pthread_mutex_t g_atomic_lock = PTHREAD_MUTEX_INITIALIZER;
+
+int
+pthread_atomic_int_get(const volatile int *atomic)
+{
+  int value;
+
+  pthread_mutex_lock (&g_atomic_lock);
+  value = *atomic;
+  pthread_mutex_unlock (&g_atomic_lock);
+
+  return value;
+}
+
+void
+pthread_atomic_int_inc(volatile int *atomic)
+{
+  pthread_mutex_lock (&g_atomic_lock);
+  (*atomic)++;
+  pthread_mutex_unlock (&g_atomic_lock);
+}
+
+void
+pthread_atomic_int_set(volatile int *atomic,
+                    int           value)
+{
+  pthread_mutex_lock (&g_atomic_lock);
+  *atomic = value;
+  pthread_mutex_unlock (&g_atomic_lock);
+}
+
+bool
+pthread_atomic_int_dec_and_test (volatile int *atomic)
+{
+  bool is_zero;
+
+  pthread_mutex_lock (&g_atomic_lock);
+  is_zero = --(*atomic) == 0;
+  pthread_mutex_unlock (&g_atomic_lock);
+
+  return is_zero;
+}
+
+bool
+pthread_atomic_int_compare_and_exchange(volatile int *atomic,
+                                     int           oldval,
+                                     int           newval)
+{
+  bool success;
+
+  pthread_mutex_lock (&g_atomic_lock);
+
+  if ((success = (*atomic == oldval)))
+    *atomic = newval;
+
+  pthread_mutex_unlock (&g_atomic_lock);
+
+  return success;
+}
+
+int
+pthread_atomic_int_add(volatile int *atomic,
+                    int           val)
+{
+  int oldval;
+
+  pthread_mutex_lock (&g_atomic_lock);
+  oldval = *atomic;
+  *atomic = oldval + val;
+  pthread_mutex_unlock (&g_atomic_lock);
+
+  return oldval;
+}
+
 #endif
 
 /* WIN32 HACK - Flag used to differentiate between a file descriptor and a socket.

src/utils/fluid_sys.c

@@ -172,6 +172,7 @@ char* fluid_get_windows_error(void);
 #define FLUID_INT_TO_POINTER(x)   ((void *)(intptr_t)(x))
 
 /* Endian detection */
+#include <stdbool.h>
 #define FLUID_IS_BIG_ENDIAN       false
 
 #define FLUID_LE32TOH(x)          le32toh(x)
@@ -342,7 +343,45 @@ int fluid_thread_join(fluid_thread_t *thread);
 
 /* Atomic operations */
 
-#include "fluid_atomic.h"
+#if HAVE_PTHREAD_H
+
+int pthread_atomic_int_get(const volatile int *atomic);
+void pthread_atomic_int_inc(volatile int *atomic);
+void pthread_atomic_int_set(volatile int *atomic, int value);
+bool pthread_atomic_int_dec_and_test (volatile int *atomic);
+bool pthread_atomic_int_compare_and_exchange(volatile int *atomic, int oldval, int newval);
+int pthread_atomic_int_add(volatile int *atomic, int val);
+
+#define fluid_atomic_int_inc(_pi) pthread_atomic_int_inc(_pi)
+#define fluid_atomic_int_get(_pi) pthread_atomic_int_get(_pi)
+#define fluid_atomic_int_set(_pi, _val) pthread_atomic_int_set(_pi, _val)
+#define fluid_atomic_int_dec_and_test(_pi) pthread_atomic_int_dec_and_test(_pi)
+#define fluid_atomic_int_compare_and_exchange(_pi, _old, _new) \
+  pthread_atomic_int_compare_and_exchange(_pi, _old, _new)
+#define fluid_atomic_int_add(_pi, _add) \
+  pthread_atomic_int_add(_pi, _add)
+#define fluid_atomic_int_exchange_and_add(_pi, _add) \
+  pthread_atomic_int_add(_pi, _add)
+
+static FLUID_INLINE void
+fluid_atomic_float_set(fluid_atomic_float_t *fptr, float val)
+{
+    int32_t ival;
+    memcpy(&ival, &val, 4);
+    fluid_atomic_int_set((fluid_atomic_int_t *)fptr, ival);
+}
+
+static FLUID_INLINE float
+fluid_atomic_float_get(fluid_atomic_float_t *fptr)
+{
+    int32_t ival;
+    float fval;
+    ival = fluid_atomic_int_get((fluid_atomic_int_t *)fptr);
+    memcpy(&fval, &ival, 4);
+    return fval;
+}
+
+#endif
 
 /* Sockets and I/O */
 

src/utils/fluid_sys.h

@@ -77,15 +77,9 @@ typedef double fluid_real_t;
 
 
 /** Atomic types */
-typedef struct {
-    volatile int value;
-} fluid_atomic_int_t;
-typedef struct {
-    volatile unsigned value;
-} fluid_atomic_uint_t;
-typedef struct {
-    volatile float value;
-} fluid_atomic_float_t;
+typedef int fluid_atomic_int_t;
+typedef unsigned int fluid_atomic_uint_t;
+typedef float fluid_atomic_float_t;
 
 /***************************************************************
  *