EIC code displayed by LXR master/​include/​opencascade/​Standard_Atomic.hxx	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-09-24 09:17:09

 // Created on: 2007-09-04
 // Created by: Andrey BETENEV
 // Copyright (c) 2007-2014 OPEN CASCADE SAS
 //
 // This file is part of Open CASCADE Technology software library.
 //
 // This library is free software; you can redistribute it and/or modify it under
 // the terms of the GNU Lesser General Public License version 2.1 as published
 // by the Free Software Foundation, with special exception defined in the file
 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
 // distribution for complete text of the license and disclaimer of any warranty.
 //
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
 //! @file
 //! Implementation of some atomic operations (elementary operations
 //! with data that cannot be interrupted by parallel threads in the
 //! multithread process) on various platforms
 //!
 //! By the moment, only operations necessary for reference counter
 //! in Standard_Transient objects are implemented.
 //!
 //! This is preferred to use fixed size types "int32_t" / "int64_t" for
 //! correct function declarations however we leave "int" assuming it is 32bits for now.
 
 #ifndef _Standard_Atomic_HeaderFile
 #define _Standard_Atomic_HeaderFile
 
 #include <Standard_Macro.hxx>
 #include <atomic>
 
 //! Increments atomically integer variable pointed by theValue
 //! and returns resulting incremented value.
 Standard_DEPRECATED("Standard_Atomic_Increment will be removed in OCCT 8.0.0")
 inline int Standard_Atomic_Increment(volatile int* theValue);
 
 //! Decrements atomically integer variable pointed by theValue
 //! and returns resulting decremented value.
 Standard_DEPRECATED("Standard_Atomic_Decrement will be removed in OCCT 8.0.0")
 inline int Standard_Atomic_Decrement(volatile int* theValue);
 
 //! Perform an atomic compare and swap.
 //! That is, if the current value of *theValue is theOldValue, then write theNewValue into
 //! *theValue.
 //! @param theValue    pointer to variable to modify
 //! @param theOldValue expected value to perform modification
 //! @param theNewValue new value to set in case if *theValue was equal to theOldValue
 //! @return TRUE if theNewValue has been set to *theValue
 Standard_DEPRECATED("Standard_Atomic_CompareAndSwap will be removed in OCCT 8.0.0")
 inline bool Standard_Atomic_CompareAndSwap(volatile int* theValue,
                                            int           theOldValue,
                                            int           theNewValue);
 
 // Platform-dependent implementation
 #if defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4) || defined(__EMSCRIPTEN__)
 // gcc explicitly defines the macros __GCC_HAVE_SYNC_COMPARE_AND_SWAP_*
 // starting with version 4.4+, although built-in functions
 // are available since 4.1.x. However unless __GCC_HAVE_SYNC_COMPARE_AND_SWAP_*
 // are defined, linking may fail without specifying -march option when
 // building for 32bit architecture on 64bit (using -m32 option). To avoid
 // making -march mandatory, check for __GCC_HAVE_SYNC_COMPARE_AND_SWAP_* is
 // enforced.
 
 Standard_DEPRECATED("Standard_Atomic_Increment will be removed in OCCT 8.0.0")
 int Standard_Atomic_Increment(volatile int* theValue)
 {
   return __sync_add_and_fetch(theValue, 1);
 }
 
 Standard_DEPRECATED("Standard_Atomic_Decrement will be removed in OCCT 8.0.0")
 int Standard_Atomic_Decrement(volatile int* theValue)
 {
   return __sync_sub_and_fetch(theValue, 1);
 }
 
 Standard_DEPRECATED("Standard_Atomic_CompareAndSwap will be removed in OCCT 8.0.0")
 bool Standard_Atomic_CompareAndSwap(volatile int* theValue, int theOldValue, int theNewValue)
 {
   return __sync_val_compare_and_swap(theValue, theOldValue, theNewValue) == theOldValue;
 }
 
 #elif defined(_WIN32)
 extern "C"
 {
   long _InterlockedIncrement(volatile long* lpAddend);
   long _InterlockedDecrement(volatile long* lpAddend);
   long _InterlockedCompareExchange(long volatile* Destination, long Exchange, long Comparand);
 }
 
   #if defined(_MSC_VER) && !defined(__INTEL_COMPILER)
     // force intrinsic instead of WinAPI calls
     #pragma intrinsic(_InterlockedIncrement)
     #pragma intrinsic(_InterlockedDecrement)
     #pragma intrinsic(_InterlockedCompareExchange)
   #endif
 
 // WinAPI function or MSVC intrinsic
 // Note that we safely cast int* to long*, as they have same size and endian-ness
 
 Standard_DEPRECATED("Standard_Atomic_Increment will be removed in OCCT 8.0.0")
 int Standard_Atomic_Increment(volatile int* theValue)
 {
   return _InterlockedIncrement(reinterpret_cast<volatile long*>(theValue));
 }
 
 Standard_DEPRECATED("Standard_Atomic_Decrement will be removed in OCCT 8.0.0")
 int Standard_Atomic_Decrement(volatile int* theValue)
 {
   return _InterlockedDecrement(reinterpret_cast<volatile long*>(theValue));
 }
 
 Standard_DEPRECATED("Standard_Atomic_CompareAndSwap will be removed in OCCT 8.0.0")
 bool Standard_Atomic_CompareAndSwap(volatile int* theValue, int theOldValue, int theNewValue)
 {
   return _InterlockedCompareExchange(reinterpret_cast<volatile long*>(theValue),
                                      theNewValue,
                                      theOldValue)
          == theOldValue;
 }
 
 #elif defined(__APPLE__)
   // use atomic operations provided by MacOS
 
   #include <libkern/OSAtomic.h>
 
 Standard_DEPRECATED("Standard_Atomic_Increment will be removed in OCCT 8.0.0")
 int Standard_Atomic_Increment(volatile int* theValue)
 {
   return OSAtomicIncrement32Barrier(theValue);
 }
 
 Standard_DEPRECATED("Standard_Atomic_Decrement will be removed in OCCT 8.0.0")
 int Standard_Atomic_Decrement(volatile int* theValue)
 {
   return OSAtomicDecrement32Barrier(theValue);
 }
 
 Standard_DEPRECATED("Standard_Atomic_CompareAndSwap will be removed in OCCT 8.0.0")
 bool Standard_Atomic_CompareAndSwap(volatile int* theValue, int theOldValue, int theNewValue)
 {
   return OSAtomicCompareAndSwapInt(theOldValue, theNewValue, theValue);
 }
 
 #elif defined(__ANDROID__)
 
   // Atomic operations that were exported by the C library didn't
   // provide any memory barriers, which created potential issues on
   // multi-core devices. Starting from ndk version r7b they are defined as
   // inlined calls to GCC sync builtins, which always provide a full barrier.
   // It is strongly recommended to use newer versions of ndk.
   #include <sys/atomics.h>
 
 Standard_DEPRECATED("Standard_Atomic_Increment will be removed in OCCT 8.0.0")
 int Standard_Atomic_Increment(volatile int* theValue)
 {
   return __atomic_inc(theValue) + 1; // analog of __sync_fetch_and_add
 }
 
 Standard_DEPRECATED("Standard_Atomic_Decrement will be removed in OCCT 8.0.0")
 int Standard_Atomic_Decrement(volatile int* theValue)
 {
   return __atomic_dec(theValue) - 1; // analog of __sync_fetch_and_sub
 }
 
 Standard_DEPRECATED("Standard_Atomic_CompareAndSwap will be removed in OCCT 8.0.0")
 bool Standard_Atomic_CompareAndSwap(volatile int* theValue, int theOldValue, int theNewValue)
 {
   return __atomic_cmpxchg(theOldValue, theNewValue, theValue) == 0;
 }
 
 #else
 
   #ifndef IGNORE_NO_ATOMICS
     #error "Atomic operation isn't implemented for current platform!"
   #endif
 Standard_DEPRECATED("Standard_Atomic_Increment will be removed in OCCT 8.0.0")
 int Standard_Atomic_Increment(volatile int* theValue)
 {
   return ++(*theValue);
 }
 
 Standard_DEPRECATED("Standard_Atomic_Decrement will be removed in OCCT 8.0.0")
 int Standard_Atomic_Decrement(volatile int* theValue)
 {
   return --(*theValue);
 }
 
 Standard_DEPRECATED("Standard_Atomic_CompareAndSwap will be removed in OCCT 8.0.0")
 bool Standard_Atomic_CompareAndSwap(volatile int* theValue, int theOldValue, int theNewValue)
 {
   if (*theValue == theOldValue)
   {
     *theValue = theNewValue;
     return true;
   }
   return false;
 }
 
 #endif
 
 #endif //_Standard_Atomic_HeaderFile

This page was automatically generated by the 2.3.7 LXR engine. The LXR team