latch

---

1. Atomic Latch

std::atomic<bool> latch;

void wait_for_latch() {
  while (!latch.load(std::memory_order_acquire)) {
    std::this_thread::yield();
  }
}

void release_latch() {
  latch.store(true, std::memory_order_release);
}

2. Condition Variable Latch

std::condition_variable latch_cv;
std::mutex latch_mtx;

void wait_for_latch() {
  std::unique_lock<std::mutex> lock(latch_mtx);
  latch_cv.wait(lock);
}

void release_latch() {
  std::unique_lock<std::mutex> lock(latch_mtx);
  latch_cv.notify_all();
}

3. Event Latch

std::event latch;

void wait_for_latch() { latch.wait(); }

void release_latch() { latch.set(); }

4. Semaphore Latch

std::binary_semaphore latch(0);

void wait_for_latch() { latch.acquire(); }

void release_latch() { latch.release(); }

5. Mutex Latch

std::mutex latch;

void wait_for_latch() { latch.lock(); }

void release_latch() { latch.unlock(); }

6. Spin Lock Latch

std::atomic<bool> latch;

void wait_for_latch() {
  while (latch.load(std::memory_order_acquire)) {
    std::this_thread::yield();
  }
}

void release_latch() {
  latch.store(false, std::memory_order_release);
}

7. Counting Latch

std::atomic<int> latch_count;

void wait_for_latch() {
  while (latch_count.load(std::memory_order_acquire) > 0) {
    std::this_thread::yield();
  }
}

void decrement_latch() {
  latch_count.fetch_sub(1, std::memory_order_release);
}

8. Cyclic Latch

std::atomic<std::size_t> latch;

void wait_for_latch() {
  auto expected_count = latch.load(std::memory_order_relaxed);
  if (expected_count == 0) {
    std::this_thread::yield();
  } else {
    while (!latch.compare_exchange_weak(expected_count, expected_count + 1)) {
      expected_count = latch.load(std::memory_order_relaxed);
    }
  }
}

void release_latch() {
  latch.store(0, std::memory_order_relaxed);
}

9. Barrier Latch

std::atomic<std::size_t> latch;
std::atomic<std::size_t> count;

void wait_for_latch() {
  auto expected_count = latch.load(std::memory_order_relaxed);
  if (expected_count == 0) {
    std::this_thread::yield();
  } else {
    while (!latch.compare_exchange_weak(expected_count, expected_count + 1)) {
      expected_count = latch.load(std::memory_order_relaxed);
    }
    auto old_count = count.load(std::memory_order_relaxed);
    while (!count.compare_exchange_weak(old_count, old_count + 1)) {
      old_count = count.load(std::memory_order_relaxed);
    }
    if (old_count + 1 == expected_count) {
      latch.store(0, std::memory_order_relaxed);
      count.store(0, std::memory_order_relaxed);
    }
  }
}

10. Multi-Phase Latch

std::atomic<std::size_t> latch_count;
std::atomic<std::size_t> latch_phase;

void wait_for_latch(std::size_t phase) {
  while (latch_phase.load(std::memory_order_acquire) < phase) {
    std::this_thread::yield();
  }
  while (latch_count.load(std::memory_order_acquire) > 0) {
    std::this_thread::yield();
  }
}

void decrement_latch() {
  latch_count.fetch_sub(1, std::memory_order_release);
}

void advance_phase() {
  latch_phase.fetch_add(1, std::memory_order_release);
}

11. Asynchronous Latch

std::future<void> latch_future;

std::promise<void> latch_promise;

void wait_for_latch() { latch_future.get(); }

void release_latch() { latch_promise.set_value(); }

12. Explicit Coroutine Latch

std::experimental::coroutine<void> latch_coroutine;

void latch_coroutine_entry() {
  std::experimental::co_await std::experimental::suspend_always();
}

void wait_for_latch() {
  latch_coroutine();
}

void release_latch() {
  latch_coroutine.resume();
}

13. Implicit Coroutine Latch

struct latch_type {
  std::experimental::suspend_always initial_suspend;

  bool await_ready() noexcept { return false; }

  void await_suspend(std::experimental::coroutine_handle<> h) noexcept {
    latch_coroutine_handle = h;
  }

  void await_resume() noexcept {}
};

latch_type latch;

std::experimental::coroutine_handle<> latch_coroutine_handle;

void wait_for_latch() { latch; }

void release_latch() { latch_coroutine_handle.resume(); }

14. Semaphore Acquisition Latch

std::binary_semaphore latch(0);

void wait_for_latch() {
  if (!latch.try_acquire()) {
    std::this_thread::sleep_for(std::chrono::milliseconds(1));
    return;
  }
}

void release_latch() { latch.release(); }

15. Mutex Acquisition Latch

std::mutex latch;

void wait_for_latch() {
  if (!latch.try_lock()) {
    std::this_thread::sleep_for(std::chrono::milliseconds(1));
    return;
  }
}

void release_latch() { latch.unlock(); }

16. Spin Lock Acquisition Latch

std::atomic<bool> latch;

void wait_for_latch() {
  if (!latch.compare_exchange_weak(false, true)) {
    std::this_thread::yield();
    return;
  }
}

void release_latch() { latch.store(false, std::memory_order_release); }

17. Counting Semaphore Acquisition Latch

std::counting_semaphore latch(0);

void wait_for_latch() {
  if (!latch.try_acquire()) {
    std::this_thread::sleep_for(std::chrono::milliseconds(1));
    return;
  }
}

void release_latch() { latch.release(); }

18. Condition Variable Wait Latch

std::condition_variable latch_cv;
std::mutex latch_mtx;

void wait_for_latch() {
  std::unique_lock<std::mutex> lock(latch_mtx);
  latch_cv.wait(lock);
}

void release_latch() { latch_cv.notify_one(); }

19. Event Wait Latch

std::event latch;

void wait_for_latch() { latch.wait(); }

void release_latch() { latch.set(); }

20. Semaphore Wait Latch

std::binary_semaphore latch(0);

void wait_for_latch() { latch.acquire(); }

void release_latch() { latch.release(); }

21. Mutex Wait Latch

std::mutex latch;

void wait_for_latch() { latch.lock(); }

void release_latch() { latch.unlock(); }

22. Spin Lock Wait Latch

std::atomic<bool> latch;

void wait_for_latch() {
  while (latch.load(std::memory_order_acquire)) {
    std::this_thread::yield();
  }
}

void release_latch() {
  latch.store(false, std::memory_order_release);
}

23. Counting Latch Wait Latch

std::atomic<int> latch_count;

void wait_for_latch() {
  while (latch_count.load(std::memory_order_acquire) > 0) {
    std::this_thread::yield();
  }
}

void decrement_latch() {
  latch_count.fetch_sub(1, std::memory_order_release);
}

24. Cyclic Latch Wait Latch

std::atomic<std::size_t> latch;

void wait_for_latch() {
  auto expected_count = latch.load(std::memory_order_relaxed);
  if (expected_count == 0) {
    std::this_thread::yield();
  } else {
    while (!latch.compare_exchange_weak(expected_count, expected_count + 1)) {
      expected_count = latch.load(std::memory_order_relaxed);
    }
  }
}

void release_latch() { latch.store(0, std::memory_order_relaxed); }

25. Barrier Latch Wait Latch

std::atomic<std::size_t> latch;
std::atomic<std::size_t> count;

void wait_for_latch() {
  auto expected_count = latch.load(std::memory_order_relaxed);
  if (expected_count == 0) {
    std::this_thread::yield();
  } else {
    while (!latch.compare_exchange_weak(expected_count, expected_count + 1)) {
      expected_count = latch.load(std::memory_order_relaxed);
    }
    auto old_count = count.load(std::memory_order_relaxed);
    while (!count.compare_exchange_weak(old_count, old_count + 1)) {
      old_count = count.load(std::memory_order_relaxed);
    }
    if (old_count + 1 == expected_count) {
      latch.store(0, std::memory_order_relaxed);
      count.store(0, std::memory_order_relaxed);
    }
  }
}

26. Multi-Phase Latch Wait Latch

std::atomic<std::size_t> latch_count;
std::atomic<std::size_t> latch_phase;

void wait_for_latch(std::size_t phase) {
  while (latch_phase.load(std::memory_order_acquire) < phase) {
    std::this_thread::yield();
  }
  while (latch_count.load(std::memory_order_acquire) > 0) {
    std::this_thread::yield();
  }
}

void decrement_latch() { latch_count.fetch_sub(1, std::memory_order_release); }

void advance_phase() { latch_phase.fetch_add(1, std::memory_order_release); }

27. Asynchronous Latch Wait Latch

std::future<void> latch_future;

std::promise<void> latch_promise;

void wait_for_latch() { latch_future.get(); }

void release_latch() { latch_promise.set_value(); }

28. Explicit Coroutine Latch Wait Latch

std::experimental::coroutine<void> latch_coroutine;

void latch_coroutine_entry() {
  std::experimental::co_await std::experimental::suspend_always();
}

void wait_for_latch() { latch_coroutine(); }

void release_latch() { latch_coroutine.resume(); }

29. Implicit Coroutine Latch Wait Latch

struct latch_type {
  std::experimental::suspend_always initial_suspend;

  bool await_ready() noexcept { return false; }

  void await_suspend(std::experimental::coroutine_handle<> h) noexcept {
    latch_coroutine_handle = h;
  }

  void await_resume() noexcept {}
};

latch_type latch;

std::experimental::coroutine_handle<> latch_coroutine_handle;

void wait_for_latch() { latch; }

void release_latch() { latch_coroutine_handle.resume(); }

30. Semaphore Acquisition Latch Wait Latch

std::binary_semaphore latch(0);

void wait_for_latch() {
  if