FileInfo.h

Go to the documentation of this file.

/*
 * Copyright 2017 MapD Technologies, 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/omnisci_fs.h"
#include "Page.h"
extern bool g_read_only;
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;  
  std::mutex freePagesMutex_;
  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);
  void print(bool pagesummary);

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

  int32_t syncToDisk();

  inline size_t available() { return freePages.size() * pageSize; }

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

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

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

}  // namespace File_Namespace