thread_barrier.hpp

/* Copyright 2009-2017 Francesco Biscani (bluescarni@gmail.com)

This file is part of the Piranha library.

The Piranha library is free software; you can redistribute it and/or modify
it under the terms of either:

  * the GNU Lesser General Public License as published by the Free
    Software Foundation; either version 3 of the License, or (at your
    option) any later version.

or

  * the GNU General Public License as published by the Free Software
    Foundation; either version 3 of the License, or (at your option) any
    later version.

or both in parallel, as here.

The Piranha library is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received copies of the GNU General Public License and the
GNU Lesser General Public License along with the Piranha library.  If not,
see https://www.gnu.org/licenses/. */

#ifndef PIRANHA_THREAD_BARRIER_HPP
#define PIRANHA_THREAD_BARRIER_HPP

#include <condition_variable>
#include <cstdlib>
#include <mutex>
#include <stdexcept>

#include <piranha/exceptions.hpp>
#include <piranha/thread_barrier.hpp>

namespace piranha
{

// This class has been minimally adapted from the barrier class in the Boost libraries 1.45.0.
// Original copyright notice follows:

// Copyright (C) 2002-2003
// David Moore, William E. Kempf
// Copyright (C) 2007-8 Anthony Williams
//
//  Distributed under the Boost Software License, Version 1.0. (See accompanying
//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)


class thread_barrier
{
public:

    explicit thread_barrier(unsigned count) : m_mutex(), m_cond(), m_threshold(count), m_count(count), m_generation(0)
    {
        if (count == 0) {
            piranha_throw(std::invalid_argument, "count cannot be zero");
        }
    }
    thread_barrier(const thread_barrier &) = delete;
    thread_barrier(thread_barrier &&) = delete;

private:
    thread_barrier &operator=(const thread_barrier &) = delete;
    thread_barrier &operator=(thread_barrier &&) = delete;

public:

    ~thread_barrier()
    {
        try {
            std::unique_lock<std::mutex> lock(m_mutex);
            if (m_count != m_threshold) {
                // NOTE: logging candidate.
                std::abort();
            }
        } catch (...) {
            // NOTE: logging candidate.
            std::abort();
        }
    }

    bool wait()
    {
        try {
            std::unique_lock<std::mutex> lock(m_mutex);
            unsigned gen = m_generation;
            if (--m_count == 0) {
                // This is the last thread, update generation count
                // and reset the count to the initial value, then
                // notify the other threads.
                ++m_generation;
                m_count = m_threshold;
                // NOTE: this is noexcept.
                m_cond.notify_all();
                return true;
            }
            // This is not the last thread, wait for the other threads
            // to clear the barrier.
            while (gen == m_generation) {
                // NOTE: this will be noexcept in C++14.
                m_cond.wait(lock);
            }
            return false;
        } catch (...) {
            // NOTE: logging candidate.
            std::abort();
        }
    }

private:
    std::mutex m_mutex;
    std::condition_variable m_cond;
    const unsigned m_threshold;
    unsigned m_count;
    unsigned m_generation;
};
}

#endif