lib/ovs-atomic-gcc4+.h

   1 /*
   2  * Copyright (c) 2013, 2014 Nicira, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /* This header implements atomic operation primitives on GCC 4.x. */
  18 #ifndef IN_OVS_ATOMIC_H
  19 #error "This header should only be included indirectly via ovs-atomic.h."
  20 #endif
  21
  22 #include "ovs-atomic-locked.h"
  23 #define OVS_ATOMIC_GCC4P_IMPL 1
  24
  25 #define ATOMIC(TYPE) TYPE
  26
  27 #define ATOMIC_BOOL_LOCK_FREE 2
  28 #define ATOMIC_CHAR_LOCK_FREE 2
  29 #define ATOMIC_SHORT_LOCK_FREE 2
  30 #define ATOMIC_INT_LOCK_FREE 2
  31 #define ATOMIC_LONG_LOCK_FREE (ULONG_MAX <= UINTPTR_MAX ? 2 : 0)
  32 #define ATOMIC_LLONG_LOCK_FREE (ULLONG_MAX <= UINTPTR_MAX ? 2 : 0)
  33 #define ATOMIC_POINTER_LOCK_FREE 2
  34
  35 typedef enum {
  36     memory_order_relaxed,
  37     memory_order_consume,
  38     memory_order_acquire,
  39     memory_order_release,
  40     memory_order_acq_rel,
  41     memory_order_seq_cst
  42 } memory_order;
  43 \f
  44 #define IS_LOCKLESS_ATOMIC(OBJECT) (sizeof(OBJECT) <= sizeof(void *))
  45 \f
  46 #define ATOMIC_VAR_INIT(VALUE) VALUE
  47 #define atomic_init(OBJECT, VALUE) (*(OBJECT) = (VALUE), (void) 0)
  48
  49 static inline void
  50 atomic_thread_fence(memory_order order)
  51 {
  52     if (order != memory_order_relaxed) {
  53         __sync_synchronize();
  54     }
  55 }
  56
  57 static inline void
  58 atomic_thread_fence_if_seq_cst(memory_order order)
  59 {
  60     if (order == memory_order_seq_cst) {
  61         __sync_synchronize();
  62     }
  63 }
  64
  65 static inline void
  66 atomic_signal_fence(memory_order order OVS_UNUSED)
  67 {
  68     if (order != memory_order_relaxed) {
  69         asm volatile("" : : : "memory");
  70     }
  71 }
  72
  73 #define atomic_is_lock_free(OBJ)                \
  74     ((void) *(OBJ),                             \
  75      IS_LOCKLESS_ATOMIC(*(OBJ)) ? 2 : 0)
  76
  77 #define atomic_store(DST, SRC) \
  78     atomic_store_explicit(DST, SRC, memory_order_seq_cst)
  79 #define atomic_store_explicit(DST, SRC, ORDER)          \
  80     ({                                                  \
  81         typeof(DST) dst__ = (DST);                      \
  82         typeof(SRC) src__ = (SRC);                      \
  83         memory_order order__ = (ORDER);                 \
  84                                                         \
  85         if (IS_LOCKLESS_ATOMIC(*dst__)) {               \
  86             atomic_thread_fence(order__);               \
  87             *dst__ = src__;                             \
  88             atomic_thread_fence_if_seq_cst(order__);    \
  89         } else {                                        \
  90             atomic_store_locked(dst__, src__);          \
  91         }                                               \
  92         (void) 0;                                       \
  93     })
  94 #define atomic_read(SRC, DST) \
  95     atomic_read_explicit(SRC, DST, memory_order_seq_cst)
  96 #define atomic_read_explicit(SRC, DST, ORDER)           \
  97     ({                                                  \
  98         typeof(DST) dst__ = (DST);                      \
  99         typeof(SRC) src__ = (SRC);                      \
 100         memory_order order__ = (ORDER);                 \
 101                                                         \
 102         if (IS_LOCKLESS_ATOMIC(*src__)) {               \
 103             atomic_thread_fence_if_seq_cst(order__);    \
 104             *dst__ = *src__;                            \
 105         } else {                                        \
 106             atomic_read_locked(src__, dst__);           \
 107         }                                               \
 108         (void) 0;                                       \
 109     })
 110
 111 #define atomic_compare_exchange_strong(DST, EXP, SRC)   \
 112     ({                                                  \
 113         typeof(DST) dst__ = (DST);                      \
 114         typeof(EXP) expp__ = (EXP);                     \
 115         typeof(SRC) src__ = (SRC);                      \
 116         typeof(SRC) exp__ = *expp__;                    \
 117         typeof(SRC) ret__;                              \
 118                                                         \
 119         ret__ = __sync_val_compare_and_swap(dst__, exp__, src__); \
 120         if (ret__ != exp__) {                                     \
 121             *expp__ = ret__;                                      \
 122         }                                                         \
 123         ret__ == exp__;                                           \
 124     })
 125 #define atomic_compare_exchange_strong_explicit(DST, EXP, SRC, ORD1, ORD2) \
 126     ((void) (ORD1), (void) (ORD2), \
 127      atomic_compare_exchange_strong(DST, EXP, SRC))
 128 #define atomic_compare_exchange_weak            \
 129     atomic_compare_exchange_strong
 130 #define atomic_compare_exchange_weak_explicit   \
 131     atomic_compare_exchange_strong_explicit
 132
 133
 134 #define atomic_op__(RMW, OP, ARG, ORIG)                     \
 135     ({                                                      \
 136         typeof(RMW) rmw__ = (RMW);                          \
 137         typeof(ARG) arg__ = (ARG);                          \
 138         typeof(ORIG) orig__ = (ORIG);                       \
 139                                                             \
 140         if (IS_LOCKLESS_ATOMIC(*rmw__)) {                   \
 141             *orig__ = __sync_fetch_and_##OP(rmw__, arg__);  \
 142         } else {                                            \
 143             atomic_op_locked(rmw__, OP, arg__, orig__);     \
 144         }                                                   \
 145     })
 146
 147 #define atomic_add(RMW, ARG, ORIG) atomic_op__(RMW, add, ARG, ORIG)
 148 #define atomic_sub(RMW, ARG, ORIG) atomic_op__(RMW, sub, ARG, ORIG)
 149 #define atomic_or( RMW, ARG, ORIG) atomic_op__(RMW, or,  ARG, ORIG)
 150 #define atomic_xor(RMW, ARG, ORIG) atomic_op__(RMW, xor, ARG, ORIG)
 151 #define atomic_and(RMW, ARG, ORIG) atomic_op__(RMW, and, ARG, ORIG)
 152
 153 #define atomic_add_explicit(RMW, OPERAND, ORIG, ORDER)  \
 154     ((void) (ORDER), atomic_add(RMW, OPERAND, ORIG))
 155 #define atomic_sub_explicit(RMW, OPERAND, ORIG, ORDER)  \
 156     ((void) (ORDER), atomic_sub(RMW, OPERAND, ORIG))
 157 #define atomic_or_explicit(RMW, OPERAND, ORIG, ORDER)   \
 158     ((void) (ORDER), atomic_or(RMW, OPERAND, ORIG))
 159 #define atomic_xor_explicit(RMW, OPERAND, ORIG, ORDER)  \
 160     ((void) (ORDER), atomic_xor(RMW, OPERAND, ORIG))
 161 #define atomic_and_explicit(RMW, OPERAND, ORIG, ORDER)  \
 162     ((void) (ORDER), atomic_and(RMW, OPERAND, ORIG))
 163 \f
 164 /* atomic_flag */
 165
 166 typedef struct {
 167     int b;
 168 } atomic_flag;
 169 #define ATOMIC_FLAG_INIT { false }
 170
 171 static inline bool
 172 atomic_flag_test_and_set(volatile atomic_flag *object)
 173 {
 174     return __sync_lock_test_and_set(&object->b, 1);
 175 }
 176
 177 static inline bool
 178 atomic_flag_test_and_set_explicit(volatile atomic_flag *object,
 179                                   memory_order order OVS_UNUSED)
 180 {
 181     return atomic_flag_test_and_set(object);
 182 }
 183
 184 static inline void
 185 atomic_flag_clear(volatile atomic_flag *object)
 186 {
 187     __sync_lock_release(&object->b);
 188 }
 189
 190 static inline void
 191 atomic_flag_clear_explicit(volatile atomic_flag *object,
 192                            memory_order order OVS_UNUSED)
 193 {
 194     atomic_flag_clear(object);
 195 }