#include <TieredCpuBufferMgr.h>

Inheritance diagram for Buffer_Namespace::TieredCpuBufferMgr:

Collaboration diagram for Buffer_Namespace::TieredCpuBufferMgr:

Public Member Functions
	TieredCpuBufferMgr (const int device_id, const size_t total_size, CudaMgr_Namespace::CudaMgr cuda_mgr, const size_t min_slab_size, const size_t max_slab_size, const size_t page_size, const CpuTierSizeVector &cpu_tier_sizes, AbstractBufferMgr parent_mgr=nullptr)

	~TieredCpuBufferMgr () override

std::vector< std::pair < std::unique_ptr< Arena > , size_t > > &	getAllocators ()

MgrType	getMgrType () override

std::string	getStringMgrType () override

Arena *	getAllocatorForSlab (int32_t slab_num) const

std::string	dump () const

Public Member Functions inherited from Buffer_Namespace::CpuBufferMgr
	CpuBufferMgr (const int device_id, const size_t max_buffer_pool_size, CudaMgr_Namespace::CudaMgr cuda_mgr, const size_t min_slab_size, const size_t max_slab_size, const size_t page_size, AbstractBufferMgr parent_mgr=nullptr)

	~CpuBufferMgr () override

MgrType	getMgrType () override

std::string	getStringMgrType () override

void	setAllocator (std::unique_ptr< DramArena > allocator)

Public Member Functions inherited from Buffer_Namespace::BufferMgr
	BufferMgr (const int device_id, const size_t max_buffer_size, const size_t min_slab_size, const size_t max_slab_size, const size_t page_size, AbstractBufferMgr *parent_mgr=0)
	Constructs a BufferMgr object that allocates memSize bytes. More...

	~BufferMgr () override
	Destructor. More...

std::string	printSlab (size_t slab_num)

std::string	printSlabs () override

void	clearSlabs ()

std::string	printMap ()

void	printSegs ()

std::string	printSeg (BufferList::iterator &seg_it)

size_t	getInUseSize () override

size_t	getMaxSize () override

size_t	getAllocated () override

size_t	getMaxBufferSize ()

size_t	getMaxSlabSize ()

size_t	getPageSize ()

bool	isAllocationCapped () override

const std::vector< BufferList > &	getSlabSegments ()

AbstractBuffer *	createBuffer (const ChunkKey &key, const size_t page_size=0, const size_t initial_size=0) override
	Creates a chunk with the specified key and page size. More...

void	deleteBuffer (const ChunkKey &key, const bool purge=true) override
	Deletes the chunk with the specified key. More...

void	deleteBuffersWithPrefix (const ChunkKey &key_prefix, const bool purge=true) override

AbstractBuffer *	getBuffer (const ChunkKey &key, const size_t num_bytes=0) override
	Returns the a pointer to the chunk with the specified key. More...

bool	isBufferOnDevice (const ChunkKey &key) override
	Puts the contents of d into the Buffer with ChunkKey key. More...

void	fetchBuffer (const ChunkKey &key, AbstractBuffer *dest_buffer, const size_t num_bytes=0) override

AbstractBuffer *	putBuffer (const ChunkKey &key, AbstractBuffer *d, const size_t num_bytes=0) override

void	checkpoint () override

void	checkpoint (const int db_id, const int tb_id) override

void	removeTableRelatedDS (const int db_id, const int table_id) override

AbstractBuffer *	alloc (const size_t num_bytes=0) override
	client is responsible for deleting memory allocated for b->mem_ More...

void	free (AbstractBuffer *buffer) override

size_t	size ()
	Returns the total number of bytes allocated. More...

size_t	getNumChunks () override

BufferList::iterator	reserveBuffer (BufferList::iterator &seg_it, const size_t num_bytes)

void	getChunkMetadataVecForKeyPrefix (ChunkMetadataVector &chunk_metadata_vec, const ChunkKey &key_prefix) override

Private Member Functions
void	addSlab (const size_t slab_size) override

void	freeAllMem () override

void	initializeMem () override

Private Attributes
std::vector< std::pair < std::unique_ptr< Arena > , size_t > >	allocators_

std::map< int32_t, Arena * >	slab_to_allocator_map_

Additional Inherited Members
Protected Member Functions inherited from Buffer_Namespace::CpuBufferMgr
void	allocateBuffer (BufferList::iterator segment_iter, const size_t page_size, const size_t initial_size) override

Protected Attributes inherited from Buffer_Namespace::CpuBufferMgr
CudaMgr_Namespace::CudaMgr *	cuda_mgr_

Protected Attributes inherited from Buffer_Namespace::BufferMgr
const size_t	max_buffer_pool_size_

const size_t	min_slab_size_
	max number of bytes allocated for the buffer pool More...

const size_t	max_slab_size_

const size_t	page_size_

std::vector< int8_t * >	slabs_

std::vector< BufferList >	slab_segments_

Detailed Description

Definition at line 33 of file TieredCpuBufferMgr.h.

Constructor & Destructor Documentation

Buffer_Namespace::TieredCpuBufferMgr::TieredCpuBufferMgr	(	const int	device_id,
		const size_t	total_size,
		CudaMgr_Namespace::CudaMgr *	cuda_mgr,
		const size_t	min_slab_size,
		const size_t	max_slab_size,
		const size_t	page_size,
		const CpuTierSizeVector &	cpu_tier_sizes,
		AbstractBufferMgr *	parent_mgr = `nullptr`
	)

Definition at line 41 of file TieredCpuBufferMgr.cpp.

References allocators_, CHECK, Data_Namespace::DRAM, kArenaBlockOverhead, Buffer_Namespace::BufferMgr::max_slab_size_, Data_Namespace::numCpuTiers, and Data_Namespace::PMEM.

     : CpuBufferMgr(device_id,
                    total_size,
                    cuda_mgr,
                    min_slab_size,
                    max_slab_size,
                    page_size,
                    parent_mgr) {
   CHECK(cpu_tier_sizes.size() == numCpuTiers);
   allocators_.emplace_back(
       std::make_unique<DramArena>(max_slab_size_ + kArenaBlockOverhead),
       cpu_tier_sizes[CpuTier::DRAM]);
   allocators_.emplace_back(
       std::make_unique<PMemArena>(max_slab_size_ + kArenaBlockOverhead),
       cpu_tier_sizes[CpuTier::PMEM]);
 }

Buffer_Namespace::TieredCpuBufferMgr::~TieredCpuBufferMgr ( )

inlineoverride

Definition at line 44 of file TieredCpuBufferMgr.h.

                                  {
     // The destruction of the allocators automatically frees all memory
   }

Member Function Documentation

void Buffer_Namespace::TieredCpuBufferMgr::addSlab ( const size_t slab_size )

overrideprivatevirtual

Reimplemented from Buffer_Namespace::CpuBufferMgr.

Definition at line 69 of file TieredCpuBufferMgr.cpp.

References allocators_, CHECK, Data_Namespace::DRAM, logger::INFO, LOG, Buffer_Namespace::BufferMgr::page_size_, Data_Namespace::PMEM, Buffer_Namespace::BufferMgr::slab_segments_, slab_to_allocator_map_, Buffer_Namespace::BufferMgr::slabs_, and anonymous_namespace{TieredCpuBufferMgr.cpp}::tier_to_string().

                                                        {
   CHECK(!allocators_.empty());
   CHECK(allocators_.begin()->first.get() != nullptr);
   slabs_.resize(slabs_.size() + 1);
   auto allocated_slab = false;
   CpuTier last_tier;
   for (auto allocator_type : {CpuTier::DRAM, CpuTier::PMEM}) {
     last_tier = allocator_type;
     auto& [allocator, allocator_limit] = allocators_.at(allocator_type);
     // If there is no space in the current allocator then move to the next one.
     if (allocator_limit >= allocator->bytesUsed() + slab_size) {
       try {
         slabs_.back() = reinterpret_cast<int8_t*>(allocator->allocate(slab_size));
       } catch (std::bad_alloc&) {
         // If anything goes wrong with an allocation, then throw an exception rather than
         // go to the next allocator.
         slabs_.resize(slabs_.size() - 1);
         throw FailedToCreateSlab(slab_size);
       }
       slab_to_allocator_map_[slabs_.size() - 1] = allocator.get();
       allocated_slab = true;
       break;
     }
   }
   if (allocated_slab) {
     // We allocated a new slab, so add segments for it.
     slab_segments_.resize(slab_segments_.size() + 1);
     slab_segments_[slab_segments_.size() - 1].push_back(
         BufferSeg(0, slab_size / page_size_));
     LOG(INFO) << "Allocated slab using " << tier_to_string(last_tier) << ".";
   } else {
     // None of the allocators allocated a slab, so revert to original size and throw.
     slabs_.resize(slabs_.size() - 1);
     throw FailedToCreateSlab(slab_size);
   }
 }

Here is the call graph for this function:

std::string Buffer_Namespace::TieredCpuBufferMgr::dump ( ) const

Definition at line 120 of file TieredCpuBufferMgr.cpp.

References allocators_.

                                          {
   size_t allocator_num = 0;
   std::stringstream ss;
   ss << "TieredCpuBufferMgr:\n";
   for (auto& [allocator, allocator_limit] : allocators_) {
     ss << "  allocator[" << allocator_num++ << "]\n    limit = " << allocator_limit
        << "\n    used = " << allocator->bytesUsed() << "\n";
   }
   return ss.str();
 }

void Buffer_Namespace::TieredCpuBufferMgr::freeAllMem ( )

overrideprivatevirtual

Reimplemented from Buffer_Namespace::CpuBufferMgr.

Definition at line 106 of file TieredCpuBufferMgr.cpp.

References allocators_, CHECK, and initializeMem().

                                     {
   CHECK(!allocators_.empty());
   CHECK(allocators_.begin()->first.get() != nullptr);
   initializeMem();
 }

Here is the call graph for this function:

Arena * Buffer_Namespace::TieredCpuBufferMgr::getAllocatorForSlab ( int32_t slab_num ) const

Definition at line 65 of file TieredCpuBufferMgr.cpp.

References shared::get_from_map(), and slab_to_allocator_map_.

                                                                      {
   return shared::get_from_map(slab_to_allocator_map_, slab_num);
 }

Here is the call graph for this function:

std::vector<std::pair<std::unique_ptr<Arena>, size_t> >& Buffer_Namespace::TieredCpuBufferMgr::getAllocators ( )

inline

Definition at line 49 of file TieredCpuBufferMgr.h.

References allocators_.

                                                                     {
     return allocators_;
   }

MgrType Buffer_Namespace::TieredCpuBufferMgr::getMgrType ( )

inlineoverride

Definition at line 53 of file TieredCpuBufferMgr.h.

53 { return TIERED_CPU_MGR; }

std::string Buffer_Namespace::TieredCpuBufferMgr::getStringMgrType ( )

inlineoverride

Definition at line 54 of file TieredCpuBufferMgr.h.

54 { return ToString(TIERED_CPU_MGR); }

void Buffer_Namespace::TieredCpuBufferMgr::initializeMem ( )

overrideprivatevirtual

Reimplemented from Buffer_Namespace::CpuBufferMgr.

Definition at line 112 of file TieredCpuBufferMgr.cpp.

References allocators_, Data_Namespace::DRAM, kArenaBlockOverhead, Buffer_Namespace::BufferMgr::max_slab_size_, Data_Namespace::PMEM, and slab_to_allocator_map_.

Referenced by freeAllMem().

                                        {
   allocators_[CpuTier::DRAM].first =
       std::make_unique<DramArena>(max_slab_size_ + kArenaBlockOverhead);
   allocators_[CpuTier::PMEM].first =
       std::make_unique<PMemArena>(max_slab_size_ + kArenaBlockOverhead);
   slab_to_allocator_map_.clear();
 }

Here is the caller graph for this function:

Member Data Documentation

std::vector<std::pair<std::unique_ptr<Arena>, size_t> > Buffer_Namespace::TieredCpuBufferMgr::allocators_

private

Definition at line 66 of file TieredCpuBufferMgr.h.

Referenced by addSlab(), dump(), freeAllMem(), getAllocators(), initializeMem(), and TieredCpuBufferMgr().

std::map<int32_t, Arena*> Buffer_Namespace::TieredCpuBufferMgr::slab_to_allocator_map_

private

Definition at line 69 of file TieredCpuBufferMgr.h.

Referenced by addSlab(), getAllocatorForSlab(), and initializeMem().

The documentation for this class was generated from the following files:

/home/jenkins-slave/workspace/core-os-doxygen/DataMgr/BufferMgr/CpuBufferMgr/TieredCpuBufferMgr.h
/home/jenkins-slave/workspace/core-os-doxygen/DataMgr/BufferMgr/CpuBufferMgr/TieredCpuBufferMgr.cpp

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation