Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #pragma once
       5             : 
       6             : #include <atomic>
       7             : 
       8             : namespace Parallel {
       9             : /*!
      10             :  * \brief A simple spinlock implemented in `std::atomic`s
      11             :  *
      12             :  * Implementation adapted from https://rigtorp.se/spinlock/
      13             :  */
      14           1 : class Spinlock {
      15             :  public:
      16           0 :   Spinlock() = default;
      17           0 :   Spinlock(const Spinlock&) = delete;
      18           0 :   Spinlock& operator=(const Spinlock&) = delete;
      19           0 :   Spinlock(Spinlock&&) = delete;
      20           0 :   Spinlock& operator=(Spinlock&&) = delete;
      21           0 :   ~Spinlock() = default;
      22             : 
      23             :   /// \brief Acquire the lock. Will block until the lock is acquired.
      24           1 :   void lock() {
      25             :     for (;;) {
      26             :       // Optimistically assume the lock is free on the first try
      27             :       if (not lock_.exchange(true, std::memory_order_acquire)) {
      28             :         return;
      29             :       }
      30             :       // Wait for lock to be released without generating cache misses
      31             :       while (lock_.load(std::memory_order_relaxed)) {
      32             :         // Issue X86 PAUSE or ARM YIELD instruction to reduce contention between
      33             :         // hyper-threads
      34             :         //
      35             :         // If no hyperthreading is being used, this will actually slow down the
      36             :         // code.
      37             :         //
      38             :         // We keep this comment and code around just in case we want to
      39             :         // experiment with it in the future.
      40             :         //
      41             :         // __builtin_ia32_pause();
      42             :       }
      43             :     }
      44             :   }
      45             : 
      46             :   /// \brief Try to acquire the lock.
      47             :   ///
      48             :   /// Returns `true` if the lock was acquired, `false` if it wasn't.
      49           1 :   bool try_lock() {
      50             :     // First do a relaxed load to check if lock is free in order to prevent
      51             :     // unnecessary cache misses if someone does while(!try_lock())
      52             :     return not lock_.load(std::memory_order_relaxed) and
      53             :            not lock_.exchange(true, std::memory_order_acquire);
      54             :   }
      55             : 
      56             :   /// \brief Release the lock.
      57           1 :   void unlock() { lock_.store(false, std::memory_order_release); }
      58             : 
      59             :  private:
      60           0 :   std::atomic<bool> lock_{false};
      61             : };
      62             : }  // namespace Parallel