Program Listing for File TwoLevelMemory.h

↰ Return to documentation for file (ADS/external/TwoLevelMemory.h)

/*--------------------------------------------------------------------------*/
/*------------------------- File TwoLevelMemory.h --------------------------*/
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
/*----------------------------- DEFINITIONS --------------------------------*/
/*--------------------------------------------------------------------------*/

#ifndef __ADS_TwoLevelMemory
 #define __ADS_TwoLevelMemory
                      /* self-identification: #endif constant */

/*--------------------------------------------------------------------------*/
/*------------------------------ INCLUDES ----------------------------------*/
/*--------------------------------------------------------------------------*/

#include "ADS/Contract.h"

#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <utility>
#include <vector>

/*--------------------------------------------------------------------------*/
/*--------------------------- NAMESPACE ------------------------------------*/
/*--------------------------------------------------------------------------*/

namespace ADS {

/*--------------------------------------------------------------------------*/
/*------------------------- CLASS TwoLevelMemory ---------------------------*/
/*--------------------------------------------------------------------------*/

class TwoLevelMemory {

/*--------------------------------------------------------------------------*/
 public:

 TwoLevelMemory( std::size_t B , std::size_t M );

 TwoLevelMemory( const TwoLevelMemory & ) = delete;
 TwoLevelMemory & operator=( const TwoLevelMemory & ) = delete;

 [[nodiscard]] std::size_t blockSize( void ) const;

 [[nodiscard]] std::size_t memorySize( void ) const;

 [[nodiscard]] std::size_t blocks( std::size_t n ) const;

 [[nodiscard]] std::uint64_t reads( void ) const;

 [[nodiscard]] std::uint64_t writes( void ) const;

 [[nodiscard]] std::uint64_t ios( void ) const;

 void resetCounters( void );

 void allocate( std::size_t k );

 void release( std::size_t k );

 [[nodiscard]] std::size_t used( void ) const;

 [[nodiscard]] std::size_t peak( void ) const;

 void countRead( void );
 void countWrite( void );

/*--------------------------------------------------------------------------*/
 private:

 std::size_t f_B;
 std::size_t f_M;
 std::uint64_t f_reads = 0;
 std::uint64_t f_writes = 0;
 std::size_t f_used = 0;
 std::size_t f_peak = 0;

 };  // end( class TwoLevelMemory )

/*--------------------------------------------------------------------------*/
/*--------------------------- CLASS MemoryLease ----------------------------*/
/*--------------------------------------------------------------------------*/

class MemoryLease {

/*--------------------------------------------------------------------------*/
 public:

 MemoryLease( TwoLevelMemory & mem , std::size_t k );

 MemoryLease( const MemoryLease & ) = delete;
 MemoryLease & operator=( const MemoryLease & ) = delete;

 ~MemoryLease();

 [[nodiscard]] std::size_t size( void ) const;

/*--------------------------------------------------------------------------*/
 private:

 TwoLevelMemory * f_mem;
 std::size_t f_k;

 };  // end( class MemoryLease )

/*--------------------------------------------------------------------------*/
/*---------------------------- CLASS DiskFile ------------------------------*/
/*--------------------------------------------------------------------------*/

template< class T >
class DiskFile {

/*--------------------------------------------------------------------------*/
 public:

 using value_type = T;
 using size_type = std::size_t;

 explicit DiskFile( TwoLevelMemory & mem );

 DiskFile( TwoLevelMemory & mem , std::vector< T > items );

 DiskFile( DiskFile && ) noexcept = default;

 DiskFile & operator=( DiskFile && other );

 DiskFile( const DiskFile & ) = delete;
 DiskFile & operator=( const DiskFile & ) = delete;

 [[nodiscard]] TwoLevelMemory & memory( void ) const;

 [[nodiscard]] std::size_t size( void ) const;

 [[nodiscard]] bool empty( void ) const;

 [[nodiscard]] std::size_t blocks( void ) const;

 std::size_t readBlock( std::size_t b , T * dest ) const;

 void appendBlock( const T * src , std::size_t n );

 void clear( void );

 [[nodiscard]] const std::vector< T > & contents( void ) const;

/*--------------------------------------------------------------------------*/
 private:

 TwoLevelMemory * f_mem;
 std::vector< T > f_items;

 };  // end( class DiskFile )

/*--------------------------------------------------------------------------*/
/*--------------------------- CLASS DiskReader -----------------------------*/
/*--------------------------------------------------------------------------*/

template< class T >
class DiskReader {

/*--------------------------------------------------------------------------*/
 public:

 explicit DiskReader( const DiskFile< T > & f );

 DiskReader( const DiskReader & ) = delete;
 DiskReader & operator=( const DiskReader & ) = delete;

 [[nodiscard]] bool hasNext( void ) const;

 const T & peek( void );

 T next( void );

 [[nodiscard]] std::size_t position( void ) const;

 const T & at( std::size_t i );

/*--------------------------------------------------------------------------*/
 private:

 void load( std::size_t b );

 const DiskFile< T > * f_file;
 MemoryLease f_lease;
 std::vector< T > f_buf;
 std::size_t f_block;
 std::size_t f_pos = 0;

 };  // end( class DiskReader )

/*--------------------------------------------------------------------------*/
/*--------------------------- CLASS DiskWriter -----------------------------*/
/*--------------------------------------------------------------------------*/

template< class T >
class DiskWriter {

/*--------------------------------------------------------------------------*/
 public:

 explicit DiskWriter( DiskFile< T > & f );

 DiskWriter( const DiskWriter & ) = delete;
 DiskWriter & operator=( const DiskWriter & ) = delete;

 ~DiskWriter();

 void push( const T & x );

 void close( void );

/*--------------------------------------------------------------------------*/
 private:

 DiskFile< T > * f_file;
 MemoryLease f_lease;
 std::vector< T > f_buf;
 bool f_closed = false;

 };  // end( class DiskWriter )

/*--------------------------------------------------------------------------*/

}  // end( namespace ADS )

/*--------------------------------------------------------------------------*/
/*-------------------------- IMPLEMENTATION --------------------------------*/
/*--------------------------------------------------------------------------*/

#include "ADS/external/impl/TwoLevelMemory.tpp"

/*--------------------------------------------------------------------------*/

#endif  /* TwoLevelMemory.h included */

/*--------------------------------------------------------------------------*/
/*----------------------- End File TwoLevelMemory.h ------------------------*/
/*--------------------------------------------------------------------------*/