From 48a970ceb9ccdf0c9331dd33cd82c57dd2e5c92c Mon Sep 17 00:00:00 2001 From: Patrick Pelissier Date: Sun, 19 Aug 2018 11:31:09 +0200 Subject: [PATCH] Avoid using '__' within words. It seems to be a reserved naming of C++. --- m-atomic.h | 66 ++++++++++++++++++++++++++-------------------------- m-i-shared.h | 4 ++-- m-shared.h | 4 ++-- m-worker.h | 6 ++--- 4 files changed, 40 insertions(+), 40 deletions(-) diff --git a/m-atomic.h b/m-atomic.h index 313ffc6e..364cd35c 100644 --- a/m-atomic.h +++ b/m-atomic.h @@ -118,17 +118,17 @@ using std::memory_order_seq_cst; #include "m-mutex.h" /* The structure is quite large: - __val : value of the atomic type, - __zero : zero value of the atomic type (constant), - __previous: temporary value used within the mutex lock, - __lock : the mutex lock. + _val : value of the atomic type, + _zero : zero value of the atomic type (constant), + _previous: temporary value used within the mutex lock, + _lock : the mutex lock. */ #define _Atomic(T) \ struct { \ - volatile T __val; \ - T __zero; \ - T __previous; \ - m_mutex_t __lock; \ + volatile T _val; \ + T _zero; \ + T _previous; \ + m_mutex_t _lock; \ } /* Even if memory order is defined, only the strongest constraint is used */ @@ -190,16 +190,16 @@ static inline long long atomic_fetch_unlock (m_mutex_t *lock, long long val) lock the atomic value, read it and returns the value. In order to avoid any compiler extension, we need to transform the atomic type into 'long long' then convert it back to its value. - This is because __previous can't be read after the lock, and we can't + This is because _previous can't be read after the lock, and we can't generate temporary variable within a macro. The trick is computing _val - _zero within the lock, then returns retvalue + _zero after the lock. */ #define atomic_fetch_op(ptr, val, op) \ - (m_mutex_lock((ptr)->__lock), \ - (ptr)->__previous = (ptr)->__val, \ - (ptr)->__val op (val), \ - atomic_fetch_unlock(&(ptr)->__lock, (ptr)->__previous-(ptr)->__zero)+(ptr)->__zero) + (m_mutex_lock((ptr)->_lock), \ + (ptr)->_previous = (ptr)->_val, \ + (ptr)->_val op (val), \ + atomic_fetch_unlock(&(ptr)->_lock, (ptr)->_previous-(ptr)->_zero)+(ptr)->_zero) #define atomic_fetch_add(ptr, val) atomic_fetch_op(ptr, val, +=) #define atomic_fetch_sub(ptr, val) atomic_fetch_op(ptr, val, -=) @@ -211,38 +211,38 @@ static inline long long atomic_fetch_unlock (m_mutex_t *lock, long long val) #define ATOMIC_VAR_INIT(val) { val, 0, 0, M_MUTEXI_INIT_VALUE } #define atomic_init(ptr, val) \ - (m_mutex_init((ptr)->__lock), (ptr)->__val = val, (ptr)->__zero = 0) + (m_mutex_init((ptr)->_lock), (ptr)->_val = val, (ptr)->_zero = 0) #define atomic_load_lock(ptr) \ - (m_mutex_lock((ptr)->__lock), \ - (ptr)->__previous = (ptr)->__val, \ - atomic_fetch_unlock(&(ptr)->__lock, (ptr)->__previous-(ptr)->__zero)+(ptr)->__zero) + (m_mutex_lock((ptr)->_lock), \ + (ptr)->_previous = (ptr)->_val, \ + atomic_fetch_unlock(&(ptr)->_lock, (ptr)->_previous-(ptr)->_zero)+(ptr)->_zero) #define atomic_store_lock(ptr, val) \ - (m_mutex_lock((ptr)->__lock), \ - (ptr)->__val = (val), \ - m_mutex_unlock((ptr)->__lock)) + (m_mutex_lock((ptr)->_lock), \ + (ptr)->_val = (val), \ + m_mutex_unlock((ptr)->_lock)) #define atomic_load(ptr) \ - ( sizeof ((ptr)->__val) <= ATOMICI_MIN_RW_SIZE \ - ? (ptr)->__val \ + ( sizeof ((ptr)->_val) <= ATOMICI_MIN_RW_SIZE \ + ? (ptr)->_val \ : atomic_load_lock(ptr)) - + #define atomic_store(ptr, val) do { \ - if ( sizeof ((ptr)->__val) <= ATOMICI_MIN_RW_SIZE) { \ - (ptr)->__val = (val); \ + if ( sizeof ((ptr)->_val) <= ATOMICI_MIN_RW_SIZE) { \ + (ptr)->_val = (val); \ } else { \ - long long _offset = (val) - (ptr)->__zero; \ - atomic_store_lock(ptr, (ptr)->__zero + _offset); \ + long long _offset = (val) - (ptr)->_zero; \ + atomic_store_lock(ptr, (ptr)->_zero + _offset); \ } \ } while (0) -#define atomic_compare_exchange_strong(ptr, exp, val) \ - (m_mutex_lock((ptr)->__lock), \ - atomic_fetch_unlock(&(ptr)->__lock, \ - (ptr)->__val == *(exp) \ - ? ((ptr)->__val = (val), true) \ - : (*(exp) = (ptr)->__val, false))) +#define atomic_compare_exchange_strong(ptr, exp, val) \ + (m_mutex_lock((ptr)->_lock), \ + atomic_fetch_unlock(&(ptr)->_lock, \ + (ptr)->_val == *(exp) \ + ? ((ptr)->_val = (val), true) \ + : (*(exp) = (ptr)->_val, false))) #define atomic_fetch_add_explicit(ptr, val, mem) atomic_fetch_op(ptr, val, +=) diff --git a/m-i-shared.h b/m-i-shared.h index 58e12e38..178aa943 100644 --- a/m-i-shared.h +++ b/m-i-shared.h @@ -22,8 +22,8 @@ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef MSTARLIB_I_SHARED_PTR__H -#define MSTARLIB_I_SHARED_PTR__H +#ifndef MSTARLIB_I_SHARED_PTR_H +#define MSTARLIB_I_SHARED_PTR_H #include "m-core.h" #include "m-atomic.h" diff --git a/m-shared.h b/m-shared.h index e4e560c0..05b9a59c 100644 --- a/m-shared.h +++ b/m-shared.h @@ -22,8 +22,8 @@ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef MSTARLIB_SHARED_PTR__H -#define MSTARLIB_SHARED_PTR__H +#ifndef MSTARLIB_SHARED_PTR_H +#define MSTARLIB_SHARED_PTR_H #include "m-core.h" #include "m-atomic.h" diff --git a/m-worker.h b/m-worker.h index 89f2d147..a77320a9 100644 --- a/m-worker.h +++ b/m-worker.h @@ -408,7 +408,7 @@ worker_count(worker_t g) #define WORKER_DEF_DATA_INPUT(...) \ M_MAP(WORKER_DEF_SINGLE_INPUT, __VA_ARGS__) #define WORKER_DEF_SINGLE_OUTPUT(var) \ - __typeof__(var) *M_C(var, __ptr); + __typeof__(var) *M_C(var, _ptr); #define WORKER_DEF_DATA_OUTPUT(...) \ M_MAP(WORKER_DEF_SINGLE_OUTPUT, __VA_ARGS__) #define WORKER_INIT_SINGLE_INPUT(var) \ @@ -416,7 +416,7 @@ worker_count(worker_t g) #define WORKER_INIT_DATA_INPUT(...) \ M_MAP(WORKER_INIT_SINGLE_INPUT, __VA_ARGS__) #define WORKER_INIT_SINGLE_OUTPUT(var) \ - .M_C(var, __ptr) = &var, + .M_C(var, _ptr) = &var, #define WORKER_INIT_DATA_OUTPUT(...) \ M_MAP(WORKER_INIT_SINGLE_OUTPUT, __VA_ARGS__) #define WORKER_DEF_SUBFUNC(_input, _output, _core) \ @@ -447,7 +447,7 @@ worker_count(worker_t g) #define WORKER_INIT_LOCAL_OUTPUT(...) \ M_MAP(WORKER_INIT_SINGLE_LOCAL_OUTPUT, __VA_ARGS__) #define WORKER_PROPAGATE_SINGLE_OUTPUT(var) \ - *(_s_data->M_C(var, __ptr)) = var; + *(_s_data->M_C(var, _ptr)) = var; #define WORKER_PROPAGATE_LOCAL_OUTPUT(...) \ M_MAP(WORKER_PROPAGATE_SINGLE_OUTPUT, __VA_ARGS__)