disk_buffer_pool.h

/* Copyright (c) 2021 Xie Meiyi(xiemeiyi@hust.edu.cn) and OceanBase and/or its affiliates. All rights reserved.
miniob is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
         http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
See the Mulan PSL v2 for more details. */
 
//
// Created by Meiyi & Longda on 2021/4/13.
//
#pragma once
 
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <string>
#include <mutex>
#include <unordered_map>
#include <functional>
 
#include "common/rc.h"
#include "common/types.h"
#include "common/lang/mutex.h"
#include "common/mm/mem_pool.h"
#include "common/lang/lru_cache.h"
#include "common/lang/lruk_cache.h"
#include "common/lang/bitmap.h"
#include "storage/buffer/page.h"
#include "storage/buffer/frame.h"
 
class BufferPoolManager;
class DiskBufferPool;
 
#define BP_FILE_SUB_HDR_SIZE (sizeof(BPFileSubHeader))
 
struct BPFileHeader 
{
  int32_t page_count;       
  int32_t allocated_pages;  
  char bitmap[0];           
 
  static const int MAX_PAGE_NUM = (BP_PAGE_DATA_SIZE - sizeof(page_count) - sizeof(allocated_pages)) * 8;
 
  std::string to_string() const;
};
 
class BPFrameManager 
{
public:
  BPFrameManager(const char *tag);
 
  RC init(int pool_num);
  RC cleanup();
 
  Frame *get(int file_desc, PageNum page_num);
 
  std::list<Frame *> find_list(int file_desc);
 
  Frame *alloc(int file_desc, PageNum page_num);
 
  RC free(int file_desc, PageNum page_num, Frame *frame);
 
  int purge_frames(int count, std::function<RC(Frame *frame)> purger);
 
  size_t frame_num() const
  {
    return frames_.count();
  }
 
  size_t total_frame_num() const
  {
    return allocator_.get_size();
  }
 
private:
  Frame *get_internal(const FrameId &frame_id);
  RC     free_internal(const FrameId &frame_id, Frame *frame);
 
private:
  class BPFrameIdHasher {
  public:
    size_t operator()(const FrameId &frame_id) const
    {
      return frame_id.hash();
    }
  };
 
  using FrameLruCache = common::LruCache<FrameId, Frame *, BPFrameIdHasher>;
  using FrameAllocator = common::MemPoolSimple<Frame>;
 
  std::mutex lock_;
  FrameLruCache  frames_;
  FrameAllocator allocator_;
 
  // npu-exp: you can try this
  // using FrameLruKCache = common::LruKCache<2, FrameId, Frame *, BPFrameIdHasher>;
  // FrameKLruCache  frames_;
};
 
class BufferPoolIterator
{
public:
  BufferPoolIterator();
  ~BufferPoolIterator();
 
  RC init(DiskBufferPool &bp, PageNum start_page = 0);
  bool has_next();
  PageNum next();
  RC reset();
 
private:
  common::Bitmap bitmap_;
  PageNum current_page_num_ = -1;
};
 
class DiskBufferPool 
{
public:
  DiskBufferPool(BufferPoolManager &bp_manager, BPFrameManager &frame_manager);
  ~DiskBufferPool();
 
  RC create_file(const char *file_name);
 
  RC open_file(const char *file_name);
 
  RC close_file();
 
  RC get_this_page(PageNum page_num, Frame **frame);
 
  RC allocate_page(Frame **frame);
 
  RC dispose_page(PageNum page_num);
 
  RC purge_page(PageNum page_num);
  RC purge_all_pages();
 
  RC unpin_page(Frame *frame);
 
  RC check_all_pages_unpinned();
 
  int file_desc() const;
 
  RC flush_page(Frame &frame);
 
  RC flush_all_pages();
 
  RC recover_page(PageNum page_num);
 
protected:
  RC allocate_frame(PageNum page_num, Frame **buf);
 
  RC purge_frame(PageNum page_num, Frame *used_frame);
  RC check_page_num(PageNum page_num);
 
  RC load_page(PageNum page_num, Frame *frame);
 
  RC flush_page_internal(Frame &frame);
 
private:
  BufferPoolManager &  bp_manager_;
  BPFrameManager &     frame_manager_;
 
  std::string          file_name_;
  int                  file_desc_ = -1;
  Frame *              hdr_frame_ = nullptr;
  BPFileHeader *       file_header_ = nullptr;
  std::set<PageNum>    disposed_pages_;
 
  common::Mutex        lock_;
private:
  friend class BufferPoolIterator;
};
 
class BufferPoolManager 
{
public:
  BufferPoolManager(int memory_size = 0);
  ~BufferPoolManager();
 
  RC create_file(const char *file_name);
  RC open_file(const char *file_name, DiskBufferPool *&bp);
  RC close_file(const char *file_name);
 
  RC flush_page(Frame &frame);
 
public:
  static void set_instance(BufferPoolManager *bpm); // TODO 优化全局变量的表示方法
  static BufferPoolManager &instance();
 
private:
  BPFrameManager frame_manager_{"BufPool"};
 
  common::Mutex  lock_;
  std::unordered_map<std::string, DiskBufferPool *> buffer_pools_;
  std::unordered_map<int, DiskBufferPool *> fd_buffer_pools_;
};