double_write_buffer.h

/* Copyright (c) 2021 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 Wenbin1002 on 2024/04/16
//
 
#pragma once
 
#include "common/lang/mutex.h"
#include "common/lang/unordered_map.h"
#include "common/types.h"
#include "common/sys/rc.h"
#include "storage/buffer/page.h"
 
class DiskBufferPool;
struct DoubleWritePage;
class BufferPoolManager;
 
class DoubleWriteBuffer
{
public:
  DoubleWriteBuffer()          = default;
  virtual ~DoubleWriteBuffer() = default;
 
  virtual RC add_page(DiskBufferPool *bp, PageNum page_num, Page &page) = 0;
 
  virtual RC read_page(DiskBufferPool *bp, PageNum page_num, Page &page) = 0;
 
  virtual RC clear_pages(DiskBufferPool *bp) = 0;
};
 
struct DoubleWriteBufferHeader
{
  int32_t page_cnt = 0;
 
  static const int32_t SIZE;
};
 
// TODO change to FrameId
struct DoubleWritePageKey
{
  int32_t buffer_pool_id;
  PageNum page_num;
 
  bool operator==(const DoubleWritePageKey &other) const
  {
    return buffer_pool_id == other.buffer_pool_id && page_num == other.page_num;
  }
};
 
struct DoubleWritePageKeyHash
{
  size_t operator()(const DoubleWritePageKey &key) const
  {
    return hash<int32_t>()(key.buffer_pool_id) ^ hash<PageNum>()(key.page_num);
  }
};
 
class DiskDoubleWriteBuffer : public DoubleWriteBuffer
{
public:
  DiskDoubleWriteBuffer(BufferPoolManager &bp_manager, int max_pages = 16);
  virtual ~DiskDoubleWriteBuffer();
 
  RC open_file(const char *filename);
 
  RC flush_page();
 
  RC add_page(DiskBufferPool *bp, PageNum page_num, Page &page) override;
 
  RC read_page(DiskBufferPool *bp, PageNum page_num, Page &page) override;
 
  RC clear_pages(DiskBufferPool *bp) override;
 
  RC recover();
 
private:
  RC write_page(DoubleWritePage *page);
 
  RC write_page_internal(DoubleWritePage *page);
 
  RC load_pages();
 
private:
  int                     file_desc_ = -1;
  int                     max_pages_ = 0;
  common::Mutex           lock_;
  BufferPoolManager      &bp_manager_;
  DoubleWriteBufferHeader header_;
 
  unordered_map<DoubleWritePageKey, DoubleWritePage *, DoubleWritePageKeyHash> dblwr_pages_;
};
 
class VacuousDoubleWriteBuffer : public DoubleWriteBuffer
{
public:
  virtual ~VacuousDoubleWriteBuffer() = default;
 
  RC add_page(DiskBufferPool *bp, PageNum page_num, Page &page) override;
 
  RC read_page(DiskBufferPool *bp, PageNum page_num, Page &page) override { return RC::BUFFERPOOL_INVALID_PAGE_NUM; }
 
  RC clear_pages(DiskBufferPool *bp) override { return RC::SUCCESS; }
};