refactor(p2): use page guard in B+ tree (#502)

* one change

* root page and page guard

* clang tidy doesn't work

* wip

* test

* base code changes mostly done

* chi changes

* whoops

* kill newline

* changed tests

* check lint

* change

* test

* test timeout

* timeout

* changing timeout

* mirror commit

* changes

* changes

Author: abigalekim

build_support/run_clang_tidy.py

@@ -79,7 +79,6 @@ def make_absolute(f, directory):
 def supports_color():
     """
     Modified from https://github.com/django/django/blob/main/django/core/management/color.py
-
     Return True if the running system's terminal supports color,
     and False otherwise.
     """
@@ -425,3 +424,4 @@ def update_progress(current_file, num_files):
 
 if __name__ == '__main__':
     main()
+    

src/include/storage/index/b_plus_tree.h

@@ -8,87 +8,118 @@
 // Copyright (c) 2018, Carnegie Mellon University Database Group
 //
 //===----------------------------------------------------------------------===//
+/**
+ * b_plus_tree.h
+ *
+ * Implementation of simple b+ tree data structure where internal pages direct
+ * the search and leaf pages contain actual data.
+ * (1) We only support unique key
+ * (2) support insert & remove
+ * (3) The structure should shrink and grow dynamically
+ * (4) Implement index iterator for range scan
+ */
 #pragma once
 
+#include <algorithm>
+#include <deque>
+#include <optional>
 #include <queue>
-#include <string>
+#include <shared_mutex>
 #include <vector>
 
+#include "common/config.h"
+#include "common/macros.h"
 #include "concurrency/transaction.h"
 #include "storage/index/index_iterator.h"
 #include "storage/page/b_plus_tree_internal_page.h"
 #include "storage/page/b_plus_tree_leaf_page.h"
+#include "storage/page/b_plus_tree_root_page.h"
+#include "storage/page/page_guard.h"
 
 namespace bustub {
 
-#define BPLUSTREE_TYPE BPlusTree<KeyType, ValueType, KeyComparator>
-
 /**
- * Main class providing the API for the Interactive B+ Tree.
+ * @brief Definition of the Context class.
  *
- * Implementation of simple b+ tree data structure where internal pages direct
- * the search and leaf pages contain actual data.
- * (1) We only support unique key
- * (2) support insert & remove
- * (3) The structure should shrink and grow dynamically
- * (4) Implement index iterator for range scan
+ * Hint: This class is designed to help you keep track of the pages
+ * that you're modifying or accessing.
  */
+class Context {
+ public:
+  std::optional<WritePageGuard> header_page_{std::nullopt};
+  page_id_t root_page_id_{INVALID_PAGE_ID};
+  std::deque<WritePageGuard> write_set_;
+  std::deque<ReadPageGuard> read_set_;
+
+  auto IsRootPage(page_id_t page_id) -> bool { return page_id == root_page_id_; }
+};
+
+#define BPLUSTREE_TYPE BPlusTree<KeyType, ValueType, KeyComparator>
+// Main class providing the API for the Interactive B+ Tree.
 INDEX_TEMPLATE_ARGUMENTS
 class BPlusTree {
   using InternalPage = BPlusTreeInternalPage<KeyType, page_id_t, KeyComparator>;
   using LeafPage = BPlusTreeLeafPage<KeyType, ValueType, KeyComparator>;
 
  public:
-  explicit BPlusTree(std::string name, BufferPoolManager *buffer_pool_manager, const KeyComparator &comparator,
-                     int leaf_max_size = LEAF_PAGE_SIZE, int internal_max_size = INTERNAL_PAGE_SIZE);
+  explicit BPlusTree(std::string name, page_id_t header_page_id, BufferPoolManager *buffer_pool_manager,
+                     const KeyComparator &comparator, int leaf_max_size = LEAF_PAGE_SIZE,
+                     int internal_max_size = INTERNAL_PAGE_SIZE);
 
   // Returns true if this B+ tree has no keys and values.
   auto IsEmpty() const -> bool;
 
   // Insert a key-value pair into this B+ tree.
-  auto Insert(const KeyType &key, const ValueType &value, Transaction *transaction = nullptr) -> bool;
+  auto Insert(const KeyType &key, const ValueType &value, Transaction *txn = nullptr) -> bool;
 
   // Remove a key and its value from this B+ tree.
-  void Remove(const KeyType &key, Transaction *transaction = nullptr);
+  void Remove(const KeyType &key, Transaction *txn);
 
-  // return the value associated with a given key
-  auto GetValue(const KeyType &key, std::vector<ValueType> *result, Transaction *transaction = nullptr) -> bool;
+  // Return the value associated with a given key
+  auto GetValue(const KeyType &key, std::vector<ValueType> *result, Transaction *txn = nullptr) -> bool;
 
-  // return the page id of the root node
+  // Return the page id of the root node
   auto GetRootPageId() -> page_id_t;
 
-  // index iterator
+  // Index iterator
   auto Begin() -> INDEXITERATOR_TYPE;
-  auto Begin(const KeyType &key) -> INDEXITERATOR_TYPE;
+
   auto End() -> INDEXITERATOR_TYPE;
 
-  // print the B+ tree
+  auto Begin(const KeyType &key) -> INDEXITERATOR_TYPE;
+
+  // Print the B+ tree
   void Print(BufferPoolManager *bpm);
 
-  // draw the B+ tree
+  // Draw the B+ tree
   void Draw(BufferPoolManager *bpm, const std::string &outf);
 
   // read data from file and insert one by one
-  void InsertFromFile(const std::string &file_name, Transaction *transaction = nullptr);
+  void InsertFromFile(const std::string &file_name, Transaction *txn = nullptr);
 
   // read data from file and remove one by one
-  void RemoveFromFile(const std::string &file_name, Transaction *transaction = nullptr);
+  void RemoveFromFile(const std::string &file_name, Transaction *txn = nullptr);
 
  private:
-  void UpdateRootPageId(int insert_record = 0);
-
   /* Debug Routines for FREE!! */
-  void ToGraph(BPlusTreePage *page, BufferPoolManager *bpm, std::ofstream &out) const;
+  void ToGraph(page_id_t page_id, const BPlusTreePage *page, std::ofstream &out);
+
+  void PrintTree(page_id_t page_id, const BPlusTreePage *page);
 
-  void ToString(BPlusTreePage *page, BufferPoolManager *bpm) const;
+  void Dump() {
+    for (auto &f : log) {
+      std::cout << f << std::endl;
+    }
+  }
 
   // member variable
   std::string index_name_;
-  page_id_t root_page_id_;
-  BufferPoolManager *buffer_pool_manager_;
+  BufferPoolManager *bpm_;
   KeyComparator comparator_;
+  std::vector<std::string> log;  // NOLINT
   int leaf_max_size_;
   int internal_max_size_;
+  page_id_t header_page_id_;
 };
 
 }  // namespace bustub

src/include/storage/index/b_plus_tree_index.h

@@ -45,7 +45,7 @@ class BPlusTreeIndex : public Index {
   // comparator for key
   KeyComparator comparator_;
   // container
-  BPlusTree<KeyType, ValueType, KeyComparator> container_;
+  std::shared_ptr<BPlusTree<KeyType, ValueType, KeyComparator>> container_;
 };
 
 /** We only support index table with one integer key for now in BusTub. Hardcode everything here. */

src/include/storage/page/b_plus_tree_root_page.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include "common/config.h"
+namespace bustub {
+
+class BPlusTreeRootPage {
+ public:
+  // Delete all constructor / destructor to ensure memory safety
+  BPlusTreeRootPage() = delete;
+  BPlusTreeRootPage(const BPlusTreeRootPage &other) = delete;
+
+  page_id_t root_page_id_;
+};
+
+}  // namespace bustub

src/include/storage/table/table_iterator.h

@@ -37,7 +37,7 @@ class TableIterator {
   ~TableIterator() { delete tuple_; }
 
   inline auto operator==(const TableIterator &itr) const -> bool {
-    return tuple_->rid_.Get() == itr.tuple_->rid_.Get();
+    return tuple_->GetRid().Get() == itr.tuple_->GetRid().Get();
   }
 
   inline auto operator!=(const TableIterator &itr) const -> bool { return !(*this == itr); }