LifoStorage.hpp

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2016-2024 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2024 Total, S.A
 * Copyright (c) 2018-2024 The Board of Trustees of the Leland Stanford Junior University
 * Copyright (c) 2023-2024 Chevron
 * Copyright (c) 2019-     GEOS/GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */
 
#ifndef LIFOSTORAGE_HPP
#define LIFOSTORAGE_HPP
 
#include <deque>
#include <future>
#include <mutex>
#include <condition_variable>
#include <camp/camp.hpp>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <algorithm>
 
#include "common/GEOS_RAJA_Interface.hpp"
#include "common/TimingMacros.hpp"
#include "common/LifoStorageCommon.hpp"
#include "common/LifoStorageHost.hpp"
#ifdef GEOS_USE_CUDA
#include "common/LifoStorageCuda.hpp"
#endif
 
namespace geos
{
template< typename T, typename INDEX_TYPE >
class LifoStorage
{
 
public:
 
 
  LifoStorage( std::string name, size_t elemCnt, int numberOfBuffersToStoreOnDevice, int numberOfBuffersToStoreOnHost, int maxNumberOfBuffers ):
    m_maxNumberOfBuffers( maxNumberOfBuffers ),
    m_bufferSize( elemCnt*sizeof( T ) ),
    m_bufferCount( 0 )
  {
    LIFO_LOG_RANK( " LIFO : maximum size "<< m_maxNumberOfBuffers << " buffers " );
    double bufferSize = ( ( double ) m_bufferSize ) / ( 1024.0 * 1024.0 );
    LIFO_LOG_RANK( " LIFO : buffer size "<< bufferSize << "MB" );
    if( numberOfBuffersToStoreOnDevice < 0 )
    {
#ifdef GEOS_USE_CUDA
      numberOfBuffersToStoreOnDevice = LifoStorageCuda< T, INDEX_TYPE >::computeNumberOfBufferOnDevice( -numberOfBuffersToStoreOnDevice, m_bufferSize, m_maxNumberOfBuffers );
#else
      numberOfBuffersToStoreOnDevice = 0;
#endif
    }
    if( numberOfBuffersToStoreOnHost < 0 )
    {
      numberOfBuffersToStoreOnHost =
        LifoStorageCommon< T, INDEX_TYPE >::computeNumberOfBufferOnHost( -numberOfBuffersToStoreOnHost, m_bufferSize, m_maxNumberOfBuffers, numberOfBuffersToStoreOnDevice );
    }
    LIFO_LOG_RANK( " LIFO : allocating "<< numberOfBuffersToStoreOnHost <<" buffers on host" );
    LIFO_LOG_RANK( " LIFO : allocating "<< numberOfBuffersToStoreOnDevice <<" buffers on device" );
#ifdef GEOS_USE_CUDA
    if( numberOfBuffersToStoreOnDevice > 0 )
    {
      m_lifo = std::make_unique< LifoStorageCuda< T, INDEX_TYPE > >( name, elemCnt, numberOfBuffersToStoreOnDevice, numberOfBuffersToStoreOnHost, maxNumberOfBuffers );
    }
    else
#endif
    {
      m_lifo = std::make_unique< LifoStorageHost< T, INDEX_TYPE > >( name, elemCnt, numberOfBuffersToStoreOnHost, maxNumberOfBuffers );
    }
 
  }
 
  LifoStorage( std::string name, arrayView1d< T > array, int numberOfBuffersToStoreOnDevice, int numberOfBuffersToStoreOnHost, int maxNumberOfBuffers ):
    LifoStorage( name, array.size(), numberOfBuffersToStoreOnDevice, numberOfBuffersToStoreOnHost, maxNumberOfBuffers ) {}
 
  void pushAsync( arrayView1d< T > array )
  {
    LIFO_MARK_FUNCTION;
    m_lifo->pushAsync( array );
  }
 
  void pushWait()
  {
    LIFO_MARK_FUNCTION;
    m_lifo->pushWait();
  }
 
  void push( arrayView1d< T > array )
  {
    LIFO_MARK_FUNCTION;
    pushAsync( array );
    pushWait();
  }
 
  void popAsync( arrayView1d< T > array )
  {
    LIFO_MARK_FUNCTION;
    m_lifo->popAsyncPrelude();
    m_lifo->popAsync( array );
  }
 
  void popWait()
  {
    LIFO_MARK_FUNCTION;
    m_lifo->popWait();
  }
 
  void pop( arrayView1d< T > array )
  {
    LIFO_MARK_FUNCTION;
    popAsync( array );
    popWait();
  }
 
  bool empty()
  {
    return m_lifo->empty();
  }
 
private:
  int m_maxNumberOfBuffers;
  size_t m_bufferSize;
  int m_bufferCount;
 
  std::unique_ptr< LifoStorageCommon< T, INDEX_TYPE > > m_lifo;
 
};
}
#endif // LIFOSTORAGE_HPP