queues.hpp

Go to the documentation of this file.

 
#ifndef PARALLEL_CELLULAR_AUTOMATA_WORKSTEALINGQUEUE_HPP
#define PARALLEL_CELLULAR_AUTOMATA_WORKSTEALINGQUEUE_HPP
#include <condition_variable>
#include <deque>
#include <functional>
#include <memory>
#include <mutex>
#include <queue>
 
template <typename T>
class ThreadSafeQueue
{
 
  public:
    ThreadSafeQueue(){};
 
    ThreadSafeQueue(ThreadSafeQueue const &other)
    {
        std::lock_guard<std::mutex> lock(m);
        queue = other.queue;
    }
    void push(T elem)
    {
        std::lock_guard<std::mutex> lock(m);
        queue.push(elem);
        cond.notify_one();
    }
    bool try_pop(T &result)
    {
        std::lock_guard<std::mutex> lock(m);
        if (queue.empty())
        {
            return false;
        }
        else
        {
            result = std::move(queue.front());
            queue.pop();
            return true;
        }
    }
    std::shared_ptr<T> try_pop()
    {
        std::lock_guard<std::mutex> lock(m);
        if (queue.empty())
        {
            return std::shared_ptr<T>();
        }
        else
        {
            auto result = std::make_shared<T>(std::move(queue.front()));
            queue.pop();
            return result;
        }
    }
    void pop(T &result)
    {
        std::unique_lock<std::mutex> lock(m);
        cond.wait(lock, [this] { return !queue.empty(); });
        result = std::move(queue.front());
        queue.pop();
    };
    std::shared_ptr<T> pop()
    {
        std::unique_lock<std::mutex> lock(m);
        cond.wait(lock, [this] { return !queue.empty(); });
        auto result = std::make_shared<T>(std::move(queue.front()));
        queue.pop();
        return result;
    }
    bool empty() const
    {
        std::lock_guard<std::mutex> lock(m);
        return queue.empty();
    }
 
    size_t size() const
    {
        std::lock_guard<std::mutex> lock(m);
        return queue.size();
    }
 
  private:
    // mutable so it can be locked in empty and in the copy constructor
    mutable std::mutex m;
    std::queue<T> queue;
    std::condition_variable cond;
};
 
template <typename T>
class WorkStealingQueue
{
 
  public:
    WorkStealingQueue(){};
    WorkStealingQueue(const WorkStealingQueue &other) = delete;
    void push(T data)
    {
        std::lock_guard<std::mutex> lock(m);
        queue.push_front(std::move(data));
    }
    bool empty() const
    {
        std::lock_guard<std::mutex> lock(m);
        return queue.empty();
    }
    bool try_pop(T &result)
    {
        std::lock_guard<std::mutex> lock(m);
        if (queue.empty())
        {
            return false;
        }
        result = std::move(queue.front());
        queue.pop_front();
        return true;
    }
    bool try_steal(T &result)
    {
        std::lock_guard<std::mutex> lock(m);
        if (queue.empty())
        {
            return false;
        }
        result = std::move(queue.back());
        queue.pop_back();
        return true;
    }
    size_t size() const
    {
        std::lock_guard<std::mutex> lock(m);
        return queue.size();
    }
 
  private:
    mutable std::mutex m;
    std::deque<T> queue;
};
#endif