CMU15445 2024Spring 课程作业

Ding233333

已于 2024-07-09 19:36:53 修改

阅读量1k

点赞数 20

文章标签：数据库 database

于 2024-04-02 20:01:50 首次发布

本文链接：https://blog.csdn.net/qq_28625359/article/details/137108932

版权

关于运行环境与提交

运行环境可以阅读我的博客：

https://editor.csdn.net/md/?articleId=137051445

提交打分需要，首先去https://www.gradescope.com/注册一个账号，但是可悲的，我好像查不到 Spring 2024的课程邀请码，我翻遍了课程首页和ppt，也没能找到一个邀请码。如果有同学找到了或者有测试群，请务必拉我一下，感谢！

Does CMU 15-445/645 Spring 2024 has a Gradescope submission site
available to non-CMU students?

PROJECT #1 - BUFFER POOL

作业的详细描述原文如下：

https://15445.courses.cs.cmu.edu/spring2024/project1

整体上说，需要完成四个子任务：

LRU-K Replacement Policy
Disk Scheduler
Buffer Pool Manager
Read/Write Page Guards

四个子任务的实现顺序最好按照描述顺序依次进行，否则需要花费很多时间去阅读理解相关依赖代码。在项目代码中，每个子任务都提供了对应的自测用例，在完成作业后可以使用测试用例或者自己额外增加测试用例来完成验证。

Task #1 - LRU-K Replacement Policy

第一个任务是完成LRU-K缓存替换算法。

算法原理

简单地说就是，访问次数不足K次的块，替换最近访问时间最早的（退化为LRU算法）。访问次数大于等于K次的块，根据倒数第K次的访问时间与当前时间的距离作为其距离（替换权重），权重越大的越容易被替换。
比如K=2，5个块的访问时间历史如下，时间从1开始，当前时间为12：

块1：1
块2：2
块3：3、6、9、11
块4：4、7、
块5：5、8、10

由于访问次数不足K，块1与块2的LRU-K距离为正无穷（+inf）；块 3的距离为12-9=3；块4的距离为12-4=8；块5的距离为：12-8=4。
如果五个块均可以被替换，那么根据LRU-K算法，块1将最先被替换出去，接着被替换出去的是块2，然后依次是4、5、3。

完成思路

基本思路是双队列。cold队列存储那些访问次数不达K的frame_id，而hot队列存储访问次数达K的frame_id。如果某个frame在访问后次数达到了K，那么将其移动到hot队列中。

具体的实现不在此过多赘述。

测试

原测试用例
这里需要将第二个形参的前缀去除，修改后如下图：
启用测试用例
然后cd进入build文件夹，make后执行单测。

make lru_k_replacer_test j8
./test/lru_k_replacer_test

Task #2 - Disk Scheduler

完成思路

这个作业的任务是实现两个函数：

Schedule(DiskRequest r)
StartWorkerThread()

Schedule的作用是将一个磁盘读写请求添加到任务队列中，而StartWorkerThread的任务是启动一个不主动停止的磁盘读写任务处理线程，这个工作线程将被Scheduler保存，并在调用析构函数时传递一个std::nullopt的任务来停止。
在此基础上，任务并没有规定我们具体的任务调度算法是什么，操作系统中常用的任务调度算法有若干，下面列出一些常见的任务调度算法：

先来先服务 (FCFS)：按照任务提交的顺序进行调度，先提交的任务先执行，后提交的任务排队等待执行。FCFS 算法简单易实现，但可能导致长任务等待时间过长，造成资源利用不足和响应时间延迟。
最短作业优先 (SJF)：选择预计执行时间最短的任务优先执行。SJF 算法能够最大程度地减少平均等待时间，但可能会造成长任务长期等待短任务完成而无法执行。
最短剩余时间优先 (SRTF)：在 SJF 算法的基础上，动态调整任务的执行顺序，优先执行剩余执行时间最短的任务。SRTF 算法可以更加灵活地响应短任务的到来，但需要频繁地进行任务切换，增加了系统开销。
轮转调度 (Round Robin)：将任务按照提交顺序排成一个队列，每次选择队头任务执行一定时间片后，将其放到队尾等待下一次调度。轮转调度算法简单高效，能够保证每个任务都有机会执行，但可能导致长任务的响应时间较长。
多级反馈队列调度 (MFQ)：将任务分成多个队列，每个队列有不同的优先级，高优先级队列的任务先执行，如果任务未完成，则降低其优先级，将其移到低优先级队列继续执行。MFQ 算法能够兼顾短任务和长任务，提高了系统的整体性能。
最高响应比优先 (HRRN)：选择响应比最高的任务优先执行，响应比定义为等待时间加上执行时间与执行时间的比值。HRRN 算法能够兼顾短任务和长任务，避免了 SJF 算法可能出现的长任务等待问题。
最高优先权优先 (HPF)：为每个任务分配一个优先级，优先级高的任务先执行。HPF 算法适用于实时系统和任务有明确优先级的场景，但可能导致低优先级任务长期等待高优先级任务完成。
公平分享调度 (Fair Share Scheduling)：根据任务的资源需求和历史使用情况进行资源分配，保证每个任务都能够获得公平的资源份额。公平分享调度算法适用于多用户、多任务共享资源的场景，能够确保系统资源的公平分配。

对于这个作业，可首先使用简单的先来先服务的调度算法完成任务，按照任务队列依次执行。即：只要在StartWorkerThread函数中不断Get请求，处理完成后设置请求的 std::promise callback_的future即可。
当然这里存在优化空间，等完成全部作业再继续优化。

测试

测试类很简单地提供了两个读写测试：

值得一提的是，实际从外存读取数据的下层工具类diskmanager，这里并没有使用。而是使用的其专门用于测试的子类DiskManagerUnlimitedMemory，这个子类并没有执行从外存读取数据的功能，它的一切数据Page都是在内存上进行操作的，通过一定的延迟算法，模拟从外存上读写文件的延迟。具体实现可以阅读我源码解读的文章：
TODO：插入链接

make disk_scheduler_test -j16
./test/disk_scheduler_test

执行上面两条编译测试语句，便可以得到测试结果：
Disk_Scheduler测试结果

Task #3 - Buffer Pool Manager

完成思路

这个任务需要完成src/buffer/buffer_pool_manager.cpp中的若干函数：

FetchPage(page_id_t page_id)
UnpinPage(page_id_t page_id, bool is_dirty)
FlushPage(page_id_t page_id)
NewPage(page_id_t* page_id)
DeletePage(page_id_t page_id)
FlushAllPages()
NewPage、FetchPage、需要使用到Task #1 - LRU-K Replacement Policy中的RecordAccess函数，用于记录对块的读取记录。NewPage、FetchPage是最复杂的函数，这两个函数需要同时检查是否待替换的frame中保存的是脏页（如果是脏页还要记得写回）、调用替换策略提供的RecordAccess接口记录对frame的访问。
具体函数的相互调用可以完全按照注解中描述一步一步编写，可以保障不遗漏。此外，一定要记得加锁，因为最终的测试是在多线程环境下测试的。
简而言之，BPM对Page状态的管理是结合frame的evictable、page的pin_count_、is_dirty_综合设计策略的。在尝试获取新页（包括从外存加载、创建新页）时，较为复杂。BPM还为脏页的写回单独提供了两个函数FlushPage、FlushAllPages，这两个函数将重新将page对象的is_dirty_置为false。

测试

这里bustub提供了两个测试方法。
BinaryDataTest用于检查是否可以恢复包含终止符的页面。
SampleTest用于测试普通页面。
测试结果

Task #4 - Read/Write Page Guards

完成思路

首先完成BasePageGuard中的各个函数。按照注解中描述的逻辑，除了两个update函数会对Page加锁保证page不会被换出，其它全部的函数都默认PageGuard已经获取了锁。
我找到了一个不太清楚是哪个版本的测试代码：

//===----------------------------------------------------------------------===//
//
//                         BusTub
//
// page_guard_test.cpp
//
// Identification: test/storage/page_guard_test.cpp
//
// Copyright (c) 2015-2019, Carnegie Mellon University Database Group
//
//===----------------------------------------------------------------------===//

#include <cstdio>
#include <random>
#include <string>

#include "buffer/buffer_pool_manager.h"
#include "storage/disk/disk_manager_memory.h"
#include "storage/page/page_guard.h"

#include "gtest/gtest.h"

namespace bustub {

// NOLINTNEXTLINE
TEST(PageGuardTest, SampleTest) {
  const size_t buffer_pool_size = 5;
  const size_t k = 2;

  auto disk_manager = std::make_shared<DiskManagerUnlimitedMemory>();
  auto bpm = std::make_shared<BufferPoolManager>(buffer_pool_size, disk_manager.get(), k);

  page_id_t page_id_temp;
  auto *page0 = bpm->NewPage(&page_id_temp);

  auto guarded_page = BasicPageGuard(bpm.get(), page0);

  EXPECT_EQ(page0->GetData(), guarded_page.GetData());
  EXPECT_EQ(page0->GetPageId(), guarded_page.PageId());
  EXPECT_EQ(1, page0->GetPinCount());

  guarded_page.Drop();

  EXPECT_EQ(0, page0->GetPinCount());

  {
    auto *page2 = bpm->NewPage(&page_id_temp);
    std::cout << "page2" << page2->GetPageId() << "" << std::endl;
    auto guard2 = ReadPageGuard(bpm.get(), page2);
    std::cout << "guard2" << guard2.PageId() << "" << std::endl;
  }

  // Shutdown the disk manager and remove the temporary file we created.
  disk_manager->ShutDown();
}

TEST(PageGuardTest, MoveTest) {
  const std::string db_name = "test.db";
  const size_t buffer_pool_size = 10;
  const size_t k = 2;

  auto disk_manager = std::make_shared<DiskManagerUnlimitedMemory>();
  auto bpm = std::make_shared<BufferPoolManager>(buffer_pool_size, disk_manager.get(), k);

  Page *init_page[6];
  page_id_t page_id_temp;
  for (int i = 0; i < 6; ++i) {
    init_page[i] = bpm->NewPage(&page_id_temp);
  }

  BasicPageGuard basic_guard0(bpm.get(), init_page[0]);
  BasicPageGuard basic_guard1(bpm.get(), init_page[1]);
  basic_guard0 = std::move(basic_guard1);
  BasicPageGuard basic_guard2(std::move(basic_guard0));

  BasicPageGuard basic_guard3(bpm.get(), init_page[2]);
  BasicPageGuard basic_guard4(bpm.get(), init_page[3]);
  ReadPageGuard read_guard0(bpm.get(), init_page[2]);
  ReadPageGuard read_guard1(bpm.get(), init_page[3]);
  read_guard0 = std::move(read_guard1);
  ReadPageGuard read_guard2(std::move(read_guard0));

  init_page[4]->WLatch();
  init_page[5]->WLatch();
  WritePageGuard write_guard0(bpm.get(), init_page[4]);
  WritePageGuard write_guard1(bpm.get(), init_page[5]);

  // Important: here, latch the page id 4 by Page*, outside the watch of WPageGuard, but the WPageGuard still needs to
  // unlatch page 4 in operator= where the page id 4 is on the left side of the operator =.
  // Error log:
  // terminate called after throwing an instance of 'std::system_error'
  //   what():  Resource deadlock avoided
  // 1/1 Test #64: PageGuardTest.MoveTest
  write_guard0 = std::move(write_guard1);
  init_page[4]->WLatch();  // A deadlock will appear here if the latch is still on after operator= is called.

  WritePageGuard write_guard2(std::move(write_guard0));

  // Shutdown the disk manager and remove the temporary file we created.
  disk_manager->ShutDown();
}

}  // namespace bustub

在倒数第6行，可以看到

// A deadlock will appear here if the latch is still on after operator= is called.

我们反向推理，发生死锁的前提是init_page[4]已经被锁住了，也就是 write_guard0 = std::move(write_guard1);没有释放锁，但是接着向上读，可以发现除了

init_page[4]->WLatch();

之外，并没有任何加锁的操作。而在这个锁之后，调用了构造函数，可以确定构造函数并不会加锁，接着调用了移动构造函数，而这里会发生死锁，所以可以确定移动构造函数将释放原本page的锁。
根据上面的规律，我们可以推断出：除了两个特殊描述的update函数会对Page加锁保证page不会被换出，其它全部的函数都默认PageGuard已经获取了锁（BasePageGuard并没有锁，在Update函数中加锁），只需要在Drop和移动构造函数处需要释放锁。
推理它们的功能实在是太难了，因为几乎没有任何地方调用了这些PageGuard让我能理解它们的作用和锁管理的机制。

测试

在原本测试代码的基础上，我又添加了一些测试。下面是全部的测试代码：

//===----------------------------------------------------------------------===//
//
//                         BusTub
//
// page_guard_test.cpp
//
// Identification: test/storage/page_guard_test.cpp
//
// Copyright (c) 2015-2019, Carnegie Mellon University Database Group
//
//===----------------------------------------------------------------------===//

#include <cstdio>
#include <random>
#include <string>

#include "buffer/buffer_pool_manager.h"
#include "storage/disk/disk_manager_memory.h"
#include "storage/page/page_guard.h"

#include "gtest/gtest.h"

namespace bustub {

// NOLINTNEXTLINE
TEST(PageGuardTest, SampleTest) {
  const size_t buffer_pool_size = 5;
  const size_t k = 2;

  auto disk_manager = std::make_shared<DiskManagerUnlimitedMemory>();
  auto bpm = std::make_shared<BufferPoolManager>(buffer_pool_size, disk_manager.get(), k);

  page_id_t page_id_temp;
  auto *page0 = bpm->NewPage(&page_id_temp);

  auto guarded_page = BasicPageGuard(bpm.get(), page0);

  EXPECT_EQ(page0->GetData(), guarded_page.GetData());
  EXPECT_EQ(page0->GetPageId(), guarded_page.PageId());
  EXPECT_EQ(1, page0->GetPinCount());

  guarded_page.Drop();

  EXPECT_EQ(0, page0->GetPinCount());

  {
    auto *page2 = bpm->NewPage(&page_id_temp);
    std::cout << "page2" << page2->GetPageId() << "" << std::endl;
    auto guard2 = ReadPageGuard(bpm.get(), page2);
    std::cout << "guard2" << guard2.PageId() << "" << std::endl;
  }

  // Shutdown the disk manager and remove the temporary file we created.
  disk_manager->ShutDown();
}

TEST(PageGuardTest, MoveTest) {
  const std::string db_name = "test.db";
  const size_t buffer_pool_size = 10;
  const size_t k = 2;

  auto disk_manager = std::make_shared<DiskManagerUnlimitedMemory>();
  auto bpm = std::make_shared<BufferPoolManager>(buffer_pool_size, disk_manager.get(), k);

  Page *init_page[6];
  page_id_t page_id_temp;
  for (int i = 0; i < 6; ++i) {
    init_page[i] = bpm->NewPage(&page_id_temp);
  }

  BasicPageGuard basic_guard0(bpm.get(), init_page[0]);
  BasicPageGuard basic_guard1(bpm.get(), init_page[1]);
  basic_guard0 = std::move(basic_guard1);
  BasicPageGuard basic_guard2(std::move(basic_guard0));

  BasicPageGuard basic_guard3(bpm.get(), init_page[2]);
  BasicPageGuard basic_guard4(bpm.get(), init_page[3]);
  ReadPageGuard read_guard0(bpm.get(), init_page[2]);
  ReadPageGuard read_guard1(bpm.get(), init_page[3]);
  read_guard0 = std::move(read_guard1);
  ReadPageGuard read_guard2(std::move(read_guard0));

  init_page[4]->WLatch();
  init_page[5]->WLatch();
  WritePageGuard write_guard0(bpm.get(), init_page[4]);
  WritePageGuard write_guard1(bpm.get(), init_page[5]);

  // Important: here, latch the page id 4 by Page*, outside the watch of WPageGuard, but the WPageGuard still needs to
  // unlatch page 4 in operator= where the page id 4 is on the left side of the operator =.
  // Error log:
  // terminate called after throwing an instance of 'std::system_error'
  //   what():  Resource deadlock avoided
  // 1/1 Test #64: PageGuardTest.MoveTest
  write_guard0 = std::move(write_guard1);
  init_page[4]->WLatch();  // A deadlock will appear here if the latch is still on after operator= is called.

  WritePageGuard write_guard2(std::move(write_guard0));

  // Shutdown the disk manager and remove the temporary file we created.
  disk_manager->ShutDown();
}

}  // namespace bustub