This makes it possible to add new uses of the underlying types for
these declarations without the "typedef" wrappers. The following commit
will make use of that feature.
Signed-off-by: Ben Pfaff <b...@nicira.com>
---
lib/ovs-atomic-gcc4+.h | 56 +++++++++++++++++++++----------------------
lib/ovs-atomic-pthreads.h | 60 ++++++++++++++++++++++-------------------------
2 files changed, 56 insertions(+), 60 deletions(-)
diff --git a/lib/ovs-atomic-gcc4+.h b/lib/ovs-atomic-gcc4+.h
index b465181..8e8b8e0 100644
--- a/lib/ovs-atomic-gcc4+.h
+++ b/lib/ovs-atomic-gcc4+.h
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2013 Nicira, Inc.
+ * Copyright (c) 2013, 2014 Nicira, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -21,28 +21,28 @@
#define OVS_ATOMIC_GCC4P_IMPL 1
-#define DEFINE_LOCKLESS_ATOMIC(TYPE, NAME) typedef struct { TYPE value; } NAME
+#define LOCKLESS_ATOMIC(TYPE) struct { TYPE value; }
#define ATOMIC_BOOL_LOCK_FREE 2
-DEFINE_LOCKLESS_ATOMIC(bool, atomic_bool);
+typedef LOCKLESS_ATOMIC(bool) atomic_bool;
#define ATOMIC_CHAR_LOCK_FREE 2
-DEFINE_LOCKLESS_ATOMIC(char, atomic_char);
-DEFINE_LOCKLESS_ATOMIC(signed char, atomic_schar);
-DEFINE_LOCKLESS_ATOMIC(unsigned char, atomic_uchar);
+typedef LOCKLESS_ATOMIC(char) atomic_char;
+typedef LOCKLESS_ATOMIC(signed char) atomic_schar;
+typedef LOCKLESS_ATOMIC(unsigned char) atomic_uchar;
#define ATOMIC_SHORT_LOCK_FREE 2
-DEFINE_LOCKLESS_ATOMIC(short, atomic_short);
-DEFINE_LOCKLESS_ATOMIC(unsigned short, atomic_ushort);
+typedef LOCKLESS_ATOMIC(short) atomic_short;
+typedef LOCKLESS_ATOMIC(unsigned short) atomic_ushort;
#define ATOMIC_INT_LOCK_FREE 2
-DEFINE_LOCKLESS_ATOMIC(int, atomic_int);
-DEFINE_LOCKLESS_ATOMIC(unsigned int, atomic_uint);
+typedef LOCKLESS_ATOMIC(int) atomic_int;
+typedef LOCKLESS_ATOMIC(unsigned int) atomic_uint;
#if ULONG_MAX <= UINTPTR_MAX
#define ATOMIC_LONG_LOCK_FREE 2
- DEFINE_LOCKLESS_ATOMIC(long, atomic_long);
- DEFINE_LOCKLESS_ATOMIC(unsigned long, atomic_ulong);
+ typedef LOCKLESS_ATOMIC(long) atomic_long;
+ typedef LOCKLESS_ATOMIC(unsigned long) atomic_ulong;
#elif ULONG_MAX == UINT64_MAX
#define ATOMIC_LONG_LOCK_FREE 0
typedef struct locked_int64 atomic_long;
@@ -53,8 +53,8 @@ DEFINE_LOCKLESS_ATOMIC(unsigned int, atomic_uint);
#if ULLONG_MAX <= UINTPTR_MAX
#define ATOMIC_LLONG_LOCK_FREE 2
- DEFINE_LOCKLESS_ATOMIC(long long, atomic_llong);
- DEFINE_LOCKLESS_ATOMIC(unsigned long long, atomic_ullong);
+ typedef LOCKLESS_ATOMIC(long long) atomic_llong;
+ typedef LOCKLESS_ATOMIC(unsigned long long) atomic_ullong;
#elif ULLONG_MAX == UINT64_MAX
#define ATOMIC_LLONG_LOCK_FREE 0
typedef struct locked_int64 atomic_llong;
@@ -64,8 +64,8 @@ DEFINE_LOCKLESS_ATOMIC(unsigned int, atomic_uint);
#endif
#if SIZE_MAX <= UINTPTR_MAX
- DEFINE_LOCKLESS_ATOMIC(size_t, atomic_size_t);
- DEFINE_LOCKLESS_ATOMIC(ptrdiff_t, atomic_ptrdiff_t);
+ typedef LOCKLESS_ATOMIC(size_t) atomic_size_t;
+ typedef LOCKLESS_ATOMIC(ptrdiff_t) atomic_ptrdiff_t;
#elif SIZE_MAX == UINT64_MAX
typedef struct locked_uint64 atomic_size_t;
typedef struct locked_int64 atomic_ptrdiff_t;
@@ -74,8 +74,8 @@ DEFINE_LOCKLESS_ATOMIC(unsigned int, atomic_uint);
#endif
#if UINTMAX_MAX <= UINTPTR_MAX
- DEFINE_LOCKLESS_ATOMIC(intmax_t, atomic_intmax_t);
- DEFINE_LOCKLESS_ATOMIC(uintmax_t, atomic_uintmax_t);
+ typedef LOCKLESS_ATOMIC(intmax_t) atomic_intmax_t;
+ typedef LOCKLESS_ATOMIC(uintmax_t) atomic_uintmax_t;
#elif UINTMAX_MAX == UINT64_MAX
typedef struct locked_int64 atomic_intmax_t;
typedef struct locked_uint64 atomic_uintmax_t;
@@ -84,19 +84,19 @@ DEFINE_LOCKLESS_ATOMIC(unsigned int, atomic_uint);
#endif
#define ATOMIC_POINTER_LOCK_FREE 2
-DEFINE_LOCKLESS_ATOMIC(intptr_t, atomic_intptr_t);
-DEFINE_LOCKLESS_ATOMIC(uintptr_t, atomic_uintptr_t);
+typedef LOCKLESS_ATOMIC(intptr_t) atomic_intptr_t;
+typedef LOCKLESS_ATOMIC(uintptr_t) atomic_uintptr_t;
/* Nonstandard atomic types. */
-DEFINE_LOCKLESS_ATOMIC(uint8_t, atomic_uint8_t);
-DEFINE_LOCKLESS_ATOMIC(uint16_t, atomic_uint16_t);
-DEFINE_LOCKLESS_ATOMIC(uint32_t, atomic_uint32_t);
-DEFINE_LOCKLESS_ATOMIC(int8_t, atomic_int8_t);
-DEFINE_LOCKLESS_ATOMIC(int16_t, atomic_int16_t);
-DEFINE_LOCKLESS_ATOMIC(int32_t, atomic_int32_t);
+typedef LOCKLESS_ATOMIC(uint8_t) atomic_uint8_t;
+typedef LOCKLESS_ATOMIC(uint16_t) atomic_uint16_t;
+typedef LOCKLESS_ATOMIC(uint32_t) atomic_uint32_t;
+typedef LOCKLESS_ATOMIC(int8_t) atomic_int8_t;
+typedef LOCKLESS_ATOMIC(int16_t) atomic_int16_t;
+typedef LOCKLESS_ATOMIC(int32_t) atomic_int32_t;
#if UINT64_MAX <= UINTPTR_MAX
- DEFINE_LOCKLESS_ATOMIC(uint64_t, atomic_uint64_t);
- DEFINE_LOCKLESS_ATOMIC(int64_t, atomic_int64_t);
+ typedef LOCKLESS_ATOMIC(uint64_t) atomic_uint64_t;
+ typedef LOCKLESS_ATOMIC(int64_t) atomic_int64_t;
#else
typedef struct locked_uint64 atomic_uint64_t;
typedef struct locked_int64 atomic_int64_t;
diff --git a/lib/ovs-atomic-pthreads.h b/lib/ovs-atomic-pthreads.h
index dc8f498..b0ca524 100644
--- a/lib/ovs-atomic-pthreads.h
+++ b/lib/ovs-atomic-pthreads.h
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2013 Nicira, Inc.
+ * Copyright (c) 2013, 2014 Nicira, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -21,55 +21,51 @@
#define OVS_ATOMIC_PTHREADS_IMPL 1
-#define DEFINE_PTHREAD_ATOMIC(TYPE, NAME) \
- typedef struct { \
- TYPE value; \
- pthread_mutex_t mutex; \
- } NAME;
+#define PTHREAD_ATOMIC_TYPE(TYPE) struct { TYPE value; pthread_mutex_t mutex; }
#define ATOMIC_BOOL_LOCK_FREE 0
-DEFINE_PTHREAD_ATOMIC(bool, atomic_bool);
+typedef PTHREAD_ATOMIC_TYPE(bool) atomic_bool;
#define ATOMIC_CHAR_LOCK_FREE 0
-DEFINE_PTHREAD_ATOMIC(char, atomic_char);
-DEFINE_PTHREAD_ATOMIC(signed char, atomic_schar);
-DEFINE_PTHREAD_ATOMIC(unsigned char, atomic_uchar);
+typedef PTHREAD_ATOMIC_TYPE(char) atomic_char;
+typedef PTHREAD_ATOMIC_TYPE(signed char) atomic_schar;
+typedef PTHREAD_ATOMIC_TYPE(unsigned char) atomic_uchar;
#define ATOMIC_SHORT_LOCK_FREE 0
-DEFINE_PTHREAD_ATOMIC(short, atomic_short);
-DEFINE_PTHREAD_ATOMIC(unsigned short, atomic_ushort);
+typedef PTHREAD_ATOMIC_TYPE(short) atomic_short;
+typedef PTHREAD_ATOMIC_TYPE(unsigned short) atomic_ushort;
#define ATOMIC_INT_LOCK_FREE 0
-DEFINE_PTHREAD_ATOMIC(int, atomic_int);
-DEFINE_PTHREAD_ATOMIC(unsigned int, atomic_uint);
+typedef PTHREAD_ATOMIC_TYPE(int) atomic_int;
+typedef PTHREAD_ATOMIC_TYPE(unsigned int) atomic_uint;
#define ATOMIC_LONG_LOCK_FREE 0
-DEFINE_PTHREAD_ATOMIC(long, atomic_long);
-DEFINE_PTHREAD_ATOMIC(unsigned long, atomic_ulong);
+typedef PTHREAD_ATOMIC_TYPE(long) atomic_long;
+typedef PTHREAD_ATOMIC_TYPE(unsigned long) atomic_ulong;
#define ATOMIC_LLONG_LOCK_FREE 0
-DEFINE_PTHREAD_ATOMIC(long long, atomic_llong);
-DEFINE_PTHREAD_ATOMIC(unsigned long long, atomic_ullong);
+typedef PTHREAD_ATOMIC_TYPE(long long) atomic_llong;
+typedef PTHREAD_ATOMIC_TYPE(unsigned long long) atomic_ullong;
-DEFINE_PTHREAD_ATOMIC(size_t, atomic_size_t);
-DEFINE_PTHREAD_ATOMIC(ptrdiff_t, atomic_ptrdiff_t);
+typedef PTHREAD_ATOMIC_TYPE(size_t) atomic_size_t;
+typedef PTHREAD_ATOMIC_TYPE(ptrdiff_t) atomic_ptrdiff_t;
-DEFINE_PTHREAD_ATOMIC(intmax_t, atomic_intmax_t);
-DEFINE_PTHREAD_ATOMIC(uintmax_t, atomic_uintmax_t);
+typedef PTHREAD_ATOMIC_TYPE(intmax_t) atomic_intmax_t;
+typedef PTHREAD_ATOMIC_TYPE(uintmax_t) atomic_uintmax_t;
#define ATOMIC_POINTER_LOCK_FREE 0
-DEFINE_PTHREAD_ATOMIC(intptr_t, atomic_intptr_t);
-DEFINE_PTHREAD_ATOMIC(uintptr_t, atomic_uintptr_t);
+typedef PTHREAD_ATOMIC_TYPE(intptr_t) atomic_intptr_t;
+typedef PTHREAD_ATOMIC_TYPE(uintptr_t) atomic_uintptr_t;
/* Nonstandard atomic types. */
-DEFINE_PTHREAD_ATOMIC(uint8_t, atomic_uint8_t);
-DEFINE_PTHREAD_ATOMIC(uint16_t, atomic_uint16_t);
-DEFINE_PTHREAD_ATOMIC(uint32_t, atomic_uint32_t);
-DEFINE_PTHREAD_ATOMIC(int8_t, atomic_int8_t);
-DEFINE_PTHREAD_ATOMIC(int16_t, atomic_int16_t);
-DEFINE_PTHREAD_ATOMIC(int32_t, atomic_int32_t);
-DEFINE_PTHREAD_ATOMIC(uint64_t, atomic_uint64_t);
-DEFINE_PTHREAD_ATOMIC(int64_t, atomic_int64_t);
+typedef PTHREAD_ATOMIC_TYPE(uint8_t) atomic_uint8_t;
+typedef PTHREAD_ATOMIC_TYPE(uint16_t) atomic_uint16_t;
+typedef PTHREAD_ATOMIC_TYPE(uint32_t) atomic_uint32_t;
+typedef PTHREAD_ATOMIC_TYPE(int8_t) atomic_int8_t;
+typedef PTHREAD_ATOMIC_TYPE(int16_t) atomic_int16_t;
+typedef PTHREAD_ATOMIC_TYPE(int32_t) atomic_int32_t;
+typedef PTHREAD_ATOMIC_TYPE(uint64_t) atomic_uint64_t;
+typedef PTHREAD_ATOMIC_TYPE(int64_t) atomic_int64_t;
typedef enum {
memory_order_relaxed,
--
1.8.5.3
_______________________________________________
dev mailing list
dev@openvswitch.org
http://openvswitch.org/mailman/listinfo/dev
