#include <DataMgr.h>

Collaboration diagram for Data_Namespace::DataMgr:

Classes
struct	SystemMemoryUsage

Public Member Functions
	DataMgr (const std::string &dataDir, const SystemParameters &system_parameters, std::unique_ptr< CudaMgr_Namespace::CudaMgr > cudaMgr, const bool useGpus, const size_t reservedGpuMem=(1<< 27), const size_t numReaderThreads=0, const File_Namespace::DiskCacheConfig cacheConfig=File_Namespace::DiskCacheConfig())

	~DataMgr ()

AbstractBuffer *	createChunkBuffer (const ChunkKey &key, const MemoryLevel memoryLevel, const int deviceId=0, const size_t page_size=0)

AbstractBuffer *	getChunkBuffer (const ChunkKey &key, const MemoryLevel memoryLevel, const int deviceId=0, const size_t numBytes=0)

void	deleteChunksWithPrefix (const ChunkKey &keyPrefix)

void	deleteChunksWithPrefix (const ChunkKey &keyPrefix, const MemoryLevel memLevel)

AbstractBuffer *	alloc (const MemoryLevel memoryLevel, const int deviceId, const size_t numBytes)

void	free (AbstractBuffer *buffer)

void	copy (AbstractBuffer destBuffer, AbstractBuffer srcBuffer)

bool	isBufferOnDevice (const ChunkKey &key, const MemoryLevel memLevel, const int deviceId)

std::vector< MemoryInfo >	getMemoryInfo (const MemoryLevel memLevel) const

std::vector< MemoryInfo >	getMemoryInfoUnlocked (const MemoryLevel memLevel) const

std::string	dumpLevel (const MemoryLevel memLevel)

void	clearMemory (const MemoryLevel memLevel)

const std::map< ChunkKey, File_Namespace::FileBuffer * > &	getChunkMap ()

void	checkpoint (const int db_id, const int tb_id)

void	checkpoint (const int db_id, const int table_id, const MemoryLevel memory_level)

void	getChunkMetadataVecForKeyPrefix (ChunkMetadataVector &chunkMetadataVec, const ChunkKey &keyPrefix)

bool	gpusPresent () const

void	removeTableRelatedDS (const int db_id, const int tb_id)

void	setTableEpoch (const int db_id, const int tb_id, const int start_epoch)

size_t	getTableEpoch (const int db_id, const int tb_id)

void	resetTableEpochFloor (const int32_t db_id, const int32_t tb_id)

CudaMgr_Namespace::CudaMgr *	getCudaMgr () const

File_Namespace::GlobalFileMgr *	getGlobalFileMgr () const

std::shared_ptr < ForeignStorageInterface >	getForeignStorageInterface () const

SystemMemoryUsage	getSystemMemoryUsage () const

PersistentStorageMgr *	getPersistentStorageMgr () const

void	resetPersistentStorage (const File_Namespace::DiskCacheConfig &cache_config, const size_t num_reader_threads, const SystemParameters &sys_params)

Buffer_Namespace::CpuBufferMgr *	getCpuBufferMgr () const

Buffer_Namespace::GpuCudaBufferMgr *	getGpuBufferMgr (int32_t device_id) const

Static Public Member Functions
static size_t	getTotalSystemMemory ()

Public Attributes
std::vector< int >	levelSizes_

Private Member Functions
void	populateMgrs (const SystemParameters &system_parameters, const size_t userSpecifiedNumReaderThreads, const File_Namespace::DiskCacheConfig &cache_config)

void	convertDB (const std::string basePath)

void	checkpoint ()

void	createTopLevelMetadata () const

void	allocateCpuBufferMgr (int32_t device_id, size_t total_cpu_size, size_t minCpuSlabSize, size_t maxCpuSlabSize, size_t page_size, const std::vector< size_t > &cpu_tier_sizes)

Private Attributes
std::vector< std::vector < AbstractBufferMgr * > >	bufferMgrs_

std::unique_ptr < CudaMgr_Namespace::CudaMgr >	cudaMgr_

std::string	dataDir_

bool	hasGpus_

size_t	reservedGpuMem_

std::mutex	buffer_access_mutex_

Friends
class	GlobalFileMgr

Detailed Description

Definition at line 172 of file DataMgr.h.

Constructor & Destructor Documentation

Data_Namespace::DataMgr::DataMgr	(	const std::string &	dataDir,
		const SystemParameters &	system_parameters,
		std::unique_ptr< CudaMgr_Namespace::CudaMgr >	cudaMgr,
		const bool	useGpus,
		const size_t	reservedGpuMem = `(1 << 27)`,
		const size_t	numReaderThreads = `0`,
		const File_Namespace::DiskCacheConfig	cacheConfig = `File_Namespace::DiskCacheConfig()`
	)

explicit

Definition at line 51 of file DataMgr.cpp.

     : cudaMgr_{std::move(cudaMgr)}
     , dataDir_{dataDir}
     , hasGpus_{false}
     , reservedGpuMem_{reservedGpuMem} {
   if (useGpus) {
     if (cudaMgr_) {
       hasGpus_ = true;
     } else {
       LOG(ERROR) << "CudaMgr instance is invalid, falling back to CPU-only mode.";
       hasGpus_ = false;
     }
   } else {
     // NOTE: useGpus == false with a valid cudaMgr is a potentially valid configuration.
     // i.e. QueryEngine can be set to cpu-only for a cuda-enabled build, but still have
     // rendering enabled. The renderer would require a CudaMgr in this case, in addition
     // to a GpuCudaBufferMgr for cuda-backed thrust allocations.
     // We're still setting hasGpus_ to false in that case tho to enforce cpu-only query
     // execution.
     hasGpus_ = false;
   }
 
   populateMgrs(system_parameters, numReaderThreads, cache_config);
   createTopLevelMetadata();
 }

Data_Namespace::DataMgr::~DataMgr ( )

Definition at line 83 of file DataMgr.cpp.

References bufferMgrs_.

                   {
   int numLevels = bufferMgrs_.size();
   for (int level = numLevels - 1; level >= 0; --level) {
     for (size_t device = 0; device < bufferMgrs_[level].size(); device++) {
       delete bufferMgrs_[level][device];
     }
   }
 }

Member Function Documentation

AbstractBuffer * Data_Namespace::DataMgr::alloc	(	const MemoryLevel	memoryLevel,
		const int	deviceId,
		const size_t	numBytes
	)

Definition at line 519 of file DataMgr.cpp.

References buffer_access_mutex_, bufferMgrs_, CHECK_LT, and levelSizes_.

Referenced by ThrustAllocator::allocate(), ThrustAllocator::allocateScopedBuffer(), CudaAllocator::allocGpuAbstractBuffer(), InValuesBitmap::InValuesBitmap(), ColumnFetcher::linearizeFixedLenArrayColFrags(), and ColumnFetcher::linearizeVarLenArrayColFrags().

                                                       {
   std::lock_guard<std::mutex> buffer_lock(buffer_access_mutex_);
   const auto level = static_cast<int>(memoryLevel);
   CHECK_LT(deviceId, levelSizes_[level]);
   return bufferMgrs_[level][deviceId]->alloc(numBytes);
 }

Here is the caller graph for this function:

void Data_Namespace::DataMgr::allocateCpuBufferMgr	(	int32_t	device_id,
		size_t	total_cpu_size,
		size_t	minCpuSlabSize,
		size_t	maxCpuSlabSize,
		size_t	page_size,
		const std::vector< size_t > &	cpu_tier_sizes
	)

private

Definition at line 172 of file DataMgr.cpp.

References bufferMgrs_, and cudaMgr_.

Referenced by populateMgrs().

                                                                             {
 #ifdef ENABLE_MEMKIND
   if (g_enable_tiered_cpu_mem) {
     bufferMgrs_[1].push_back(new Buffer_Namespace::TieredCpuBufferMgr(0,
                                                                       total_cpu_size,
                                                                       cudaMgr_.get(),
                                                                       minCpuSlabSize,
                                                                       maxCpuSlabSize,
                                                                       page_size,
                                                                       cpu_tier_sizes,
                                                                       bufferMgrs_[0][0]));
     return;
   }
 #endif
 
   bufferMgrs_[1].push_back(new Buffer_Namespace::CpuBufferMgr(0,
                                                               total_cpu_size,
                                                               cudaMgr_.get(),
                                                               minCpuSlabSize,
                                                               maxCpuSlabSize,
                                                               page_size,
                                                               bufferMgrs_[0][0]));
 }

Here is the caller graph for this function:

void Data_Namespace::DataMgr::checkpoint	(	const int	db_id,
		const int	tb_id
	)

Definition at line 548 of file DataMgr.cpp.

References buffer_access_mutex_, and bufferMgrs_.

Referenced by UpdelRoll::stageUpdate().

                                                          {
   // TODO(adb): do we need a buffer mgr lock here?
   // MAT Yes to reduce Parallel Executor TSAN issues (and correctness for now)
   std::lock_guard<std::mutex> buffer_lock(buffer_access_mutex_);
   for (auto levelIt = bufferMgrs_.rbegin(); levelIt != bufferMgrs_.rend(); ++levelIt) {
     // use reverse iterator so we start at GPU level, then CPU then DISK
     for (auto deviceIt = levelIt->begin(); deviceIt != levelIt->end(); ++deviceIt) {
       (*deviceIt)->checkpoint(db_id, tb_id);
     }
   }
 }

Here is the caller graph for this function:

void Data_Namespace::DataMgr::checkpoint	(	const int	db_id,
		const int	table_id,
		const MemoryLevel	memory_level
	)

Definition at line 560 of file DataMgr.cpp.

References buffer_access_mutex_, bufferMgrs_, CHECK_LT, and levelSizes_.

                                                          {
   std::lock_guard<std::mutex> buffer_lock(buffer_access_mutex_);
   CHECK_LT(static_cast<size_t>(memory_level), bufferMgrs_.size());
   CHECK_LT(static_cast<size_t>(memory_level), levelSizes_.size());
   for (int device_id = 0; device_id < levelSizes_[memory_level]; device_id++) {
     bufferMgrs_[memory_level][device_id]->checkpoint(db_id, table_id);
   }
 }

void Data_Namespace::DataMgr::checkpoint ( )

private

Definition at line 571 of file DataMgr.cpp.

References buffer_access_mutex_, and bufferMgrs_.

Referenced by convertDB().

                          {
   // TODO(adb): SAA
   // MAT Yes to reduce Parallel Executor TSAN issues (and correctness for now)
   std::lock_guard<std::mutex> buffer_lock(buffer_access_mutex_);
   for (auto levelIt = bufferMgrs_.rbegin(); levelIt != bufferMgrs_.rend(); ++levelIt) {
     // use reverse iterator so we start at GPU level, then CPU then DISK
     for (auto deviceIt = levelIt->begin(); deviceIt != levelIt->end(); ++deviceIt) {
       (*deviceIt)->checkpoint();
     }
   }
 }

Here is the caller graph for this function:

void Data_Namespace::DataMgr::clearMemory ( const MemoryLevel memLevel )

Definition at line 437 of file DataMgr.cpp.

References buffer_access_mutex_, bufferMgrs_, CHECK, cudaMgr_, Data_Namespace::GPU_LEVEL, logger::INFO, LOG, and logger::WARNING.

Referenced by Executor::clearMemory().

                                                     {
   std::lock_guard<std::mutex> buffer_lock(buffer_access_mutex_);
 
   // if gpu we need to iterate through all the buffermanagers for each card
   if (memLevel == MemoryLevel::GPU_LEVEL) {
     if (cudaMgr_) {
       int numGpus = cudaMgr_->getDeviceCount();
       for (int gpuNum = 0; gpuNum < numGpus; ++gpuNum) {
         LOG(INFO) << "clear slabs on gpu " << gpuNum;
         auto buffer_mgr_for_gpu =
             dynamic_cast<Buffer_Namespace::BufferMgr*>(bufferMgrs_[memLevel][gpuNum]);
         CHECK(buffer_mgr_for_gpu);
         buffer_mgr_for_gpu->clearSlabs();
       }
     } else {
       LOG(WARNING) << "Unable to clear GPU memory: No GPUs detected";
     }
   } else {
     auto buffer_mgr_for_cpu =
         dynamic_cast<Buffer_Namespace::BufferMgr*>(bufferMgrs_[memLevel][0]);
     CHECK(buffer_mgr_for_cpu);
     buffer_mgr_for_cpu->clearSlabs();
   }
 }

Here is the caller graph for this function:

void Data_Namespace::DataMgr::convertDB ( const std::string basePath )

private

Definition at line 303 of file DataMgr.cpp.

References bufferMgrs_, CHECK, checkpoint(), logger::FATAL, getGlobalFileMgr(), logger::INFO, shared::kDataDirectoryName, and LOG.

                                                 {
   // no need for locking, as this is only called in the constructor
 
   /* check that the data directory exists and it's empty */
   std::string mapdDataPath(basePath + "/../" + shared::kDataDirectoryName + "/");
   boost::filesystem::path path(mapdDataPath);
   if (boost::filesystem::exists(path)) {
     if (!boost::filesystem::is_directory(path)) {
       LOG(FATAL) << "Path to directory \"" + shared::kDataDirectoryName +
                         "\" to convert DB is not a directory.";
     }
   } else {  // data directory does not exist
     LOG(FATAL) << "Path to directory \"" + shared::kDataDirectoryName +
                       "\" to convert DB does not exist.";
   }
 
   File_Namespace::GlobalFileMgr* gfm{nullptr};
   gfm = dynamic_cast<PersistentStorageMgr*>(bufferMgrs_[0][0])->getGlobalFileMgr();
   CHECK(gfm);
 
   size_t defaultPageSize = gfm->getDefaultPageSize();
   LOG(INFO) << "Database conversion started.";
   File_Namespace::FileMgr* fm_base_db = new File_Namespace::FileMgr(
       gfm,
       defaultPageSize,
       basePath);  // this call also copies data into new DB structure
   delete fm_base_db;
 
   /* write content of DB into newly created/converted DB structure & location */
   checkpoint();  // outputs data files as well as metadata files
   LOG(INFO) << "Database conversion completed.";
 }

Here is the call graph for this function:

void Data_Namespace::DataMgr::copy	(	AbstractBuffer *	destBuffer,
		AbstractBuffer *	srcBuffer
	)

Definition at line 534 of file DataMgr.cpp.

References Data_Namespace::AbstractBuffer::getDeviceId(), Data_Namespace::AbstractBuffer::getMemoryPtr(), Data_Namespace::AbstractBuffer::getType(), Data_Namespace::AbstractBuffer::size(), and Data_Namespace::AbstractBuffer::write().

                                                                         {
   destBuffer->write(srcBuffer->getMemoryPtr(),
                     srcBuffer->size(),
                     0,
                     srcBuffer->getType(),
                     srcBuffer->getDeviceId());
 }

Here is the call graph for this function:

AbstractBuffer * Data_Namespace::DataMgr::createChunkBuffer	(	const ChunkKey &	key,
		const MemoryLevel	memoryLevel,
		const int	deviceId = `0`,
		const size_t	page_size = `0`
	)

Definition at line 475 of file DataMgr.cpp.

References buffer_access_mutex_, and bufferMgrs_.

Referenced by Chunk_NS::Chunk::createChunkBuffer().

                                                                    {
   std::lock_guard<std::mutex> buffer_lock(buffer_access_mutex_);
   int level = static_cast<int>(memoryLevel);
   return bufferMgrs_[level][deviceId]->createBuffer(key, page_size);
 }

Here is the caller graph for this function:

void Data_Namespace::DataMgr::createTopLevelMetadata ( ) const

private

Definition at line 336 of file DataMgr.cpp.

References bufferMgrs_, CHECK, and getGlobalFileMgr().

Referenced by resetPersistentStorage().

           {  // create metadata shared by all tables of all DBs
   ChunkKey chunkKey(2);
   chunkKey[0] = 0;  // top level db_id
   chunkKey[1] = 0;  // top level tb_id
 
   File_Namespace::GlobalFileMgr* gfm{nullptr};
   gfm = dynamic_cast<PersistentStorageMgr*>(bufferMgrs_[0][0])->getGlobalFileMgr();
   CHECK(gfm);
 
   auto fm_top = gfm->getFileMgr(chunkKey);
   if (dynamic_cast<File_Namespace::FileMgr*>(fm_top)) {
     static_cast<File_Namespace::FileMgr*>(fm_top)->createTopLevelMetadata();
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Data_Namespace::DataMgr::deleteChunksWithPrefix ( const ChunkKey & keyPrefix )

Definition at line 495 of file DataMgr.cpp.

References buffer_access_mutex_, bufferMgrs_, and levelSizes_.

Referenced by anonymous_namespace{RelAlgExecutor.cpp}::prepare_for_system_table_execution(), UpdelRoll::updateFragmenterAndCleanupChunks(), StorageIOFacility::yieldDeleteCallback(), and StorageIOFacility::yieldUpdateCallback().

                                                               {
   std::lock_guard<std::mutex> buffer_lock(buffer_access_mutex_);
 
   int numLevels = bufferMgrs_.size();
   for (int level = numLevels - 1; level >= 0; --level) {
     for (int device = 0; device < levelSizes_[level]; ++device) {
       bufferMgrs_[level][device]->deleteBuffersWithPrefix(keyPrefix);
     }
   }
 }

Here is the caller graph for this function:

void Data_Namespace::DataMgr::deleteChunksWithPrefix	(	const ChunkKey &	keyPrefix,
		const MemoryLevel	memLevel
	)

Definition at line 507 of file DataMgr.cpp.

References buffer_access_mutex_, bufferMgrs_, and levelSizes_.

                                                                  {
   std::lock_guard<std::mutex> buffer_lock(buffer_access_mutex_);
 
   if (bufferMgrs_.size() <= memLevel) {
     return;
   }
   for (int device = 0; device < levelSizes_[memLevel]; ++device) {
     bufferMgrs_[memLevel][device]->deleteBuffersWithPrefix(keyPrefix);
   }
 }

std::string Data_Namespace::DataMgr::dumpLevel ( const MemoryLevel memLevel )

Definition at line 421 of file DataMgr.cpp.

References buffer_access_mutex_, bufferMgrs_, cudaMgr_, and Data_Namespace::GPU_LEVEL.

                                                        {
   std::lock_guard<std::mutex> buffer_lock(buffer_access_mutex_);
 
   // if gpu we need to iterate through all the buffermanagers for each card
   if (memLevel == MemoryLevel::GPU_LEVEL) {
     int numGpus = cudaMgr_->getDeviceCount();
     std::ostringstream tss;
     for (int gpuNum = 0; gpuNum < numGpus; ++gpuNum) {
       tss << bufferMgrs_[memLevel][gpuNum]->printSlabs();
     }
     return tss.str();
   } else {
     return bufferMgrs_[memLevel][0]->printSlabs();
   }
 }

void Data_Namespace::DataMgr::free ( AbstractBuffer * buffer )

Definition at line 528 of file DataMgr.cpp.

References buffer_access_mutex_, bufferMgrs_, Data_Namespace::AbstractBuffer::getDeviceId(), and Data_Namespace::AbstractBuffer::getType().

Referenced by UpdelRoll::cancelUpdate(), ThrustAllocator::deallocate(), CudaAllocator::free(), CudaAllocator::freeGpuAbstractBuffer(), CudaAllocator::~CudaAllocator(), InValuesBitmap::~InValuesBitmap(), PerfectHashTable::~PerfectHashTable(), StringDictionaryTranslationMgr::~StringDictionaryTranslationMgr(), and ThrustAllocator::~ThrustAllocator().

                                          {
   std::lock_guard<std::mutex> buffer_lock(buffer_access_mutex_);
   int level = static_cast<int>(buffer->getType());
   bufferMgrs_[level][buffer->getDeviceId()]->free(buffer);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

AbstractBuffer * Data_Namespace::DataMgr::getChunkBuffer	(	const ChunkKey &	key,
		const MemoryLevel	memoryLevel,
		const int	deviceId = `0`,
		const size_t	numBytes = `0`
	)

Definition at line 484 of file DataMgr.cpp.

References buffer_access_mutex_, bufferMgrs_, CHECK_LT, and levelSizes_.

Referenced by Chunk_NS::Chunk::getChunkBuffer().

                                                                {
   std::lock_guard<std::mutex> buffer_lock(buffer_access_mutex_);
   const auto level = static_cast<size_t>(memoryLevel);
   CHECK_LT(level, levelSizes_.size());     // make sure we have a legit buffermgr
   CHECK_LT(deviceId, levelSizes_[level]);  // make sure we have a legit buffermgr
   return bufferMgrs_[level][deviceId]->getBuffer(key, numBytes);
 }

Here is the caller graph for this function:

const std::map<ChunkKey, File_Namespace::FileBuffer*>& Data_Namespace::DataMgr::getChunkMap ( )

void Data_Namespace::DataMgr::getChunkMetadataVecForKeyPrefix	(	ChunkMetadataVector &	chunkMetadataVec,
		const ChunkKey &	keyPrefix
	)

Definition at line 469 of file DataMgr.cpp.

References buffer_access_mutex_, and bufferMgrs_.

Referenced by TableOptimizer::vacuumFragments().

                                                                          {
   std::lock_guard<std::mutex> buffer_lock(buffer_access_mutex_);
   bufferMgrs_[0][0]->getChunkMetadataVecForKeyPrefix(chunkMetadataVec, keyPrefix);
 }

Here is the caller graph for this function:

Buffer_Namespace::CpuBufferMgr * Data_Namespace::DataMgr::getCpuBufferMgr ( ) const

Definition at line 641 of file DataMgr.cpp.

References bufferMgrs_, and Data_Namespace::CPU_LEVEL.

                                                              {
   return dynamic_cast<Buffer_Namespace::CpuBufferMgr*>(
       bufferMgrs_[MemoryLevel::CPU_LEVEL][0]);
 }

CudaMgr_Namespace::CudaMgr* Data_Namespace::DataMgr::getCudaMgr ( ) const

inline

Definition at line 222 of file DataMgr.h.

References cudaMgr_.

Referenced by Executor::blockSize(), copy_to_nvidia_gpu(), CudaAllocator::copyFromDevice(), CudaAllocator::copyToDevice(), CudaAllocator::CudaAllocator(), Executor::cudaMgr(), get_available_gpus(), Executor::gridSize(), Executor::isCPUOnly(), CudaAllocator::setDeviceMem(), and CudaAllocator::zeroDeviceMem().

222 { return cudaMgr_.get(); }

Data_Namespace::DataMgr::cudaMgr_

std::unique_ptr< CudaMgr_Namespace::CudaMgr > cudaMgr_

Definition: DataMgr.h:271

Here is the caller graph for this function:

std::shared_ptr< ForeignStorageInterface > Data_Namespace::DataMgr::getForeignStorageInterface ( ) const

Definition at line 617 of file DataMgr.cpp.

References bufferMgrs_.

                                                                                  {
   return dynamic_cast<PersistentStorageMgr*>(bufferMgrs_[0][0])
       ->getForeignStorageInterface();
 }

File_Namespace::GlobalFileMgr * Data_Namespace::DataMgr::getGlobalFileMgr ( ) const

Definition at line 609 of file DataMgr.cpp.

References bufferMgrs_, and CHECK.

Referenced by convertDB(), createTopLevelMetadata(), TableArchiver::dumpTable(), anonymous_namespace{DdlCommandExecutor.cpp}::get_agg_storage_stats(), getTableEpoch(), foreign_storage::InternalStorageStatsDataWrapper::initializeObjectsForTable(), resetTableEpochFloor(), TableArchiver::restoreTable(), setTableEpoch(), and TableOptimizer::vacuumDeletedRows().

                                                              {
   File_Namespace::GlobalFileMgr* global_file_mgr{nullptr};
   global_file_mgr =
       dynamic_cast<PersistentStorageMgr*>(bufferMgrs_[0][0])->getGlobalFileMgr();
   CHECK(global_file_mgr);
   return global_file_mgr;
 }

Here is the caller graph for this function:

Buffer_Namespace::GpuCudaBufferMgr * Data_Namespace::DataMgr::getGpuBufferMgr ( int32_t device_id ) const

Definition at line 646 of file DataMgr.cpp.

References bufferMgrs_, CHECK_GT, and Data_Namespace::GPU_LEVEL.

                                                                                   {
   if (bufferMgrs_.size() > MemoryLevel::GPU_LEVEL) {
     CHECK_GT(bufferMgrs_[MemoryLevel::GPU_LEVEL].size(), static_cast<size_t>(device_id));
     return dynamic_cast<Buffer_Namespace::GpuCudaBufferMgr*>(
         bufferMgrs_[MemoryLevel::GPU_LEVEL][device_id]);
   } else {
     return nullptr;
   }
 }

std::vector< MemoryInfo > Data_Namespace::DataMgr::getMemoryInfo ( const MemoryLevel memLevel ) const

Definition at line 352 of file DataMgr.cpp.

References buffer_access_mutex_, and getMemoryInfoUnlocked().

Referenced by Executor::createKernels().

                                                                               {
   std::lock_guard<std::mutex> buffer_lock(buffer_access_mutex_);
   return getMemoryInfoUnlocked(mem_level);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::vector< MemoryInfo > Data_Namespace::DataMgr::getMemoryInfoUnlocked ( const MemoryLevel memLevel ) const

Definition at line 357 of file DataMgr.cpp.

Referenced by getMemoryInfo().

                                        {
   std::vector<MemoryInfo> mem_info;
   if (mem_level == MemoryLevel::CPU_LEVEL) {
     Buffer_Namespace::CpuBufferMgr* cpu_buffer =
         dynamic_cast<Buffer_Namespace::CpuBufferMgr*>(
             bufferMgrs_[MemoryLevel::CPU_LEVEL][0]);
     CHECK(cpu_buffer);
     MemoryInfo mi;
 
     mi.pageSize = cpu_buffer->getPageSize();
     mi.maxNumPages = cpu_buffer->getMaxSize() / mi.pageSize;
     mi.isAllocationCapped = cpu_buffer->isAllocationCapped();
     mi.numPageAllocated = cpu_buffer->getAllocated() / mi.pageSize;
 
     const auto& slab_segments = cpu_buffer->getSlabSegments();
     for (size_t slab_num = 0; slab_num < slab_segments.size(); ++slab_num) {
       for (auto segment : slab_segments[slab_num]) {
         MemoryData md;
         md.slabNum = slab_num;
         md.startPage = segment.start_page;
         md.numPages = segment.num_pages;
         md.touch = segment.last_touched;
         md.memStatus = segment.mem_status;
         md.chunk_key.insert(
             md.chunk_key.end(), segment.chunk_key.begin(), segment.chunk_key.end());
         mi.nodeMemoryData.push_back(md);
       }
     }
     mem_info.push_back(mi);
   } else if (hasGpus_) {
     int numGpus = cudaMgr_->getDeviceCount();
     for (int gpuNum = 0; gpuNum < numGpus; ++gpuNum) {
       Buffer_Namespace::GpuCudaBufferMgr* gpu_buffer =
           dynamic_cast<Buffer_Namespace::GpuCudaBufferMgr*>(
               bufferMgrs_[MemoryLevel::GPU_LEVEL][gpuNum]);
       CHECK(gpu_buffer);
       MemoryInfo mi;
 
       mi.pageSize = gpu_buffer->getPageSize();
       mi.maxNumPages = gpu_buffer->getMaxSize() / mi.pageSize;
       mi.isAllocationCapped = gpu_buffer->isAllocationCapped();
       mi.numPageAllocated = gpu_buffer->getAllocated() / mi.pageSize;
 
       const auto& slab_segments = gpu_buffer->getSlabSegments();
       for (size_t slab_num = 0; slab_num < slab_segments.size(); ++slab_num) {
         for (auto segment : slab_segments[slab_num]) {
           MemoryData md;
           md.slabNum = slab_num;
           md.startPage = segment.start_page;
           md.numPages = segment.num_pages;
           md.touch = segment.last_touched;
           md.chunk_key.insert(
               md.chunk_key.end(), segment.chunk_key.begin(), segment.chunk_key.end());
           md.memStatus = segment.mem_status;
           mi.nodeMemoryData.push_back(md);
         }
       }
       mem_info.push_back(mi);
     }
   }
   return mem_info;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

PersistentStorageMgr * Data_Namespace::DataMgr::getPersistentStorageMgr ( ) const

Definition at line 637 of file DataMgr.cpp.

References bufferMgrs_, and Data_Namespace::DISK_LEVEL.

Referenced by RelAlgExecutor::initializeParallelismHints(), and anonymous_namespace{RelAlgExecutor.cpp}::set_parallelism_hints().

                                                              {
   return dynamic_cast<PersistentStorageMgr*>(bufferMgrs_[MemoryLevel::DISK_LEVEL][0]);
 }

Here is the caller graph for this function:

DataMgr::SystemMemoryUsage Data_Namespace::DataMgr::getSystemMemoryUsage ( ) const

Definition at line 92 of file DataMgr.cpp.

References Data_Namespace::DataMgr::SystemMemoryUsage::frag, Data_Namespace::DataMgr::SystemMemoryUsage::free, Data_Namespace::ProcBuddyinfoParser::getFragmentationPercent(), Data_Namespace::DataMgr::SystemMemoryUsage::regular, Data_Namespace::DataMgr::SystemMemoryUsage::resident, Data_Namespace::DataMgr::SystemMemoryUsage::shared, Data_Namespace::DataMgr::SystemMemoryUsage::total, and Data_Namespace::DataMgr::SystemMemoryUsage::vtotal.

                                                              {
   SystemMemoryUsage usage;
 
 #ifdef __linux__
 
   // Determine Linux available memory and total memory.
   // Available memory is different from free memory because
   // when Linux sees free memory, it tries to use it for
   // stuff like disk caching. However, the memory is not
   // reserved and is still available to be allocated by
   // user processes.
   // Parsing /proc/meminfo for this info isn't very elegant
   // but as a virtual file it should be reasonably fast.
   // See also:
   //   https://github.com/torvalds/linux/commit/34e431b0ae398fc54ea69ff85ec700722c9da773
   ProcMeminfoParser mi;
   usage.free = mi["MemAvailable"];
   usage.total = mi["MemTotal"];
 
   // Determine process memory in use.
   // See also:
   //   https://stackoverflow.com/questions/669438/how-to-get-memory-usage-at-runtime-using-c
   //   http://man7.org/linux/man-pages/man5/proc.5.html
   int64_t size = 0;
   int64_t resident = 0;
   int64_t shared = 0;
 
   std::ifstream fstatm("/proc/self/statm");
   fstatm >> size >> resident >> shared;
   fstatm.close();
 
   long page_size =
       sysconf(_SC_PAGE_SIZE);  // in case x86-64 is configured to use 2MB pages
 
   usage.resident = resident * page_size;
   usage.vtotal = size * page_size;
   usage.regular = (resident - shared) * page_size;
   usage.shared = shared * page_size;
 
   ProcBuddyinfoParser bi;
   usage.frag = bi.getFragmentationPercent();
 
 #else
 
   usage.total = 0;
   usage.free = 0;
   usage.resident = 0;
   usage.vtotal = 0;
   usage.regular = 0;
   usage.shared = 0;
   usage.frag = 0;
 
 #endif
 
   return usage;
 }

Here is the call graph for this function:

size_t Data_Namespace::DataMgr::getTableEpoch	(	const int	db_id,
		const int	tb_id
	)

Definition at line 595 of file DataMgr.cpp.

References bufferMgrs_, CHECK, and getGlobalFileMgr().

                                                               {
   File_Namespace::GlobalFileMgr* gfm{nullptr};
   gfm = dynamic_cast<PersistentStorageMgr*>(bufferMgrs_[0][0])->getGlobalFileMgr();
   CHECK(gfm);
   return gfm->getTableEpoch(db_id, tb_id);
 }

Here is the call graph for this function:

size_t Data_Namespace::DataMgr::getTotalSystemMemory ( )

static

Definition at line 149 of file DataMgr.cpp.

Referenced by populateMgrs().

                                      {
 #ifdef __APPLE__
   int mib[2];
   size_t physical_memory;
   size_t length;
   // Get the Physical memory size
   mib[0] = CTL_HW;
   mib[1] = HW_MEMSIZE;
   length = sizeof(size_t);
   sysctl(mib, 2, &physical_memory, &length, NULL, 0);
   return physical_memory;
 #elif defined(_MSC_VER)
   MEMORYSTATUSEX status;
   status.dwLength = sizeof(status);
   GlobalMemoryStatusEx(&status);
   return status.ullTotalPhys;
 #else  // Linux
   long pages = sysconf(_SC_PHYS_PAGES);
   long page_size = sysconf(_SC_PAGE_SIZE);
   return pages * page_size;
 #endif
 }

Here is the caller graph for this function:

bool Data_Namespace::DataMgr::gpusPresent ( ) const

inline

Definition at line 216 of file DataMgr.h.

References hasGpus_.

Referenced by get_available_gpus().

216 { return hasGpus_; }

Data_Namespace::DataMgr::hasGpus_

bool hasGpus_

Definition: DataMgr.h:273

Here is the caller graph for this function:

bool Data_Namespace::DataMgr::isBufferOnDevice	(	const ChunkKey &	key,
		const MemoryLevel	memLevel,
		const int	deviceId
	)

Definition at line 462 of file DataMgr.cpp.

References buffer_access_mutex_, and bufferMgrs_.

Referenced by Chunk_NS::Chunk::isChunkOnDevice().

                                                    {
   std::lock_guard<std::mutex> buffer_lock(buffer_access_mutex_);
   return bufferMgrs_[memLevel][deviceId]->isBufferOnDevice(key);
 }

Here is the caller graph for this function:

void Data_Namespace::DataMgr::populateMgrs	(	const SystemParameters &	system_parameters,
		const size_t	userSpecifiedNumReaderThreads,
		const File_Namespace::DiskCacheConfig &	cache_config
	)

private

Definition at line 216 of file DataMgr.cpp.

References allocateCpuBufferMgr(), bufferMgrs_, SystemParameters::cpu_buffer_mem_bytes, cudaMgr_, dataDir_, Data_Namespace::DRAM, g_pmem_size, getTotalSystemMemory(), SystemParameters::gpu_buffer_mem_bytes, hasGpus_, logger::INFO, levelSizes_, LOG, SystemParameters::max_cpu_slab_size, SystemParameters::max_gpu_slab_size, SystemParameters::min_cpu_slab_size, SystemParameters::min_gpu_slab_size, Data_Namespace::numCpuTiers, Data_Namespace::PMEM, reservedGpuMem_, and VLOG.

Referenced by resetPersistentStorage().

                                                                               {
   // no need for locking, as this is only called in the constructor
   bufferMgrs_.resize(2);
   bufferMgrs_[0].push_back(
       new PersistentStorageMgr(dataDir_, userSpecifiedNumReaderThreads, cache_config));
 
   levelSizes_.push_back(1);
   size_t page_size{512};
   size_t cpuBufferSize = system_parameters.cpu_buffer_mem_bytes;
   if (cpuBufferSize == 0) {  // if size is not specified
     const auto total_system_memory = getTotalSystemMemory();
     VLOG(1) << "Detected " << (float)total_system_memory / (1024 * 1024)
             << "M of total system memory.";
     cpuBufferSize = total_system_memory *
                     0.8;  // should get free memory instead of this ugly heuristic
   }
   size_t minCpuSlabSize = std::min(system_parameters.min_cpu_slab_size, cpuBufferSize);
   minCpuSlabSize = (minCpuSlabSize / page_size) * page_size;
   size_t maxCpuSlabSize = std::min(system_parameters.max_cpu_slab_size, cpuBufferSize);
   maxCpuSlabSize = (maxCpuSlabSize / page_size) * page_size;
   LOG(INFO) << "Min CPU Slab Size is " << (float)minCpuSlabSize / (1024 * 1024) << "MB";
   LOG(INFO) << "Max CPU Slab Size is " << (float)maxCpuSlabSize / (1024 * 1024) << "MB";
   LOG(INFO) << "Max memory pool size for CPU is " << (float)cpuBufferSize / (1024 * 1024)
             << "MB";
 
   size_t total_cpu_size = 0;
 
 #ifdef ENABLE_MEMKIND
   CpuTierSizeVector cpu_tier_sizes(numCpuTiers, 0);
   cpu_tier_sizes[CpuTier::DRAM] = cpuBufferSize;
   if (g_enable_tiered_cpu_mem) {
     cpu_tier_sizes[CpuTier::PMEM] = g_pmem_size;
     LOG(INFO) << "Max memory pool size for PMEM is " << (float)g_pmem_size / (1024 * 1024)
               << "MB";
   }
   for (auto cpu_tier_size : cpu_tier_sizes) {
     total_cpu_size += cpu_tier_size;
   }
 #else
   CpuTierSizeVector cpu_tier_sizes{};
   total_cpu_size = cpuBufferSize;
 #endif
 
   if (hasGpus_ || cudaMgr_) {
     LOG(INFO) << "Reserved GPU memory is " << (float)reservedGpuMem_ / (1024 * 1024)
               << "MB includes render buffer allocation";
     bufferMgrs_.resize(3);
     allocateCpuBufferMgr(
         0, total_cpu_size, minCpuSlabSize, maxCpuSlabSize, page_size, cpu_tier_sizes);
 
     levelSizes_.push_back(1);
     int numGpus = cudaMgr_->getDeviceCount();
     for (int gpuNum = 0; gpuNum < numGpus; ++gpuNum) {
       size_t gpuMaxMemSize =
           system_parameters.gpu_buffer_mem_bytes != 0
               ? system_parameters.gpu_buffer_mem_bytes
               : (cudaMgr_->getDeviceProperties(gpuNum)->globalMem) - (reservedGpuMem_);
       size_t minGpuSlabSize =
           std::min(system_parameters.min_gpu_slab_size, gpuMaxMemSize);
       minGpuSlabSize = (minGpuSlabSize / page_size) * page_size;
       size_t maxGpuSlabSize =
           std::min(system_parameters.max_gpu_slab_size, gpuMaxMemSize);
       maxGpuSlabSize = (maxGpuSlabSize / page_size) * page_size;
       LOG(INFO) << "Min GPU Slab size for GPU " << gpuNum << " is "
                 << (float)minGpuSlabSize / (1024 * 1024) << "MB";
       LOG(INFO) << "Max GPU Slab size for GPU " << gpuNum << " is "
                 << (float)maxGpuSlabSize / (1024 * 1024) << "MB";
       LOG(INFO) << "Max memory pool size for GPU " << gpuNum << " is "
                 << (float)gpuMaxMemSize / (1024 * 1024) << "MB";
       bufferMgrs_[2].push_back(new Buffer_Namespace::GpuCudaBufferMgr(gpuNum,
                                                                       gpuMaxMemSize,
                                                                       cudaMgr_.get(),
                                                                       minGpuSlabSize,
                                                                       maxGpuSlabSize,
                                                                       page_size,
                                                                       bufferMgrs_[1][0]));
     }
     levelSizes_.push_back(numGpus);
   } else {
     allocateCpuBufferMgr(
         0, total_cpu_size, minCpuSlabSize, maxCpuSlabSize, page_size, cpu_tier_sizes);
     levelSizes_.push_back(1);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void Data_Namespace::DataMgr::removeTableRelatedDS	(	const int	db_id,
		const int	tb_id
	)

Definition at line 583 of file DataMgr.cpp.

References buffer_access_mutex_, and bufferMgrs_.

                                                                    {
   std::lock_guard<std::mutex> buffer_lock(buffer_access_mutex_);
   bufferMgrs_[0][0]->removeTableRelatedDS(db_id, tb_id);
 }

void Data_Namespace::DataMgr::resetPersistentStorage	(	const File_Namespace::DiskCacheConfig &	cache_config,
		const size_t	num_reader_threads,
		const SystemParameters &	sys_params
	)

Definition at line 202 of file DataMgr.cpp.

References bufferMgrs_, createTopLevelMetadata(), and populateMgrs().

                                                                          {
   int numLevels = bufferMgrs_.size();
   for (int level = numLevels - 1; level >= 0; --level) {
     for (size_t device = 0; device < bufferMgrs_[level].size(); device++) {
       delete bufferMgrs_[level][device];
     }
   }
   bufferMgrs_.clear();
   populateMgrs(sys_params, num_reader_threads, cache_config);
   createTopLevelMetadata();
 }

Here is the call graph for this function:

void Data_Namespace::DataMgr::resetTableEpochFloor	(	const int32_t	db_id,
		const int32_t	tb_id
	)

Definition at line 602 of file DataMgr.cpp.

References bufferMgrs_, CHECK, and getGlobalFileMgr().

                                                                            {
   File_Namespace::GlobalFileMgr* gfm{nullptr};
   gfm = dynamic_cast<PersistentStorageMgr*>(bufferMgrs_[0][0])->getGlobalFileMgr();
   CHECK(gfm);
   gfm->resetTableEpochFloor(db_id, tb_id);
 }

Here is the call graph for this function:

void Data_Namespace::DataMgr::setTableEpoch	(	const int	db_id,
		const int	tb_id,
		const int	start_epoch
	)

Definition at line 588 of file DataMgr.cpp.

References bufferMgrs_, CHECK, and getGlobalFileMgr().

                                                                                    {
   File_Namespace::GlobalFileMgr* gfm{nullptr};
   gfm = dynamic_cast<PersistentStorageMgr*>(bufferMgrs_[0][0])->getGlobalFileMgr();
   CHECK(gfm);
   gfm->setTableEpoch(db_id, tb_id, start_epoch);
 }

Here is the call graph for this function:

Friends And Related Function Documentation

friend class GlobalFileMgr

friend

Definition at line 173 of file DataMgr.h.

Member Data Documentation

std::mutex Data_Namespace::DataMgr::buffer_access_mutex_

mutableprivate

Definition at line 275 of file DataMgr.h.

Referenced by alloc(), checkpoint(), clearMemory(), createChunkBuffer(), deleteChunksWithPrefix(), dumpLevel(), free(), getChunkBuffer(), getChunkMetadataVecForKeyPrefix(), getMemoryInfo(), isBufferOnDevice(), and removeTableRelatedDS().

std::vector<std::vector<AbstractBufferMgr*> > Data_Namespace::DataMgr::bufferMgrs_

private

std::unique_ptr<CudaMgr_Namespace::CudaMgr> Data_Namespace::DataMgr::cudaMgr_

private

Definition at line 271 of file DataMgr.h.

Referenced by allocateCpuBufferMgr(), clearMemory(), dumpLevel(), getCudaMgr(), getMemoryInfoUnlocked(), and populateMgrs().

std::string Data_Namespace::DataMgr::dataDir_

private

Definition at line 272 of file DataMgr.h.

Referenced by populateMgrs().

bool Data_Namespace::DataMgr::hasGpus_

private

Definition at line 273 of file DataMgr.h.

Referenced by getMemoryInfoUnlocked(), gpusPresent(), and populateMgrs().

std::vector<int> Data_Namespace::DataMgr::levelSizes_

Definition at line 227 of file DataMgr.h.

Referenced by alloc(), checkpoint(), deleteChunksWithPrefix(), getChunkBuffer(), and populateMgrs().

size_t Data_Namespace::DataMgr::reservedGpuMem_

private

Definition at line 274 of file DataMgr.h.

Referenced by populateMgrs().

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

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

Classes

Public Member Functions

Static Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation