#include <FileInfo.h>

Collaboration diagram for File_Namespace::FileInfo:

Public Member Functions
	FileInfo (FileMgr fileMgr, const int32_t fileId, FILE f, const size_t pageSize, const size_t numPages, const std::string &file_path, const bool init=false)
	Constructor. More...

	~FileInfo ()
	Destructor. More...

void	initNewFile ()
	Adds all pages to freePages and zeroes first four bytes of header. More...

void	freePageDeferred (int32_t pageId)

void	freePage (int32_t pageId, const bool isRolloff, int32_t epoch)

int32_t	getFreePage ()

size_t	write (const size_t offset, const size_t size, const int8_t *buf)

size_t	read (const size_t offset, const size_t size, int8_t *buf)

void	openExistingFile (std::vector< HeaderInfo > &headerVec)

std::string	print () const
	Prints a summary of the file to stdout. More...

size_t	size () const
	Returns the number of bytes used by the file. More...

int32_t	syncToDisk ()

size_t	available () const
	Returns the number of free bytes available. More...

size_t	numFreePages () const
	Returns the number of free pages available. More...

std::set< size_t >	getFreePages () const

size_t	used () const
	Returns the amount of used bytes; size() - available() More...

void	freePageImmediate (int32_t page_num)

void	recoverPage (const ChunkKey &chunk_key, int32_t page_num)

Public Attributes
FileMgr *	fileMgr

int32_t	fileId

FILE *	f
	unique file identifier (i.e., used for a file name) More...

size_t	pageSize
	file stream object for the represented file More...

size_t	numPages
	the fixed size of each page in the file More...

bool	isDirty {false}
	the number of pages in the file More...

std::set< size_t >	freePages

std::string	file_path
	set of page numbers of free pages More...

std::mutex	freePagesMutex_

std::mutex	readWriteMutex_

Detailed Description

Definition at line 55 of file FileInfo.h.

Constructor & Destructor Documentation

File_Namespace::FileInfo::FileInfo	(	FileMgr *	fileMgr,
		const int32_t	fileId,
		FILE *	f,
		const size_t	pageSize,
		const size_t	numPages,
		const std::string &	file_path,
		const bool	init = `false`
	)

Constructor.

Definition at line 31 of file FileInfo.cpp.

References initNewFile().

     : fileMgr(fileMgr)
     , fileId(fileId)
     , f(f)
     , pageSize(pageSize)
     , numPages(numPages)
     , file_path(file_path) {
   if (init) {
     initNewFile();
   }
 }

Here is the call graph for this function:

File_Namespace::FileInfo::~FileInfo ( )

Destructor.

Definition at line 49 of file FileInfo.cpp.

References File_Namespace::close(), and f.

                     {
   // close file, if applicable
   if (f) {
     close(f);
   }
 }

Here is the call graph for this function:

Member Function Documentation

size_t File_Namespace::FileInfo::available ( ) const

inline

Returns the number of free bytes available.

Definition at line 102 of file FileInfo.h.

References numFreePages(), and pageSize.

Referenced by print(), and used().

102 { return numFreePages() * pageSize; }

File_Namespace::FileInfo::numFreePages

size_t numFreePages() const

Returns the number of free pages available.

Definition: FileInfo.h:105

File_Namespace::FileInfo::pageSize

size_t pageSize

file stream object for the represented file

Definition: FileInfo.h:59

Here is the call graph for this function:

Here is the caller graph for this function:

void File_Namespace::FileInfo::freePage	(	int32_t	pageId,
		const bool	isRolloff,
		int32_t	epoch
	)

Definition at line 191 of file FileInfo.cpp.

References CHECK, File_Namespace::DELETE_CONTINGENT, f, fileMgr, File_Namespace::FileMgr::free_page(), isDirty, pageSize, readWriteMutex_, File_Namespace::ROLLOFF_CONTINGENT, and File_Namespace::write().

Referenced by File_Namespace::FileBuffer::freePage(), and File_Namespace::CachingFileMgr::updatePageIfDeleted().

                                                                        {
   std::lock_guard<std::mutex> lock(readWriteMutex_);
   int32_t epoch_freed_page[2] = {DELETE_CONTINGENT, epoch};
   if (isRolloff) {
     epoch_freed_page[0] = ROLLOFF_CONTINGENT;
   }
   File_Namespace::write(f,
                         pageId * pageSize + sizeof(int32_t),
                         sizeof(epoch_freed_page),
                         reinterpret_cast<const int8_t*>(epoch_freed_page));
   fileMgr->free_page(std::make_pair(this, pageId));
   isDirty = true;
 
 #ifdef ENABLE_CRASH_CORRUPTION_TEST
   signal(SIGUSR2, sighandler);
   if (goto_crash)
     CHECK(pageId % 8 != 4);
 #endif
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void File_Namespace::FileInfo::freePageDeferred ( int32_t pageId )

Definition at line 176 of file FileInfo.cpp.

References freePages, and freePagesMutex_.

Referenced by freePageImmediate().

                                               {
   std::lock_guard<std::mutex> lock(freePagesMutex_);
   freePages.insert(pageId);
 }

Here is the caller graph for this function:

void File_Namespace::FileInfo::freePageImmediate ( int32_t page_num )

Definition at line 252 of file FileInfo.cpp.

References f, freePageDeferred(), g_multi_instance, g_read_only, pageSize, and File_Namespace::write().

Referenced by openExistingFile(), and File_Namespace::FileMgr::updatePageIfDeleted().

                                                  {
   // we should not get here but putting protection in place
   // as it seems we are no guaranteed to have f/synced so
   // protecting from RO trying to write
   if (!g_read_only && !g_multi_instance) {
     int32_t zero{0};
     File_Namespace::write(
         f, page_num * pageSize, sizeof(int32_t), reinterpret_cast<const int8_t*>(&zero));
     freePageDeferred(page_num);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int32_t File_Namespace::FileInfo::getFreePage ( )

Definition at line 211 of file FileInfo.cpp.

References freePages, and freePagesMutex_.

Referenced by File_Namespace::FileMgr::copySourcePageForCompaction(), File_Namespace::FileMgr::requestFreePage(), File_Namespace::CachingFileMgr::requestFreePage(), and File_Namespace::FileMgr::requestFreePages().

                               {
   // returns -1 if there is no free page
   std::lock_guard<std::mutex> lock(freePagesMutex_);
   if (freePages.size() == 0) {
     return -1;
   }
   auto pageIt = freePages.begin();
   int32_t pageNum = *pageIt;
   freePages.erase(pageIt);
   return pageNum;
 }

Here is the caller graph for this function:

std::set<size_t> File_Namespace::FileInfo::getFreePages ( ) const

inline

Definition at line 110 of file FileInfo.h.

References freePages, and freePagesMutex_.

                                              {
     std::lock_guard<std::mutex> lock(freePagesMutex_);
     return freePages;
   }

void File_Namespace::FileInfo::initNewFile ( )

Adds all pages to freePages and zeroes first four bytes of header.

Definition at line 56 of file FileInfo.cpp.

References f, freePages, isDirty, numPages, pageSize, and File_Namespace::write().

Referenced by FileInfo().

                            {
   // initialize pages and free page list
   // Also zeroes out first four bytes of every header
 
   int32_t headerSize = 0;
   int8_t* headerSizePtr = (int8_t*)(&headerSize);
   for (size_t pageId = 0; pageId < numPages; ++pageId) {
     File_Namespace::write(f, pageId * pageSize, sizeof(int32_t), headerSizePtr);
     freePages.insert(pageId);
   }
   isDirty = true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

size_t File_Namespace::FileInfo::numFreePages ( ) const

inline

Returns the number of free pages available.

Definition at line 105 of file FileInfo.h.

References freePages, and freePagesMutex_.

Referenced by available().

                                      {
     std::lock_guard<std::mutex> lock(freePagesMutex_);
     return freePages.size();
   }

Here is the caller graph for this function:

void File_Namespace::FileInfo::openExistingFile ( std::vector< HeaderInfo > & headerVec )

Definition at line 80 of file FileInfo.cpp.

References CHECK_EQ, CHECK_GE, CHUNK_KEY_DB_IDX, CHUNK_KEY_TABLE_IDX, File_Namespace::FileMgr::epoch(), f, fileId, fileMgr, freePageImmediate(), freePages, g_multi_instance, g_read_only, LOG, numPages, pageSize, show_chunk(), File_Namespace::FileMgr::updatePageIfDeleted(), VLOG, and logger::WARNING.

Referenced by File_Namespace::FileMgr::openExistingFile().

                                                                 {
   // HeaderInfo is defined in Page.h
 
   // Oct 2020: Changing semantics such that fileMgrEpoch should be last checkpointed
   // epoch, not incremented epoch. This changes some of the gt/gte/lt/lte comparison below
   ChunkKey oldChunkKey(4);
   int32_t oldPageId = -99;
   int32_t oldVersionEpoch = -99;
   int32_t skipped = 0;
   for (size_t pageNum = 0; pageNum < numPages; ++pageNum) {
     // TODO(Misiu): It would be nice to replace this array with a struct that would
     // clarify what is being read and have a single definition (currently this code is
     // replicated in TableArchiver and possibly elsewhere).
     constexpr size_t MAX_INTS_TO_READ{10};  // currently use 1+6 ints
     int32_t ints[MAX_INTS_TO_READ];
     CHECK_EQ(fseek(f, pageNum * pageSize, SEEK_SET), 0);
     CHECK_EQ(fread(ints, sizeof(int32_t), MAX_INTS_TO_READ, f), MAX_INTS_TO_READ);
 
     auto headerSize = ints[0];
     if (headerSize == 0) {
       // no header for this page - insert into free list
       freePages.insert(pageNum);
       continue;
     }
 
     // headerSize doesn't include headerSize itself
     // We're tying ourself to headers of ints here
     size_t numHeaderElems = headerSize / sizeof(int32_t);
     CHECK_GE(numHeaderElems, size_t(2));
     // We don't want to read headerSize in our header - so start
     // reading 4 bytes past it
     ChunkKey chunkKey(&ints[1], &ints[1 + numHeaderElems - 2]);
     if (fileMgr->updatePageIfDeleted(this, chunkKey, ints[1], ints[2], pageNum)) {
       continue;
     }
     // Last two elements of header are always PageId and Version
     // epoch - these are not in the chunk key so seperate them
     int32_t pageId = ints[1 + numHeaderElems - 2];
     int32_t versionEpoch = ints[1 + numHeaderElems - 1];
     if (chunkKey != oldChunkKey || oldPageId != pageId - (1 + skipped)) {
       if (skipped > 0) {
         VLOG(4) << "FId.PSz: " << fileId << "." << pageSize
                 << " Chunk key: " << show_chunk(oldChunkKey)
                 << " Page id from : " << oldPageId << " to : " << oldPageId + skipped
                 << " Epoch: " << oldVersionEpoch;
       } else if (oldPageId != -99) {
         VLOG(4) << "FId.PSz: " << fileId << "." << pageSize
                 << " Chunk key: " << show_chunk(oldChunkKey) << " Page id: " << oldPageId
                 << " Epoch: " << oldVersionEpoch;
       }
       oldPageId = pageId;
       oldVersionEpoch = versionEpoch;
       oldChunkKey = chunkKey;
       skipped = 0;
     } else {
       skipped++;
     }
 
     /* Check if version epoch is equal to
      * or greater (note: should never be greater)
      * than FileMgr epoch_ - this means that this
      * page wasn't checkpointed and thus we should
      * not use it
      */
     int32_t fileMgrEpoch =
         fileMgr->epoch(chunkKey[CHUNK_KEY_DB_IDX], chunkKey[CHUNK_KEY_TABLE_IDX]);
     if (versionEpoch > fileMgrEpoch) {
       // First write 0 to first four bytes of
       // header to mark as free
       if (!g_read_only && !g_multi_instance) {
         // TODO(sy): Confirm that proper locking is held before writing here.
         freePageImmediate(pageNum);
         LOG(WARNING) << "Was not checkpointed: Chunk key: " << show_chunk(chunkKey)
                      << " Page id: " << pageId << " Epoch: " << versionEpoch
                      << " FileMgrEpoch " << fileMgrEpoch << endl;
       }
     } else {  // page was checkpointed properly
       Page page(fileId, pageNum);
       headerVec.emplace_back(chunkKey, pageId, versionEpoch, page);
     }
   }
   // printlast
   if (oldPageId != -99) {
     if (skipped > 0) {
       VLOG(4) << "FId.PSz: " << fileId << "." << pageSize
               << " Chunk key: " << show_chunk(oldChunkKey)
               << " Page id from : " << oldPageId << " to : " << oldPageId + skipped
               << " Epoch: " << oldVersionEpoch;
     } else {
       VLOG(4) << "FId.PSz: " << fileId << "." << pageSize
               << " Chunk key: " << show_chunk(oldChunkKey) << " Page id: " << oldPageId
               << " Epoch: " << oldVersionEpoch;
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string File_Namespace::FileInfo::print ( ) const

Prints a summary of the file to stdout.

Definition at line 223 of file FileInfo.cpp.

References available(), fileId, size(), and used().

                                 {
   std::stringstream ss;
   ss << "File: " << fileId << std::endl;
   ss << "Size: " << size() << std::endl;
   ss << "Used: " << used() << std::endl;
   ss << "Free: " << available() << std::endl;
   return ss.str();
 }

Here is the call graph for this function:

size_t File_Namespace::FileInfo::read	(	const size_t	offset,
		const size_t	size,
		int8_t *	buf
	)

Definition at line 75 of file FileInfo.cpp.

References f, file_path, File_Namespace::read(), and readWriteMutex_.

Referenced by File_Namespace::FileBuffer::copyPage(), File_Namespace::FileMgr::copyPage(), File_Namespace::FileMgr::copyPageWithoutHeaderSize(), and File_Namespace::readForThread().

                                                                          {
   std::lock_guard<std::mutex> lock(readWriteMutex_);
   return File_Namespace::read(f, offset, size, buf, file_path);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void File_Namespace::FileInfo::recoverPage	(	const ChunkKey &	chunk_key,
		int32_t	page_num
	)

Definition at line 265 of file FileInfo.cpp.

References f, g_multi_instance, g_read_only, pageSize, and File_Namespace::write().

Referenced by File_Namespace::FileMgr::updatePageIfDeleted().

                                                                       {
   // we should not get here but putting protection in place
   // as it seems we are no guaranteed to have f/synced so
   // protecting from RO trying to write
   if (!g_read_only && !g_multi_instance) {
     File_Namespace::write(f,
                           page_num * pageSize + sizeof(int32_t),
                           2 * sizeof(int32_t),
                           reinterpret_cast<const int8_t*>(chunk_key.data()));
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

size_t File_Namespace::FileInfo::size ( ) const

inline

Returns the number of bytes used by the file.

Definition at line 95 of file FileInfo.h.

References numPages, and pageSize.

Referenced by print(), and used().

95 { return pageSize * numPages; }

File_Namespace::FileInfo::pageSize

size_t pageSize

file stream object for the represented file

Definition: FileInfo.h:59

File_Namespace::FileInfo::numPages

size_t numPages

the fixed size of each page in the file

Definition: FileInfo.h:60

Here is the caller graph for this function:

int32_t File_Namespace::FileInfo::syncToDisk ( )

Syncs file to disk via a buffer flush and then a sync (fflush and fsync on posix systems)

Definition at line 232 of file FileInfo.cpp.

References f, logger::FATAL, heavyai::fsync(), isDirty, LOG, and readWriteMutex_.

                              {
   std::lock_guard<std::mutex> lock(readWriteMutex_);
   if (isDirty) {
     if (fflush(f) != 0) {
       LOG(FATAL) << "Error trying to flush changes to disk, the error was: "
                  << std::strerror(errno);
     }
 #ifdef __APPLE__
     const int32_t sync_result = fcntl(fileno(f), 51);
 #else
     const int32_t sync_result = heavyai::fsync(fileno(f));
 #endif
     if (sync_result == 0) {
       isDirty = false;
     }
     return sync_result;
   }
   return 0;  // if file was not dirty and no syncing was needed
 }

Here is the call graph for this function:

size_t File_Namespace::FileInfo::used ( ) const

inline

Returns the amount of used bytes; size() - available()

Definition at line 116 of file FileInfo.h.

References available(), and size().

Referenced by print().

116 { return size() - available(); }

File_Namespace::FileInfo::size

size_t size() const

Returns the number of bytes used by the file.

Definition: FileInfo.h:95

File_Namespace::FileInfo::available

size_t available() const

Returns the number of free bytes available.

Definition: FileInfo.h:102

Here is the call graph for this function:

Here is the caller graph for this function:

size_t File_Namespace::FileInfo::write	(	const size_t	offset,
		const size_t	size,
		const int8_t *	buf
	)

Definition at line 69 of file FileInfo.cpp.

References f, isDirty, readWriteMutex_, and File_Namespace::write().

Referenced by File_Namespace::FileBuffer::append(), File_Namespace::FileBuffer::copyPage(), File_Namespace::FileMgr::copyPage(), File_Namespace::FileMgr::copyPageWithoutHeaderSize(), File_Namespace::FileBuffer::write(), and File_Namespace::FileBuffer::writeHeader().

                                                                                 {
   std::lock_guard<std::mutex> lock(readWriteMutex_);
   isDirty = true;
   return File_Namespace::write(f, offset, size, buf);
 }