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 <fcntl.h>
#include <functional>
#include <mutex>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <sys/stat.h>
#include <sys/types.h>
#include <time.h>
#include <optional>
 
#include "common/lang/bitmap.h"
#include "common/lang/lru_cache.h"
#include "common/lang/mutex.h"
#include "common/lang/memory.h"
#include "common/lang/unordered_map.h"
#include "common/mm/mem_pool.h"
#include "common/sys/rc.h"
#include "common/types.h"
#include "storage/buffer/frame.h"
#include "storage/buffer/page.h"
#include "storage/buffer/buffer_pool_log.h"
 
class BufferPoolManager;
class DiskBufferPool;
class DoubleWriteBuffer;
class LogHandler;
class BufferPoolLogHandler;
 
#define BP_FILE_SUB_HDR_SIZE (sizeof(BPFileSubHeader))
 
struct BPFileHeader
{
  int32_t buffer_pool_id;   
  int32_t page_count;       
  int32_t allocated_pages;  
  char    bitmap[0];        
 
  static const int MAX_PAGE_NUM =
      (BP_PAGE_DATA_SIZE - sizeof(buffer_pool_id) - sizeof(page_count) - sizeof(allocated_pages)) * 8;
 
  string to_string() const;
};
 
class BPFrameManager
{
public:
  BPFrameManager(const char *tag);
 
  RC init(int pool_num);
  RC cleanup();
 
  Frame *get(int buffer_pool_id, PageNum page_num);
 
  list<Frame *> find_list(int buffer_pool_id);
 
  Frame *alloc(int buffer_pool_id, PageNum page_num);
 
  RC free(int buffer_pool_id, PageNum page_num, Frame *frame);
 
  int purge_frames(int count, 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>;
 
  mutex          lock_;
  FrameLruCache  frames_;
  FrameAllocator allocator_;
};
 
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 final
{
public:
  DiskBufferPool(BufferPoolManager &bp_manager, BPFrameManager &frame_manager, DoubleWriteBuffer &dblwr_manager,
      LogHandler &log_handler);
  ~DiskBufferPool();
 
  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);
 
  RC write_page(PageNum page_num, Page &page);
 
  RC redo_allocate_page(LSN lsn, PageNum page_num);
  RC redo_deallocate_page(LSN lsn, PageNum page_num);
 
public:
  int32_t id() const { return buffer_pool_id_; }
 
  const char *filename() const { return file_name_.c_str(); }
 
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_;  
  DoubleWriteBuffer   &dblwr_manager_;  
  BufferPoolLogHandler log_handler_;    
 
  int file_desc_ = -1;  
  int32_t       buffer_pool_id_ = -1;
  Frame        *hdr_frame_      = nullptr;  
  BPFileHeader *file_header_    = nullptr;  
  set<PageNum>  disposed_pages_;            
 
  string file_name_;  
 
  common::Mutex lock_;
  common::Mutex wr_lock_;
 
private:
  friend class BufferPoolIterator;
};
 
class BufferPoolManager final
{
public:
  BufferPoolManager(int memory_size = 0);
  ~BufferPoolManager();
 
  RC init(unique_ptr<DoubleWriteBuffer> dblwr_buffer);
 
  RC create_file(const char *file_name);
  RC open_file(LogHandler &log_handler, const char *file_name, DiskBufferPool *&bp);
  RC close_file(const char *file_name);
 
  RC flush_page(Frame &frame);
 
  BPFrameManager    &get_frame_manager() { return frame_manager_; }
  DoubleWriteBuffer *get_dblwr_buffer() { return dblwr_buffer_.get(); }
 
  RC get_buffer_pool(int32_t id, DiskBufferPool *&bp);
 
private:
  BPFrameManager frame_manager_{"BufPool"};
 
  unique_ptr<DoubleWriteBuffer> dblwr_buffer_;
 
  common::Mutex                            lock_;
  unordered_map<string, DiskBufferPool *>  buffer_pools_;
  unordered_map<int32_t, DiskBufferPool *> id_to_buffer_pools_;
  atomic<int32_t>                          next_buffer_pool_id_{1};  // 系统启动时，会打开所有的表，这样就可以知道当前系统最大的ID是多少了
};