FileManager.h

Go to the documentation of this file.

#ifndef STORAGE_FILEMANAGER_H
#define STORAGE_FILEMANAGER_H
 
#include "tdb.h"
 
#include <mutex>
 
#include "storage/BufferManager.h"
#include "storage/FSFile.h"
 
#include "utils/Latch.h"
 
namespace taco {
 
class PageHeaderData {
public:
    constexpr bool
    IsAllocated() const {
        return m_flags & (FLAG_META_PAGE | FLAG_VFILE_PAGE);
    }
 
    constexpr bool
    IsMetaPage() const {
        return m_flags & FLAG_META_PAGE;
    }
 
    constexpr bool
    IsVFilePage() const {
        return m_flags & FLAG_VFILE_PAGE;
    }
 
    constexpr bool
    IsFMMetaPage() const {
        return (m_flags & (FLAG_META_PAGE | FLAG_VFILE_PAGE)) ==
               FLAG_META_PAGE;
    }
 
    constexpr bool
    IsVFileMetaPage() const {
        return (m_flags & (FLAG_META_PAGE | FLAG_VFILE_PAGE)) ==
               (FLAG_META_PAGE | FLAG_VFILE_PAGE);
    }
 
    constexpr bool
    IsVFileDataPage() const {
        return (m_flags & (FLAG_META_PAGE | FLAG_VFILE_PAGE)) ==
               FLAG_VFILE_PAGE;
    }
 
    PageNumber
    GetNextPageNumber() const {
        return m_next_pid.load(memory_order_acquire);
    }
 
    PageNumber
    GetPrevPageNumber() const {
        return m_prev_pid.load(memory_order_relaxed);
    }
 
    constexpr FileId
    GetFileId() const {
        return m_fid;
    }
 
 
private:
    uint16_t            m_flags;
    uint16_t            m_reserved;
    FileId              m_fid;
    atomic<PageNumber>  m_prev_pid;
    atomic<PageNumber>  m_next_pid;
 
    static constexpr uint16_t FLAG_META_PAGE = 0x1;
    static constexpr uint16_t FLAG_VFILE_PAGE = 0x2;
 
    friend class FileManager;
    friend class File;
};
 
// We require PageHeaderData to be in standard-layout and trivial (for it's
// written to a disk page as binary), i.e., a POD prior to C++20.
static_assert(std::is_standard_layout<PageHeaderData>::value &&
              std::is_trivial<PageHeaderData>::value);
 
constexpr FileId WAL_FILEID_MASK = ((FileId) 1) << 31;
constexpr FileId TMP_FILEID_MASK = ((FileId) 1) << 30;
constexpr int FileIdBits = 19;
constexpr FileId MinRegularFileId = 1;
constexpr FileId MaxRegularFileId = (((FileId) 1) << (FileIdBits + 1)) - 1;
constexpr FileId INVALID_FID = 0;
 
 
constexpr FileId NEW_REGULAR_FID = INVALID_FID;
constexpr FileId NEW_TMP_FID = TMP_FILEID_MASK;
 
class FMMetaPageData;
class File;
class FreePageList;
class FileManager;
 
}   // namespace taco
 
// no namepsace for unmangled names, use taco_ prefix instead.
// The functions may be wrapped with --wrap flag to GNU ld in tests.
extern "C" {
 
void taco_fileman_readpage_impl(::taco::FileManager *fileman,
                                ::taco::PageNumber pid,
                                char *buf);
 
void __wrap_taco_fileman_readpage_impl(::taco::FileManager *fileman,
                                       ::taco::PageNumber pid,
                                       char *buf);
 
void __real_taco_fileman_readpage_impl(::taco::FileManager *fileman,
                                       ::taco::PageNumber pid,
                                       char *buf);
 
void taco_fileman_writepage_impl(::taco::FileManager *fileman,
                                 ::taco::PageNumber pid,
                                 const char *buf);
 
void __wrap_taco_fileman_writepage_impl(::taco::FileManager *fileman,
                                        ::taco::PageNumber pid,
                                        const char *buf);
 
void __real_taco_fileman_writepage_impl(::taco::FileManager *fileman,
                                        ::taco::PageNumber pid,
                                        const char *buf);
}
namespace taco {
class FileManager {
public:
    FileManager();
 
    ~FileManager();
 
    void CloseAll();
 
    void Init(std::string datadir, size_t init_size, bool create);
 
    std::unique_ptr<File> Open(FileId fid);
 
    inline void
    ReadPage(PageNumber pid, char *buf) {
        taco_fileman_readpage_impl(this, pid, buf);
    }
 
    inline void
    WritePage(PageNumber pid, const char *buf) {
        taco_fileman_writepage_impl(this, pid, buf);
    }
 
    void Flush();
 
    std::string GetMainDataFilePath(uint64_t DataFileId) const;
 
private:
    void FormatMeta();
 
    void LoadMeta();
 
    std::unique_ptr<File> CreateTmpFile();
 
    std::unique_ptr<File> OpenTmpFile(FileId fid);
 
    std::unique_ptr<File> CreateRegularFile();
 
    std::unique_ptr<File> OpenRegularFile(FileId fid);
 
    FileId FindFreeFileId();
 
    void AllocateL2FileDirectory(BufferId fdir1_bufid, size_t fdir1_off);
 
    PageNumber AllocatePageGroup();
 
    void InitFreePageList(FreePageList *fpl, PageNumber last_pg);
 
    PageNumber GetNextFreePageNumber(FreePageList *fpl, BufferId meta_bufid);
 
    void AddToFreePageList(FreePageList *fpl,
                           BufferId pg_bufid,
                           BufferId meta_bufid);
 
    std::mutex                                      m_fsfile_extension_latch;
 
    std::mutex                                      m_fdir1_latch;
 
    std::mutex                                      m_meta_latch;
 
    std::string                                     m_datadir;
 
    std::string                                     m_maindir;
 
    std::string                                     m_tmpdir;
 
    std::string                                     m_waldir;
 
    std::vector<std::unique_ptr<FSFile>>            m_mainfiles;
 
    FMMetaPageData                                  *m_meta;
 
    friend class File;
 
    friend void ::taco_fileman_readpage_impl(::taco::FileManager*,
                                             ::taco::PageNumber,
                                             char*);
    friend void ::taco_fileman_writepage_impl(::taco::FileManager*,
                                              ::taco::PageNumber,
                                              const char*);
    friend void ::__wrap_taco_fileman_readpage_impl(::taco::FileManager*,
                                                    ::taco::PageNumber,
                                                    char*);
    friend void ::__wrap_taco_fileman_writepage_impl(::taco::FileManager*,
                                                     ::taco::PageNumber,
                                                     const char*);
};
 
class File {
public:
    ~File();
 
    void Close();
 
    constexpr bool
    IsOpen() const noexcept {
        return m_fileid != INVALID_FID;
    }
 
    void ReadPage(PageNumber pid, char *buf) const;
 
    void WritePage(PageNumber pid, const char *buf);
 
    PageNumber
    AllocatePage() {
        return (PageNumber) AllocatePageImpl(false, LatchMode::SH);
    }
 
    BufferId
    AllocatePage(LatchMode mode) {
        return (BufferId) AllocatePageImpl(true, mode);
    }
 
    void FreePage(BufferId bufid);
 
    void FreePage(ScopedBufferId &bufid) {
        FreePage(bufid.Release());
    }
 
    PageNumber GetFirstPageNumber() const;
 
    PageNumber GetLastPageNumber() const;
 
    void Flush();
 
    constexpr FileId
    GetFileId() const {
        return m_fileid;
    }
 
    constexpr bool
    IsMainFile() const {
        return !(m_fileid & (WAL_FILEID_MASK | TMP_FILEID_MASK));
    }
 
    constexpr bool
    IsTmpFile() const {
        return m_fileid & TMP_FILEID_MASK;
    }
 
    constexpr bool
    IsWalFile() const {
        return m_fileid & WAL_FILEID_MASK;
    }
 
private:
    File():
        m_fileid(INVALID_FID),
        m_meta_pid(INVALID_PID),
        m_fsfile(nullptr) {}
 
    uint64_t AllocatePageImpl(bool need_latch, LatchMode mode);
 
    // state for all files
    FileId                      m_fileid;
 
    // state for main file
    PageNumber                  m_meta_pid;
 
    // alternative state for tmp file
    std::unique_ptr<FSFile>     m_fsfile;
 
    friend class FileManager;
};
 
}   // namespace taco
 
#endif      // STORAGE_FILEMANAGER_H