A FileMgr capable of limiting it's size and storing data from multiple tables in a shared directory. For any table that supports DiskCaching, the CachingFileMgr must contain either metadata for all table chunks, or for none (the cache is either has no knowledge of that table, or has complete knowledge of that table). Any data chunk within a table may or may not be contained within the cache. More...

#include <CachingFileMgr.h>

Inheritance diagram for File_Namespace::CachingFileMgr:

Collaboration diagram for File_Namespace::CachingFileMgr:

Public Member Functions
	CachingFileMgr (const DiskCacheConfig &config)

	~CachingFileMgr () override

MgrType	getMgrType () override

std::string	getStringMgrType () override

size_t	getPageSize ()

size_t	getMaxSize () override

size_t	getMaxDataFiles () const

size_t	getMaxMetaFiles () const

size_t	getMaxWrapperSize () const

size_t	getDataFileSize () const

size_t	getMetadataFileSize () const

size_t	getNumDataFiles () const

size_t	getNumMetaFiles () const

size_t	getAvailableSpace ()

size_t	getAvailableWrapperSpace ()

size_t	getAllocated () override

size_t	getMaxDataFilesSize () const

void	removeChunkKeepMetadata (const ChunkKey &key)
	Free pages for chunk and remove it from the chunk eviction algorithm. More...

void	clearForTable (int32_t db_id, int32_t tb_id)
	Removes all data related to the given table (pages and subdirectories). More...

bool	hasFileMgrKey () const override
	Query to determine if the contained pages will have their database and table ids overriden by the filemgr key (FileMgr does this). More...

void	closeRemovePhysical () override
	Closes files and removes the caching directory. More...

size_t	getChunkSpaceReservedByTable (int32_t db_id, int32_t tb_id) const

size_t	getMetadataSpaceReservedByTable (int32_t db_id, int32_t tb_id) const

size_t	getTableFileMgrSpaceReserved (int32_t db_id, int32_t tb_id) const

size_t	getSpaceReservedByTable (int32_t db_id, int32_t tb_id) const

std::string	describeSelf () const override
	describes this FileMgr for logging purposes. More...

void	checkpoint (const int32_t db_id, const int32_t tb_id) override
	writes buffers for the given table, synchronizes files to disk, updates file epoch, and commits free pages. More...

int32_t	epoch (int32_t db_id, int32_t tb_id) const override
	obtain the epoch version for the given table. More...

FileBuffer *	putBuffer (const ChunkKey &key, AbstractBuffer *srcBuffer, const size_t numBytes=0) override
	deletes any existing buffer for the given key then copies in a new one. More...

CachingFileBuffer *	allocateBuffer (const size_t page_size, const ChunkKey &key, const size_t num_bytes=0) override
	allocates a new CachingFileBuffer and tracks it's use in the eviction algorithms. More...

CachingFileBuffer *	allocateBuffer (const ChunkKey &key, const std::vector< HeaderInfo >::const_iterator &headerStartIt, const std::vector< HeaderInfo >::const_iterator &headerEndIt) override

bool	updatePageIfDeleted (FileInfo *file_info, ChunkKey &chunk_key, int32_t contingent, int32_t page_epoch, int32_t page_num) override
	checks whether a page should be deleted. More...

bool	failOnReadError () const override
	True if a read error should cause a fatal error. More...

void	deleteBufferIfExists (const ChunkKey &key)
	deletes a buffer if it exists in the mgr. Otherwise do nothing. More...

size_t	getNumChunksWithMetadata () const
	Returns the number of buffers with metadata in the CFM. Any buffer with an encoder counts. More...

size_t	getNumDataChunks () const
	Returns the number of buffers with chunk data in the CFM. More...

std::vector< ChunkKey >	getChunkKeysForPrefix (const ChunkKey &prefix) const
	Returns the keys for chunks with chunk data that match the given prefix. More...

std::unique_ptr< CachingFileMgr >	reconstruct () const
	Initializes a new CFM using the initialization values in the current CFM. More...

void	deleteWrapperFile (int32_t db, int32_t tb)
	Deletes the wrapper file from a table subdir. More...

void	writeWrapperFile (const std::string &doc, int32_t db, int32_t tb)
	Writes a wrapper file to a table subdir. More...

bool	hasWrapperFile (int32_t db_id, int32_t table_id) const

std::string	getTableFileMgrPath (int32_t db, int32_t tb) const

size_t	getFilesSize () const
	Get the total size of page files (data and metadata files). This includes allocated, but unused space. More...

size_t	getTableFileMgrsSize () const
	Returns the total size of all subdirectory files. Each table represented in the CFM has a subdirectory for serialized data wrappers and epoch files. More...

std::optional< FileBuffer * >	getBufferIfExists (const ChunkKey &key)
	an optional version of get buffer if we are not sure a chunk exists. More...

void	free_page (std::pair< FileInfo *, int32_t > &&page) override
	Unlike the FileMgr, the CFM frees pages immediately instead of holding them until the next checkpoint. More...

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

std::string	dumpKeysWithMetadata () const

std::string	dumpKeysWithChunkData () const

std::string	dumpTableQueue () const

std::string	dumpEvictionQueue () const

std::string	dump () const

void	setMaxNumDataFiles (size_t max)

void	setMaxNumMetadataFiles (size_t max)

void	setMaxWrapperSpace (size_t max)

std::set< ChunkKey >	getKeysWithMetadata () const

void	setDataSizeLimit (size_t max)

Page	requestFreePage (size_t pagesize, const bool isMetadata) override
	requests a free page similar to FileMgr, but this override will also evict existing pages to make space if there are none available. More...

Public Member Functions inherited from File_Namespace::FileMgr
	FileMgr (const int32_t device_id, GlobalFileMgr *gfm, const TablePair file_mgr_key, const int32_t max_rollback_epochs=-1, const size_t num_reader_threads=0, const int32_t epoch=-1)
	Constructor. More...

	FileMgr (const int32_t device_id, GlobalFileMgr *gfm, const TablePair file_mgr_key, const bool run_core_init)

	FileMgr (GlobalFileMgr *gfm, std::string basePath)

	~FileMgr () override
	Destructor. More...

StorageStats	getStorageStats () const

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

bool	isBufferOnDevice (const ChunkKey &key) override

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

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

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

void	fetchBuffer (const ChunkKey &key, AbstractBuffer *destBuffer, const size_t numBytes) override

FileBuffer *	putBuffer (const ChunkKey &key, AbstractBuffer *d, const size_t numBytes=0) override
	Puts the contents of d into the Chunk with the given key. More...

AbstractBuffer *	alloc (const size_t numBytes) override

void	free (AbstractBuffer *buffer) override

MgrType	getMgrType () override

std::string	getStringMgrType () override

std::string	printSlabs () override

size_t	getMaxSize () override

size_t	getInUseSize () override

size_t	getAllocated () override

bool	isAllocationCapped () override

FileInfo *	getFileInfoForFileId (const int32_t fileId) const

FileMetadata	getMetadataForFile (const boost::filesystem::directory_iterator &fileIterator) const

void	copyPage (Page &srcPage, FileMgr *destFileMgr, Page &destPage, const size_t reservedHeaderSize, const size_t numBytes, const size_t offset)

void	requestFreePages (size_t npages, size_t pagesize, std::vector< Page > &pages, const bool isMetadata)
	Obtains free pages – creates new files if necessary – of the requested size. More...

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

bool	hasChunkMetadataForKeyPrefix (const ChunkKey &keyPrefix)

void	checkpoint () override
	Fsyncs data files, writes out epoch and fsyncs that. More...

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

int32_t	epochFloor () const

int32_t	incrementEpoch ()

int32_t	lastCheckpointedEpoch () const
	Returns value of epoch at last checkpoint. More...

void	resetEpochFloor ()

int32_t	maxRollbackEpochs ()
	Returns value max_rollback_epochs. More...

size_t	getNumReaderThreads ()
	Returns number of threads defined by parameter num-reader-threads which should be used during initial load and consequent read of data. More...

FILE *	getFileForFileId (const int32_t fileId)
	Returns FILE pointer associated with requested fileId. More...

size_t	getNumChunks () override

size_t	getNumUsedMetadataPagesForChunkKey (const ChunkKey &chunkKey) const

bool	getDBConvert () const
	Index for looking up chunks. More...

void	createOrMigrateTopLevelMetadata ()

std::string	getFileMgrBasePath () const

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

const TablePair	get_fileMgrKey () const

boost::filesystem::path	getFilePath (const std::string &file_name) const

void	writePageMappingsToStatusFile (const std::vector< PageMapping > &page_mappings)

void	renameCompactionStatusFile (const char const from_status, const char const to_status)

void	compactFiles ()

size_t	getPageSize () const

size_t	getMetadataPageSize () const

FILE *	createFile (const std::string &full_path, const size_t requested_file_size) const

std::pair< FILE *, std::string >	createFile (const std::string &base_path, const int file_id, const size_t page_size, const size_t num_pages) const

size_t	writeFile (FILE f, const size_t offset, const size_t size, const int8_t buf) const

Static Public Member Functions
static size_t	getMinimumSize ()

Static Public Member Functions inherited from File_Namespace::FileMgr
static void	setNumPagesPerDataFile (size_t num_pages)

static void	setNumPagesPerMetadataFile (size_t num_pages)

static void	renameAndSymlinkLegacyFiles (const std::string &table_data_dir)

Static Public Attributes
static constexpr char	WRAPPER_FILE_NAME [] = "wrapper_metadata.json"

static constexpr float	METADATA_SPACE_PERCENTAGE {0.1}

static constexpr float	METADATA_FILE_SPACE_PERCENTAGE {0.01}

Static Public Attributes inherited from File_Namespace::FileMgr
static constexpr size_t	DEFAULT_NUM_PAGES_PER_DATA_FILE {256}

static constexpr size_t	DEFAULT_NUM_PAGES_PER_METADATA_FILE {4096}

static constexpr char const *	COPY_PAGES_STATUS {"pending_data_compaction_0"}

static constexpr char const *	UPDATE_PAGE_VISIBILITY_STATUS {"pending_data_compaction_1"}

static constexpr char const *	DELETE_EMPTY_FILES_STATUS {"pending_data_compaction_2"}

static constexpr char	LEGACY_EPOCH_FILENAME [] = "epoch"

static constexpr char	EPOCH_FILENAME [] = "epoch_metadata"

static constexpr char	DB_META_FILENAME [] = "dbmeta"

static constexpr char	FILE_MGR_VERSION_FILENAME [] = "filemgr_version"

static constexpr int32_t	INVALID_VERSION = -1

static constexpr int32_t	LATEST_FILE_MGR_VERSION = 2

Private Member Functions
void	incrementEpoch (int32_t db_id, int32_t tb_id)
	Increments epoch for the given table. More...

void	init (const size_t num_reader_threads)
	Initializes a CFM, parsing any existing files and initializing data structures appropriately (currently not thread-safe). More...

void	writeAndSyncEpochToDisk (int32_t db_id, int32_t tb_id)
	Flushes epoch value to disk for a table. More...

void	readTableFileMgrs ()
	Checks for any sub-directories containing table-specific data and creates epochs from found files. More...

FileBuffer *	createBufferFromHeaders (const ChunkKey &key, const std::vector< HeaderInfo >::const_iterator &startIt, const std::vector< HeaderInfo >::const_iterator &endIt) override
	Creates a buffer and initializes it with info read from files on disk. More...

FileBuffer *	createBufferUnlocked (const ChunkKey &key, size_t pageSize=0, const size_t numBytes=0) override
	Creates a buffer. More...

void	createTableFileMgrIfNoneExists (const int32_t db_id, const int32_t tb_id)
	Create and initialize a subdirectory for a table if none exists. More...

void	incrementAllEpochs ()
	Increment epochs for each table in the CFM. More...

void	removeTableFileMgr (int32_t db_id, int32_t tb_id)
	Removes the subdirectory content for a table. More...

void	removeTableBuffers (int32_t db_id, int32_t tb_id)
	Erases and cleans up all buffers for a table. More...

void	writeDirtyBuffers (int32_t db_id, int32_t tb_id)
	helper function to flush all dirty buffers to disk. More...

void	touchKey (const ChunkKey &key) const
	Used to track which tables/chunks were least recently used. More...

void	removeKey (const ChunkKey &key) const

std::vector< ChunkKey >	getKeysForTable (int32_t db_id, int32_t tb_id) const
	returns set of keys contained in chunkIndex_ that match the given table prefix. More...

FileInfo *	evictMetadataPages ()
	evicts all metadata pages for the least recently used table. Returns the first FileInfo that a page was evicted from (guaranteed to now have at least one free page in it). More...

FileInfo *	evictPages ()
	evicts all data pages for the least recently used Chunk (metadata pages persist). Returns the first FileInfo that a page was evicted from (guaranteed to now have at least one free page in it). More...

void	deleteCacheIfTooLarge ()
	When the cache is read from disk, we don't know which chunks were least recently used. Rather than try to evict random pages to get down to size we just reset the cache to make sure we have space. More...

void	setMaxSizes ()
	Sets the maximum number of files/space for each type of storage based on the maximum size. More...

FileBuffer *	getBufferUnlocked (const ChunkKey &key, const size_t numBytes=0) const override

ChunkKeyToChunkMap::iterator	deleteBufferUnlocked (const ChunkKeyToChunkMap::iterator chunk_it, const bool purge=true) override

void	readOnlyCheck (const std::string &action, const std::optional< std::string > &file_name={}) const override

Private Attributes
heavyai::shared_mutex	table_dirs_mutex_

std::map< TablePair, std::unique_ptr< TableFileMgr > >	table_dirs_

size_t	max_num_data_files_

size_t	max_num_meta_files_

size_t	max_wrapper_space_

size_t	max_size_

std::optional< size_t >	limit_data_size_ {}

LRUEvictionAlgorithm	chunk_evict_alg_

LRUEvictionAlgorithm	table_evict_alg_

Additional Inherited Members
Public Attributes inherited from File_Namespace::FileMgr
ChunkKeyToChunkMap	chunkIndex_

Protected Member Functions inherited from File_Namespace::FileMgr
	FileMgr (const size_t defaultPageSize, const size_t defaultMetadataPageSize)

FileInfo *	createFileInfo (const size_t pageSize, const size_t numPages)
	Adds a file to the file manager repository. More...

FileInfo *	openExistingFile (const std::string &path, const int32_t fileId, const size_t pageSize, const size_t numPages, std::vector< HeaderInfo > &headerVec)

void	createEpochFile (const std::string &epochFileName)

int32_t	openAndReadLegacyEpochFile (const std::string &epochFileName)

void	openAndReadEpochFile (const std::string &epochFileName)

void	writeAndSyncEpochToDisk ()

void	setEpoch (const int32_t newEpoch)

int32_t	readVersionFromDisk (const std::string &versionFileName) const

void	writeAndSyncVersionToDisk (const std::string &versionFileName, const int32_t version)

void	processFileFutures (std::vector< std::future< std::vector< HeaderInfo >>> &file_futures, std::vector< HeaderInfo > &headerVec)

void	migrateToLatestFileMgrVersion ()

void	migrateEpochFileV0 ()

void	migrateLegacyFilesV1 ()

OpenFilesResult	openFiles ()

void	clearFileInfos ()

void	copySourcePageForCompaction (const Page &source_page, FileInfo *destination_file_info, std::vector< PageMapping > &page_mappings, std::set< Page > &touched_pages)

int32_t	copyPageWithoutHeaderSize (const Page &source_page, const Page &destination_page)

void	sortAndCopyFilePagesForCompaction (size_t page_size, std::vector< PageMapping > &page_mappings, std::set< Page > &touched_pages)

void	updateMappedPagesVisibility (const std::vector< PageMapping > &page_mappings)

void	deleteEmptyFiles ()

void	resumeFileCompaction (const std::string &status_file_name)

std::vector< PageMapping >	readPageMappingsFromStatusFile ()

	FileMgr (const int epoch)

void	closePhysicalUnlocked ()

void	syncFilesToDisk ()

void	freePages ()

void	initializeNumThreads (size_t num_reader_threads=0)

Protected Attributes inherited from File_Namespace::FileMgr
int32_t	maxRollbackEpochs_

std::string	fileMgrBasePath_

std::map< int32_t, std::unique_ptr< FileInfo > >	files_

PageSizeFileMMap	fileIndex_

size_t	num_reader_threads_
	Maps page sizes to FileInfo objects. More...

unsigned	nextFileId_
	number of threads used when loading data More...

int32_t	fileMgrVersion_
	the index of the next file id More...

FILE *	DBMetaFile_ = nullptr

std::mutex	getPageMutex_
	pointer to DB level metadata More...

heavyai::shared_mutex	chunkIndexMutex_

heavyai::shared_mutex	files_rw_mutex_

heavyai::shared_mutex	mutex_free_page_

std::vector< std::pair < FileInfo *, int32_t > >	free_pages_

bool	isFullyInitted_ {false}

const size_t	page_size_

const size_t	metadata_page_size_

Static Protected Attributes inherited from File_Namespace::FileMgr
static size_t	num_pages_per_data_file_ {DEFAULT_NUM_PAGES_PER_DATA_FILE}

static size_t	num_pages_per_metadata_file_ {DEFAULT_NUM_PAGES_PER_METADATA_FILE}

Detailed Description

A FileMgr capable of limiting it's size and storing data from multiple tables in a shared directory. For any table that supports DiskCaching, the CachingFileMgr must contain either metadata for all table chunks, or for none (the cache is either has no knowledge of that table, or has complete knowledge of that table). Any data chunk within a table may or may not be contained within the cache.

Definition at line 178 of file CachingFileMgr.h.

Constructor & Destructor Documentation

File_Namespace::CachingFileMgr::CachingFileMgr ( const DiskCacheConfig & config )

Definition at line 71 of file CachingFileMgr.cpp.

References File_Namespace::FileMgr::fileMgrBasePath_, init(), max_size_, File_Namespace::FileMgr::maxRollbackEpochs_, File_Namespace::FileMgr::nextFileId_, File_Namespace::DiskCacheConfig::num_reader_threads, File_Namespace::DiskCacheConfig::path, setMaxSizes(), and File_Namespace::DiskCacheConfig::size_limit.

     : FileMgr(config.page_size, config.meta_page_size) {
   fileMgrBasePath_ = config.path;
   maxRollbackEpochs_ = 0;
   nextFileId_ = 0;
   max_size_ = config.size_limit;
   init(config.num_reader_threads);
   setMaxSizes();
 }

Here is the call graph for this function:

File_Namespace::CachingFileMgr::~CachingFileMgr ( )

override

Definition at line 81 of file CachingFileMgr.cpp.

81 {}

Member Function Documentation

CachingFileBuffer * File_Namespace::CachingFileMgr::allocateBuffer	(	const size_t	page_size,
		const ChunkKey &	key,
		const size_t	num_bytes = `0`
	)

overridevirtual

allocates a new CachingFileBuffer and tracks it's use in the eviction algorithms.

Reimplemented from File_Namespace::FileMgr.

Definition at line 346 of file CachingFileMgr.cpp.

                                                                           {
   return new CachingFileBuffer(this, page_size, key, num_bytes);
 }

CachingFileBuffer * File_Namespace::CachingFileMgr::allocateBuffer	(	const ChunkKey &	key,
		const std::vector< HeaderInfo >::const_iterator &	headerStartIt,
		const std::vector< HeaderInfo >::const_iterator &	headerEndIt
	)

overridevirtual

Reimplemented from File_Namespace::FileMgr.

Definition at line 352 of file CachingFileMgr.cpp.

                                                             {
   return new CachingFileBuffer(this, key, headerStartIt, headerEndIt);
 }

void File_Namespace::CachingFileMgr::checkpoint	(	const int32_t	db_id,
		const int32_t	tb_id
	)

override

writes buffers for the given table, synchronizes files to disk, updates file epoch, and commits free pages.

Definition at line 246 of file CachingFileMgr.cpp.

References CHECK, table_dirs_, and table_dirs_mutex_.

                                                                         {
   {
     heavyai::shared_lock<heavyai::shared_mutex> read_lock(table_dirs_mutex_);
     CHECK(table_dirs_.find({db_id, tb_id}) != table_dirs_.end()) << "No data for table";
   }
   VLOG(2) << "Checkpointing " << describeSelf() << " (" << db_id << ", " << tb_id
           << ") epoch: " << epoch(db_id, tb_id);
   writeDirtyBuffers(db_id, tb_id);
   syncFilesToDisk();
   writeAndSyncEpochToDisk(db_id, tb_id);
   incrementEpoch(db_id, tb_id);
   freePages();
 }

void File_Namespace::CachingFileMgr::clearForTable	(	int32_t	db_id,
		int32_t	tb_id
	)

Removes all data related to the given table (pages and subdirectories).

Definition at line 173 of file CachingFileMgr.cpp.

References File_Namespace::FileMgr::freePages(), removeTableBuffers(), and removeTableFileMgr().

                                                                {
   removeTableBuffers(db_id, tb_id);
   removeTableFileMgr(db_id, tb_id);
   freePages();
 }

Here is the call graph for this function:

void File_Namespace::CachingFileMgr::closeRemovePhysical ( )

overridevirtual

Closes files and removes the caching directory.

Reimplemented from File_Namespace::FileMgr.

Definition at line 183 of file CachingFileMgr.cpp.

References File_Namespace::FileMgr::closePhysicalUnlocked(), File_Namespace::FileMgr::files_rw_mutex_, File_Namespace::FileMgr::getFileMgrBasePath(), table_dirs_, and table_dirs_mutex_.

                                          {
   {
     heavyai::unique_lock<heavyai::shared_mutex> write_lock(files_rw_mutex_);
     closePhysicalUnlocked();
   }
   {
     heavyai::unique_lock<heavyai::shared_mutex> tables_lock(table_dirs_mutex_);
     table_dirs_.clear();
   }
   bf::remove_all(getFileMgrBasePath());
 }

Here is the call graph for this function:

FileBuffer * File_Namespace::CachingFileMgr::createBufferFromHeaders	(	const ChunkKey &	key,
		const std::vector< HeaderInfo >::const_iterator &	startIt,
		const std::vector< HeaderInfo >::const_iterator &	endIt
	)

overrideprivatevirtual

Creates a buffer and initializes it with info read from files on disk.

Reimplemented from File_Namespace::FileMgr.

Definition at line 279 of file CachingFileMgr.cpp.

References get_table_prefix().

Referenced by init().

                                                       {
   if (startIt->pageId != -1) {
     // If the first pageId is not -1 then there is no metadata page for the
     // current key (which means it was never checkpointed), so we should skip.
     return nullptr;
   }
   touchKey(key);
   auto [db_id, tb_id] = get_table_prefix(key);
   createTableFileMgrIfNoneExists(db_id, tb_id);
   auto buffer = FileMgr::createBufferFromHeaders(key, startIt, endIt);
   if (buffer->isMissingPages()) {
     // Detect the case where a page is missing by comparing the amount of pages read
     // with the metadata size.  If data are missing, discard the chunk.
     buffer->freeChunkPages();
   }
   return buffer;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

FileBuffer * File_Namespace::CachingFileMgr::createBufferUnlocked	(	const ChunkKey &	key,
		size_t	pageSize = `0`,
		const size_t	numBytes = `0`
	)

overrideprivatevirtual

Creates a buffer.

Reimplemented from File_Namespace::FileMgr.

Definition at line 270 of file CachingFileMgr.cpp.

References get_table_prefix().

                                                                          {
   touchKey(key);
   auto [db_id, tb_id] = get_table_prefix(key);
   createTableFileMgrIfNoneExists(db_id, tb_id);
   return FileMgr::createBufferUnlocked(key, page_size, num_bytes);
 }

Here is the call graph for this function:

void File_Namespace::CachingFileMgr::createTableFileMgrIfNoneExists	(	const int32_t	db_id,
		const int32_t	tb_id
	)

private

Create and initialize a subdirectory for a table if none exists.

Definition at line 260 of file CachingFileMgr.cpp.

                                                                          {
   heavyai::unique_lock<heavyai::shared_mutex> write_lock(table_dirs_mutex_);
   TablePair table_pair{db_id, tb_id};
   if (table_dirs_.find(table_pair) == table_dirs_.end()) {
     table_dirs_.emplace(
         table_pair, std::make_unique<TableFileMgr>(getTableFileMgrPath(db_id, tb_id)));
   }
 }

void File_Namespace::CachingFileMgr::deleteBufferIfExists ( const ChunkKey & key )

deletes a buffer if it exists in the mgr. Otherwise do nothing.

Definition at line 396 of file CachingFileMgr.cpp.

                                                              {
   heavyai::unique_lock<heavyai::shared_mutex> chunk_index_write_lock(chunkIndexMutex_);
   auto chunk_it = chunkIndex_.find(key);
   if (chunk_it != chunkIndex_.end()) {
     deleteBufferUnlocked(chunk_it);
   }
 }

ChunkKeyToChunkMap::iterator File_Namespace::CachingFileMgr::deleteBufferUnlocked	(	const ChunkKeyToChunkMap::iterator	chunk_it,
		const bool	purge = `true`
	)

overrideprivatevirtual

Reimplemented from File_Namespace::FileMgr.

Definition at line 713 of file CachingFileMgr.cpp.

                       {
   removeKey(chunk_it->first);
   return FileMgr::deleteBufferUnlocked(chunk_it, purge);
 }

void File_Namespace::CachingFileMgr::deleteCacheIfTooLarge ( )

private

When the cache is read from disk, we don't know which chunks were least recently used. Rather than try to evict random pages to get down to size we just reset the cache to make sure we have space.

Definition at line 415 of file CachingFileMgr.cpp.

References logger::INFO, LOG, and anonymous_namespace{CachingFileMgr.cpp}::size_of_dir().

Referenced by init().

                                            {
   if (size_of_dir(fileMgrBasePath_) > max_size_) {
     closeRemovePhysical();
     bf::create_directory(fileMgrBasePath_);
     LOG(INFO) << "Cache path over limit.  Existing cache deleted.";
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void File_Namespace::CachingFileMgr::deleteWrapperFile	(	int32_t	db,
		int32_t	tb
	)

Deletes the wrapper file from a table subdir.

Definition at line 652 of file CachingFileMgr.cpp.

References CHECK.

                                                              {
   heavyai::shared_lock<heavyai::shared_mutex> read_lock(table_dirs_mutex_);
   auto it = table_dirs_.find({db, tb});
   CHECK(it != table_dirs_.end()) << "Wrapper does not exist.";
   it->second->deleteWrapperFile();
 }

std::string File_Namespace::CachingFileMgr::describeSelf ( ) const

overridevirtual

describes this FileMgr for logging purposes.

Reimplemented from File_Namespace::FileMgr.

Definition at line 241 of file CachingFileMgr.cpp.

                                              {
   return "cache";
 }

std::string File_Namespace::CachingFileMgr::dump ( ) const

Definition at line 58 of file CachingFileMgr.cpp.

References chunk_evict_alg_, File_Namespace::FileMgr::chunkIndex_, LRUEvictionAlgorithm::dumpEvictionQueue(), show_chunk(), and table_evict_alg_.

                                      {
   std::stringstream ss;
   ss << "Dump Cache:\n";
   for (const auto& [key, buf] : chunkIndex_) {
     ss << "  " << show_chunk(key) << " num_pages: " << buf->pageCount()
        << ", is dirty: " << buf->isDirty() << "\n";
   }
   ss << "Data Eviction Queue:\n" << chunk_evict_alg_.dumpEvictionQueue();
   ss << "Metadata Eviction Queue:\n" << table_evict_alg_.dumpEvictionQueue();
   ss << "\n";
   return ss.str();
 }

Here is the call graph for this function:

std::string File_Namespace::CachingFileMgr::dumpEvictionQueue ( ) const

inline

Definition at line 373 of file CachingFileMgr.h.

References chunk_evict_alg_, and LRUEvictionAlgorithm::dumpEvictionQueue().

373 { return chunk_evict_alg_.dumpEvictionQueue(); }

LRUEvictionAlgorithm::dumpEvictionQueue

std::string dumpEvictionQueue()

Definition: LRUEvictionAlgorithm.cpp:59

File_Namespace::CachingFileMgr::chunk_evict_alg_

LRUEvictionAlgorithm chunk_evict_alg_

Definition: CachingFileMgr.h:512

Here is the call graph for this function:

std::string File_Namespace::CachingFileMgr::dumpKeysWithChunkData ( ) const

Definition at line 631 of file CachingFileMgr.cpp.

References show_chunk().

                                                       {
   heavyai::shared_lock<heavyai::shared_mutex> read_lock(chunkIndexMutex_);
   std::string ret_string = "CFM keys with chunk data:\n";
   for (const auto& [key, buf] : chunkIndex_) {
     if (buf->hasDataPages()) {
       ret_string += "  " + show_chunk(key) + "\n";
     }
   }
   return ret_string;
 }

Here is the call graph for this function:

std::string File_Namespace::CachingFileMgr::dumpKeysWithMetadata ( ) const

Definition at line 620 of file CachingFileMgr.cpp.

References show_chunk().

                                                      {
   heavyai::shared_lock<heavyai::shared_mutex> read_lock(chunkIndexMutex_);
   std::string ret_string = "CFM keys with metadata:\n";
   for (const auto& [key, buf] : chunkIndex_) {
     if (buf->hasEncoder()) {
       ret_string += "  " + show_chunk(key) + "\n";
     }
   }
   return ret_string;
 }

Here is the call graph for this function:

std::string File_Namespace::CachingFileMgr::dumpTableQueue ( ) const

inline

Definition at line 372 of file CachingFileMgr.h.

References LRUEvictionAlgorithm::dumpEvictionQueue(), and table_evict_alg_.

372 { return table_evict_alg_.dumpEvictionQueue(); }

File_Namespace::CachingFileMgr::table_evict_alg_

LRUEvictionAlgorithm table_evict_alg_

Definition: CachingFileMgr.h:513

LRUEvictionAlgorithm::dumpEvictionQueue

std::string dumpEvictionQueue()

Definition: LRUEvictionAlgorithm.cpp:59

Here is the call graph for this function:

int32_t File_Namespace::CachingFileMgr::epoch	(	int32_t	db_id,
		int32_t	tb_id
	)		const

overridevirtual

obtain the epoch version for the given table.

Reimplemented from File_Namespace::FileMgr.

Definition at line 141 of file CachingFileMgr.cpp.

References Epoch::min_allowable_epoch(), table_dirs_, and table_dirs_mutex_.

                                                                 {
   heavyai::shared_lock<heavyai::shared_mutex> read_lock(table_dirs_mutex_);
   auto tables_it = table_dirs_.find({db_id, tb_id});
   if (tables_it == table_dirs_.end()) {
     // If there is no directory for this table, that means the cache does not recognize
     // the table that is requested.  This can happen if a table was dropped, and it's
     // pages were invalidated but not yet freed and then the server crashed before they
     // were freed.  Upon re-starting the FileMgr will find these pages and attempt to
     // compare their epoch to know if they are valid or not.  In this case we should
     // return an invalid epoch to indicate that any page for this table is not valid and
     // should be freed.
     return Epoch::min_allowable_epoch();
   }
   auto& [pair, table_dir] = *tables_it;
   return table_dir->getEpoch();
 }

Here is the call graph for this function:

FileInfo * File_Namespace::CachingFileMgr::evictMetadataPages ( )

private

evicts all metadata pages for the least recently used table. Returns the first FileInfo that a page was evicted from (guaranteed to now have at least one free page in it).

Definition at line 475 of file CachingFileMgr.cpp.

References CHECK, anonymous_namespace{CachingFileMgr.cpp}::evict_chunk_or_fail(), and get_table_prefix().

                                              {
   // Locks should already be in place before calling this method.
   FileInfo* file_info{nullptr};
   auto key_to_evict = evict_chunk_or_fail(table_evict_alg_);
   auto [db_id, tb_id] = get_table_prefix(key_to_evict);
   const auto keys = getKeysForTable(db_id, tb_id);
   for (const auto& key : keys) {
     auto chunk_it = chunkIndex_.find(key);
     CHECK(chunk_it != chunkIndex_.end());
     auto& buf = chunk_it->second;
     if (!file_info) {
       // Return the FileInfo for the first file we are freeing a page from so that the
       // caller does not have to search for a FileInfo guaranteed to have at least one
       // free page.
       CHECK(buf->getMetadataPage().pageVersions.size() > 0);
       file_info =
           getFileInfoForFileId(buf->getMetadataPage().pageVersions.front().page.fileId);
     }
     // We erase all pages and entries for the chunk, as without metadata all other
     // entries are useless.
     deleteBufferUnlocked(chunk_it);
   }
   // Serialized datawrappers require metadata to be in the cache.
   deleteWrapperFile(db_id, tb_id);
   CHECK(file_info) << "FileInfo with freed page not found";
   return file_info;
 }

Here is the call graph for this function:

FileInfo * File_Namespace::CachingFileMgr::evictPages ( )

private

evicts all data pages for the least recently used Chunk (metadata pages persist). Returns the first FileInfo that a page was evicted from (guaranteed to now have at least one free page in it).

Definition at line 503 of file CachingFileMgr.cpp.

References CHECK, and anonymous_namespace{CachingFileMgr.cpp}::evict_chunk_or_fail().

                                      {
   FileInfo* file_info{nullptr};
   FileBuffer* buf{nullptr};
   while (!file_info) {
     buf = chunkIndex_.at(evict_chunk_or_fail(chunk_evict_alg_));
     CHECK(buf);
     if (!buf->hasDataPages()) {
       // This buffer contains no chunk data (metadata only, uninitialized, size == 0,
       // etc...) so we won't recover any space by evicting it.  In this case it gets
       // removed from the eviction queue (it will get re-added if it gets populated with
       // data) and we look at the next chunk in queue until we find a buffer with page
       // data.
       continue;
     }
     // Return the FileInfo for the first file we are freeing a page from so that the
     // caller does not have to search for a FileInfo guaranteed to have at least one free
     // page.
     CHECK(buf->getMultiPage().front().pageVersions.size() > 0);
     file_info = getFileInfoForFileId(
         buf->getMultiPage().front().pageVersions.front().page.fileId);
   }
   auto pages_freed = buf->freeChunkPages();
   CHECK(pages_freed > 0) << "failed to evict a page";
   CHECK(file_info) << "FileInfo with freed page not found";
   return file_info;
 }

Here is the call graph for this function:

bool File_Namespace::CachingFileMgr::failOnReadError ( ) const

inlineoverridevirtual

True if a read error should cause a fatal error.

Reimplemented from File_Namespace::FileMgr.

Definition at line 298 of file CachingFileMgr.h.

298 { return false; }

void File_Namespace::CachingFileMgr::free_page ( std::pair< FileInfo *, int32_t > && page )

overridevirtual

Unlike the FileMgr, the CFM frees pages immediately instead of holding them until the next checkpoint.

Reimplemented from File_Namespace::FileMgr.

Definition at line 735 of file CachingFileMgr.cpp.

                                                                  {
   page.first->freePageDeferred(page.second);
 }

size_t File_Namespace::CachingFileMgr::getAllocated ( )

inlineoverride

Definition at line 218 of file CachingFileMgr.h.

References getFilesSize(), and getTableFileMgrsSize().

Referenced by getAvailableSpace().

                                         {
     return getFilesSize() + getTableFileMgrsSize();
   }

Here is the call graph for this function:

Here is the caller graph for this function:

size_t File_Namespace::CachingFileMgr::getAvailableSpace ( )

inline

Definition at line 214 of file CachingFileMgr.h.

References getAllocated(), and max_size_.

214 { return max_size_ - getAllocated(); }

File_Namespace::CachingFileMgr::max_size_

size_t max_size_

Definition: CachingFileMgr.h:509

File_Namespace::CachingFileMgr::getAllocated

size_t getAllocated() override

Definition: CachingFileMgr.h:218

Here is the call graph for this function:

size_t File_Namespace::CachingFileMgr::getAvailableWrapperSpace ( )

inline

Definition at line 215 of file CachingFileMgr.h.

References getTableFileMgrsSize(), and max_wrapper_space_.

                                            {
     return max_wrapper_space_ - getTableFileMgrsSize();
   }

Here is the call graph for this function:

std::optional< FileBuffer * > File_Namespace::CachingFileMgr::getBufferIfExists ( const ChunkKey & key )

an optional version of get buffer if we are not sure a chunk exists.

Definition at line 704 of file CachingFileMgr.cpp.

                                                                               {
   heavyai::shared_lock<heavyai::shared_mutex> chunk_index_read_lock(chunkIndexMutex_);
   auto chunk_it = chunkIndex_.find(key);
   if (chunk_it == chunkIndex_.end()) {
     return {};
   }
   return getBufferUnlocked(key);
 }

FileBuffer * File_Namespace::CachingFileMgr::getBufferUnlocked	(	const ChunkKey &	key,
		const size_t	numBytes = `0`
	)		const

overrideprivatevirtual

Reimplemented from File_Namespace::FileMgr.

Definition at line 729 of file CachingFileMgr.cpp.

                                                                             {
   touchKey(key);
   return FileMgr::getBufferUnlocked(key, num_bytes);
 }

std::vector< ChunkKey > File_Namespace::CachingFileMgr::getChunkKeysForPrefix ( const ChunkKey & prefix ) const

Returns the keys for chunks with chunk data that match the given prefix.

Definition at line 582 of file CachingFileMgr.cpp.

References in_same_table().

                                   {
   heavyai::shared_lock<heavyai::shared_mutex> read_lock(chunkIndexMutex_);
   std::vector<ChunkKey> chunks;
   for (auto [key, buf] : chunkIndex_) {
     if (in_same_table(key, prefix)) {
       if (buf->hasDataPages()) {
         chunks.emplace_back(key);
         touchKey(key);
       }
     }
   }
   return chunks;
 }

Here is the call graph for this function:

void File_Namespace::CachingFileMgr::getChunkMetadataVecForKeyPrefix	(	ChunkMetadataVector &	chunkMetadataVec,
		const ChunkKey &	keyPrefix
	)

override

Definition at line 720 of file CachingFileMgr.cpp.

                                {
   FileMgr::getChunkMetadataVecForKeyPrefix(chunkMetadataVec, keyPrefix);
   for (const auto& [key, meta] : chunkMetadataVec) {
     touchKey(key);
   }
 }

size_t File_Namespace::CachingFileMgr::getChunkSpaceReservedByTable	(	int32_t	db_id,
		int32_t	tb_id
	)		const

Set of functions to determine how much space is reserved in a table by type.

Definition at line 195 of file CachingFileMgr.cpp.

References File_Namespace::FileMgr::chunkIndex_, File_Namespace::FileMgr::chunkIndexMutex_, and File_Namespace::FileMgr::page_size_.

Referenced by getSpaceReservedByTable().

                                                                                       {
   heavyai::shared_lock<heavyai::shared_mutex> read_lock(chunkIndexMutex_);
   size_t space_used = 0;
   ChunkKey min_table_key{db_id, tb_id};
   ChunkKey max_table_key{db_id, tb_id, std::numeric_limits<int32_t>::max()};
   for (auto it = chunkIndex_.lower_bound(min_table_key);
        it != chunkIndex_.upper_bound(max_table_key);
        ++it) {
     auto& [key, buffer] = *it;
     space_used += (buffer->numChunkPages() * page_size_);
   }
   return space_used;
 }

Here is the caller graph for this function:

size_t File_Namespace::CachingFileMgr::getDataFileSize ( ) const

inline

Definition at line 207 of file CachingFileMgr.h.

References File_Namespace::FileMgr::num_pages_per_data_file_, and File_Namespace::FileMgr::page_size_.

207 { return page_size_ * num_pages_per_data_file_; }

File_Namespace::FileMgr::page_size_

const size_t page_size_

Definition: FileMgr.h:551

File_Namespace::FileMgr::num_pages_per_data_file_

static size_t num_pages_per_data_file_

Definition: FileMgr.h:427

size_t File_Namespace::CachingFileMgr::getFilesSize ( ) const

Get the total size of page files (data and metadata files). This includes allocated, but unused space.

Definition at line 554 of file CachingFileMgr.cpp.

Referenced by getAllocated().

                                           {
   heavyai::shared_lock<heavyai::shared_mutex> read_lock(files_rw_mutex_);
   size_t sum = 0;
   for (const auto& [id, file] : files_) {
     sum += file->size();
   }
   return sum;
 }

Here is the caller graph for this function:

std::vector< ChunkKey > File_Namespace::CachingFileMgr::getKeysForTable	(	int32_t	db_id,
		int32_t	tb_id
	)		const

private

returns set of keys contained in chunkIndex_ that match the given table prefix.

Definition at line 462 of file CachingFileMgr.cpp.

                                                                            {
   std::vector<ChunkKey> keys;
   ChunkKey min_table_key{db_id, tb_id};
   ChunkKey max_table_key{db_id, tb_id, std::numeric_limits<int32_t>::max()};
   for (auto it = chunkIndex_.lower_bound(min_table_key);
        it != chunkIndex_.upper_bound(max_table_key);
        ++it) {
     keys.emplace_back(it->first);
   }
   return keys;
 }

std::set< ChunkKey > File_Namespace::CachingFileMgr::getKeysWithMetadata ( ) const

Definition at line 739 of file CachingFileMgr.cpp.

                                                            {
   heavyai::shared_lock<heavyai::shared_mutex> read_lock(chunkIndexMutex_);
   std::set<ChunkKey> ret;
   for (const auto& [key, buf] : chunkIndex_) {
     if (buf->hasEncoder()) {
       ret.emplace(key);
     }
   }
   return ret;
 }

size_t File_Namespace::CachingFileMgr::getMaxDataFiles ( ) const

inline

Definition at line 204 of file CachingFileMgr.h.

References max_num_data_files_.

204 { return max_num_data_files_; }

File_Namespace::CachingFileMgr::max_num_data_files_

size_t max_num_data_files_

Definition: CachingFileMgr.h:506

size_t File_Namespace::CachingFileMgr::getMaxDataFilesSize ( ) const

Definition at line 750 of file CachingFileMgr.cpp.

                                                  {
   if (limit_data_size_) {
     return *limit_data_size_;
   }
   return getMaxDataFiles() * getDataFileSize();
 }

size_t File_Namespace::CachingFileMgr::getMaxMetaFiles ( ) const

inline

Definition at line 205 of file CachingFileMgr.h.

References max_num_meta_files_.

205 { return max_num_meta_files_; }

File_Namespace::CachingFileMgr::max_num_meta_files_

size_t max_num_meta_files_

Definition: CachingFileMgr.h:507

size_t File_Namespace::CachingFileMgr::getMaxSize ( )

inlineoverride

Definition at line 203 of file CachingFileMgr.h.

References max_size_.

203 { return max_size_; }

File_Namespace::CachingFileMgr::max_size_

size_t max_size_

Definition: CachingFileMgr.h:509

size_t File_Namespace::CachingFileMgr::getMaxWrapperSize ( ) const

inline

Definition at line 206 of file CachingFileMgr.h.

References max_wrapper_space_.

206 { return max_wrapper_space_; }

File_Namespace::CachingFileMgr::max_wrapper_space_

size_t max_wrapper_space_

Definition: CachingFileMgr.h:508

size_t File_Namespace::CachingFileMgr::getMetadataFileSize ( ) const

inline

Definition at line 208 of file CachingFileMgr.h.

References File_Namespace::FileMgr::metadata_page_size_, and File_Namespace::FileMgr::num_pages_per_metadata_file_.

                                             {
     return metadata_page_size_ * num_pages_per_metadata_file_;
   }

size_t File_Namespace::CachingFileMgr::getMetadataSpaceReservedByTable	(	int32_t	db_id,
		int32_t	tb_id
	)		const

Definition at line 209 of file CachingFileMgr.cpp.

References File_Namespace::FileMgr::chunkIndex_, File_Namespace::FileMgr::chunkIndexMutex_, and File_Namespace::FileMgr::metadata_page_size_.

Referenced by getSpaceReservedByTable().

                                                                             {
   heavyai::shared_lock<heavyai::shared_mutex> read_lock(chunkIndexMutex_);
   size_t space_used = 0;
   ChunkKey min_table_key{db_id, tb_id};
   ChunkKey max_table_key{db_id, tb_id, std::numeric_limits<int32_t>::max()};
   for (auto it = chunkIndex_.lower_bound(min_table_key);
        it != chunkIndex_.upper_bound(max_table_key);
        ++it) {
     auto& [key, buffer] = *it;
     space_used += (buffer->numMetadataPages() * metadata_page_size_);
   }
   return space_used;
 }

Here is the caller graph for this function:

MgrType File_Namespace::CachingFileMgr::getMgrType ( )

inlineoverride

Definition at line 200 of file CachingFileMgr.h.

200 { return CACHING_FILE_MGR; };

static size_t File_Namespace::CachingFileMgr::getMinimumSize ( )

inlinestatic

Definition at line 188 of file CachingFileMgr.h.

References DEFAULT_METADATA_PAGE_SIZE, File_Namespace::FileMgr::DEFAULT_NUM_PAGES_PER_METADATA_FILE, and METADATA_FILE_SPACE_PERCENTAGE.

Referenced by CommandLineOptions::validate().

                                  {
     // Currently the minimum default size is based on the metadata file size and
     // percentage usage.
     return (DEFAULT_METADATA_PAGE_SIZE * DEFAULT_NUM_PAGES_PER_METADATA_FILE) /
            METADATA_FILE_SPACE_PERCENTAGE;
   }

Here is the caller graph for this function:

size_t File_Namespace::CachingFileMgr::getNumChunksWithMetadata ( ) const

Returns the number of buffers with metadata in the CFM. Any buffer with an encoder counts.

Definition at line 609 of file CachingFileMgr.cpp.

                                                       {
   heavyai::shared_lock<heavyai::shared_mutex> read_lock(chunkIndexMutex_);
   size_t sum = 0;
   for (const auto& [key, buf] : chunkIndex_) {
     if (buf->hasEncoder()) {
       sum++;
     }
   }
   return sum;
 }

size_t File_Namespace::CachingFileMgr::getNumDataChunks ( ) const

Returns the number of buffers with chunk data in the CFM.

Definition at line 404 of file CachingFileMgr.cpp.

                                               {
   heavyai::shared_lock<heavyai::shared_mutex> read_lock(chunkIndexMutex_);
   size_t num_chunks = 0;
   for (auto [key, buf] : chunkIndex_) {
     if (buf->hasDataPages()) {
       num_chunks++;
     }
   }
   return num_chunks;
 }

size_t File_Namespace::CachingFileMgr::getNumDataFiles ( ) const

Definition at line 572 of file CachingFileMgr.cpp.

                                              {
   heavyai::shared_lock<heavyai::shared_mutex> read_lock(files_rw_mutex_);
   return fileIndex_.count(page_size_);
 }

size_t File_Namespace::CachingFileMgr::getNumMetaFiles ( ) const

Definition at line 577 of file CachingFileMgr.cpp.

                                              {
   heavyai::shared_lock<heavyai::shared_mutex> read_lock(files_rw_mutex_);
   return fileIndex_.count(metadata_page_size_);
 }

size_t File_Namespace::CachingFileMgr::getPageSize ( )

inline

Definition at line 202 of file CachingFileMgr.h.

References File_Namespace::FileMgr::page_size_.

202 { return page_size_; }

File_Namespace::FileMgr::page_size_

const size_t page_size_

Definition: FileMgr.h:551

size_t File_Namespace::CachingFileMgr::getSpaceReservedByTable	(	int32_t	db_id,
		int32_t	tb_id
	)		const

Definition at line 234 of file CachingFileMgr.cpp.

References getChunkSpaceReservedByTable(), getMetadataSpaceReservedByTable(), and getTableFileMgrSpaceReserved().

                                                                                  {
   auto chunk_space = getChunkSpaceReservedByTable(db_id, tb_id);
   auto meta_space = getMetadataSpaceReservedByTable(db_id, tb_id);
   auto subdir_space = getTableFileMgrSpaceReserved(db_id, tb_id);
   return chunk_space + meta_space + subdir_space;
 }

Here is the call graph for this function:

std::string File_Namespace::CachingFileMgr::getStringMgrType ( )

inlineoverride

Definition at line 201 of file CachingFileMgr.h.

201 { return ToString(CACHING_FILE_MGR); }

std::string File_Namespace::CachingFileMgr::getTableFileMgrPath	(	int32_t	db,
		int32_t	tb
	)		const

Definition at line 179 of file CachingFileMgr.cpp.

References File_Namespace::get_dir_name_for_table(), and File_Namespace::FileMgr::getFileMgrBasePath().

                                                                                 {
   return getFileMgrBasePath() + "/" + get_dir_name_for_table(db_id, tb_id);
 }

Here is the call graph for this function:

size_t File_Namespace::CachingFileMgr::getTableFileMgrSpaceReserved	(	int32_t	db_id,
		int32_t	tb_id
	)		const

Definition at line 224 of file CachingFileMgr.cpp.

References table_dirs_, and table_dirs_mutex_.

Referenced by getSpaceReservedByTable().

                                                                                       {
   heavyai::shared_lock<heavyai::shared_mutex> read_lock(table_dirs_mutex_);
   size_t space = 0;
   auto table_it = table_dirs_.find({db_id, tb_id});
   if (table_it != table_dirs_.end()) {
     space += table_it->second->getReservedSpace();
   }
   return space;
 }

Here is the caller graph for this function:

size_t File_Namespace::CachingFileMgr::getTableFileMgrsSize ( ) const

Returns the total size of all subdirectory files. Each table represented in the CFM has a subdirectory for serialized data wrappers and epoch files.

Definition at line 563 of file CachingFileMgr.cpp.

Referenced by getAllocated(), and getAvailableWrapperSpace().

                                                   {
   heavyai::shared_lock<heavyai::shared_mutex> read_lock(table_dirs_mutex_);
   size_t space_used = 0;
   for (const auto& [pair, table_dir] : table_dirs_) {
     space_used += table_dir->getReservedSpace();
   }
   return space_used;
 }

Here is the caller graph for this function:

bool File_Namespace::CachingFileMgr::hasFileMgrKey ( ) const

inlineoverridevirtual

Query to determine if the contained pages will have their database and table ids overriden by the filemgr key (FileMgr does this).

Reimplemented from File_Namespace::FileMgr.

Definition at line 237 of file CachingFileMgr.h.

237 { return false; }

bool File_Namespace::CachingFileMgr::hasWrapperFile	(	int32_t	db_id,
		int32_t	table_id
	)		const

Checks if data wrapper file has been written to disk/cached.

Definition at line 671 of file CachingFileMgr.cpp.

                                                                          {
   heavyai::shared_lock<heavyai::shared_mutex> read_lock(table_dirs_mutex_);
   auto it = table_dirs_.find({db_id, table_id});
   if (it != table_dirs_.end()) {
     return it->second->hasWrapperFile();
   }
   return false;
 }

void File_Namespace::CachingFileMgr::incrementAllEpochs ( )

private

Increment epochs for each table in the CFM.

Definition at line 318 of file CachingFileMgr.cpp.

Referenced by init().

                                         {
   heavyai::shared_lock<heavyai::shared_mutex> read_lock(table_dirs_mutex_);
   for (auto& table_dir : table_dirs_) {
     table_dir.second->incrementEpoch();
   }
 }

Here is the caller graph for this function:

void File_Namespace::CachingFileMgr::incrementEpoch	(	int32_t	db_id,
		int32_t	tb_id
	)

private

Increments epoch for the given table.

Definition at line 158 of file CachingFileMgr.cpp.

References CHECK, table_dirs_, and table_dirs_mutex_.

                                                                 {
   heavyai::shared_lock<heavyai::shared_mutex> read_lock(table_dirs_mutex_);
   auto tables_it = table_dirs_.find({db_id, tb_id});
   CHECK(tables_it != table_dirs_.end());
   auto& [pair, table_dir] = *tables_it;
   table_dir->incrementEpoch();
 }

void File_Namespace::CachingFileMgr::init ( const size_t num_reader_threads )

private

Initializes a CFM, parsing any existing files and initializing data structures appropriately (currently not thread-safe).

Definition at line 83 of file CachingFileMgr.cpp.

References createBufferFromHeaders(), deleteCacheIfTooLarge(), File_Namespace::FileMgr::freePages(), incrementAllEpochs(), File_Namespace::FileMgr::initializeNumThreads(), File_Namespace::FileMgr::isFullyInitted_, File_Namespace::FileMgr::nextFileId_, File_Namespace::FileMgr::openFiles(), readTableFileMgrs(), gpu_enabled::sort(), and VLOG.

Referenced by CachingFileMgr().

                                                          {
   deleteCacheIfTooLarge();
   readTableFileMgrs();
   auto open_files_result = openFiles();
   /* Sort headerVec so that all HeaderInfos
    * from a chunk will be grouped together
    * and in order of increasing PageId
    * - Version Epoch */
   auto& header_vec = open_files_result.header_infos;
   std::sort(header_vec.begin(), header_vec.end());
 
   /* Goal of next section is to find sequences in the
    * sorted headerVec of the same ChunkId, which we
    * can then initiate a FileBuffer with */
   VLOG(3) << "Number of Headers in Vector: " << header_vec.size();
   if (header_vec.size() > 0) {
     auto startIt = header_vec.begin();
     ChunkKey lastChunkKey = startIt->chunkKey;
     for (auto it = header_vec.begin() + 1; it != header_vec.end(); ++it) {
       if (it->chunkKey != lastChunkKey) {
         createBufferFromHeaders(lastChunkKey, startIt, it);
         lastChunkKey = it->chunkKey;
         startIt = it;
       }
     }
     createBufferFromHeaders(lastChunkKey, startIt, header_vec.end());
   }
   nextFileId_ = open_files_result.max_file_id + 1;
   incrementAllEpochs();
   freePages();
   initializeNumThreads(num_reader_threads);
   isFullyInitted_ = true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

FileBuffer * File_Namespace::CachingFileMgr::putBuffer	(	const ChunkKey &	key,
		AbstractBuffer *	src_buffer,
		const size_t	num_bytes = `0`
	)

override

deletes any existing buffer for the given key then copies in a new one.

putBuffer() needs to behave differently than it does in FileMgr. Specifically, it needs to delete the buffer beforehand and then append, rather than overwrite the existing buffer. This way we only store a single version of the buffer rather than accumulating versions that need to be rolled off.

Definition at line 306 of file CachingFileMgr.cpp.

References CHECK, Data_Namespace::AbstractBuffer::isDirty(), Data_Namespace::AbstractBuffer::setAppended(), Data_Namespace::AbstractBuffer::setDirty(), and Data_Namespace::AbstractBuffer::size().

                                                               {
   CHECK(!src_buffer->isDirty()) << "Cannot cache dirty buffers.";
   deleteBufferIfExists(key);
   // Since the buffer is not dirty we mark it as dirty if we are only writing metadata and
   // appended if we are writing chunk data.  We delete + append rather than write to make
   // sure we don't write multiple page versions.
   (src_buffer->size() == 0) ? src_buffer->setDirty() : src_buffer->setAppended();
   return FileMgr::putBuffer(key, src_buffer, num_bytes);
 }

Here is the call graph for this function:

void File_Namespace::CachingFileMgr::readOnlyCheck	(	const std::string &	action,
		const std::optional< std::string > &	file_name = `{}`
	)		const

inlineoverrideprivatevirtual

Reimplemented from File_Namespace::FileMgr.

Definition at line 499 of file CachingFileMgr.h.

500 {}) const override{};

void File_Namespace::CachingFileMgr::readTableFileMgrs ( )

private

Checks for any sub-directories containing table-specific data and creates epochs from found files.

Definition at line 117 of file CachingFileMgr.cpp.

References CHECK, File_Namespace::FileMgr::fileMgrBasePath_, table_dirs_, and table_dirs_mutex_.

Referenced by init().

                                        {
   heavyai::unique_lock<heavyai::shared_mutex> write_lock(table_dirs_mutex_);
   bf::path path(fileMgrBasePath_);
   CHECK(bf::exists(path)) << "Cache path: " << fileMgrBasePath_ << " does not exit.";
   CHECK(bf::is_directory(path))
       << "Specified path '" << fileMgrBasePath_ << "' for disk cache is not a directory.";
 
   // Look for directories with table-specific names.
   boost::regex table_filter("table_([0-9]+)_([0-9]+)");
   for (const auto& file : bf::directory_iterator(path)) {
     boost::smatch match;
     auto file_name = file.path().filename().string();
     if (boost::regex_match(file_name, match, table_filter)) {
       int32_t db_id = std::stoi(match[1]);
       int32_t tb_id = std::stoi(match[2]);
       TablePair table_pair{db_id, tb_id};
       CHECK(table_dirs_.find(table_pair) == table_dirs_.end())
           << "Trying to read data for existing table";
       table_dirs_.emplace(table_pair,
                           std::make_unique<TableFileMgr>(file.path().string()));
     }
   }
 }

Here is the caller graph for this function:

std::unique_ptr< CachingFileMgr > File_Namespace::CachingFileMgr::reconstruct ( ) const

Initializes a new CFM using the initialization values in the current CFM.

Definition at line 642 of file CachingFileMgr.cpp.

                                                                 {
   DiskCacheConfig config{fileMgrBasePath_,
                          DiskCacheLevel::none,
                          num_reader_threads_,
                          max_size_,
                          page_size_,
                          metadata_page_size_};
   return std::make_unique<CachingFileMgr>(config);
 }

void File_Namespace::CachingFileMgr::removeChunkKeepMetadata ( const ChunkKey & key )

Free pages for chunk and remove it from the chunk eviction algorithm.

Definition at line 597 of file CachingFileMgr.cpp.

References CHECK.

                                                                 {
   if (isBufferOnDevice(key)) {
     auto chunkIt = chunkIndex_.find(key);
     CHECK(chunkIt != chunkIndex_.end());
     auto& buf = chunkIt->second;
     if (buf->hasDataPages()) {
       buf->freeChunkPages();
       chunk_evict_alg_.removeChunk(key);
     }
   }
 }

void File_Namespace::CachingFileMgr::removeKey ( const ChunkKey & key ) const

private

Definition at line 535 of file CachingFileMgr.cpp.

References get_table_prefix().

                                                         {
   // chunkIndex lock should already be acquired.
   chunk_evict_alg_.removeChunk(key);
   auto [db_id, tb_id] = get_table_prefix(key);
   ChunkKey table_key{db_id, tb_id};
   ChunkKey max_table_key{db_id, tb_id, std::numeric_limits<int32_t>::max()};
   for (auto it = chunkIndex_.lower_bound(table_key);
        it != chunkIndex_.upper_bound(max_table_key);
        ++it) {
     if (it->first != key) {
       // If there are any keys in this table other than that one we are removing, then
       // keep the table in the eviction queue.
       return;
     }
   }
   // No other keys exist for this table, so remove it from the queue.
   table_evict_alg_.removeChunk(table_key);
 }

Here is the call graph for this function:

void File_Namespace::CachingFileMgr::removeTableBuffers	(	int32_t	db_id,
		int32_t	tb_id
	)

private

Erases and cleans up all buffers for a table.

Definition at line 335 of file CachingFileMgr.cpp.

Referenced by clearForTable().

                                                                     {
   // Free associated FileBuffers and clear buffer entries.
   heavyai::unique_lock<heavyai::shared_mutex> write_lock(chunkIndexMutex_);
   ChunkKey min_table_key{db_id, tb_id};
   ChunkKey max_table_key{db_id, tb_id, std::numeric_limits<int32_t>::max()};
   for (auto it = chunkIndex_.lower_bound(min_table_key);
        it != chunkIndex_.upper_bound(max_table_key);) {
     it = deleteBufferUnlocked(it);
   }
 }

Here is the caller graph for this function:

void File_Namespace::CachingFileMgr::removeTableFileMgr	(	int32_t	db_id,
		int32_t	tb_id
	)

private

Removes the subdirectory content for a table.

Definition at line 325 of file CachingFileMgr.cpp.

Referenced by clearForTable().

                                                                     {
   // Delete table-specific directory (stores table epoch data and serialized data wrapper)
   heavyai::unique_lock<heavyai::shared_mutex> write_lock(table_dirs_mutex_);
   auto it = table_dirs_.find({db_id, tb_id});
   if (it != table_dirs_.end()) {
     it->second->removeDiskContent();
     table_dirs_.erase(it);
   }
 }

Here is the caller graph for this function:

Page File_Namespace::CachingFileMgr::requestFreePage	(	size_t	pagesize,
		const bool	isMetadata
	)

overridevirtual

requests a free page similar to FileMgr, but this override will also evict existing pages to make space if there are none available.

Reimplemented from File_Namespace::FileMgr.

Definition at line 423 of file CachingFileMgr.cpp.

References CHECK, File_Namespace::FileInfo::fileId, and File_Namespace::FileInfo::getFreePage().

                                                                            {
   std::lock_guard<std::mutex> lock(getPageMutex_);
   int32_t pageNum = -1;
   // Splits files into metadata and regular data by size.
   auto candidateFiles = fileIndex_.equal_range(pageSize);
   // Check if there is a free page in an existing file.
   for (auto fileIt = candidateFiles.first; fileIt != candidateFiles.second; ++fileIt) {
     FileInfo* fileInfo = getFileInfoForFileId(fileIt->second);
     pageNum = fileInfo->getFreePage();
     if (pageNum != -1) {
       return (Page(fileInfo->fileId, pageNum));
     }
   }
 
   // Try to add a new file if there is free space available.
   FileInfo* fileInfo = nullptr;
   if (isMetadata) {
     if (getMaxMetaFiles() > getNumMetaFiles()) {
       fileInfo = createFileInfo(pageSize, num_pages_per_metadata_file_);
     }
   } else {
     if (getMaxDataFiles() > getNumDataFiles()) {
       fileInfo = createFileInfo(pageSize, num_pages_per_data_file_);
     }
   }
 
   if (!fileInfo) {
     // We were not able to create a new file, so we try to evict space.
     // Eviction will return the first file it evicted a page from (a file now guaranteed
     // to have a free page).
     fileInfo = isMetadata ? evictMetadataPages() : evictPages();
   }
   CHECK(fileInfo);
 
   pageNum = fileInfo->getFreePage();
   CHECK(pageNum != -1);
   return (Page(fileInfo->fileId, pageNum));
 }

Here is the call graph for this function:

void File_Namespace::CachingFileMgr::setDataSizeLimit ( size_t max )

inline

Definition at line 381 of file CachingFileMgr.h.

References limit_data_size_.

381 { limit_data_size_ = max; }

File_Namespace::CachingFileMgr::limit_data_size_

std::optional< size_t > limit_data_size_

Definition: CachingFileMgr.h:510

void File_Namespace::CachingFileMgr::setMaxNumDataFiles ( size_t max )

inline

Definition at line 377 of file CachingFileMgr.h.

References max_num_data_files_.

377 { max_num_data_files_ = max; }

File_Namespace::CachingFileMgr::max_num_data_files_

size_t max_num_data_files_

Definition: CachingFileMgr.h:506

void File_Namespace::CachingFileMgr::setMaxNumMetadataFiles ( size_t max )

inline

Definition at line 378 of file CachingFileMgr.h.

References max_num_meta_files_.

378 { max_num_meta_files_ = max; }

File_Namespace::CachingFileMgr::max_num_meta_files_

size_t max_num_meta_files_

Definition: CachingFileMgr.h:507

void File_Namespace::CachingFileMgr::setMaxSizes ( )

private

Sets the maximum number of files/space for each type of storage based on the maximum size.

Definition at line 689 of file CachingFileMgr.cpp.

References CHECK_GT.

Referenced by CachingFileMgr().

                                  {
   size_t max_meta_space = std::floor(max_size_ * METADATA_SPACE_PERCENTAGE);
   size_t max_meta_file_space = std::floor(max_size_ * METADATA_FILE_SPACE_PERCENTAGE);
   max_wrapper_space_ = max_meta_space - max_meta_file_space;
   auto max_data_space = max_size_ - max_meta_space;
   auto meta_file_size = metadata_page_size_ * num_pages_per_metadata_file_;
   auto data_file_size = page_size_ * num_pages_per_data_file_;
   max_num_data_files_ = max_data_space / data_file_size;
   max_num_meta_files_ = max_meta_file_space / meta_file_size;
   CHECK_GT(max_num_data_files_, 0U) << "Cannot create a cache of size " << max_size_
                                     << ".  Not enough space to create a data file.";
   CHECK_GT(max_num_meta_files_, 0U) << "Cannot create a cache of size " << max_size_
                                     << ".  Not enough space to create a metadata file.";
 }

Here is the caller graph for this function:

void File_Namespace::CachingFileMgr::setMaxWrapperSpace ( size_t max )

inline

Definition at line 379 of file CachingFileMgr.h.

References max_wrapper_space_.

379 { max_wrapper_space_ = max; }

File_Namespace::CachingFileMgr::max_wrapper_space_

size_t max_wrapper_space_

Definition: CachingFileMgr.h:508

void File_Namespace::CachingFileMgr::touchKey ( const ChunkKey & key ) const

private

Used to track which tables/chunks were least recently used.

Definition at line 530 of file CachingFileMgr.cpp.

References get_table_key().

                                                        {
   chunk_evict_alg_.touchChunk(key);
   table_evict_alg_.touchChunk(get_table_key(key));
 }

Here is the call graph for this function:

bool File_Namespace::CachingFileMgr::updatePageIfDeleted	(	FileInfo *	file_info,
		ChunkKey &	chunk_key,
		int32_t	contingent,
		int32_t	page_epoch,
		int32_t	page_num
	)

overridevirtual

checks whether a page should be deleted.

Reimplemented from File_Namespace::FileMgr.

Definition at line 360 of file CachingFileMgr.cpp.

References File_Namespace::DELETE_CONTINGENT, File_Namespace::FileInfo::freePage(), and File_Namespace::ROLLOFF_CONTINGENT.

                                                            {
   // These contingents are stored by overwriting the bytes used for chunkKeys.  If
   // we run into a key marked for deletion in a fileMgr with no fileMgrKey (i.e.
   // CachingFileMgr) then we can't know if the epoch is valid because we don't know
   // the key.  At this point our only option is to free the page as though it was
   // checkpointed (which should be fine since we only maintain one version of each
   // page).
   if (contingent == DELETE_CONTINGENT || contingent == ROLLOFF_CONTINGENT) {
     file_info->freePage(page_num, false, page_epoch);
     return true;
   }
   return false;
 }

Here is the call graph for this function:

void File_Namespace::CachingFileMgr::writeAndSyncEpochToDisk	(	int32_t	db_id,
		int32_t	tb_id
	)

private

Flushes epoch value to disk for a table.

Definition at line 166 of file CachingFileMgr.cpp.

References CHECK, table_dirs_, and table_dirs_mutex_.

                                                                          {
   heavyai::shared_lock<heavyai::shared_mutex> read_lock(table_dirs_mutex_);
   auto table_it = table_dirs_.find({db_id, tb_id});
   CHECK(table_it != table_dirs_.end());
   table_it->second->writeAndSyncEpochToDisk();
 }

void File_Namespace::CachingFileMgr::writeDirtyBuffers	(	int32_t	db_id,
		int32_t	tb_id
	)

private

helper function to flush all dirty buffers to disk.

Definition at line 378 of file CachingFileMgr.cpp.

                                                                    {
   heavyai::unique_lock<heavyai::shared_mutex> chunk_index_write_lock(chunkIndexMutex_);
   ChunkKey min_table_key{db_id, tb_id};
   ChunkKey max_table_key{db_id, tb_id, std::numeric_limits<int32_t>::max()};
 
   for (auto chunk_it = chunkIndex_.lower_bound(min_table_key);
        chunk_it != chunkIndex_.upper_bound(max_table_key);
        ++chunk_it) {
     if (auto [key, buf] = *chunk_it; buf->isDirty()) {
       // Free previous versions first so we only have one metadata version.
       buf->freeMetadataPages();
       buf->writeMetadata(epoch(db_id, tb_id));
       buf->clearDirtyBits();
       touchKey(key);
     }
   }
 }

void File_Namespace::CachingFileMgr::writeWrapperFile	(	const std::string &	doc,
		int32_t	db,
		int32_t	tb
	)

Writes a wrapper file to a table subdir.

Definition at line 659 of file CachingFileMgr.cpp.

References CHECK_LE.

                                                                                   {
   createTableFileMgrIfNoneExists(db, tb);
   auto wrapper_size = doc.size();
   CHECK_LE(wrapper_size, getMaxWrapperSize())
       << "Wrapper is too big to fit into the cache";
   while (wrapper_size > getAvailableWrapperSpace()) {
     evictMetadataPages();
   }
   heavyai::shared_lock<heavyai::shared_mutex> read_lock(table_dirs_mutex_);
   table_dirs_.at({db, tb})->writeWrapperFile(doc);
 }

Member Data Documentation

LRUEvictionAlgorithm File_Namespace::CachingFileMgr::chunk_evict_alg_

mutableprivate

Definition at line 512 of file CachingFileMgr.h.

Referenced by dump(), and dumpEvictionQueue().

std::optional<size_t> File_Namespace::CachingFileMgr::limit_data_size_ {}

private

Definition at line 510 of file CachingFileMgr.h.

Referenced by setDataSizeLimit().

size_t File_Namespace::CachingFileMgr::max_num_data_files_

private

Definition at line 506 of file CachingFileMgr.h.

Referenced by getMaxDataFiles(), and setMaxNumDataFiles().

size_t File_Namespace::CachingFileMgr::max_num_meta_files_

private

Definition at line 507 of file CachingFileMgr.h.

Referenced by getMaxMetaFiles(), and setMaxNumMetadataFiles().

size_t File_Namespace::CachingFileMgr::max_size_

private

Definition at line 509 of file CachingFileMgr.h.

Referenced by CachingFileMgr(), getAvailableSpace(), and getMaxSize().

size_t File_Namespace::CachingFileMgr::max_wrapper_space_

private

Definition at line 508 of file CachingFileMgr.h.

Referenced by getAvailableWrapperSpace(), getMaxWrapperSize(), and setMaxWrapperSpace().

constexpr float File_Namespace::CachingFileMgr::METADATA_FILE_SPACE_PERCENTAGE {0.01}

static

Definition at line 186 of file CachingFileMgr.h.

Referenced by getMinimumSize().

constexpr float File_Namespace::CachingFileMgr::METADATA_SPACE_PERCENTAGE {0.1}

static

Definition at line 184 of file CachingFileMgr.h.

std::map<TablePair, std::unique_ptr<TableFileMgr> > File_Namespace::CachingFileMgr::table_dirs_

private

Definition at line 504 of file CachingFileMgr.h.

Referenced by checkpoint(), closeRemovePhysical(), epoch(), getTableFileMgrSpaceReserved(), incrementEpoch(), readTableFileMgrs(), and writeAndSyncEpochToDisk().

heavyai::shared_mutex File_Namespace::CachingFileMgr::table_dirs_mutex_

mutableprivate

Definition at line 500 of file CachingFileMgr.h.

Referenced by checkpoint(), closeRemovePhysical(), epoch(), getTableFileMgrSpaceReserved(), incrementEpoch(), readTableFileMgrs(), and writeAndSyncEpochToDisk().

LRUEvictionAlgorithm File_Namespace::CachingFileMgr::table_evict_alg_

mutableprivate

Definition at line 513 of file CachingFileMgr.h.

Referenced by dump(), and dumpTableQueue().

constexpr char File_Namespace::CachingFileMgr::WRAPPER_FILE_NAME[] = "wrapper_metadata.json"

static

Definition at line 180 of file CachingFileMgr.h.

Referenced by foreign_storage::ForeignStorageCache::getSerializedWrapperPath().

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

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

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation