latch.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2006-2021, Knut Reinert & Freie Universität Berlin
// Copyright (c) 2016-2021, Knut Reinert & MPI für molekulare Genetik
// This file may be used, modified and/or redistributed under the terms of the 3-clause BSD-License
// shipped with this file and also available at: https://github.com/seqan/seqan3/blob/master/LICENSE.md
// -----------------------------------------------------------------------------------------------------
 
#pragma once
 
#include <atomic>
#include <cassert>
#include <seqan3/std/new>
 
#include <seqan3/utility/parallel/detail/spin_delay.hpp>
 
namespace seqan3::detail
{
 
class latch
{
public:
 
    latch()                           = delete;  
    latch(latch const &)              = delete;  
    latch(latch &&)                   = delete;  
    latch & operator=(latch const &)  = delete;  
    latch & operator=(latch &&)       = delete;  
 
    ~latch()
    {
        spin_delay delay{};
        while (num_waiting.load(std::memory_order_acquire) > 0)
            delay.wait();
    }
 
    explicit latch(ptrdiff_t const expected) :
        counter{expected}
    {
        assert(expected >= 0);
        num_waiting.store(0, std::memory_order_relaxed);
    }
 
    void arrive(ptrdiff_t n = 1) noexcept
    {
        assert(counter.load(std::memory_order_acquire) >= n);
        assert(counter.load(std::memory_order_acquire) >= 0);
 
        counter.fetch_sub(n, std::memory_order_acq_rel);
    }
 
    void arrive_and_wait(ptrdiff_t n = 1) noexcept
    {
        ++num_waiting; // ensure that destructor is not finished in-between the arrive and wait call.
        arrive(n);
        wait();
        --num_waiting;
    }
 
    bool try_wait() const noexcept
    {
        return counter.load(std::memory_order_acquire) == 0;
    }
 
    void wait() const
    {
        ++num_waiting; // register waiting thread to synchronise with destructor.
        spin_delay delay{};
        while (counter.load(std::memory_order_acquire) > 0)
            delay.wait();
        --num_waiting;
    }
 
private:
 
    alignas(std::hardware_destructive_interference_size) std::atomic<std::ptrdiff_t>         counter;
    alignas(std::hardware_destructive_interference_size) mutable std::atomic<std::ptrdiff_t> num_waiting;
};
 
} // namespace seqan3::detail