FileInfo.h

Go to the documentation of this file.

/*
 * Copyright 2022 HEAVY.AI, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#pragma once

#include <cstdio>
#include <cstring>
#include <mutex>
#include <set>
#include <vector>

#ifdef __APPLE__
#include <fcntl.h>
#endif

#include "../../Shared/types.h"
#include "Logger/Logger.h"
#include "OSDependent/heavyai_fs.h"
#include "Page.h"
namespace File_Namespace {

struct Page;

constexpr int32_t DELETE_CONTINGENT = -1;
constexpr int32_t ROLLOFF_CONTINGENT = -2;

class FileMgr;
struct FileInfo {
  FileMgr* fileMgr;
  int32_t fileId;              
  FILE* f;                     
  size_t pageSize;             
  size_t numPages;             
  bool isDirty{false};         // True if writes have occured since last sync
  std::set<size_t> freePages;  
  mutable std::mutex freePagesMutex_;
  mutable std::mutex readWriteMutex_;

  FileInfo(FileMgr* fileMgr,
           const int32_t fileId,
           FILE* f,
           const size_t pageSize,
           const size_t numPages,
           const bool init = false);

  ~FileInfo();

  // for each apge
  void initNewFile();

  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;

  inline size_t size() const { return pageSize * numPages; }

  int32_t syncToDisk();

  inline size_t available() const { return numFreePages() * pageSize; }

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

  inline std::set<size_t> getFreePages() const {
    std::lock_guard<std::mutex> lock(freePagesMutex_);
    return freePages;
  }

  inline size_t used() const { return size() - available(); }

  void freePageImmediate(int32_t page_num);
  void recoverPage(const ChunkKey& chunk_key, int32_t page_num);
};

bool is_page_deleted_with_checkpoint(int32_t table_epoch,
                                     int32_t page_epoch,
                                     int32_t contingent);

bool is_page_deleted_without_checkpoint(int32_t table_epoch,
                                        int32_t page_epoch,
                                        int32_t contingent);

}  // namespace File_Namespace