Stdatomic Flag Test And Set Stdatomic Flag Test And Set Explicit Function In C++

The std::atomicflagtestandset and std::atomicflagtestandsetexplicit functions in the C++ programming language belong to the standard template library (STL) and play a crucial role in enabling lock-free and thread-safe operations. These functions are specifically designed to work with a std::atomicflag, an atomic data type created for boolean flags that can be either set or clear. This is particularly beneficial for creating elementary spinlocks.

std::atomic_flag_test_and_set:

The objective of this function is to verify the current status of the flag (true) and if it is not set, then to set the flag. This entire process occurs atomically, guaranteeing that when one thread alters the flag, no other thread can do so concurrently. This feature is crucial for maintaining the thread safety of the function's operations.

Usage: flag.testandset

It provides the value that was set for the flag before (either true or false). If the flag is already enabled, the function will return true. If the flag is disabled, it will enable the flag and return false.

A common scenario where std::atomicflagtestandset is often applied is in implementing a spinlock. In this situation, a thread can iteratively invoke testandset within a loop, pausing until the method returns false, signifying that it effectively marked the flag and gained exclusive access to the "locked" asset.

Example Code:

#include <atomic>
#include <thread>
#include <iostream>
std::atomic_flag lock_flag = ATOMIC_FLAG_INIT;
void critical_section() {
    while (lock_flag.test_and_set(std::memory_order_acquire)) {
        // Wait until the lock is acquired (spinning).
    }
    // Critical section code.
    std::cout << "In critical section\n";
    lock_flag.clear(std::memory_order_release); // Release the lock
}
int main() {
    std::thread t1(critical_section);
    std::thread t2(critical_section);
    t1.join();
    t2.join();
}

Output:

In critical section
In critical section

Explanation:

In this instance, the testandset function is employed to obtain a lock. If the flag is already set, it enters a loop (spinning) until another thread resets the flag. Subsequent to the completion of the critical section, invoking lock_flag.clear relinquishes the lock, enabling other threads to access the section.

std::atomic_flag_test_and_set_explicit

The std::atomicflagtestandsetexplicit function serves as an enhanced alternative to testand_set, offering the flexibility to define the memory ordering. Memory ordering plays a crucial role in determining how actions on the flag are interpreted among various threads, influencing both the efficiency and accuracy of multithreaded applications.

Usage: flag.testandset_explicit(order)

Parameters:

• ✅ Order: This is the memory order for the operation, and it can be one of several options:
• ✅ std::memoryorderrelaxed: No synchronization or ordering constraints.
• ✅ std::memoryorderacquire: Ensures that operations after the acquire in the current thread are not moved before it.
• ✅ std::memoryorderrelease: Ensures that all operations before the release in the current thread are not moved after it.
• ✅ std::memoryorderacq_rel: Both acquire and release semantics.
• ✅ std::memoryorderseq_cst: Ensures sequential consistency among threads.

Return Value: Similar to the behavior of the testandset function, it provides the previous status of the flag, returning true if it was already set and false if it was clear.

Example Code:

#include <atomic>
#include <thread>
#include <iostream>
std::atomic_flag lock_flag = ATOMIC_FLAG_INIT;
void critical_section() {
    while (lock_flag.test_and_set_explicit(std::memory_order_acquire)) {
        // Spin until lock is acquired.
    }
    // Critical section code.
    std::cout << "In critical section\n";
    lock_flag.clear(std::memory_order_release); // Release the lock
}
int main() {
    std::thread t1(critical_section);
    std::thread t2(critical_section);
    t1.join();
    t2.join();
}

Key differences between std::atomic_flag_test_and_set, std::atomic_flag_test_and_set_explicit function in C++ :

Some key variances between these functions are outlined below: