总的收获：

1. 通过学习操作系统对rust 编程中的借用和生命周期对保存内存安全有了深刻的理解

2. 对risc-v 和 arm以及x86 的不同的架构体系有了更深入的理解，理解了ISA 是软硬件接口，深化了接口的理解

3. 理解了 操作系统实现中软硬件配合方式，包括机制和策略。尤其是实现虚拟内存时 为了达到硬件不过于复杂而且性能的最大化，硬件和操作系统各有折中 需要紧密配合

4. 对于进程和文件的抽象 ，为什么会这样做 以及演变过程 有了更深刻的了解。

   从单纯执行任务的job进化到拥有 虚拟空间和状态 且可以动态创建和销毁的进程，并不是一开始就是这样的。

   对于文件系统的抽象，我理解了抽象的2个角度.第一个角度是从使用者角度，要越简单越好，第二个角度是从实现者角度，其实现的过程时复杂的，但暴露的接口是简单的，统一的

5. 对多线程和协程的实现机制，让我了解到了 对于不同的任务io密集和cpu 密集型，为什么协程更有效。对多线程之间的同步互斥机制有了更加具体深刻的认识，能够分辨自旋锁和基于等待的锁 的应用场景。

6. 通过这次学习填补了 概念和实践上的鸿沟，操作系统不再仅仅存在于书本中的理论中。感谢训练营的各位老师！！

第一阶段

之前在公司工作的时候就了解到了 rust，工作中客户端使用 rust，当时觉得 rust 离后端(服务端)比较远，就错过了 rust 的深入了解与学习。
在这几年的工作与学习中，慢慢接触到rust在操作系统的领域也在使用。于是准备学习一下这门新的语言。自己也想对操作系统相关方面做一些
更加深入的了解。

一次偶然的机会在github 上看到了 rcore，用 rust 写操作系统，这个和自己的需求完美契合了。。。

本课程第一阶段采用 rustlings，在线测评，然后对应的知识点也会有出处。是一个非常好的学习工具，但是整体来说数据结构部分相对较难，需要
一些相关数据结构的基础，以及对 rust 语法的了解。

自己对 rust 相关的一学习的例子与记录： https://github.com/FunCheney/Fos/tree/main/rust-study

整体感觉：

1. 语言的学习还是要多动手练习，多写代码才能理解
2. 数据结构与算法相关的章节还需要持续的练习
3. 后续还要安排并发相关的学习与记录：https://github.com/FunCheney/Fos/tree/main/rust-study/rust-atomics-and-locks

第二阶段

整体来时实验教程偏简单且大多都一笔带过。学习的过程中主要还是参考: rCore-Tutorial-Book 第三版！

因为在训练营开始之前我就已经在通过看： rCore-Tutorial-Book 以及抄 https://github.com/rcore-os/rCore-Tutorial-v3 中每一章节相关的代码，
因此在训练营阶段也在抄其中代码，在自己的仓库里面手写了一遍相关代码。

对 risc-v 精简指令架构有了一些了解：https://github.com/FunCheney/Fos/tree/main/code/asm 主要代码实现。
整体感觉：

1. risc-v 的指令架构没有 intel x86 指令复杂。
2. 文件系统，与锁相关的实验部分用时教程，偏难。
3. rust-sbi 和 qemu 会简化很多汇编的相关的工作。降低了对操作系统启动记载相关的一些理解门槛，之间看过 linux 0.11 相关的启动逻辑，还是比较复杂。
4. 通过在线测评的方式，通过一些测试用例可以起到检测的收手段。比自己写代码的时候（尤其是还在学习过程中）不知到对错会更有方向。但是还是缺少一些
   最佳的实现知道，因为不知道自己过了是否就是好的编码方式，好的实现思路。

一阶段 Rustlings

​ 机缘巧合之下,对我教育颇深的学长为我介绍了这个训练营,于是一段艰辛的历史就开始了

​ 初学rust,被他严格是语法体系给搞傻了,这也不给那也不给,对于写惯C++ 的我来说简直不可理喻。rust语法体系中不允许隐式类型转换,即使是在C++中的非窄化类型转换也不允许。更要命的一点是,所有变量默认全是按const不可变变量来处理的,这极大地降低了我的愉悦性,在C++中此类const操作时显示的,在这变为隐式。还有一点则是类型的特性不会自动从父类继承(C++是这么称呼的,rust学的不太行),必须我去一 一 写出,也是很难受。

​ 介绍完了令我不愉快的地方,rust的优势也很明显,不允许随意更改变量,不允许直接操作指针,变量的所有权等等,在重重限制下无疑降低了代码出错率,不过我还是喜欢C++。

二阶段rcore

​ 这一阶段别提多痛苦了,一阶段语法就没学好,大半时间都在调语法错误,章节知识点介绍都挺好的,想一想也容易想出来,over,不过我还是喜欢C++,rust使我痛苦 , 重复可变借用我恨你

第一阶段总结

rustlings很有用，年轻人的第一款cpp.

第二阶段总结

老实说，文档很抽象，框架体验也比较一般……

希望越来越好

希望有更多的工具相关内容，例如gdb和cmake。os相关工作其实相对少，但是学习工具的使用对各方面都很有用。

文档要是能多一些图就更好了，理解起来实在有难处。

Rust编程技巧与示例：宏、算法与类型转换

在Rust编程中，有许多细节和技巧可以帮助开发者更好地组织代码、优化算法性能，以及确保类型安全。本篇博客汇总了一些Rust编程的核心要点和实用代码示例，涵盖了宏的使用、排序算法、树和图的操作等内容。

1. 宏与#[macro_export]、#[macro_use]

Rust中的宏非常强大，用于生成重复代码和提升代码的灵活性。使用#[macro_export]可以导出宏，使其在其他模块或包中可用；而#[macro_use]则在现代Rust中被推荐通过use语句显式引入。

示例宏定义：

1
2
3
4
5

#[rustfmt::skip]
macro_rules! my_macro {
    () => { println!("Check out my macro!"); };
    ($val:expr) => { println!("Look at this other macro: {}", $val); };
}

这里的#[rustfmt::skip]用于避免自动格式化，保持代码样式的灵活性和可读性。

2. Rust中的类型与特性

在实现数据结构或算法时，我们通常需要对泛型类型T施加一些特性约束，例如：

• Ord：使得元素可以比较大小，适用于排序、合并等操作。
• Clone：便于复制元素值，即使是复杂类型，也可以无所有权转移地复制。
• Display：实现字符串友好的格式化输出，便于打印和日志记录。

这些特性可以通过where语句在泛型实现中指定：

1
2

impl<T> LinkedList<T> 
where T: Ord + Clone + Display

3. 内存操作与指针

Rust通过unsafe块支持手动管理内存和指针操作，用于高性能或底层操作。
例如，获取节点的指针并解引用：

1
2
3

let node_ptr = Some(unsafe { NonNull::new_unchecked(Box::into_raw(node)) });
res.add((*node_ptr.as_ptr()).val.clone());
cur_a = (*node_ptr.as_ptr()).next;  // 注意这里直接获取的是ta的next指针

指针的安全解包和操作要格外小心，可以使用Option配合unsafe避免空指针风险。

4. 算法设计示例

4.1 链表与树的操作

插入与查找

在链表或树结构中，我们经常用到Option类型来表示节点的存在与否。例如，在插入和查找二叉树中，可以选择使用if let语句来处理Some和None的情况：

1
2
3
4
5
6
7

fn insert(&mut self, value: T) {
    if let Some(ref mut node) = self.root {
        node.insert(value);
    } else {
        self.root = Some(Box::new(TreeNode::new(value)));
    }
}

这种写法在处理可变引用时尤其简洁。

4.2 排序算法与Ord与PartialOrd

选择排序等算法需要比较泛型元素的大小，通常需要PartialOrd特性来支持部分排序（如非全序关系的情况），而对于要求全序的场景可以使用Ord。

4.3 深度优先与广度优先搜索

在图算法中，深度优先搜索（DFS）和广度优先搜索（BFS）是两种基础的遍历方式：

• DFS示例：

  1 2 3 4 5 6 7 8 9

  fn dfs_util(&self, v: usize, visited: &mut HashSet<usize>, visit_order: &mut Vec<usize>) { visited.insert(v); visit_order.push(v); for &nei in self.adj[v].iter() { if !visited.contains(&nei) { self.dfs_util(nei, visited, visit_order); } } }

• BFS示例：

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

  fn bfs_with_return(&self, start: usize) -> Vec<usize> { let mut visit_order = vec![]; let mut visited = vec![false; self.adj.len()]; let mut queue = VecDeque::new(); queue.push_back(start); visited[start] = true; while let Some(node) = queue.pop_front() { visit_order.push(node); for &neighbor in &self.adj[node] { if !visited[neighbor] { visited[neighbor] = true; queue.push_back(neighbor); } } } visit_order }

4.4 平衡堆的插入与调整

Rust标准库中Vec的swap_remove方法可以高效地删除指定位置的元素，适用于实现优先队列等堆结构：

1

let result = self.items.swap_remove(1);  // 移除并返回指定位置的元素

在删除元素后，可以通过调整堆结构（如最小/最大堆）来保持堆的性质。

5. 实现栈与队列

使用双队列实现栈的操作逻辑：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

pub struct myStack<T> {
    q1: Queue<T>,
    q2: Queue<T>
}

impl<T> myStack<T> {
    pub fn push(&mut self, elem: T) {
        self.q2.enqueue(elem);
        while !self.q1.is_empty() {
            self.q2.enqueue(self.q1.dequeue().unwrap());
        }
        std::mem::swap(&mut self.q1, &mut self.q2);
    }
}

这种方法利用队列的FIFO特性来模拟栈的LIFO特性。

6. 函数与内存管理

Rust中的Box和unsafe结合用于手动管理堆内存。Box::from_raw可以从裸指针重新创建Box，这在需要手动内存管理的场景中非常有用。

1
2
3
4
5

unsafe fn raw_pointer_to_box(ptr: *mut Foo) -> Box<Foo> {
    let mut ret: Box<Foo> = unsafe { Box::from_raw(ptr) };
    ret.b = Some(String::from("hello"));
    ret
}

这种方法常用于FFI（外部函数接口）中将指针恢复为拥有所有权的Rust类型。

总结

Rust语言通过丰富的内存管理工具和类型系统，确保了在安全性和性能上的平衡。无论是自定义数据结构还是排序、图遍历等基础算法，Rust的特性可以为代码提供极大的灵活性和安全保障。

调度

三级调度：

作业调度、高级调度(频次最低)：主要解决：接纳多少个任务+接纳那哪些任务这两个工作

进程调度、低级调度(频次最高): 必须有、核心，确定哪个进程可以占有CPU并执行

中级调度：将那些暂时不能运行的进程从内存挂起到外存，(阻塞状态下进程实体(程序 + 数据 + PCB)还在内存中，而挂起状态会把进程实体挂到外存，但是PCB会存在系统内核空间中，会记录进程在外存的状态以及位置)，一般在内存紧张时使用

高级调度，用于批处理系统中，将任务从外存调度到内存中去。(在分时/实时系统中，任务是直接在内存，因此没有高级调度)

分时系统：只有进程调度

批处理系统：进程调度 + 作业调度

调度算法相关

准则：周转时间(常用于批处理系统)、平均周转时间、带权周转时间

响应时间(交互性作业、分时系统)、截止时间的保证(实时系统)、优先权准则

周转时间 = 完成时间 - 到达时间

带权周转时间 = 周转时间 / 服务时间

调度算法

• FCFS(first come first serve), SJ(P)F等等
  对于抢占式调度，注意服务时间的更新，然后再比较，看谁抢

• 高优先权 优先调度算法

  静态优先权：简单，但存在饥饿现象

  动态优先权：eg Rp = （等待时间 + 服务时间）/ 服务时间 作为优先权 1 + tw / ts;

• 时间片轮转 ……?

  多级反馈队列 S1 < S2 < S3 优先权 S1 > S2 > S3

• 实时调度

  非抢占：轮转 || 优先权

  抢占：基于中断时钟，好处是减少了上下文保存切换的次数

  ​ 立即抢占

  实时调度算法：EDF、LLF，还有例题

• 其他一些？？

  MPS：CPU共享内存， 共享缓存(单个儿独立的，容易出现绑定，忙闲不均)

  SMP中进程分配方式：静态分配和动态分配

  ​ 调度方式： 自调度和成组调度(两种方式就对应了用户级线程和系统级线程)， 专用处理机分配？

死锁

一些定义：

• 可剥夺资源：如主存，CPU，可以在使用时被强占的资源
• 不可剥夺资源：不可被打断抢占的资源，如驱动器，打印机
• 永久资源(外存)，临时资源(进程运行过程中临时产生的数据资源等等)

竞争非剥夺资源，或者竞争临时资源可导致死锁

死锁的必要条件

• 互斥条件：进程互斥的使用临界资源
• 不剥夺条件(不可抢占)
• 请求-保持条件：进程在申请新的资源的同时，保持对某些资源的占有
• 环路等待：循环等待链

解决死锁的方法

从严格依次降低，为

预防 -> 避免 -> 检测与解除

预防

上面4个条件是死锁的必要条件 ， Deadlock -> 4 其逆否命题为 !4 -> !Deadlock,所以我们从4个条件入手

1. 互斥，并没有好的办法
2. 不抢占：不抢占变成”抢占”，如果进程申请不到全部资源时，主动释放
3. 请求保持条件：使用AND机制，但是有点浪费资源
4. 环路等待：破除环路，资源排序，参考哲学家进餐

避免死锁

这是比较中庸的做法，既不损耗很多的效率，也比较的严格

银行家算法

一种是，资源分配表，为

另一种是，计算表

对资源进行分配时，分成两步

1. 判断分配请求 R是否满足 R < Available && R < Need
2. 如果满足1，使用表1表示分配后的资源表T1，再次计算是否存在安全序列，如果不安全，退回至T0，否则保存T1，下次分配将从T1开始。

检测和解除

使用方法：资源分配图

几个结论

• 不可完全简化 => 存在死锁
• 分配图中无环 => 不会存在死锁
• 分配图中有环 => 不一定死锁

简化方法，对一个资源分配图，首先考虑持有边，如果持有者线程能够完成(获得所有需要的资源)，将持有边消去后，将资源返回，如果不能完成，边消去后，仍保持资源占有，直到完成。

然后考虑请求边，如果请求的资源有空闲的，可以把边消去，若请求线程能够完成，则可将该资源返回，否则保持占有

重复上述过程，直至卡住，或者全部成孤立。

解除

通过撤销进程或者挂起进程来释放一些资源，进而推动僵持状态。

而具体的对哪些进程，以什么样的顺序进行操作，可以参考Dijkstra之类的算法，找到一种损耗最小、利益最大的方法。

阶段一：rust语言学习阶段

学了一门新的语言，很是开心，对于Rust这门语言，在使用了一段时间后，虽然编译器折磨了我好久好久，但是，适应后我觉得实在是太贴心了。我不用担心内存
莫名其妙崩溃，不用担心自己的代码“不够快”。对于C++来说，Rust更像工业化的结晶，浑身上下散发着标准化的气息，我认为Rust的未来是光明的，它肯定会逐渐
顶替掉现在几大编程语言的地位。

阶段二：rCore OS设计实现阶段

这个阶段我获益匪浅，反复修bug也极大增强了我的编程能力，真的很喜欢，就是时间好感呀┭┮﹏┭┮，现在马上时间就截止了

lab1

实现了一个TaskInfo的提取，本身难度不大，不过刚接触系统的我写了好久，后面发现关键问题后自然就“迎刃而解”了
。

lab2

实现虚拟内存，诶，之前我暑假就学习了CSAPP，对虚拟内存的运作还是比较熟悉的，可是，我没有做实验，呀呀呀呀。做实验时那个TimeVal我一直不确定怎么
处理，还有就是我一开始思路严重有问题，舍弃了已有的封装好的系统，企图自己在写一个全局内存管理器。其实用户空间跟每个任务已经绑定在一起了，轻轻push
一下就好了。在四处求救后TimVal也是解决了

lab3

这个实验不理解具体区别，我一遍就过了，嘻嘻

lab4

文件IO重定向，这个我全程独立解决，并且我认为很好的实现了最开始的要求，unlinkat能够替换掉close,并且更改到了内存。

lab5

很难，很有跳战，银行家算法也让人眼前一亮，哈哈，写出来了

其他：

诶，最后一个实验自己sys_get_time没写，一直卡关，真的好无语

第一阶段

在参加训练营之前，我已经简单学习了一些 Rust 的相关知识，因此 Rustlings 我非常块的就完成了。在这个阶段的学习中，我复习了一些 Rust 的卖点，像是所有权和生命周期模型；除此之外也有一些新东西，尤其是宏和单元测试相关的内容，在之前的入门学习中我只是匆匆略过，到了现在才发现还有许多我没有关注到的重要的细节。

除了对 Rust 的学习，这个阶段对于我熟悉开发工具也提供了很大的帮助。由于学习时基本接触不到现代的项目开发，我对 git 这样的开发工具以及远程仓库、第三方库等等概念都没有了解。通过在设置 Rustling 的过程中反复使用各种命令、配置开发环境，我对接触大型项目也稍微自信起来了。

第二阶段

第二阶段对我就是非常大的挑战了。这次训练营可以说是我第一次接触操作系统底层，中间很多课程、作业也学的很辛苦，不过看着 ci 一片绿油油的 [PASS] 还是不由得感觉到一些成就感的。

这一阶段的学习我都是按照“看简略版教程 -> 看源代码 -> 参考完整版教程 -> 尝试实现 -> 看群友讨论难点”这样的节奏完成的。中间被别的事情占了一点时间，所以最后变得很仓促，好在是压线过关了，大概我的答案还有很多问题要我回去修改吧。

lab3 现在看来是其中最基础的一课了，不过刚拿到题目的时候还是让我面对着茫茫代码无从下手。现在想来，这一章最重要的就是推动我大胆行动，不要害怕动已经写好的部分。后面的作业很多需要跨越好几级抽象直接在系统最底层的部分做改动，如果还是按照学校里对着函数填空的思维去做是不可能有办法的。

lab4 主要关注的是“地址空间”抽象，对于写习惯了应用软件的人来说“解引用指针”突然变成了一个要跨越页面页帧、从好几层字典树中查表的行为，算是一个不小的跨度了，从群友的反馈来看这一篇作业也有一定难度。不过系统已经完成的部分中其实有许多可以类比推广的部分，比如 translated_byte_buffer 的实现稍加修改就能够变成“解引用指针”的 translated_refmut，像是作业中的其它部分也有类似的部分可以借鉴。

lab5 的 sys_spawn 可以参考 fork 和 exec 两大函数比较轻松的写完，不过 stride 算法就有一些难度了。说实话由于测例无法涵盖算法的所有问题，我在写这一段的时候也是一头雾水，到现在也不知道自己写的有没有问题。

lab6 是我认为这次作业的另一大难点，文件系统的几个 Inode 一开始让我陷入了混乱，不知不觉就把该磁盘上修改的节点修改到抽象节点上了。最后的实现也有一些偷懒的地方，链接没有和文件分开，擦除链接也有点粗暴，不过我想几个关键的思考方向我是没有搞错的。

lab8 虽然指导我使用银行家算法，但我的实现采用的是维护资源图、尝试解锁时寻找环的思路，好在从最后的结果来看我想应该是没有太大的问题的。

最后还是很幸运能通过这一阶段的训练营，感觉这两个月因为训练营过的非常充实，也对自己以后很可能投入的领域有了真正的了解，希望能带着这些收获继续走下去吧。

阶段1

21年冬季就接触过rust，但是后续没有继续学，直到今年5月份劳动节假期看到rust嵌入式群里活跃的气氛才逐渐入门，这次rustlings做第三次了，这次比之前多了算法题环节。
一直有人调侃用rust写个链表，这次真就写了一次链表，rust的裸指针乱飞。

阶段2

ch1-3

深刻理解了操作系统的上下文切换，从最开始内核创建用户态程序，到用户态发起系统调用在返回的整个流程。

ch4

工作第二年接触过内存分配的代码一直不是很明白，尤其是在触发中断时，页表是怎么从进程空间切换到内核空间，以前只是粗略的了解Linux会将内核对应的内存映射到进程空间，在这个实验中又学到“双页表这个概念”，比较两种的优劣

ch5

以前对进程创建的了解仅限于fork这个系统调用，对其他进程相关的系统调用知之甚少，这次在参考fork、exec两个系统调用实现spwan过程中，理解了为什么

ch6

这个实验中学习了文件系统在物理存储设备的布局方式，不过，该文件系统较为简单，应该是类似ramdisk的实现，并未考虑磨损均衡，实验中的部分实现也都可以偷懒。
实验中最难的部分就是文件相关的那么多结构体，部分是方便操作系统进行管理的，部分是真实存在于块设备中的索引结构以及文件组织结构。
在实验代码中也学到了rust trait对象的使用方式，Linux里一切皆文件的概念有了真切的感受。

ch7

在过去写代码时，对进程间通信没有明确概念，尤其是敲命令行时，并没有想过管道符的实现，操作系统借助文件的概念，通过标准输入输出将管道符的多个程序连接到一起，在流水线处理某一任务时又方便又能充分发挥机器性能。

ch8

到最后六小时才开始做这个，多亏群里好心人指点，才能赶在最后时间完成，不得不承认rust的静态分析真的不错，哪里变红改哪里。

感想

在毕业两年后有机会学习清华的操作系统课程倍感荣幸，补上了我本科操作系统选修未开课的遗憾，也补上了我工作两年中知识欠缺的地方。

阶段三我来了！！！

前言

其实在笔者去年大二的时候，就了解了一些系统赛和rCore的相关信息，当时人比现在少很多，笔者也因为课业压力很早就放弃了。今年虽然同样有些别的事要忙，但是也各抽出一周写了前两个阶段。

在此期间，充分感受到了rust的优势，如果换成cpp的话我可能早就放弃或者早就做完了（x，rust有一种被编译器推着前行的感觉，并且rcore的代码组织相当优秀，无论是抽象层还是语法设计，都十分值得学习。

rustlings

第一阶段是来自rust官方社区的rustlings语法练习，并且经过了一定的增加，加了一些用得到的数据结构算法内容。总体没有什么难度，也并不需要完全弄懂，起到了一个入门的作用。所有权，生命周期，泛型之前就在moderncpp中有所涉猎，所以理解起来没有遇到什么困难。

rCore

整个第二阶段的质量相当高，除了视频以外可以说感觉做下来不逊于6.1810，题目相当的有代表性并且需要读懂很多部分的代码才能获取正确的思路，起到了很好的引导作用。

ch3

ch3的潜在难度在于内核栈较小导致无法直接传递较大的数组，导致只能通过引用来传递，即使这里并不涉及地址变换。如果在ch3中遇到了这个坑，就更能理解后续页表的意义。

ch4

ch4中带领入门了段页式的页表和页帧。需要正确掌握好页表和物理页帧的对应关系，确保这两者是同步的而且是有效的。

ch5

ch5的编码量较少，只需要找到正确的地方插入pcb的转移和下个task的获取即可。

ch7

ch7入门了fs的抽象，从OSInode到Inode到diskInode到blockcache的抽象，层层深入，再加上用于查找的dirEnrty和fdtable，使得整个抽象层设计相当清晰。

ch8

ch8的难度在于语义含糊，我们仅有两类资源，其中mutex每种只有一个，semaphore每种可以有多个。在此基础上需要正确的理解need和alloc对应的语义，并且在阻塞线程被唤醒时及时更新。