From 105b95835f4da7cf3fa583ee2779ce3bff866891 Mon Sep 17 00:00:00 2001 From: Bastien Montagne Date: Thu, 23 Nov 2017 16:13:23 +0100 Subject: [PATCH 1/3] atomic_ops: add signed versions of primitives. Reason is motsly that dealing with type conversion in calling code is not great, makes it less readable, and can generate hidden bugs in case original type changes and atomic primitive calls are not updated accordingly... --- intern/atomic/atomic_ops.h | 17 +++ intern/atomic/intern/atomic_ops_msvc.h | 81 +++++++++++++ intern/atomic/intern/atomic_ops_unix.h | 161 ++++++++++++++++++++++++- 3 files changed, 256 insertions(+), 3 deletions(-) diff --git a/intern/atomic/atomic_ops.h b/intern/atomic/atomic_ops.h index 38670be56fd..7fab8f2ac57 100644 --- a/intern/atomic/atomic_ops.h +++ b/intern/atomic/atomic_ops.h @@ -82,6 +82,12 @@ ATOMIC_INLINE uint64_t atomic_sub_and_fetch_uint64(uint64_t *p, uint64_t x); ATOMIC_INLINE uint64_t atomic_fetch_and_add_uint64(uint64_t *p, uint64_t x); ATOMIC_INLINE uint64_t atomic_fetch_and_sub_uint64(uint64_t *p, uint64_t x); ATOMIC_INLINE uint64_t atomic_cas_uint64(uint64_t *v, uint64_t old, uint64_t _new); + +ATOMIC_INLINE int64_t atomic_add_and_fetch_int64(int64_t *p, int64_t x); +ATOMIC_INLINE int64_t atomic_sub_and_fetch_int64(int64_t *p, int64_t x); +ATOMIC_INLINE int64_t atomic_fetch_and_add_int64(int64_t *p, int64_t x); +ATOMIC_INLINE int64_t atomic_fetch_and_sub_int64(int64_t *p, int64_t x); +ATOMIC_INLINE int64_t atomic_cas_int64(int64_t *v, int64_t old, int64_t _new); #endif ATOMIC_INLINE uint32_t atomic_add_and_fetch_uint32(uint32_t *p, uint32_t x); @@ -92,9 +98,20 @@ ATOMIC_INLINE uint32_t atomic_fetch_and_add_uint32(uint32_t *p, uint32_t x); ATOMIC_INLINE uint32_t atomic_fetch_and_or_uint32(uint32_t *p, uint32_t x); ATOMIC_INLINE uint32_t atomic_fetch_and_and_uint32(uint32_t *p, uint32_t x); +ATOMIC_INLINE int32_t atomic_add_and_fetch_int32(int32_t *p, int32_t x); +ATOMIC_INLINE int32_t atomic_sub_and_fetch_int32(int32_t *p, int32_t x); +ATOMIC_INLINE int32_t atomic_cas_int32(int32_t *v, int32_t old, int32_t _new); + +ATOMIC_INLINE int32_t atomic_fetch_and_add_int32(int32_t *p, int32_t x); +ATOMIC_INLINE int32_t atomic_fetch_and_or_int32(int32_t *p, int32_t x); +ATOMIC_INLINE int32_t atomic_fetch_and_and_int32(int32_t *p, int32_t x); + ATOMIC_INLINE uint8_t atomic_fetch_and_or_uint8(uint8_t *p, uint8_t b); ATOMIC_INLINE uint8_t atomic_fetch_and_and_uint8(uint8_t *p, uint8_t b); +ATOMIC_INLINE int8_t atomic_fetch_and_or_int8(int8_t *p, int8_t b); +ATOMIC_INLINE int8_t atomic_fetch_and_and_int8(int8_t *p, int8_t b); + ATOMIC_INLINE size_t atomic_add_and_fetch_z(size_t *p, size_t x); ATOMIC_INLINE size_t atomic_sub_and_fetch_z(size_t *p, size_t x); ATOMIC_INLINE size_t atomic_fetch_and_add_z(size_t *p, size_t x); diff --git a/intern/atomic/intern/atomic_ops_msvc.h b/intern/atomic/intern/atomic_ops_msvc.h index 034ac1e3e53..ab31b3b789a 100644 --- a/intern/atomic/intern/atomic_ops_msvc.h +++ b/intern/atomic/intern/atomic_ops_msvc.h @@ -43,6 +43,7 @@ /******************************************************************************/ /* 64-bit operations. */ #if (LG_SIZEOF_PTR == 8 || LG_SIZEOF_INT == 8) +/* Unsigned */ ATOMIC_INLINE uint64_t atomic_add_and_fetch_uint64(uint64_t *p, uint64_t x) { return InterlockedExchangeAdd64((int64_t *)p, (int64_t)x) + x; @@ -67,10 +68,37 @@ ATOMIC_INLINE uint64_t atomic_fetch_and_sub_uint64(uint64_t *p, uint64_t x) { return InterlockedExchangeAdd64((int64_t *)p, -((int64_t)x)); } + +/* Signed */ +ATOMIC_INLINE int64_t atomic_add_and_fetch_int64(int64_t *p, int64_t x) +{ + return InterlockedExchangeAdd64(p, x) + x; +} + +ATOMIC_INLINE int64_t atomic_sub_and_fetch_int64(int64_t *p, int64_t x) +{ + return InterlockedExchangeAdd64(p, -x) - x; +} + +ATOMIC_INLINE int64_t atomic_cas_int64(int64_t *v, int64_t old, int64_t _new) +{ + return InterlockedCompareExchange64(v, _new, old); +} + +ATOMIC_INLINE int64_t atomic_fetch_and_add_int64(int64_t *p, int64_t x) +{ + return InterlockedExchangeAdd64(p, x); +} + +ATOMIC_INLINE int64_t atomic_fetch_and_sub_int64(int64_t *p, int64_t x) +{ + return InterlockedExchangeAdd64(p, -x); +} #endif /******************************************************************************/ /* 32-bit operations. */ +/* Unsigned */ ATOMIC_INLINE uint32_t atomic_add_and_fetch_uint32(uint32_t *p, uint32_t x) { return InterlockedExchangeAdd(p, x) + x; @@ -101,9 +129,41 @@ ATOMIC_INLINE uint32_t atomic_fetch_and_and_uint32(uint32_t *p, uint32_t x) return InterlockedAnd((long *)p, x); } +/* Signed */ +ATOMIC_INLINE int32_t atomic_add_and_fetch_int32(int32_t *p, int32_t x) +{ + return InterlockedExchangeAdd(p, x) + x; +} + +ATOMIC_INLINE int32_t atomic_sub_and_fetch_int32(int32_t *p, int32_t x) +{ + return InterlockedExchangeAdd(p, -x) - x; +} + +ATOMIC_INLINE int32_t atomic_cas_int32(int32_t *v, int32_t old, int32_t _new) +{ + return InterlockedCompareExchange(v, _new, old); +} + +ATOMIC_INLINE int32_t atomic_fetch_and_add_int32(int32_t *p, int32_t x) +{ + return InterlockedExchangeAdd(p, x); +} + +ATOMIC_INLINE int32_t atomic_fetch_and_or_int32(int32_t *p, int32_t x) +{ + return InterlockedOr(p, x); +} + +ATOMIC_INLINE int32_t atomic_fetch_and_and_int32(int32_t *p, int32_t x) +{ + return InterlockedAnd(p, x); +} + /******************************************************************************/ /* 8-bit operations. */ +/* Unsigned */ #pragma intrinsic(_InterlockedAnd8) ATOMIC_INLINE uint8_t atomic_fetch_and_and_uint8(uint8_t *p, uint8_t b) { @@ -124,4 +184,25 @@ ATOMIC_INLINE uint8_t atomic_fetch_and_or_uint8(uint8_t *p, uint8_t b) #endif } +/* Signed */ +#pragma intrinsic(_InterlockedAnd8) +ATOMIC_INLINE int8_t atomic_fetch_and_and_int8(int8_t *p, int8_t b) +{ +#if (LG_SIZEOF_PTR == 8 || LG_SIZEOF_INT == 8) + return InterlockedAnd8((char *)p, (char)b); +#else + return _InterlockedAnd8((char *)p, (char)b); +#endif +} + +#pragma intrinsic(_InterlockedOr8) +ATOMIC_INLINE int8_t atomic_fetch_and_or_int8(int8_t *p, int8_t b) +{ +#if (LG_SIZEOF_PTR == 8 || LG_SIZEOF_INT == 8) + return InterlockedOr8((char *)p, (char)b); +#else + return _InterlockedOr8((char *)p, (char)b); +#endif +} + #endif /* __ATOMIC_OPS_MSVC_H__ */ diff --git a/intern/atomic/intern/atomic_ops_unix.h b/intern/atomic/intern/atomic_ops_unix.h index 0a3322ad2b1..783a30f743b 100644 --- a/intern/atomic/intern/atomic_ops_unix.h +++ b/intern/atomic/intern/atomic_ops_unix.h @@ -58,6 +58,7 @@ /* 64-bit operations. */ #if (LG_SIZEOF_PTR == 8 || LG_SIZEOF_INT == 8) # if (defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8) || defined(JE_FORCE_SYNC_COMPARE_AND_SWAP_8)) +/* Unsigned */ ATOMIC_INLINE uint64_t atomic_add_and_fetch_uint64(uint64_t *p, uint64_t x) { return __sync_add_and_fetch(p, x); @@ -82,7 +83,35 @@ ATOMIC_INLINE uint64_t atomic_cas_uint64(uint64_t *v, uint64_t old, uint64_t _ne { return __sync_val_compare_and_swap(v, old, _new); } + +/* Signed */ +ATOMIC_INLINE int64_t atomic_add_and_fetch_int64(int64_t *p, int64_t x) +{ + return __sync_add_and_fetch(p, x); +} + +ATOMIC_INLINE int64_t atomic_sub_and_fetch_int64(int64_t *p, int64_t x) +{ + return __sync_sub_and_fetch(p, x); +} + +ATOMIC_INLINE int64_t atomic_fetch_and_add_int64(int64_t *p, int64_t x) +{ + return __sync_fetch_and_add(p, x); +} + +ATOMIC_INLINE int64_t atomic_fetch_and_sub_int64(int64_t *p, int64_t x) +{ + return __sync_fetch_and_sub(p, x); +} + +ATOMIC_INLINE int64_t atomic_cas_int64(int64_t *v, int64_t old, int64_t _new) +{ + return __sync_val_compare_and_swap(v, old, _new); +} + # elif (defined(__amd64__) || defined(__x86_64__)) +/* Unsigned */ ATOMIC_INLINE uint64_t atomic_fetch_and_add_uint64(uint64_t *p, uint64_t x) { asm volatile ( @@ -124,6 +153,49 @@ ATOMIC_INLINE uint64_t atomic_cas_uint64(uint64_t *v, uint64_t old, uint64_t _ne : "memory"); return ret; } + +/* Signed */ +ATOMIC_INLINE int64_t atomic_fetch_and_add_int64(int64_t *p, int64_t x) +{ + asm volatile ( + "lock; xaddq %0, %1;" + : "+r" (x), "=m" (*p) /* Outputs. */ + : "m" (*p) /* Inputs. */ + ); + return x; +} + +ATOMIC_INLINE int64_t atomic_fetch_and_sub_int64(int64_t *p, int64_t x) +{ + x = -x; + asm volatile ( + "lock; xaddq %0, %1;" + : "+r" (x), "=m" (*p) /* Outputs. */ + : "m" (*p) /* Inputs. */ + ); + return x; +} + +ATOMIC_INLINE int64_t atomic_add_and_fetch_int64(int64_t *p, int64_t x) +{ + return atomic_fetch_and_add_int64(p, x) + x; +} + +ATOMIC_INLINE int64_t atomic_sub_and_fetch_int64(int64_t *p, int64_t x) +{ + return atomic_fetch_and_sub_int64(p, x) - x; +} + +ATOMIC_INLINE int64_t atomic_cas_int64(int64_t *v, int64_t old, int64_t _new) +{ + int64_t ret; + asm volatile ( + "lock; cmpxchgq %2,%1" + : "=a" (ret), "+m" (*v) + : "r" (_new), "0" (old) + : "memory"); + return ret; +} # else # error "Missing implementation for 64-bit atomic operations" # endif @@ -132,6 +204,7 @@ ATOMIC_INLINE uint64_t atomic_cas_uint64(uint64_t *v, uint64_t old, uint64_t _ne /******************************************************************************/ /* 32-bit operations. */ #if (defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4) || defined(JE_FORCE_SYNC_COMPARE_AND_SWAP_4)) +/* Unsigned */ ATOMIC_INLINE uint32_t atomic_add_and_fetch_uint32(uint32_t *p, uint32_t x) { return __sync_add_and_fetch(p, x); @@ -146,7 +219,25 @@ ATOMIC_INLINE uint32_t atomic_cas_uint32(uint32_t *v, uint32_t old, uint32_t _ne { return __sync_val_compare_and_swap(v, old, _new); } + +/* Signed */ +ATOMIC_INLINE int32_t atomic_add_and_fetch_int32(int32_t *p, int32_t x) +{ + return __sync_add_and_fetch(p, x); +} + +ATOMIC_INLINE int32_t atomic_sub_and_fetch_int32(int32_t *p, int32_t x) +{ + return __sync_sub_and_fetch(p, x); +} + +ATOMIC_INLINE int32_t atomic_cas_int32(int32_t *v, int32_t old, int32_t _new) +{ + return __sync_val_compare_and_swap(v, old, _new); +} + #elif (defined(__i386__) || defined(__amd64__) || defined(__x86_64__)) +/* Unsigned */ ATOMIC_INLINE uint32_t atomic_add_and_fetch_uint32(uint32_t *p, uint32_t x) { uint32_t ret = x; @@ -155,18 +246,18 @@ ATOMIC_INLINE uint32_t atomic_add_and_fetch_uint32(uint32_t *p, uint32_t x) : "+r" (ret), "=m" (*p) /* Outputs. */ : "m" (*p) /* Inputs. */ ); - return ret+x; + return ret + x; } ATOMIC_INLINE uint32_t atomic_sub_and_fetch_uint32(uint32_t *p, uint32_t x) { - ret = (uint32_t)(-(int32_t)x); + uint32_t ret = (uint32_t)(-(int32_t)x); asm volatile ( "lock; xaddl %0, %1;" : "+r" (ret), "=m" (*p) /* Outputs. */ : "m" (*p) /* Inputs. */ ); - return ret-x; + return ret - x; } ATOMIC_INLINE uint32_t atomic_cas_uint32(uint32_t *v, uint32_t old, uint32_t _new) @@ -179,11 +270,47 @@ ATOMIC_INLINE uint32_t atomic_cas_uint32(uint32_t *v, uint32_t old, uint32_t _ne : "memory"); return ret; } + +/* Signed */ +ATOMIC_INLINE int32_t atomic_add_and_fetch_int32(int32_t *p, int32_t x) +{ + int32_t ret = x; + asm volatile ( + "lock; xaddl %0, %1;" + : "+r" (ret), "=m" (*p) /* Outputs. */ + : "m" (*p) /* Inputs. */ + ); + return ret + x; +} + +ATOMIC_INLINE int32_t atomic_sub_and_fetch_int32(int32_t *p, int32_t x) +{ + int32_t ret = -x; + asm volatile ( + "lock; xaddl %0, %1;" + : "+r" (ret), "=m" (*p) /* Outputs. */ + : "m" (*p) /* Inputs. */ + ); + return ret - x; +} + +ATOMIC_INLINE int32_t atomic_cas_int32(int32_t *v, int32_t old, int32_t _new) +{ + int32_t ret; + asm volatile ( + "lock; cmpxchgl %2,%1" + : "=a" (ret), "+m" (*v) + : "r" (_new), "0" (old) + : "memory"); + return ret; +} + #else # error "Missing implementation for 32-bit atomic operations" #endif #if (defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4) || defined(JE_FORCE_SYNC_COMPARE_AND_SWAP_4)) +/* Unsigned */ ATOMIC_INLINE uint32_t atomic_fetch_and_add_uint32(uint32_t *p, uint32_t x) { return __sync_fetch_and_add(p, x); @@ -199,6 +326,22 @@ ATOMIC_INLINE uint32_t atomic_fetch_and_and_uint32(uint32_t *p, uint32_t x) return __sync_fetch_and_and(p, x); } +/* Signed */ +ATOMIC_INLINE int32_t atomic_fetch_and_add_int32(int32_t *p, int32_t x) +{ + return __sync_fetch_and_add(p, x); +} + +ATOMIC_INLINE int32_t atomic_fetch_and_or_int32(int32_t *p, int32_t x) +{ + return __sync_fetch_and_or(p, x); +} + +ATOMIC_INLINE int32_t atomic_fetch_and_and_int32(int32_t *p, int32_t x) +{ + return __sync_fetch_and_and(p, x); +} + #else # error "Missing implementation for 32-bit atomic operations" #endif @@ -206,6 +349,7 @@ ATOMIC_INLINE uint32_t atomic_fetch_and_and_uint32(uint32_t *p, uint32_t x) /******************************************************************************/ /* 8-bit operations. */ #if (defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1) || defined(JE_FORCE_SYNC_COMPARE_AND_SWAP_1)) +/* Unsigned */ ATOMIC_INLINE uint8_t atomic_fetch_and_and_uint8(uint8_t *p, uint8_t b) { return __sync_fetch_and_and(p, b); @@ -214,6 +358,17 @@ ATOMIC_INLINE uint8_t atomic_fetch_and_or_uint8(uint8_t *p, uint8_t b) { return __sync_fetch_and_or(p, b); } + +/* Signed */ +ATOMIC_INLINE int8_t atomic_fetch_and_and_int8(int8_t *p, int8_t b) +{ + return __sync_fetch_and_and(p, b); +} +ATOMIC_INLINE int8_t atomic_fetch_and_or_int8(int8_t *p, int8_t b) +{ + return __sync_fetch_and_or(p, b); +} + #else # error "Missing implementation for 8-bit atomic operations" #endif From 497e2b3dfaded5ed1e260b0fb518bc8f97ccca89 Mon Sep 17 00:00:00 2001 From: Bastien Montagne Date: Thu, 23 Nov 2017 16:14:53 +0100 Subject: [PATCH 2/3] Cleanup: use signed atomic ops when needed. --- source/blender/blenkernel/intern/library.c | 4 ++-- source/blender/blenkernel/intern/object.c | 4 ++-- source/blender/blenlib/intern/task.c | 5 ++--- 3 files changed, 6 insertions(+), 7 deletions(-) diff --git a/source/blender/blenkernel/intern/library.c b/source/blender/blenkernel/intern/library.c index 7e259b38842..b84a494c70e 100644 --- a/source/blender/blenkernel/intern/library.c +++ b/source/blender/blenkernel/intern/library.c @@ -2383,10 +2383,10 @@ void BKE_library_filepath_set(Library *lib, const char *filepath) void BKE_id_tag_set_atomic(ID *id, int tag) { - atomic_fetch_and_or_uint32((uint32_t *)&id->tag, tag); + atomic_fetch_and_or_int32(&id->tag, tag); } void BKE_id_tag_clear_atomic(ID *id, int tag) { - atomic_fetch_and_and_uint32((uint32_t *)&id->tag, ~tag); + atomic_fetch_and_and_int32(&id->tag, ~tag); } diff --git a/source/blender/blenkernel/intern/object.c b/source/blender/blenkernel/intern/object.c index c64a183a511..f231f8f61c9 100644 --- a/source/blender/blenkernel/intern/object.c +++ b/source/blender/blenkernel/intern/object.c @@ -330,14 +330,14 @@ void BKE_object_free_derived_caches(Object *ob) Mesh *me = ob->data; if (me && me->bb) { - atomic_fetch_and_or_uint32((uint *)&me->bb->flag, BOUNDBOX_DIRTY); + atomic_fetch_and_or_int32(&me->bb->flag, BOUNDBOX_DIRTY); } } else if (ELEM(ob->type, OB_SURF, OB_CURVE, OB_FONT)) { Curve *cu = ob->data; if (cu && cu->bb) { - atomic_fetch_and_or_uint32((uint *)&cu->bb->flag, BOUNDBOX_DIRTY); + atomic_fetch_and_or_int32(&cu->bb->flag, BOUNDBOX_DIRTY); } } diff --git a/source/blender/blenlib/intern/task.c b/source/blender/blenlib/intern/task.c index e050f3148b8..d69241c3737 100644 --- a/source/blender/blenlib/intern/task.c +++ b/source/blender/blenlib/intern/task.c @@ -1003,8 +1003,7 @@ BLI_INLINE bool parallel_range_next_iter_get( ParallelRangeState * __restrict state, int * __restrict iter, int * __restrict count) { - uint32_t uval = atomic_fetch_and_add_uint32((uint32_t *)(&state->iter), state->chunk_size); - int previter = *(int32_t *)&uval; + int previter = atomic_fetch_and_add_int32(&state->iter, state->chunk_size); *iter = previter; *count = max_ii(0, min_ii(state->chunk_size, state->stop - previter)); @@ -1124,7 +1123,7 @@ static void task_parallel_range_ex( } num_tasks = min_ii(num_tasks, (stop - start) / state.chunk_size); - atomic_fetch_and_add_uint32((uint32_t *)(&state.iter), 0); + atomic_fetch_and_add_int32(&state.iter, 0); if (use_userdata_chunk) { userdata_chunk_array = MALLOCA(userdata_chunk_size * num_tasks); From 580b34e52b0cf231cea70891831efd4b1b1c4ee2 Mon Sep 17 00:00:00 2001 From: Bastien Montagne Date: Thu, 23 Nov 2017 16:23:45 +0100 Subject: [PATCH 3/3] atomic_ops: add char versions of uint8_t atomic primitives. --- intern/atomic/atomic_ops.h | 3 +++ intern/atomic/intern/atomic_ops_ext.h | 12 ++++++++++++ source/blender/blenkernel/intern/pbvh.c | 4 +--- 3 files changed, 16 insertions(+), 3 deletions(-) diff --git a/intern/atomic/atomic_ops.h b/intern/atomic/atomic_ops.h index 7fab8f2ac57..578cfb76eb6 100644 --- a/intern/atomic/atomic_ops.h +++ b/intern/atomic/atomic_ops.h @@ -112,6 +112,9 @@ ATOMIC_INLINE uint8_t atomic_fetch_and_and_uint8(uint8_t *p, uint8_t b); ATOMIC_INLINE int8_t atomic_fetch_and_or_int8(int8_t *p, int8_t b); ATOMIC_INLINE int8_t atomic_fetch_and_and_int8(int8_t *p, int8_t b); +ATOMIC_INLINE char atomic_fetch_and_or_char(char *p, char b); +ATOMIC_INLINE char atomic_fetch_and_and_char(char *p, char b); + ATOMIC_INLINE size_t atomic_add_and_fetch_z(size_t *p, size_t x); ATOMIC_INLINE size_t atomic_sub_and_fetch_z(size_t *p, size_t x); ATOMIC_INLINE size_t atomic_fetch_and_add_z(size_t *p, size_t x); diff --git a/intern/atomic/intern/atomic_ops_ext.h b/intern/atomic/intern/atomic_ops_ext.h index 34158a0b45e..51275e2b36b 100644 --- a/intern/atomic/intern/atomic_ops_ext.h +++ b/intern/atomic/intern/atomic_ops_ext.h @@ -179,6 +179,18 @@ ATOMIC_INLINE unsigned int atomic_cas_u(unsigned int *v, unsigned int old, unsig #endif } +/******************************************************************************/ +/* Char operations. */ +ATOMIC_INLINE char atomic_fetch_and_or_char(char *p, char b) +{ + return (char)atomic_fetch_and_or_uint8((uint8_t *)p, (uint8_t)b); +} + +ATOMIC_INLINE char atomic_fetch_and_and_char(char *p, char b) +{ + return (char)atomic_fetch_and_and_uint8((uint8_t *)p, (uint8_t)b); +} + /******************************************************************************/ /* Pointer operations. */ diff --git a/source/blender/blenkernel/intern/pbvh.c b/source/blender/blenkernel/intern/pbvh.c index aa8ab07518f..39d1d8e8510 100644 --- a/source/blender/blenkernel/intern/pbvh.c +++ b/source/blender/blenkernel/intern/pbvh.c @@ -1007,9 +1007,7 @@ static void pbvh_update_normals_store_task_cb(void *userdata, const int n) MVert *mvert = &bvh->verts[v]; /* mvert is shared between nodes, hence between threads. */ - if (atomic_fetch_and_and_uint8( - (uint8_t *)&mvert->flag, (uint8_t)~ME_VERT_PBVH_UPDATE) & ME_VERT_PBVH_UPDATE) - { + if (atomic_fetch_and_and_char(&mvert->flag, (char)~ME_VERT_PBVH_UPDATE) & ME_VERT_PBVH_UPDATE) { normalize_v3(vnors[v]); normal_float_to_short_v3(mvert->no, vnors[v]); }