concurrent.hpp

Go to the documentation of this file.

#pragma once
 
#include <atomic_queue/include/atomic_queue/atomic_queue.h>
#include <deque>
#include <mutex>
#include <oneapi/tbb/concurrent_map.h>
#include <phmap/parallel_hashmap/phmap.h>
#include <stddef.h>
 
namespace jaffarCommon
{
 
namespace concurrent
{
 
template <class T>
using atomicQueue_t = atomic_queue::AtomicQueueB<T>;
 
template <class V>
using HashSet_t = phmap::parallel_flat_hash_set<V, phmap::priv::hash_default_hash<V>, phmap::priv::hash_default_eq<V>, std::allocator<V>, 4, std::mutex>;
 
template <class K, class V>
using HashMap_t = phmap::parallel_flat_hash_map<K, V, phmap::priv::hash_default_hash<K>, phmap::priv::hash_default_eq<K>, std::allocator<std::pair<const K, V>>, 4, std::mutex>;
 
template <class K, class V, class C = std::greater<K>>
using concurrentMultimap_t = oneapi::tbb::concurrent_multimap<K, V, C>;
 
template <class T>
class Deque
{
public:
  Deque()  = default;
  ~Deque() = default;
 
  __JAFFAR_COMMON__INLINE__ auto& getInternalStorage() { return _internalDeque; }
 
  __JAFFAR_COMMON__INLINE__ void push_back_no_lock(T element) { _internalDeque.push_back(element); }
 
  __JAFFAR_COMMON__INLINE__ void push_back(T element)
  {
    _mutex.lock();
    _internalDeque.push_back(element);
    _mutex.unlock();
  }
 
  __JAFFAR_COMMON__INLINE__ void push_front_no_lock(T element) { _internalDeque.push_front(element); }
 
  __JAFFAR_COMMON__INLINE__ void push_front(T element)
  {
    _mutex.lock();
    _internalDeque.push_front(element);
    _mutex.unlock();
  }
 
  __JAFFAR_COMMON__INLINE__ T front() const { return _internalDeque.front(); }
 
  __JAFFAR_COMMON__INLINE__ T back() const { return _internalDeque.back(); }
 
  __JAFFAR_COMMON__INLINE__ void pop_front()
  {
    _mutex.lock();
    _internalDeque.pop_front();
    _mutex.unlock();
  }
 
  __JAFFAR_COMMON__INLINE__ void pop_back()
  {
    _mutex.lock();
    _internalDeque.pop_back();
    _mutex.unlock();
  }
 
  __JAFFAR_COMMON__INLINE__ bool pop_back_get(T& element)
  {
    _mutex.lock();
 
    if (_internalDeque.empty())
    {
      _mutex.unlock();
      return false;
    }
 
    element = _internalDeque.back();
    _internalDeque.pop_back();
 
    _mutex.unlock();
    return true;
  }
 
  __JAFFAR_COMMON__INLINE__ bool pop_front_get(T& element)
  {
    _mutex.lock();
 
    if (_internalDeque.empty())
    {
      _mutex.unlock();
      return false;
    }
 
    element = _internalDeque.front();
    _internalDeque.pop_front();
 
    _mutex.unlock();
    return true;
  }
 
  __JAFFAR_COMMON__INLINE__ size_t wasSize() const { return _internalDeque.size(); }
 
private:
  std::mutex _mutex;
 
  std::deque<T> _internalDeque;
};
 
} // namespace concurrent
 
} // namespace jaffarCommon