frame.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 lianyu on 2022/10/29.
//
 
#pragma once
 
#include <pthread.h>
#include <string.h>
 
#include "common/lang/mutex.h"
#include "common/lang/string.h"
#include "common/lang/atomic.h"
#include "common/lang/unordered_map.h"
#include "common/log/log.h"
#include "common/types.h"
#include "storage/buffer/page.h"
 
class FrameId
{
public:
  FrameId() = default;
  FrameId(int buffer_pool_id, PageNum page_num);
  bool    equal_to(const FrameId &other) const;
  bool    operator==(const FrameId &other) const;
  size_t  hash() const;
  int     buffer_pool_id() const;
  PageNum page_num() const;
 
  void set_buffer_pool_id(int buffer_pool_id) { buffer_pool_id_ = buffer_pool_id; }
  void set_page_num(PageNum page_num) { page_num_ = page_num; }
 
  string to_string() const;
 
private:
  int     buffer_pool_id_ = -1;
  PageNum page_num_       = -1;
};
 
class Frame
{
public:
  ~Frame()
  {
    // LOG_DEBUG("deallocate frame. this=%p, lbt=%s", this, common::lbt());
  }
 
  void reinit() {}
  void reset() {}
 
  void clear_page() { memset(&page_, 0, sizeof(page_)); }
 
  int  buffer_pool_id() const { return frame_id_.buffer_pool_id(); }
  void set_buffer_pool_id(int id) { frame_id_.set_buffer_pool_id(id); }
 
  Page &page() { return page_; }
 
  PageNum page_num() const { return frame_id_.page_num(); }
  void    set_page_num(PageNum page_num) { frame_id_.set_page_num(page_num); }
  FrameId frame_id() const { return frame_id_; }
 
  LSN  lsn() const { return page_.lsn; }
  void set_lsn(LSN lsn) { page_.lsn = lsn; }
 
  CheckSum check_sum() const { return page_.check_sum; }
  void     set_check_sum(CheckSum check_sum) { page_.check_sum = check_sum; }
 
  void access();
 
  void mark_dirty() { dirty_ = true; }
 
  void clear_dirty() { dirty_ = false; }
  bool dirty() const { return dirty_; }
 
  char *data() { return page_.data; }
 
  bool can_purge() { return pin_count_.load() == 0; }
 
  void pin();
 
  int unpin();
  int pin_count() const { return pin_count_.load(); }
 
  void write_latch();
  void write_latch(intptr_t xid);
 
  void write_unlatch();
  void write_unlatch(intptr_t xid);
 
  void read_latch();
  void read_latch(intptr_t xid);
  bool try_read_latch();
 
  void read_unlatch();
  void read_unlatch(intptr_t xid);
 
  string to_string() const;
 
private:
  friend class BufferPool;
 
  bool          dirty_ = false;
  atomic<int>   pin_count_{0};
  unsigned long acc_time_ = 0;
  FrameId       frame_id_;
  Page          page_;
 
  common::RecursiveSharedMutex lock_;
 
  common::DebugMutex           debug_lock_;
  intptr_t                     write_locker_          = 0;
  int                          write_recursive_count_ = 0;
  unordered_map<intptr_t, int> read_lockers_;
};