Ctrl+K

speculative_spin_mutex

speculative_spin_mutex#

[mutex.speculative_spin_mutex]

A speculative_spin_mutex is a class that models the Mutex requirement using a spin lock, and for processors that support hardware transactional memory (such as Intel® Transactional Synchronization Extensions (Intel® TSX)) may be implemented in a way that allows non-contending changes to the protected data to proceed in parallel.

The speculative_spin_mutex is not fair and not recursive. The speculative_spin_mutex is like a spin_mutex, but it may provide better throughput than non-speculative mutexes when the following conditions are met:

  • Running on a processor that supports hardware transactional memory.

  • Multiple threads can concurrently execute the critical section(s) protected by the mutex, mostly without conflicting.

Otherwise, it performs like a spin_mutex, possibly with worse throughput.

// Defined in header <oneapi/tbb/spin_mutex.h>

namespace oneapi {
namespace tbb {
    class speculative_spin_mutex {
    public:
        speculative_spin_mutex() noexcept;
        ~speculative_spin_mutex();

        speculative_spin_mutex(const speculative_spin_mutex&) = delete;
        speculative_spin_mutex& operator=(const speculative_spin_mutex&) = delete;

        class scoped_lock;

        static constexpr bool is_rw_mutex = false;
        static constexpr bool is_recursive_mutex = false;
        static constexpr bool is_fair_mutex = false;
    };
} // namespace tbb
} // namespace oneapi

Member classes#

class scoped_lock#

Corresponding scoped_lock class. See the Mutex requirement.

Member functions#

speculative_spin_mutex()#

Constructs speculative_spin_mutex with unlocked state.

~speculative_spin_mutex()#

Destroys an unlocked speculative_spin_mutex.

Contents