C++ Atomic Library - Compare Exchange

It atomically compares the value of the atomic object with non-atomic argument and performs atomic exchange if equal or atomic load if not.
Following is the declaration for std::atomic_compare_exchange_weak.
template< class T >
bool atomic_compare_exchange_weak( volatile std::atomic<T>* obj, 
                                   T* expected, T desired );
template< class T <
bool atomic_compare_exchange_weak( std::atomic<T>* obj, 
                                   T* expected, T desired );
Following is the declaration for std::atomic_compare_exchange_strong.
template< class T >
bool atomic_compare_exchange_strong( volatile std::atomic<T>* obj,
                                     T* expected, T desired );
template< class T >
bool atomic_compare_exchange_strong( std::atomic<T>* obj,
                                     T* expected, T desired );
Following is the declaration for std::atomic_compare_exchange_weak_explicit.
template< class T >
bool atomic_compare_exchange_weak_explicit( volatile std::atomic<T>* obj,
                                            T* expected, T desired,
                                            std::memory_order succ, 
                                            std::memory_order fail );
template< class T >
bool atomic_compare_exchange_weak_explicit( std::atomic<T>* obj,
                                            T* expected, T desired,
                                            std::memory_order succ, 
                                            std::memory_order fail );
Following is the declaration for std::atomic_compare_exchange_strong_explicit.
template< class T >
bool atomic_compare_exchange_strong_explicit( std::atomic<T>* obj,
                                              T* expected, T desired,
                                              std::memory_order succ, 
                                              std::memory_order fail );
template< class T >
bool atomic_compare_exchange_strong_explicit( volatile std::atomic<T>* obj, 
                                              T* expected, T desired,
                                              std::memory_order succ, 
                                              std::memory_order fail );
obj − It is used in pointer to the atomic object to modify.
obj − It is used in pointer to the atomic object to modify.
desr − It is used to store the value in the atomic object.
desr − It is used to store the value in the atomic object.
order − It is used to synchronise the memory ordering for this operation.
order − It is used to synchronise the memory ordering for this operation.
succ − It is used in the memory synchronization ordering for the read-modify-write operation if the comparison succeeds. All values are permitted.
succ − It is used in the memory synchronization ordering for the read-modify-write operation if the comparison succeeds. All values are permitted.
fail − It is used in the memory synchronization ordering for the load operation if the comparison fails. Cannot be std::memory_order_release or std::memory_order_acq_rel and cannot specify stronger ordering than succ.
fail − It is used in the memory synchronization ordering for the load operation if the comparison fails. Cannot be std::memory_order_release or std::memory_order_acq_rel and cannot specify stronger ordering than succ.
It returns the result of the comparison: true if *obj was equal to *expected, false otherwise.
No-noexcept − this member function never throws exceptions.
In below example for std::atomic_compare_exchange.
#include <atomic>

template<class T>
struct node {
   T data;
   node* next;
   node(const T& data) : data(data), next(nullptr) {}
};

template<class T>
class stack {
   std::atomic<node<T>*> head;
   public:
      void push(const T& data) {
         node<T>* new_node = new node<T>(data);
         new_node->next = head.load(std::memory_order_relaxed);
         while(!std::atomic_compare_exchange_weak_explicit(&head, &new_node->next,
            new_node, std::memory_order_release, std::memory_order_relaxed))
            ;
      }
};

int main() {
   stack<int> s;
   s.push(1);
   s.push(2);
   s.push(3);
}
 Print
 Add Notes
 Bookmark this page