FixedSizeDeque.hpp

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2018-2020 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2020 The Board of Trustees of the Leland Stanford Junior University
 * Copyright (c) 2018-2020 TotalEnergies
 * Copyright (c) 2019-     GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */
#ifndef FIXEDSIZEDEQUE_HPP
#define FIXEDSIZEDEQUE_HPP
 
#include "LvArray/src/Array.hpp"
#include "LvArray/src/memcpy.hpp"
#include "LvArray/src/ChaiBuffer.hpp"
#include "common/Logger.hpp"
 
#define POSITIVE_MODULO( a, b ) ( ( ( a ) % ( b ) ) + b ) % ( b )
namespace geos
{
template< typename T, typename INDEX_TYPE >
class FixedSizeDeque
{
  using IndexType = INDEX_TYPE;
  using ArraySlice1DLarge = LvArray::ArraySlice< T const, 1, 0, std::ptrdiff_t >;
  using Array2D = LvArray::Array< T, 2, camp::make_idx_seq_t< 2 >, std::ptrdiff_t, LvArray::ChaiBuffer >;
public:
  FixedSizeDeque( IndexType maxEntries, IndexType valuesPerEntry, LvArray::MemorySpace space, camp::resources::Resource stream ):
    m_stream( stream )
  {
    GEOS_ERROR_IF( maxEntries < 0, "Fixed sized queue size must be positive" );
    GEOS_ERROR_IF( valuesPerEntry < 0, "Fixed sized queue array size must be positive" );
    m_storage.resizeWithoutInitializationOrDestruction( space, maxEntries, valuesPerEntry );
  }
 
  bool empty() const
  {
    return m_begin > m_end;
  }
 
  bool full() const
  {
    return size() == (size_t)m_storage.size( 0 );
  }
 
  size_t size() const
  {
    return (size_t)( m_end - m_begin + 1 );
  }
 
  size_t capacity() const
  {
    return m_storage.size( 0 );
  }
 
  ArraySlice1DLarge front() const
  {
    GEOS_ERROR_IF( empty(), "Can't get front from empty queue" );
    return m_storage[ POSITIVE_MODULO( m_begin, m_storage.size( 0 ) ) ];
  }
 
  ArraySlice1DLarge next_front() const
  {
    GEOS_ERROR_IF( full(), "Can't increase in a full queue" );
    return m_storage[ POSITIVE_MODULO( m_begin-1, m_storage.size( 0 ) ) ];
  }
 
  ArraySlice1DLarge back() const
  {
    GEOS_ERROR_IF( empty(), "Can't get back from empty queue" );
    return m_storage[ POSITIVE_MODULO( m_end, m_storage.size( 0 ) ) ];
  }
 
  ArraySlice1DLarge next_back() const
  {
    GEOS_ERROR_IF( full(), "Can't increase in a full queue" );
    return m_storage[ POSITIVE_MODULO( m_end+1, m_storage.size( 0 ) ) ];
  }
 
  void pop_front()
  {
    GEOS_ERROR_IF( empty(), "Can't pop front from empty queue" );
    m_begin++;
  }
 
  void pop_back()
  {
    GEOS_ERROR_IF( empty(), "Can't pop back from empty queue" );
    m_end--;
  }
 
  void inc_front()
  {
    GEOS_ERROR_IF( full(), "Can't increase in a full queue" );
    m_begin--;
  }
 
  void inc_back()
  {
    GEOS_ERROR_IF( full(), "Can't increase in a full queue" );
    m_end++;
  }
 
  template< typename INDEX_TYPE2 >
  camp::resources::Event emplace_front( const LvArray::ArraySlice< T const, 1, 0, INDEX_TYPE2 > & src )
  {
    GEOS_ERROR_IF( full(), "Can't emplace in a full  queue" );
    camp::resources::Event e = LvArray::memcpy( m_stream, m_storage[ POSITIVE_MODULO( m_begin-1, m_storage.size( 0 ) ) ], src );
    --m_begin;
    return e;
  }
 
  template< typename INDEX_TYPE2 >
  camp::resources::Event emplace_back( const LvArray::ArraySlice< T const, 1, 0, INDEX_TYPE2 > & src )
  {
    GEOS_ERROR_IF( full(), "Can't emplace in a full queue" );
    camp::resources::Event e = LvArray::memcpy( m_stream, m_storage[ POSITIVE_MODULO( m_end+1, m_storage.size( 0 ) ) ], src );
    ++m_end;
    return e;
 
  }
 
  camp::resources::Resource getStream()
  {
    return m_stream;
  }
 
 
private:
  Array2D m_storage;
  IndexType m_begin = 0;
  IndexType m_end = -1;
  camp::resources::Resource m_stream;
};
}
#endif // FIXEDSIZEDEQUE_HPP