JiaLog

Project 6 - 令牌撤销与单点登出

Tue, 12 Aug 2025 00:00:00 +0000

实验目标

恭喜你来到最后一个实验！本周我们将实现 OAuth 2.0 系统的收尾工作：令牌撤销和单点登出。完成本实验后，你将能够：

✅ 理解令牌撤销的重要性和应用场景
✅ 实现符合 RFC 7009 的令牌撤销端点
✅ 理解单点登出（Single Logout, SLO）的工作原理
✅ 实现前端通道登出（Front-Channel Logout）
✅ 理解后端通道登出（Back-Channel Logout）的概念
✅ 完成整个 OAuth 2.0 授权服务器的实现

实验任务

任务 1：完善令牌管理器的撤销逻辑

文件位置

smart-sso-server/src/main/java/com/smart/sso/server/token/LocalTokenManager.java

1.1 完善 `remove` 方法

@Override
public void remove(String refreshToken) {
    // TODO 1: 获取令牌内容
    // 提示：使用 refreshTokenCache.getIfPresent() 方法
    // 思考：如果令牌不存在应该如何处理？（幂等性）
  
    // TODO 2: 从刷新令牌缓存中移除
    // 提示：使用 refreshTokenCache.invalidate() 方法
  
    // TODO 3: 移除关联的访问令牌
    // 提示：从 TokenContent 中获取 accessToken
    // 注意：访问令牌可能为 null，需要判空
  
    // TODO 4: 从 TGT 反向索引中移除
    // 提示：
    // - 获取 TGT 和对应的令牌集合
    // - 从集合中移除当前刷新令牌
    // - 如果集合为空，清理整个 TGT 缓存条目
    // - 否则更新缓存
  
    // TODO 5: 记录日志
    // 提示：记录刷新令牌和用户 ID（用于审计）
}

设计提示：

Project 5 - 令牌颁发与刷新令牌轮换

Tue, 05 Aug 2025 00:00:00 +0000

实验目标

本周是整个项目的核心部分！我们将实现 OAuth 2.0 的引擎：令牌管理系统。完成本实验后，你将能够：

✅ 理解访问令牌和刷新令牌的不同生命周期
✅ 实现令牌的创建、验证和存储
✅ 实现刷新令牌轮换（Refresh Token Rotation）
✅ 实现刷新令牌盗窃检测机制
✅ 理解令牌家族（Token Family）的概念
✅ 掌握令牌与 TGT 的关联管理

理论背景

1. 访问令牌 vs. 刷新令牌

1.1 核心区别

特性	访问令牌 (Access Token)	刷新令牌 (Refresh Token)
用途	访问受保护的 API 资源	获取新的访问令牌
生命周期	短（15 分钟）	长（30 天）
传输频率	每次 API 请求都携带	仅在刷新时使用
泄露风险	高（频繁传输）	低（使用频率低）
存储位置	客户端内存	安全存储（加密）
撤销成本	低（自动过期）	高（需要主动撤销）

1.2 为什么需要两种令牌？

安全与体验的平衡：

场景 1：仅使用访问令牌
问题：访问令牌过期后，用户必须重新登录
结果：用户体验差 ❌

场景 2：访问令牌永不过期
问题：一旦泄露，攻击者可永久访问
结果：安全性差 ❌

场景 3：访问令牌 + 刷新令牌
优势：
- 访问令牌短期有效，降低泄露风险 ✅
- 刷新令牌长期有效，无需频繁登录 ✅
- 刷新令牌可追踪和撤销 ✅

2. 刷新令牌轮换 (Refresh Token Rotation)

2.1 传统方法 vs. 轮换方法

传统方法（不推荐）：

Project 3 - 全局会话管理 (TGT)

Tue, 22 Jul 2025 00:00:00 +0000

实验目标

本周我们将实现单点登录的核心机制：**票据授予票据（TGT）**管理。完成本实验后，你将能够：

✅ 理解 TGT 在 SSO 系统中的关键作用
✅ 使用缓存实现会话的创建、检索和移除
✅ 实现基于 TTL 的会话自动过期机制
✅ 实现滑动窗口过期策略（提升用户体验）
✅ 限制每个用户的并发会话数量（安全增强）
✅ 理解会话级联失效机制（为单点登出做准备）

理论背景

1. 什么是票据授予票据 (TGT)？

1.1 TGT 的定义

TGT（Ticket Granting Ticket）是 SSO 系统中的全局会话令牌，类似于传统 Web 应用中的 Session ID，但具有更强的安全性和跨应用能力。

关键特性：

唯一性：每个 TGT 对应一个用户会话
安全性：通常使用 UUID 或密码学随机数生成
时效性：具有明确的过期时间（如 30 分钟无操作）
跨域性：可在多个子应用间共享

1.2 TGT 在 OAuth 2.0 流程中的作用

用户首次登录流程：
1. 用户访问应用 A → 重定向到 SSO 登录页
2. 用户输入账号密码 → SSO 验证成功
3. SSO 创建 TGT → 将 TGT ID 写入浏览器 Cookie
4. SSO 颁发授权码 → 应用 A 获取访问令牌

用户再次访问应用 B（单点登录体现）：
1. 用户访问应用 B → 重定向到 SSO
2. 浏览器自动携带 TGT Cookie → SSO 验证 TGT 有效
3. SSO 直接颁发授权码 → 应用 B 获取访问令牌
   （无需用户再次输入密码！）

2. 会话管理策略

2.1 生存时间 (TTL) 策略

固定过期时间：

Project 1 - 环境搭建与系统设计

Tue, 08 Jul 2025 00:00:00 +0000

实验目标

本节主要完成以下任务：

✅ 搭建完整的 Java 开发环境
✅ 配置 MySQL 数据库并初始化数据
✅ 配置 Redis 缓存服务
✅ 运行项目并验证环境正确性
✅ 理解 OAuth 2.0 基本概念和系统整体设计

详细任务

一、环境搭建

1. 安装 JDK 17

步骤

下载 JDK
- 官方版本：Oracle JDK 17
- 开源版本：OpenJDK 17（推荐）

安装 JDK

Windows：

# 双击运行 .exe 文件，按提示完成安装
# 默认安装路径：C:\Program Files\Java\jdk-17

macOS：

# 使用 Homebrew 安装（推荐）
brew install openjdk@17

# 或下载 .dmg 文件手动安装

Linux (Ubuntu/Debian)：

sudo apt update
sudo apt install openjdk-17-jdk

Linux (CentOS/RHEL)：

sudo yum install java-17-openjdk-devel

配置环境变量

Project #0 - 实验准备

Sun, 22 Jun 2025 00:00:00 +0000

重要提醒

⚠️ 请勿公开你的代码 - 本课程遵循学术诚信原则，代码仅供个人学习使用。

概述

本课程所有代码基于 Java 编写。在开始项目之前，请确保你具备以下基础：

Java SE 基础：面向对象编程、集合框架、异常处理
Java Web 基础：Spring Boot、Spring MVC、RESTful API
数据库基础：SQL 基本操作、MyBatis 使用
缓存基础：Redis 基本概念和操作

本项目严格按照 OAuth 2.0 协议标准实现，主要基于授权码模式（Authorization Code Flow）。

必读材料

在开始实验前，请仔细阅读以下材料：

OAuth 2.0 核心概念
- 理解OAuth 2.0 - 阮一峰的网络日志
- RFC 6749 - The OAuth 2.0 Authorization Framework
授权码模式深入理解
- 重点关注：授权请求、授权响应、令牌请求、令牌响应的完整流程
安全增强特性
- RFC 7009 - OAuth 2.0 Token Revocation
- RFC 7636 - Proof Key for Code Exchange (PKCE)

你的任务

本实验采用**“完形填空”**的形式：

理解项目架构：阅读提供的框架代码，理解各模块的职责
完成关键函数：在标记了 // TODO 的地方实现核心逻辑
通过单元测试：每个实验都配有 JUnit 测试用例
手动测试验证：使用 Postman 或其他工具进行端到端测试

实验评估方式

自动化测试：每个模块都有对应的单元测试（约 60%）
功能验证：手动测试关键流程（约 30%）
代码质量：代码规范性和安全性（约 10%）

重要提醒：本项目没有完全自动化的评分系统，请以学到知识为目标，诚信完成实验。

我与杭高——25国科大杭高院上岸记录

Tue, 08 Apr 2025 00:00:00 +0000

可以移步到我的博客.

笔者高考在河南，英语是除去听力分 * 1.25，所以英语底子比较差，基本处于勉强应付考试的水平。数学自认为处于中等水平。如果你的情况跟笔者类似，那么这篇经验帖讲十分值得参考。

如果赶时间可直接看备考经验部分。

个人背景

本科：CUMT计算机科学与技术专业，本科期间成绩可以用惨不忍睹来形容，基本属于是60分万岁的状态，不过专业课成绩还不错基本都在90+。英语：四六级水平，六级460+。项目：

CMU15-445
MIT6.1810（主要项目）主要是以上两个，还有一个参加软件杯的时候做的智能编辑器，一个有智能推荐算法的短视频平台。都是一些web项目，没什么含金量，感觉高校的老师对web项目也不是很感兴趣，只能作为锦上添花之用。 个人兴趣：我找到自己的兴趣所在可谓道阻且长。从大一的时候学一些逆向知识写一些pojie补丁，大二的时候学习java和go搞后端开发，都感觉自己不是发自内心的感兴趣，只是被周围的氛围所感染而被动学习。直到大三接触了Xv6才渐渐的发现自己对比较偏底层一点的东西很感兴趣，同时这也成为我想要考研的契机。

为什么考研？

在说择校之前我想先说一点题外话：不要为了研究生而考研。我不想说什么学历贬值之类的没有营养的话。我认为读研应该是是一个自我驱动的学习过程，是在学习的过程中萌生了自己需要一个更好的平台或者需要有人指导的想法之后的选择。而不是面对就业压力而进行的一种不得不的选择。两者相比我认为最大的区别就是前者会具有一股强大的内驱力。

在23年的十月份我面临两个选择：考研or就业。在兴趣驱动下我几乎没怎么想就决定了要考研。此时我的两个室友都已经手握大厂实习offer，说实话身处这个环境很难不受影响，我几乎日夜思考是否要坚持考研似乎现在跳车去就业也是不错的选择。直到我看到这样一句话：他人之得，非我之失。看到室友拿到offer我也想当然认为自己同样也能拿到，可现实是在就业方面我付出的努力不及我室友万分之一，想到这里我不再纠结，轻装上阵。

择校过程

决赛圈：

华东师范大学
东北大学
北航
国科大杭高院

从大学入校到此时此刻我对于AI的兴趣也不是很大，我承认AI很有意义，现在我每天日常的生活和学习都离不开AI，但我就是没有兴趣。所以确定了大方向：计算机体系结构。然后我是先确定了自己要考的科目，我有三不考，首先自命题我不考，自命题水太深，我把握不住。其次，数一英一我不考，这个组合太难，我学不会。最后，太靠北的学校我不考，我算过命，我的福地在南方。这样22408的神秘数字呼之欲出！此时再配上引流神图，我最后上车了杭高。

备考经验

初试总分不是很高，在复试名单中处于中间位次。笔者认为自身的条件和所处情况应该能代表大部分考研人，因此比较具有参考价值。

🎯 考研复习时间安排（2025）

时间	英语	数学	408 专业课	政治
4 月	单词+阅读真题	《基础30讲》+0.1w	《数据结构》
5 月	单词+阅读真题	《基础30讲》+0.1w	《计算机组成原理》
6 月	单词+阅读真题	《基础30讲》+0.1w	《操作系统》
7 月	单词+阅读真题	《基础30讲》+0.1w	《计算机网络》
8 月	回家休息	回家休息	回家休息
9 月	单词+阅读真题	武忠祥强化	王道强化选听+王道书大题
10 月	单词+阅读真题+句子积累	真题套卷	真题套卷
11 月	大作文+小作文	模拟套卷	真题套卷	背诵手册+带背
12 月	翻译+练字	回归基础	查漏补缺	小程序刷题

我开始复习的时间点不算早，开始的时候看了很多经验帖，又找了主流老师的课试听了一下看看自己适合什么风格。其实直到三月底才算步入正轨。

2021——2025：我的大学

Fri, 04 Apr 2025 00:00:00 +0000

毕设写到致谢，回首四年本科，感慨万千。

关山难越

大一时，我带着"退而求其次"的心态来到CUMT，心中充满不甘。那时对周围的一切都十分抗拒，无论是上课还是作业。每周最快乐的事就是和舍友一起联机打求生之路，对着僵尸宣泄情绪，晚自习后和好厚米双人成行，借此麻痹自己。那时的我对生活毫无期待，对未来也是——总的来说就是得过且过，考试也都是60分万岁。口罩期间被封在宿舍更是如此。曾经也想要努力学习，却发现自己已经无法集中注意力做任何事：学习五分钟，却要刷两个小时抖音；快节奏的生活甚至让我看电视剧都得开倍速。

直到大三上学期末，我才真正感受到一种紧迫感。优绩主义下的"学霸寝室"公众号文章，以及某浙江985高校《9/1XXXX，这些学生脱颖而出》的标题，把其他所有学生都异化为分母，这种冲击让我感到不亚于封建礼教的荒谬。在我看来，大学应该是多元化、丰富多彩的。不存在所谓"最好的选择"，每个人都有最适合自己的道路——我两个去大厂就业的室友很优秀，选择考公务员的哥们很明智，而保研则是对保研er三年努力的认可。也是这时，我想明白了自己究竟想要什么。

机缘巧合下，我接触到了一个颇感兴趣的研究方向。很庆幸自己能够坚持下去，尽管随着深入学习，现成的学习资料越来越少，遇到的问题也常常无人可以请教。我想，读研可以为自己提供一个更大的平台，于是便下定决心继续深造。凭借一点小聪明和一年的努力，在大学生活即将结束时，我找到了一个不错的去处。让我最欣慰的不是收到国科大拟录取通知的那一刻，而是意识到自己终于有机会在热爱的方向上走得更远。

谁悲失路之人

在备考的过程中，我遇到了许多善良热心的人。他们给予我不同程度的帮助，这些恩情我都默默地记在心里。

现在的人往往只关注结果而忽视过程（我也不例外）。我总是想当然地从结果反推过程，认为不理想的结果一定源于不完善的过程。但这忽略了一个事实：每个人本就与众不同。无论是在高中还是大学，我见过太多优秀的人，深知自己与这些大佬之间存在着难以逾越的差距。有些事情即便竭尽全力也无法做到。但这并未让我感到挫败，相反，有了奋斗的方向和目标让我感到无比充实。

这一年不仅让我在知识上有所收获，更教会我以平和的心态面对周遭环境。无论身在何处，我学会了充分利用一切可用资源，团结一切能够团结的力量来提升自己。东隅已逝，桑榆非晚，日拱一卒，功不唐捐。一切都会好起来。

最后，我的大学生活结束了。

Lab1 Xv6 && system calls

Tue, 25 Feb 2025 00:00:00 +0000

Using gdb

平时我们用的调试工具其实都是图形化后的gdb，使用起来非常的方便，但是熟悉原生的gdb会使我们的效率进一步提升。我认为学习好用gdb调试是一项非常重要的技能。

编译并启动

==make qemu-gdb==

使用上述命令编译项目并且直接以调试模式启动。但是这个项目启动的其实是在本地的一个远程gdb，通过另一个窗口进行调试。

下面有几个关于系统调用的小问题

Looking at the backtrace output, which function called syscall?

显然是usertrap（）

What is the value of p->trapframe->a7 and what does that value represent? (Hint: look user/initcode.S, the first user program xv6 starts.) 通过提示找到trapframe的地址，在kernel/proc.h中找到a7寄存器对应的偏移地址。把168换算成16进制尝试着打印0x87f560a8 这个就是寄存器a7的值。其代表的具体含义通过所给的提示到对应文件中查找之后也是十分的明了。应该就是系统的调用号。

What was the previous mode that the CPU was in?

spp位表示其在什么状态。通过图示得出，spp在二进制的第8bit. 由图可知8bit是0，所以之前是用户状态。

System call tracing

Attack xv6

这个task主要是利用xv6故意留下的bug然后获取到销毁内存但是保留了脏页的数据。然后通过一些比较hack的手段把字段给找出来。

page组成

上图是一个简化的逻辑页表，下一个实验也会用到，这里理顺一下逻辑有利于分析代码的组成。上图是地址转化的细节。页表项（PTE）包含标志位，告诉硬件应该如何使用这些虚拟地址。这些相关位的定义都在(kernel/riscv.h)中

变量

Mon, 03 Feb 2025 00:00:00 +0000

变量的绑定与解构

手动设置可变性

在rust语言中可以手动设置变量的可变性。这是灵活性和安全性的结合。但是这样肯定会在编码的过程中付出更多的思考，但这也是权衡之后做出的选择。

变量绑定

在rust语言中变量和标识符之间是一种绑定关系，直接是所有权的改变。简单来说任何一块有意义的内存都有所属，而且这个关系是唯一的。这样就以为这变量和内存之间只能真诚的进行1v1了。

变量可变性

rust语言的变量在默认情况下是不可变的，但是可以通过mut关键字让变量变为可变的。下面我们进行编码进行实践操作

fn main() {
   let x = 5;
   println!("The value of x is: {}", x);
   x = 6;
   println!("The value of x is: {}", x);
}

我们可以预想的到这样的代码会报错由于我们对x发生了两次赋值。我们遵循报错给出的建议，使用mut对变量进行修饰。这样由于显示的规定变量是否可以被修改，在多线程的编程过程中能让我们少死很多脑细胞，对程序员也是一种保护。

let mut x=5;
   println!("the value of x is:{}",x);
   x=6;
   println!("the value of x is:{}",x);

这次非常的顺利运行结果没有任何问题。

使用下划线忽略未使用的变量

在日常编程的过程中经常会发出“变量从未使用”的警告，如果此时你正在设计一个项目，你可能会拥有很多的未使用的变量。此时你可以使用下划线作为变量的开头，屏蔽警告。

fn main() {
    let _x = 5;
    let y = 10;
}

这样的话就不会对未使用的变形进行警告了。

虚拟化--进程管理API：fork, execve, exit

Sun, 02 Feb 2025 00:00:00 +0000

操作系统上的进程

背景回顾：有关状态机、并发和中断的讨论给我们真正理解操作系统奠定了基础，现在我们正式进入操作系统和应用程序的 “边界” 了。让我们把视角回到单线程应用程序，即 “执行计算指令和系统调用指令的状态机”，开始对操作系统和进程的讨论。

本讲内容：操作系统上的进程

操作系统上的第一个进程
UNIX/Linux 进程管理 API: fork, execve, exit

fork（）

理解 fork(): fork() 会完整复制状态机；新创建的状态机返回值为 0，执行 fork() 的进程会返回子进程的进程号。同时，操作系统中的进程是并行执行的。程序的精确行为并不显然——model checker 可以帮助我们理解它。

在这个例子中，我们还发现执行 ./a.out 打印的行数和 ./a.out | wc -l 得到的行数不同。根据 “机器永远是对的” 的原则，我们可以通过提出假设 (libc 缓冲区影响) 求证、对比 strace 系统调用序列等方式，最终理解背后的原因。标准输入输出的缓冲控制可以通过 setbuf(3) 和 stdbuf(1) 实现。

execve（）

exit（）

Project 4 - 授权码管理与 PKCE

Wed, 29 Jan 2025 00:00:00 +0000

实验目标

本周我们将实现 OAuth 2.0 的核心：授权码流程。完成本实验后，你将能够：

✅ 理解授权码在 OAuth 2.0 流程中的关键作用
✅ 实现授权码的创建和一次性使用验证
✅ 理解授权码被截获的安全威胁
✅ 实现 PKCE（Proof Key for Code Exchange）安全增强
✅ 掌握 SHA-256 哈希和 Base64 URL 编码

理论背景

1. 授权码流程详解

1.1 为什么需要授权码？

OAuth 2.0 使用两步验证而非直接颁发访问令牌，主要出于安全考虑：

❌ 不安全的单步流程（隐式授权）：
用户登录 → SSO 直接返回访问令牌到浏览器
问题：访问令牌暴露在浏览器历史记录、日志中

✅ 安全的两步流程（授权码）：
步骤 1：用户登录 → SSO 返回临时授权码到浏览器
步骤 2：客户端后端用授权码 + 密钥换取访问令牌
优势：访问令牌只在后端传输，永不经过浏览器

1.2 授权码的生命周期

时间轴：
T0: 用户完成登录，SSO 生成授权码
    授权码特性：
    - 随机生成（UUID 或密码学随机数）
    - 生命周期极短（5 分钟）
    - 一次性使用（use once and destroy）

T0+30s: 客户端用授权码换取令牌
        授权码被立即销毁

T0+5min: 授权码自动过期
         （即使未被使用）

2. 授权码截获攻击与 PKCE

2.1 授权码截获攻击场景

攻击场景：恶意应用截获授权码

正常流程：
1. 合法 App 发起授权请求
2. 用户登录，SSO 重定向到 callback URL
3. 恶意 App 拦截重定向（通过注册相同的 URL Scheme）
4. 恶意 App 获取授权码
5. 恶意 App 用授权码 + 客户端密钥换取令牌 ← 问题！

在移动应用中，客户端密钥无法安全存储
（反编译即可获取）

2.2 PKCE 工作原理

PKCE（读作 “pixy”）通过动态密钥解决此问题：

Project 2 - 用户和客户端验证

Wed, 15 Jan 2025 00:00:00 +0000

实验目标

本周我们将实现 OAuth 2.0 授权流程的第一道防线：身份验证。完成本实验后，你将能够：

✅ 实现安全的用户密码验证（使用 BCrypt）
✅ 实现账户锁定机制（防止暴力破解）
✅ 实现密码过期策略（强制定期更换密码）
✅ 实现客户端应用验证（验证 client_id、client_secret 和 redirect_uri）
✅ 理解重定向 URI 验证的安全重要性

理论背景

1. 用户认证的安全原则

1.1 密码存储

绝对禁止：以明文或可逆加密方式存储密码

推荐方案：使用强单向哈希算法（BCrypt、Argon2、PBKDF2）

BCrypt 优势：

内置盐值（Salt），每次哈希结果不同
计算成本可调（通过 work factor 参数）
抗彩虹表攻击

示例：

// 生成密码哈希
String hashedPassword = passwordEncoder.encode("userPassword123");
// 输出类似：$2a$10$N9qo8uLOickgx2ZMRZoMye1J9rY7AVMZ8tPNLPZdRs5u5xP5c5fUa

// 验证密码
boolean matches = passwordEncoder.matches("userPassword123", hashedPassword);
// 返回 true

1.2 账户锁定策略

目的：防止暴力破解攻击

实现方案：

追踪每个用户的连续登录失败次数
达到阈值（如 5 次）后锁定账户一段时间（如 10 分钟）
成功登录后清除失败计数器

使用缓存的原因：

高性能：失败计数不需要持久化到数据库
自动过期：利用缓存的 TTL 特性实现锁定时间
降低数据库压力

1.3 密码过期策略

目的：降低长期使用同一密码的风险

xv6-环境搭建

Sat, 04 Jan 2025 00:00:00 +0000

xv6 启动！

万事开头难！这是我所用的开发环境，Kubuntu+VsCode，这样的环境对我来说是比较舒服的，也是比较好用的在实际使用的过程中我没感觉ubuntu和kubuntu有任何的区别，反正我也不在乎桌面，我只在终端里用。用debian系的有一个好处就是软件生态真的很不错，可别是最新的，版本什么的直接用apt都能直接获得，虽然不想archwiki那样完善，但是Google一下基本上问题也都能解决。

一个很有意思的工具 bear

我相信有很多同学在用vscode看项目代码的时候会发现，全是红线，项目变得根本就不可读，无法跳转，更无法获得依赖关系，只能把vscode当一个能用鼠标的阉割版的vim用。我们可以获取编译的命令行，然后让vscode知道然后把这些报错给消掉 1.make -nB 当然可以手动获取编译选项，但是这样也是比较复杂的而且十分的低效 2.bear 善于使用工具，君子性非异也，善假于物也。用bear把编译过程包起来就能自动获取编译选项。

如何在vscode中debug

==官方非GUI界面==

make qemu-gdb

之后系统会在本地启动一个gdb，另起一个终端使用gdb连接。到这就说明gdb启动成功了，但是后面会有一个小小的坑。

Type “apropos word” to search for commands related to “word”. warning: File “/home/learn_code/xv6-labs-2024/.gdbinit” auto-loading has been declined by your `auto-load safe-path’ set to “$debugdir:$datadir/auto-load:/home/learn_code/xv6-riscv/.gdbinit”. To enable execution of this file add add-auto-load-safe-path /home/learn_code/xv6-labs-2024/.gdbinit line to your configuration file “/root/.config/gdb/gdbinit”. To completely disable this security protection add set auto-load safe-path / line to your configuration file “/root/.config/gdb/gdbinit”.

CMU15-445总结

Thu, 22 Feb 2024 00:00:00 +0000

先随便写几个要点，等整个结束了再详细写。

动手之前先计划，详细周到考虑
多动手，多试错
多读源代码，多练习debug
英语好好学，英语太重要了。

Bustub架构简单分析

Wed, 21 Feb 2024 00:00:00 +0000

写在前面

在这篇文章中我们先抛开SQL在bustub的中的历程，直接快进到最后开始执行的阶段，这篇文章只关注设计上的细节。

至于如何理顺这些细节在[[CMU15-445 Project3 - Query Execution]]文章中会有详细的介绍，这里就不再赘述。😃

架构总览

上图中catalog其实不是特别准确，按照我的理解应该是下面这种情况👇。通过一个table_id双向映射表的名字和实体table。

接下来就按照从上到下的顺序依次介绍各个部分的结构。

Catalog

下面这个图是是整个catalog关于table的。👇这里引出了TableInfo.

Catalog中不仅仅包含table的信息还储存了index的信息。这里引出了IndexInfo,但是后边用的不是很多。

接下来看TableInfo的组成。（TableInfo的定义就在Catalog.h文件中）

TableInfo

name_:就是表的名字
table_: 是一个每个节点都是tablepage的双向链表
oid_: 顾名思义就是表的id
Schema_：其实到现在我都没有很弄懂这个是干什么的东西，但是chat给出了答案。

什么是Schema

按照我的理解应该是一个类似于表头的包含各种配置信息的一个抽象集合。现在就看看源码。👇

在bustub中schema的信息似乎没有包含很多，就是对每一个列的数据类型约束进行了记录。以及对所有的列进行一个汇总，方便获取到每一个列。

==Column==

实际上每个列的实现实体是Column，在这个实体中包含列名，数据类型，长度等基本信息。

⚠️值得注意的是column对于varchar单独做了处理🙂,变长数组终究还是不一样啊。

TableHeap

实质上就是配合TablePage里面的信息构成的双向链表，我觉得这个设计真的非常的巧妙。只用了基本的pre_page_id 和next_page_id这两个变量就把双向链表给建立起来而且耦合度非常的低。

first_page_id_: 就是第一个pageid
bufferpool：所有的page都需要从bufferpool中去取。

TablePage的结构

ok看到这里有疑问了？那么多的信息都存在那里，这继承的加上初始化的也不够啊。答案在这里👇

通过偏移量直接在page的剩余空间里去定义各种变量。

==通过InsertTuple（）函数了解详细结构==

直接看源代码：

 if (tuple.size_ + 32 > BUSTUB_PAGE_SIZE) { 
  // larger than one page size
    txn->SetState(TransactionState::ABORTED);
    return false;
  }
  auto cur_page = static_cast<TablePage *>(buffer_pool_manager_->FetchPage(first_page_id_));
  if (cur_page == nullptr) {
    txn->SetState(TransactionState::ABORTED);
    return false;
  }

这主要是判断一些前置条件的合法性

为什么要用tuple的大小+32进行比较呢？ 文末给出答案

在第一页中进行插入，如果没有足够的空间就开一个新页然后插进去
⚠️需要注意的是，在离开第一页的时候仍然要持有写锁，因为还要写next_page_id变量.

💡跟随代码跳转到TablePage::InserTuple().

数据库事务

Tue, 20 Feb 2024 00:00:00 +0000

事务

==Transaction==

在英文中事务用transaction表示，一般约定俗成的缩写为txn，所以在数据库的源代码中看到txn的话多半就是事务。

==事务诞生的背景==

我们假设一个银行的场景，转账这一操作在外界看来是单一的操作，但是在数据库内部涉及到很多的操作，假如转账操作发生了失败，那么数据的不一致是不能被接受的。所以这一连串的操作可以被归为逻辑上的一个操作集。要么整体都成功要么都失败。

事务的概念

在chatgpt上问事务的概念他会这样子进行回答。这也正是事务的关键。我们回归课本，看课本上给出的定义

事务的隔离性级别

我个人觉得对于隔离性的的理解是非常重要的，在后续的算子的实现当中几乎都要考虑事务的隔离等级，根据不同的隔离等级去进行不同的操作。（我个人现在比较迷茫的是怎么能比较周全的考虑不同隔离等级所带来的影响。：）。看来是时候找个大佬请教一下了。🙃

查询的处理和优化

Fri, 09 Feb 2024 00:00:00 +0000

Join Operation，连表

在查询过程中经常会涉及到连表的操作。那么为什么总是需要连表呢？

==为什么需要连表？==

在存储的时候为了避免数据的冗杂，将表进行规范化，导致表的割裂。
在查询的时候需要获取完整的信息，所以将表进行重新的组装。

连表的算法

Fetching Title#i6kq

CMU15-445-Project #3 - Project3 - Query Execution

Thu, 08 Feb 2024 00:00:00 +0000

做这个p3首先需要明晰整个bustub的架构[[Bustub执行器架构简单分析]],在这个文章中进行了很详细的分析。

CMU15-445-Project #2 - B+ Tree Index Checkpoint 2

Sun, 04 Feb 2024 00:00:00 +0000

CHECKPOINT-2

Task #3 - Index Iterator

简单来说就是实现一个迭代器

将所有的叶子节点视为一个链表，要求实现给出的函数。在当前的迭代器中保存所在的pageId和当前的起始位置，然后通过leafpage中的next_page_id来获取下一个叶子节点。总体上来说难度不是很大，没有什么好说的，就是还是注意要加锁，其中的某一个函数在实现的时候需要考虑跨页的情况，这时候就要考虑加锁和去锁的情况了。

Task #4 - Concurrent Index

这就是要完实现一个多线程的b+树，加锁的实现方式和原理在[[B+ Tree Index#b+ tree latches]]中有比较详细的介绍，这里我简单的解释一下。

这是整个项目的重点也是难点，考察对b+树整个结构和每个操作涉及到的点，当然可以像之前的项目一样一把大锁报平安，但是对于b+树来说这样会使的性能约等于单线程，每次都需要从根节点进入整个树，但是一把大锁就意味着每次整个树中都只能存在一个线程在操作。。。

所以我们需要更细粒度的锁，于是螃蟹锁🦀应运而生。：）rust的吉祥物也是个螃蟹吧。。

==螃蟹锁==

因为其加锁和解锁的过程以及逻辑特别像螃蟹的行走的方式，因此而得名螃蟹锁。

读模式

在读模式的时候最为形象，当获取到父节点的读锁之后，尝试着获取目标子节点的读锁，当获取到锁之后立马释放父节点的锁在上图中，一个线程获取A页的锁之后会尝试着获取目标子节点B的锁，当获取B的锁之后就会释放A的锁。如此循环往复，就像螃蟹在走。

写模式

写模式的时候只是锁释放的条件不一样，读模式的时候当获取的下一个页的锁的时候就可以立马释放当前页的锁，但是写模式涉及到插入和删除，可能整个路径上的页都会受影响。如上图所示，当获取到B页的锁的时候不能释放A页的锁，因为B有可能会发生合并，于是继续向下获取锁，获取到C页的锁之后发现C页是处于安全状态的。所以可以释放C页之上的所有锁。⚠️注意：并不包括C本身。

安全状态

安全状态的这个概念只存在于写模式的时候。需要注意的是：在删除和插入的时候页处于安全状态的条件并不一样。

在插入的时候：该页不是满的—–》就算发生分裂的情况，到此页也就结束了。
在删除的时候：大于半数———》就算删除之后发生合并或者重新分配到此页就结束了。

螃蟹锁的优势在哪里？

⚠️这里的优势是相较于一把大锁而言。

虽然B+树可以做的很高很大，但是无论如何都只有一个入口。如果每次都是一把大锁，那不管什么操作都会先获取根节点并且锁住，那直接就编程单线程的了。

所以整个的瓶颈就是根节点上锁的时间太长了。影响了并发。所以螃蟹锁的优势就在于：

能够显著的减少根结点上锁的时间，让更多的线程进入B+树进行操作

更优的螃蟹锁执行策略

当前释放的策略仍然拥有很大的优化空间。在原来的策略上写模式的时候会对根节点上写锁，知道找到一个安全节点之后才会释放，这就占用了很长时间，导致效率降低。这种不分青红皂白的直接给各个节点上写锁的行为称之为悲观锁。顾名思义，悲观锁表示这种策略对多线程的执行非常的悲观，觉得每个页都会被修改，必须都上锁才安心。但是事实上在实际的应用过程中触发分裂或者合并并不是很频繁。

所以就诞生了一种更优的加锁策略乐观锁，在写模式的时候就大胆的假设从根节点到最后的叶子节点都是安全的，给路径的页都上读锁，最后的叶子节点才上写锁。如果在这个过程中发现了某个节点跟假设的不一样，不是安全的，那么之前的所有锁都释放，再重新按照悲观锁的方式进行操作。

这样做的好处是，在相较于悲观锁乐观锁在一定程度上能改善根节点总是上写锁导致并发时读取效率的降低。

但是我本人还没有实现乐观锁，修改FindLeafPage()或者添加FindLeafPageHelper()应该都是可以的。

具体实现

==GetValue（）==

如上如所示，当获取到下一个读锁的时候就释放父节点的读锁，然后接着循环这样的操作
这样子像螃蟹走路的方式，也是这种加锁策略的由来。

==Insert（）==

还有一个图我懒得画了，page4也是不安全的，所以page2、3、4.在这里都不能释放。
找到一个安全的节点之后如何安全有便捷的释放所有父节点链的锁呢？

==Remove（）==

移除和上图大同小异啦，就是判断安全的条件不一样啦。注意一下就好了

Transaction、事务

这里就用到了我在checkpoint1中提到的这个东西[[CMU15-445 Project2-B+ Tree Index Checkpoint 1#^d53eec|对Transaction的详细介绍]],可以翻看前文。它可以跟踪记录某个线程上的锁，并且是按照顺序的。从上到下。便于进行统筹操作。

由于越往上page越密集，竞争越激烈，在释放锁的时候可以优先释放处于顶部的锁，也算是一个小优化🤣。

Summary

整个checkpoint2想较于checkpoint1来说我觉得需要注意的事情更多。特别是对根节点的加锁时机的把握，很重要的。难度我觉得是有提升的。

写完这个让我体会最深的是，代码写完整个工作完成百分之20，跑起来并且过本地测试勉强算完成一半，线上测试是真难啊啊啊，每次卡玩都回来一点一点看log👀，眼瞪的比黑猫警长还大。

最后附上通过截图。

CMU15-445-Project #2 - B+ Tree Index Checkpoint 1

Thu, 01 Feb 2024 00:00:00 +0000

一些工具

BusTub B+Tree PrinterCMU官方在线的B+树的生成工具。我主要用来细节实现的时候进行参考。
JavaScript B+ TreeB+树插入和删除的动态演示。
Graphviz Online可视化自己的树。在debug的时候会用到。将生成的dot文件转换成svg图片。
Log In | Gradescope在线评测网站,邀请码：PXWVR5，
Project #2 - B+Tree | CMU 15-445/645 :: Intro to Database Systems (Fall 2022)最重要的当然还是课程网站了
课程的视频，还有对应的教材还是推荐看一下的上面有很多实现细节的。非常值得参考。

如何Debug自己的🌳

大致上可以分为两种方式

可视化的用自带的printer将树生成dot文件然后复制到上面的可视化网站。
由于本项目采用的是cmake构建的，所以可以很方便的在测试文件中打上断点。进行调试。

==可视化调试==

在终端中执行以下命令，构建和执行printer。

➜  build git:(main) make b_plus_tree_printer -j2 // 构建printer
➜  build git:(main) ./bin/b_plus_tree_printer    // 执行printer

执行完之后就会有以下提示：

按照这个提示就可以生成dot文件，然后复制到上述的网站进行可视化。（当你看到自己的树呈现出来的时候还是非常有成就感的😁）

==非可视化==

可以很方便的直接打断点，然后在vscode中的cmake插件中选择调试进行debug。

官方还提供了一种大打log的方式进行debug，我是不太习惯这种方式所以没有进行很深入的研究。感兴趣的可以自己进行了解😗。

两种debug的方式是相辅相成的，在你过不了本地样例的时候好好的用非可视化的方式进行debug，线上样例过不了大部分原因是细节处理上出问题了。用可视化的方式会更加的直观。

请不要公开代码，尊重Andy劳动成果

概览

Project2是实现B+树索引，整个project大致被分为了两个部分

checkpoint1：实现一个单线程的b+树。
checkpoint2：实现一个多线程的b+树。

实验代码中给出的自由发挥的空间非常的大，只给出了Getvalue(),Insert(),Remove()这三个函数的接口，剩下的所有的实现都非常的自由，整个实验实现的过程就像一个黑盒一样，只在乎输入和输出。

本实验需要完成b+ index部分，b+树中的页（page）都需要从上一个实验中实现的buffer pool中取。

Checkpoint-1

Task #1 - B+Tree Pages

需要完成以下三个page，主要都是一些getter和setter的函数，重在理解各部分的组成。

其中parentPage是internal page和leaf page的父类。我更倾向于把这几个page类型理解为从buffer pool中取回来的Page的不同解释形式。Page还是那个Page。主要就是在于你如何去解释它的组成部分。

基本类型

Sun, 07 Jan 2024 00:00:00 +0000

数值类型

整数类型

整数就是没有小数部分的数字。之前使用过的 i32 类型，表示有符号的 32 位整数（ i 是英文单词 integer 的首字母，与之相反的是 u，代表无符号 unsigned 类型）。下表显示了 Rust 中的内置的整数类型：

整型溢出

在使用编程的过程中难免会发生数的范围超过了类型范围这时候就会发生溢出的现象。

有趣的是：在debug模式下编译器会检测有没有发生整形溢出的现象，如果有发生整数溢出的现象编译就会发生panic.

但是在release模式下，编译器不会进行整数溢出的的检测。当发生整数溢出的时候会按照补码循环溢出进行处理。简单来讲就是取余。

要显式的处理可能的溢出，可以使用标准库提供的类型。

使用warpping_*的方法在所有模式下都按照补码循环溢出的规则进行处理
使用check_*方法发生溢出的时候返回None值。
使用overflowing_*方法返回该值和是否溢出的一个bool值
使用saturating_*的方法返回最大值或者最小值

下面是一个演示warpping_*的一个示例代码

fn main() {
    let a : u8 = 255;
    let b = a.wrapping_add(20);
    println!("{}", b);  // 19
}

最后这个输出结果也没有出乎意料。

浮点类型

浮点类型是带有小数点的数字。在Rust中浮点数类型也有两种表示f32,f64. 分别表示32位和64位。在现代CPU中32位的运算速度几乎和64位是一样的。所以默认是f64.

浮点数陷阱

浮点数在其底层表示上有很大的特殊性，这就导致了如果在使用的时候不够谨慎就会造成危险。主要有以下两个原因。

浮点数是一种近似的表达。由于所有的生活中的数字我们都是用十进制进行标识但是计算机用二进制在底层进行表示，所以我们很难非常准确的表示十进制的小数。
浮点数在某一些事情上是反直觉的。例如很多人都觉得浮点数是可以进行比较的对吧。但是实际上如果我们编写如下的代码会发生什么呢？

fn main(){
assert!(0.1+0.2==0.3);
}

程序将会panic，因为二进制精度的问题，0.1+0.2将会在N位之后与0.3发生偏差。

为了避免掉入陷阱当中，我们需要注意以下两点。

避免在浮点数上测试相等性
当结果在数学上存在未定义的时候我们需要格外的小心

但是如果非要进行比较呢？可以考虑用这种方式 (0.1_f64 + 0.2 - 0.3).abs() < 0.00001 ，具体小于多少，取决于你对精度的需求。

some ideas

Sat, 06 Jan 2024 00:00:00 +0000

一些关于为什么要学rust的想法

其实在大一的时候我就有了解过rust语言，当时甚至还看了一周b站的视频，在我最近准备再看rust的时候发现我大一装的环境还在，我甚至自己都不记得有这件事了。

rust语言据说有非常好的内存管理机制和安全措施，以及极高的执行效率，所以近些年被用作开发底层非常的多，而我对这方面也是非常的感兴趣，也算是兴趣驱动吧。希望能有助于提高一下自己的编程能力，让自己也多了解一下rust语言。

Effective Modern C++ 笔记

Sat, 09 Dec 2023 00:00:00 +0000

auto

在概念上auto已经极简了，但是实际上仍然要微妙许多。它可以节约声明类型，也可以避免许多手动类型的正确性和声明问题。但是从结果的角度来说，尽管auto很努力在做事了，但是仍然可能是错误的。如果出现这种情况我们要知道如何去引导auto让他成为正确的类型，因为退回使用手动声明类型仍然是下下策。

接下来的内容会涵盖auto的所有细节

Item 5: Prefer auto to explicit type declarations.

不仅可以避免出现为初始化的变量，避免啰嗦又繁杂的类型声明，能直接持有闭包，还可以避免一些因为“类型捷径”出现的问题。 eg1.

有一些程序员会对类型发生误判，到时用范围较小的类型在32位机器上能够运行但是在64位机器上发生了改变，导致程序在移植的时候出现问题。

eg2.

上述代码看起来没什么问题，但是当实际运行之后并没有对哈希表m进行操作。原因在于哈希表中的kay值是const类型的，手动声明的类型不一样的话编译器会进行一个神奇的操作，它会讲m中的内容复制成为临时变量将key的类型改为和声明一致的，再将p绑定到临时变量上。

Summary

auto说到底只是一个可选项罢了，不是必选项，如果你觉得你的项目使用显式的声明能够使得项目变得更加的可读和高效，当然可以继续使用。但是c++引入auto并不是一个多新鲜的东西，只是一个在其他语言中被称为“类型推导”的东西罢了。在其他的静态类型语言中类型推导都或多或少存在。而且动态语言还为类型推导积累了大量的经验。而且此类技术并不会于大型的工程项目产生冲突。

一些人觉得用完auto之后会让变量的类型变得不是一眼可以识别，但是这个问题随着ide的优化和适配已经被解决的相当完美了。

事实上手动声明变量经常是在画蛇添足，无论是正确率还是效率上。

Item 6: Use the explicitly typed initializer idiom when auto deduces undesired types.

纵使auto有万般好，但是auto也会出现推断的类型和你心目中期待的不一样的情况（当然也不完全是auto错了哦😀）下面举一个auto推断不符合预期的例子。

上述声明了一个返回vector< bool >类型的函数，使用了auto之后虽然仍然能够直接进行编译和运行但是结果却不是所想要的。

而发生这样错误的原因是，在c++的设计当中回避了bit的引用所以返回的不是bool&，实际上c++中设计了一个代理类来完成向bool的转换操作，这就不展开细说了，但是代理类并不少见，我们经常使用的两个智能指针就是一种代理类。

代理类的设计在使用的时候尽量少的对程序员暴露内部细节，这些代理类的使用往往会在文档中标识出来，如果在文档中没有体现的话，也避免不了在头文件中漏出一些破绽，最不济在debug的时候可能也会发觉是使用了代理类。

但是这些都不重要了，现在重要的事怎么把auto引导到正确的道路上🙃。

就是使用一个强制的类型转换，让它去到该去的位置，虽然看起来有点滑稽，给人一种头痛医脚的感觉🤣。虽然在这些时候你也可以放弃使用auto，但是在这个踩坑的过程中不是也收获了新的知识么?😁

总之记住以下两点

隐形的代理类可能会让auto推断出错误的类型。
显式的类型转换可以让auto走向正确道路。

Moving to Modern C++

接下来这一章会详细介绍现代c++的一些细节特性。我自己会记录几个我认为比较实用的。并不是全部。

Item 8: Prefer nullptr to 0 and NULL.

非常显然的是0的类型是int，不是一个指针，但是在一个本应该出现指针类型的地方出现了0，编译器也会勉强吧0解释为空指针，但这毕竟是不得已而为之的行为🙉，总之0是int，不是指针。

nullptr’s advantage is that it doesn’t have an integral type. To be honest, it doesn’t have a pointer type, either, but you can think of it as a pointer of all types. nullptr’s actual type is std::nullptr_t, and, in a wonderfully circular definition, std::nullptr_t is defined to be the type of nullptr. The type std::nullptr_t implicitly converts to all raw pointer types, and that’s what makes nullptr act as if it were a pointer of all types.

CMU15-445- Project #1 - Buffer Pool Manager

Fri, 08 Dec 2023 00:00:00 +0000

环境搭建

按照P0的指导中进行环境的搭建，由于我本人现在时WIN平台，课程没有提供一键配置环境的脚本，所以我选择云服务器进行环境的构建，很稳。

但是我的云服务器配置只有2核2G在编译的时候会爆内存。这里还有个故事，在爆内存之后我已经意识到这个问题，我给阿里云客服提了个工单试图能白嫖一些配置，客服还是很有水平的，直接就分析出来我是内存爆了导致的，但是直接建议我加钱升级配置，不告诉我设置swap分区，有点不厚道了。

话说回来，设置完swap分区之后就没有再出现过爆内存的现象。用VScode的远程开发，体验还是很不错的。

Overview

p1主要是内存管理部分的内容，这门课程的课本和录制视频还是很有必要看一下的。

主要的任务是以下三个部分：

可扩展的哈希表
LRU-K的淘汰策略的视线
Buffer Pool的一个实例

在开始梳理项目之前我想要先解释清楚一下三个任务之间的关系，以及各个部分的负责。

frame更像是一个载体，而page是其中的内容。打个比方来说，一个仓库（buffer pool）只有100辆货车（frame），而货物（page）成千上万种，每次都是仓库告诉货车需要什么货物然后由货车带着货物来到仓库，而可扩展的哈希表就是登记货车和货物的对应关系。因为只有100辆货车，当每辆车都是满的时候（没有闲置的车辆free_list不为空）就需要根据task2的LRU-K算法挑选出一个符合要求的货车清空后去装载指定的货物。而task3就是负责整个的管理和交互。

大概解释了一下，可能比方不是很恰当，做的时候一定要多看文档和注释，因为漏看注释给我带来了极大的痛苦。

Task #1 -ExtendibleHashTable

项目架构

首先要清楚这个是自己动手实现一个可扩展哈希表用于保存frame和page的映射关系的。我觉得首先要明白frame和page之间的关系。不清楚的可以回看上文的解释。

Bucket 存储桶

在可可以扩展的哈希表种引入和Bucket的概念，用于解决哈希冲突的问题，每一个Bucket的大小都是固定的，当一个Bucket满了的时候就需要进行哈希表的扩展。

Bucket的组成

depth_：表示本地深度的一个标识，用于识别当前的深度是否和全局深度相同。要特别注意这个变量。
list_：发生哈希冲突时保存多个（K，V）映射的双向链表。
size：为了保证效率，list的长度不能无限延伸，所以达到一定长度的时候要进行哈希表的扩展。

可扩展的哈希表结构

Bucket_size:用于限制每个bucket的list的长度
dir_:用于哈西运算后保存映射关系。
global_depth_:全局深度，在插入的时候根据全局深度和局部深度来确定这个桶是否要进行重新的分配。
num_buckets:用于统计现在一共有多少bucket。

ReHash的过程详解

1.hash的规则是什么样的

template <typename K, typename V>

auto ExtendibleHashTable<K, V>::IndexOf(const K &key) -> size_t {
  int mask = (1 << global_depth_) - 1;
  return std::hash<K>()(key) & mask;

}

上述函数就是该哈希表的映射规则，总的来说就是取hash函数值的低global_depth位

假如现在global_depth_的值为3。那么 1 << global_depth_的值就是8转换为二进制就是 1000 。mask=8-1=7，转换为二进制就是 111.

mask 的作用就是取一个位数和global_depth_一样的全1的二进制数，为了取低global_depth_位做铺垫。

现在假如key的值进行完hash之后是 10110100011010 和 mask进行进行 & 的操作之后就变成了 010 （低3位）

B+ Tree Index

Thu, 07 Dec 2023 00:00:00 +0000

TABLE INDEX

A table index is a replica of a subset of a table’s attributes that are organized and/or sorted for efficient access using those attributes.The DBMS ensures that the contents of the table and the index are logically synchronized.

索引让数据在数据库中的查询更加的高效，DBMS负责使索引和实际内容同步。

DBMS的工作是选择最优的索引去执行查询，这就带来一个需要权衡的问题——索引越多查询越高效但是相对的维护成本（Maintenance Overhead）和存储成本（Storage Overhead）就会相应的提高。

B-TREE FAMILY

B-树家族。

重点了解B+树。

（B树虽然是一个平衡树（balance），但B树的B不是balance的缩写，到底代表什么还存疑）

B+TREE

B+树是一个自平衡树的数据结构，顺序的存储数据，并且将查询，顺序访问，插入和删除的时间复杂度基本控制在O(log n)。

是二叉搜索树的推广，因为它可以有超过两个的孩子节点。
它针对系统和存储之间的大块数据读写进行了特别的优化。

B+TREE PROPERTIES

B+树是一个多叉搜索树，有以下特性：

他完美平衡
除了根节点都至少半满
k个值会把一个节点分为k+1部分。

B+TREE EXAMPLE

上图是一个小例子，能够发现B+树底层是能够双向访问的，这在多线程的时候有可能会造成死锁问题。这在后面讲解B+树多线程的章节也会对原因进行讲解。

CMU15-445- Project #0 - C++ Primer

Tue, 28 Nov 2023 23:44:18 +0000

CMU15-445

作为 CMU 数据库的入门课，这门课由数据库领域的大牛 Andy Pavlo 讲授（“这个世界上我只在乎两件事，一是我的老婆，二就是数据库”）。

这是一门质量极高，资源极齐全的 Database 入门课，这门课的 Faculty 和背后的 CMU Database Group 将课程对应的基础设施 (Autograder, Discord) 和课程资料 (Lectures, Notes, Homework) 完全开源，让每一个愿意学习数据库的同学都可以享受到几乎等同于 CMU 本校学生的课程体验。

亮点在于这门课程实现了一个关系型数据库的Demo–bustub，并对组成部分进行修改，最后达到完成整个数据库的目的，非常的有意思。

近年来由于CMU15-445这门课的热度大增，无论是找工作还是保研的简历上都少不了这个课程。到了可以说是人手一个的地步（还有MIT6.824），但是最后的排行榜上真正完成4个项目并且有成绩的不过100余人。在这种背景下也催生出了很多卖课的机构和个人。还有种种乱象。暂且按下不表，进入主题。

前言

先附上课程链接我原本是想要完成最新的课程即2023fall的，但是2023fall的P0直接就把我劝退了，相较于2022fall的P0我认为难度上升了不止一点。但是其他的Project的实现差别并不是太大，所以我选择了较为容易下手的2022fall的课程进行学习。

Project0-C++ Primer

还是先放上项目Project#0-C++primer链接

概述

这是一个相当于先导课程的项目，旨在培养和检验学生的现代C++编程能力 ，BusTub大量使用C++17，当你上手之后可能就会发现和你印象中的C++不一样。

在CMU如果你没能满分通过P0，那么你会被要求退课。

所需前置知识

我认为需要的前置知识主要包括C++11的新特性 这是在2023fall课程的一个可能是助教写的一个小demo包含了几个例子能够帮助你快速的上手c++11的新特性。

熟悉字典树能够理解字典树原理能够完成一个字典树的小demoLeetCode.208实现前缀字典树可以先把这个做了，了解一下什么是字典树。

上图就是一个字典树的简单示意图

文件结构

在文件中作为字典树的架子文件中包含了三个类。

TrieNode
TrieNodeWithValue
Trie

Task#1 字典树

先完成一个单线程版本的字典树，后期再考虑并发。

TrieNode

TrieNode定义了一个Trie树的一个节点。

一个包含关键字的char类型`key_char_。
一个bool类型is_node的标志来标记这个节点是否是值节点
包含一个存储类型为 char to unique_ptr<TrieNode>映射的哈希表 需要注意的点： C++中智能指针std::unique_ptr的特性所带来的： The InsertChildNode and GetChildNode both return a pointer to unique_ptr 这个独享类型的智能指针也不支持被复制，所以要么使用std::move()把所有权交出去，要么就用get()函数把裸指针交出去。 the move constructor TrieNode(TrieNode &&other_trie_node) is used to transfer old TrieNode’s unique pointers to a new TrieNode。因为是unique_ptr所以在传递的时候不能对指针进行复制。（解决方法就是使用move()函数）。

Mon, 01 Jan 0001 00:00:00 +0000

麻雀虽小五脏俱全的一个小而全的类unix教学用操作系统，由MIT开发

多核的操作系统，大约6000行还有大约300行的汇编，代码简洁易懂，有很多设计都值得借鉴。

一些特性

有进程管理功能
有虚拟地址和空间，pagetable
文件系统
时间片
21个syscall

用户程序

sh cat echo grep kill 能够被视为一个真正的操作系统

缺失的功能

用户ID
登录功能
文件保护
虚拟内存
无法联网
只有两个设备驱动

xv6特性

SMP 多线程共享内存

设备

UART 发送字节流，从一端到另一端
disk 磁盘驱动器
定时器
PLIC 平台级中断控制器，哪个核心应该被告诉中断
CLINT 本地中断控制器

内存管理

pagesize 4096B
一个freelist
没有可变的内存分配
没有“malloc”
三级页表 sv39，在pgtbl 巨页中有用到

调度器

基本的循环调度时间片的大小是固定的所有的核心共享一个就绪队列，循环的寻找可以执行的进程不是完全的循环，如果在时间片内结束，会把这个进程放进队列然后换一个来

启动顺序

加载核心代码到固定的地址0x8000_0000,没有bios，bootloader bootblock

锁

自旋锁，sleep（），wakeup（）

param.h

用户地址空间

函数的参数将会被放在栈中。

xv6的虚拟地址

sv39，三级页表之地实际上xv6只使用了38位所以最大的是256GB

xv6启动过程和组织

控制权逐步的转移

数据的类型

自旋锁

循环不断的检查，直到能够获取锁为止 test and set，原子的操作。释放的时候直接修改值就行，可能看起来不是很原子，但是在内存里这被视为一个单独的操作。

JiaLog

Project 6 - 令牌撤销与单点登出

实验目标

实验任务

任务 1：完善令牌管理器的撤销逻辑

文件位置

1.1 完善 remove 方法

Project 5 - 令牌颁发与刷新令牌轮换

实验目标

理论背景

1. 访问令牌 vs. 刷新令牌

1.1 核心区别

1.2 为什么需要两种令牌？

2. 刷新令牌轮换 (Refresh Token Rotation)

2.1 传统方法 vs. 轮换方法

Project 3 - 全局会话管理 (TGT)

实验目标

理论背景

1. 什么是票据授予票据 (TGT)？

1.1 TGT 的定义

1.2 TGT 在 OAuth 2.0 流程中的作用

2. 会话管理策略

2.1 生存时间 (TTL) 策略

Project 1 - 环境搭建与系统设计

实验目标

详细任务

一、环境搭建

1. 安装 JDK 17

步骤

Project #0 - 实验准备

重要提醒

概述

必读材料

你的任务

实验评估方式

我与杭高——25国科大杭高院上岸记录

个人背景

为什么考研？

择校过程

备考经验

🎯 考研复习时间安排（2025）

2021——2025：我的大学

关山难越

谁悲失路之人

Lab1 Xv6 && system calls

Using gdb

编译并启动

System call tracing

Attack xv6

page组成

变量

变量的绑定与解构

变量可变性

使用下划线忽略未使用的变量

虚拟化--进程管理API：fork, execve, exit

操作系统上的进程

fork（）

execve（）

exit（）

Project 4 - 授权码管理与 PKCE

实验目标

理论背景

1. 授权码流程详解

1.1 为什么需要授权码？

1.2 授权码的生命周期

2. 授权码截获攻击与 PKCE

2.1 授权码截获攻击场景

2.2 PKCE 工作原理

Project 2 - 用户和客户端验证

实验目标

理论背景

1. 用户认证的安全原则

1.1 密码存储

1.2 账户锁定策略

1.3 密码过期策略

xv6-环境搭建

xv6 启动！

一个很有意思的工具 bear

如何在vscode中debug

CMU15-445总结

1.1 完善 `remove` 方法

Join Operation，连表