ovs-atomic: New library for atomic operations.

This library should prove useful for the threading changes coming up.
The following commit introduces one (very simple) user.

Signed-off-by: Ben Pfaff <[email protected]>
Acked-by: Ethan Jackson <[email protected]>

configure.ac

@@ -64,7 +64,7 @@ AC_CHECK_MEMBERS([struct stat.st_mtim.tv_nsec, struct stat.st_mtimensec],
   [], [], [[#include <sys/stat.h>]])
 AC_CHECK_MEMBERS([struct ifreq.ifr_flagshigh], [], [], [[#include <net/if.h>]])
 AC_CHECK_FUNCS([mlockall strnlen getloadavg statvfs getmntent_r])
-AC_CHECK_HEADERS([mntent.h sys/statvfs.h linux/types.h linux/if_ether.h])
+AC_CHECK_HEADERS([mntent.h sys/statvfs.h linux/types.h linux/if_ether.h stdatomic.h])
 AC_CHECK_HEADERS([net/if_mib.h], [], [], [[#include <sys/types.h>
 #include <net/if.h>]])
 
@@ -81,6 +81,10 @@ OVS_CHECK_GROFF
 OVS_CHECK_GNU_MAKE
 OVS_CHECK_CACHE_TIME
 OVS_CHECK_TLS
+OVS_CHECK_ATOMIC_ALWAYS_LOCK_FREE(1)
+OVS_CHECK_ATOMIC_ALWAYS_LOCK_FREE(2)
+OVS_CHECK_ATOMIC_ALWAYS_LOCK_FREE(4)
+OVS_CHECK_ATOMIC_ALWAYS_LOCK_FREE(8)
 
 OVS_ENABLE_OPTION([-Wall])
 OVS_ENABLE_OPTION([-Wno-sign-compare])

lib/automake.mk

@@ -121,6 +121,13 @@ lib_libopenvswitch_a_SOURCES = \
 	lib/ofp-version-opt.c \
 	lib/ofpbuf.c \
 	lib/ofpbuf.h \
+	lib/ovs-atomic-c11.h \
+	lib/ovs-atomic-gcc4+.c \
+	lib/ovs-atomic-gcc4+.h \
+	lib/ovs-atomic-gcc4.7+.h \
+	lib/ovs-atomic-pthreads.c \
+	lib/ovs-atomic-pthreads.h \
+	lib/ovs-atomic.h \
 	lib/ovs-thread.c \
 	lib/ovs-thread.h \
 	lib/ovsdb-data.c \

lib/ovs-atomic-c11.h

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2013 Nicira, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* This header implements atomic operation primitives on compilers that
+ * have built-in support for C11 <stdatomic.h>  */
+#ifndef IN_OVS_ATOMIC_H
+#error "This header should only be included indirectly via ovs-atomic.h."
+#endif
+
+#include <stdatomic.h>
+
+/* Nonstandard atomic types. */
+typedef _Atomic(uint8_t)   atomic_uint8_t;
+typedef _Atomic(uint16_t)  atomic_uint16_t;
+typedef _Atomic(uint32_t)  atomic_uint32_t;
+typedef _Atomic(uint64_t)  atomic_uint64_t;
+
+typedef _Atomic(int8_t)    atomic_int8_t;
+typedef _Atomic(int16_t)   atomic_int16_t;
+typedef _Atomic(int32_t)   atomic_int32_t;
+typedef _Atomic(int64_t)   atomic_int64_t;
+
+#define atomic_read(SRC, DST) \
+    atomic_read_explicit(SRC, DST, memory_order_seq_cst)
+#define atomic_read_explicit(SRC, DST, ORDER)   \
+    (*(DST) = atomic_load_explicit(SRC, ORDER), \
+     (void) 0)
+
+#define atomic_add(RMW, ARG, ORIG) \
+    atomic_add_explicit(RMW, ARG, ORIG, memory_order_seq_cst)
+#define atomic_sub(RMW, ARG, ORIG) \
+    atomic_sub_explicit(RMW, ARG, ORIG, memory_order_seq_cst)
+#define atomic_or(RMW, ARG, ORIG) \
+    atomic_or_explicit(RMW, ARG, ORIG, memory_order_seq_cst)
+#define atomic_xor(RMW, ARG, ORIG) \
+    atomic_xor_explicit(RMW, ARG, ORIG, memory_order_seq_cst)
+#define atomic_and(RMW, ARG, ORIG) \
+    atomic_and_explicit(RMW, ARG, ORIG, memory_order_seq_cst)
+
+#define atomic_add_explicit(RMW, ARG, ORIG, ORDER) \
+    (*(ORIG) = atomic_fetch_add_explicit(RMW, ARG, ORDER), (void) 0)
+#define atomic_sub_explicit(RMW, ARG, ORIG, ORDER) \
+    (*(ORIG) = atomic_fetch_sub_explicit(RMW, ARG, ORDER), (void) 0)
+#define atomic_or_explicit(RMW, ARG, ORIG, ORDER) \
+    (*(ORIG) = atomic_fetch_or_explicit(RMW, ARG, ORDER), (void) 0)
+#define atomic_xor_explicit(RMW, ARG, ORIG, ORDER) \
+    (*(ORIG) = atomic_fetch_xor_explicit(RMW, ARG, ORDER), (void) 0)
+#define atomic_and_explicit(RMW, ARG, ORIG, ORDER) \
+    (*(ORIG) = atomic_fetch_and_explicit(RMW, ARG, ORDER), (void) 0)

lib/ovs-atomic-gcc4+.c

@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2013 Nicira, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <config.h>
+
+#include "ovs-atomic.h"
+#include "ovs-thread.h"
+
+#if OVS_ATOMIC_GCC4P_IMPL
+static pthread_mutex_t mutex = PTHREAD_ADAPTIVE_MUTEX_INITIALIZER;
+
+#define DEFINE_LOCKED_OP(TYPE, NAME, OPERATOR)                          \
+    TYPE##_t                                                            \
+    locked_##TYPE##_##NAME(struct locked_##TYPE *u, TYPE##_t arg)       \
+    {                                                                   \
+        TYPE##_t old_value;                                             \
+                                                                        \
+        xpthread_mutex_lock(&mutex);                                    \
+        old_value = u->value;                                           \
+        u->value OPERATOR arg;                                          \
+        xpthread_mutex_unlock(&mutex);                                  \
+                                                                        \
+        return old_value;                                               \
+    }
+
+#define DEFINE_LOCKED_TYPE(TYPE)                                        \
+    TYPE##_t                                                            \
+    locked_##TYPE##_load(const struct locked_##TYPE *u)                 \
+    {                                                                   \
+        TYPE##_t value;                                                 \
+                                                                        \
+        xpthread_mutex_lock(&mutex);                                    \
+        value = u->value;                                               \
+        xpthread_mutex_unlock(&mutex);                                  \
+                                                                        \
+        return value;                                                   \
+    }                                                                   \
+                                                                        \
+    void                                                                \
+    locked_##TYPE##_store(struct locked_##TYPE *u, TYPE##_t value)      \
+    {                                                                   \
+        xpthread_mutex_lock(&mutex);                                    \
+        u->value = value;                                               \
+        xpthread_mutex_unlock(&mutex);                                  \
+    }                                                                   \
+    DEFINE_LOCKED_OP(TYPE, add, +=);                                    \
+    DEFINE_LOCKED_OP(TYPE, sub, -=);                                    \
+    DEFINE_LOCKED_OP(TYPE, or,  |=);                                    \
+    DEFINE_LOCKED_OP(TYPE, xor, ^=);                                    \
+    DEFINE_LOCKED_OP(TYPE, and, &=)
+
+DEFINE_LOCKED_TYPE(uint64);
+DEFINE_LOCKED_TYPE(int64);
+
+#endif  /* OVS_ATOMIC_GCC4P_IMPL */