开端

从同学听到有关这个开源夏令营的事情，一方面对rust这种新兴语言颇为感兴趣，另一方面也正巧学习计算机系统知识，认识到计算机系统的精妙，也希望借此机会提高自己对计算机系统的理解，获得一定的开源经验。

链接

主要的笔记都记录在notion中，主要包含我rustlings过程中的思考和体会，记录比较精简。
https://ash-chair-1e2.notion.site/193e1434faf44e5587e71865fc9614af?v=6e2890c3bd084a77b864410b009d9706&pvs=4

第一阶段总结

这一阶段主要是熟悉rust语法以及相关知识。在我的学习中看来，rust主要有以下几个难点：

1. 控制权转换。
   • rust中，move是默认语义，而浅拷贝（在rust中被称为引用）成为了次要语义，这使得程序需要不断地考虑生命周期
2. 引用的简写
   • rust中让我最不能够理解的是引用的自动解引用功能，我认为一个强类型语言可以用更加明了的方式进行引用和非引用的区分。当然这只是我的浅薄观点，因为引用和非引用的自动转换实在让我伤透脑筋。
3. 生命周期
   • 实际上rust中存在对生命周期非常精准的控制，然而受限于我的学习速度，还没有对生命周期参数和控制有更深的了解。
4. 大量的现代特性
   • 在学习rust的过程中，我体会到了很多“旧语言”没有的特性，例如函数式编程、模板约束、宏的元编程等特性。这不禁让我想起了学习现代C++的某些特性（但是根本没有实际使用过）

第二阶段

接下来，主要就是学习riscv指令集，同时准备把更多时间花在系统课程上，配合CSAPP学习一个操作系统的基础实现。

学习Rust有一段时间了，做rustlings中途没有写blog，正好总结一下作为初学者对Rust的一些关注点和总结。

没写完，就先这样吧（逃）

todo!();

Rust基本语法

变量

Rust变量声明使用let，类型放在变量名后面。例如：

1

let x: i32 = 114514;

Rust也能自动推断类型：

1
2

let i = 114514;
let s = "string".to_string();

i被自动推断为i32，s被自动推断为String

有些情况Rust也不能自动推断类型，比如：

1

let v = vec![];

报错信息如下：

1
2
3
4
5
6
7
8
9
10

error[E0282]: type annotations needed for `Vec<_>`
  --> exercises/variables/variables1.rs:10:9
   |
10 |     let v = vec![];
   |         ^   ------ type must be known at this point
   |
help: consider giving `v` an explicit type, where the placeholders `_` are specified
   |
10 |     let v: Vec<_> = vec![];
   |          ++++++++

这是因为Rust是一门静态类型语言在编译期必须得知变量类型的大小。

函数声明

声明方式大致如下。

1
2
3

fn func(a: i32, b: i32) -> i32 {
	a + b
}

…很多内容在其他语言都有类似的概念，只是语法稍有不同，因为懒惰不再赘述

Rust的特色

作为一门年轻的语言，Rust整合了许多其他语言的优势，比如C/C++的底层系统编程能力、Ruby 的包管理器Bundler （cargo）等等。而除了严格的编译期检查、所有权和生命周期机制实现的内存安全，Rust也有许多其他大大小小的特色和亮点，比如：

组合优于继承

表达式

模式匹配

闭包

使用Option来表达可能为空的值

使用Result来处理异常

各种智能指针

使用RefCell实现内部可变性

Rust与数据结构和算法

学Rust当然要从链表写起！
==学Rust千万不要从链表写起！==

Rust如何实现链表？

按照C/C++的一贯做法，我们可能会写出：

1
2
3
4

struct node {
	val: i32,
	next: Box<node>,
}

然而实际用起来，会发现你用不起来：

1
2
3
4
5
6

let n = node {
	val: 114514,
	next: Box::new(node {

	})
}

问题就在于Box里必须要有东西，即它任何时候必须指向一个有效的元素！别说链表末尾节点如何实现，我们甚至无法完成头节点（任何节点）这样一个递归定义的形式。

于是我们想到使用Option来表示可能为空的值，从而能够定义单个节点。

1
2
3
4

struct node {
	val: i32,
	next: Option<Box<node>>,
}

面向rCore的Rust

为了完成rCore，还需要深入了解Rust的哪些？

unsafe

外部接口

Rust编译和链接

Rust项目结构

另外推荐：《Rust死灵书》

始于rust

在参加训练营之前，我学rust有大概一年的时间了。rust是一门让我惊叹的语言，同时我也学到了很多。第一次完整阅读一本英文书正是官方的the book，它极大的提高我对英语的兴趣以及阅读能力。在rust之前，我学过c、c++、java、python以及go，但是毫无疑问我现在是rustacean，因为rust的设计哲学简直太赞了，其中特别是rust对option和错误的优雅处理。
学完rust后我就经常逛rust中文网，刚好了解到开源操作系统训练营，由此开始了我的开源操作系统之旅。

第一阶段总结

前100题主要是熟悉rust语法，其实这次我是第二次参加了，因此前100题对我来说没什么压力。后十题是算法题，涉及链表、二叉树、图等。学过rust的同学知道，在rust中处理自引用的数据结构相对其它语言会难上许多，不过真正了解过Box、NonNull等之后会感觉还好。这次二刷rustlings我又深入看了下标准库的Box、NonNull等结构，收获颇丰！

Rustling心得

Rustlings对于rust的上手帮助很大，不过它的难度比较松弛，而额外添加的10道算法题又弥补了这一部分。尽管如此，我在完成rustlings过程中还是遇到了很多问题和疑惑，解决这些问题让我对rust的理解提高了很多

24 vecs2

1
2
3
4
5

fn vec_map(v: &Vec<i32>) -> Vec<i32> {
    v.iter().map(|element| {
        element*2
    }).collect()
}

在这里出现了map和collect方法。map和collect的搭配是rust非常常用的元素处理方法，代表对迭代器中的每一个元素都进行传入的闭包的操作，并最后collect进一个集合中，collect可以指定集合的类型，如collect::<Vec<i32>>()，非常的好用

39 strings4

1
2
3
4
5
6
7
8
9
10

string_slice("blue");
string("red".to_string());
string(String::from("hi"));
string("rust is fun!".to_owned());
string("nice weather".into());
string(format!("Interpolation {}", "Station"));
string_slice(&String::from("abc")[0..1]);
string_slice("  hello there ".trim());
string("Happy Monday!".to_string().replace("Mon", "Tues"));
string("mY sHiFt KeY iS sTiCkY".to_lowercase());

string主题的练习中，&str和string类型的互相转换是一个重点，但是需要额外注意的不仅是各类函数的适用对象，还有其返回值所有权的不同，如to_lowercase()方法返回的是一个全新的string类型变量，而不是发生了所有权的转移。

51 errors2

1
2
3
4
5
6
7

pub fn total_cost(item_quantity: &str) -> Result<i32, ParseIntError> {
    let processing_fee = 1;
    let cost_per_item = 5;
    let qty = item_quantity.parse::<i32>()?;
    
    Ok(qty * cost_per_item + processing_fee)
}

在这里解析item_quantity时，如果使用unwrap方法，解析错误会导致程序崩溃，而使用？运算符简化之后，如果发生解析错误，? 运算符会自动将 Err 值返回给调用方，从而避免了使用 unwrap 方法导致的潜在崩溃。

72 iterators2

rust的迭代器非常强大，也具有非常多的特性，这里进行整理：

1. 创建迭代器：你可以通过调用集合的 .iter()、.iter_mut() 或 .into_iter() 方法来创建迭代器，具体取决于你需要对集合进行何种操作（只读、可变或所有权转移）。

   1 2 3 4

   let numbers = vec![1, 2, 3, 4, 5]; let iter = numbers.iter(); // 创建只读迭代器 let iter_mut = numbers.iter_mut(); // 创建可变迭代器 let into_iter = numbers.into_iter();// 创建所有权转移迭代器

2. 迭代元素：使用 for 循环来遍历迭代器中的元素。在每次迭代中，迭代器会返回一个元素，并将其绑定到指定的变量上。

   1 2 3 4

   let numbers = vec![1, 2, 3, 4, 5]; for num in numbers.iter() { println!("Number: {}", num); }

3. 使用迭代器逐个处理元素：你可以使用迭代器的方法链来对元素进行各种操作。例如，你可以使用 .map() 方法对每个元素进行映射，使用 .filter() 方法进行过滤，使用 .fold() 方法进行累积等等。

1
2
3
4
5

let numbers = vec![1, 2, 3, 4, 5];
let doubled_numbers: Vec<i32> = numbers.iter()
                                     .map(|&num| num * 2)
                                     .collect();
println!("{:?}", doubled_numbers);  // 输出: [2, 4, 6, 8, 10]

4. 惰性求值与及早求值：Rust 的迭代器是惰性求值的，意味着它们只在需要时才会产生元素。这使得你可以在迭代器链中组合多个操作，而不会立即执行它们。只有在需要结果时（例如调用 .collect() 方法）才会触发迭代器链的执行。

   1 2 3 4 5 6

   let numbers = vec![1, 2, 3, 4, 5]; let sum: i32 = numbers.iter() .filter(|&num| num % 2 == 0) .map(|&num| num * 2) .sum(); println!("Sum: {}", sum); // 输出: 12

104 algorithm4

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

fn insert(&mut self, value: T) {
    if self.root.is_none() {
        self.root = Some(Box::new(TreeNode::new(value)));
        return;
    }
    let mut root = self.root.as_mut().unwrap();
    loop {
        if value > root.value {
            if root.right.is_none() {
                root.right = Some(Box::new(TreeNode::new(value)));
                break;
            } else {
                root = root.right.as_mut().unwrap();
            }
        } else if value < root.value {
            if root.left.is_none() {
                root.left = Some(Box::new(TreeNode::new(value)));
                break;
            } else {
                root = root.left.as_mut().unwrap();
            }
        }
        else { break; }
    }
}

在算法题中涉及了好几次获取可变引用和unwrap，这里要注意的点是unwrap会导致所有权的转移，所以需要首先调用as_mut获取可变引用，再进行unwrap，防止出现所有权问题。

#第一阶段

开营前提前刷了下 rustlings，虽然这次练习代码不是最新的 rustlings，但考察内容是一样的。除此之外本次练习还扩充了一些编译和数据结构的题目，数据结构的题目写起来还是有点卡。不说了… LeetCode 走起。

作为想了解操作系统小白一枚，希望能跟完全程吧（🤔）。

事件0：报名！

因为学长的推荐，正准备自己开始做rcore lab的时候突然在rcore的官方repo里面看到news:

开源操作系统训练营报名！

wow，看到里面的正是自己想要了解学习的内容，一下子打起了12分精神，感觉很切合自己所在的嵌入式方向，并且完美的满足自己想要在更深平台上学习的想法（之前是在stm32的机器上跑过简单的ucOSII 实时操作系统）。

事件1：rust，启动！

感觉自己花在学rust的时间挺长的，主要是想更深入的学习这个语言（正巧大二上学了编译原理），在rustlings上花了不少时间，不想一个个说语法了，只是记得smart_pointers的特性很有意思狠狠的理解了，当然还有所有权（第一次见到在编译阶段去强调这个概念的语言，之前写malloc实验的时候有想过能不能在写语言的时候把内存的管理考虑好），option之类的东西和c++真的很像，前面的智能指针也是c++那一套的东西（有种写cs144的感觉）。范型的使用我就类比之前学java的时候的用法了，让我记忆深刻的还有rust对于错误处理包装成一个enum，居然是个枚举，还有它的宏，也太多了吧（学c的时候确实体会过宏的强大）。

最后10个algorithms花了小半天写完，确实算是对之前的学习合起来应用了一下。

记录的笔记我就留在个人博客上了，因为用的notion写博客，试试推送很方便，所以习惯了：

Rust基础积累—常更

我其实在去年的时候就对训练营略有耳闻，但是由于在准备算法竞赛，并且对未来研究生的方向还没有一个明确的规划，所以没有参加。而现在，我基本上已经确定了未来要往体系结构和操作系统方向发展，所以第一时间便报名参加了训练营。

第一阶段学的内容是 Rust。Rust 也是我很喜欢的一门语言，因为他性能高、内存安全、又有良好的包管理器支持，相比于 C、C++，它的语言表达能力更加强大，也有很多好用的语法糖；而相比于 Java、Python 等，它又更为严谨、更贴近硬件。

经过这一段时间的学习，我越学越觉得 Rust 的很多特性其实是为了给他严格的所有权机制打补丁。最明显的就是生命周期了，还有诸如 unsafe 等。刚好最近同时也在一家公司实习做操作系统内核开发，正在使用 C 语言，因此对这两门语言的风格深有所感：

• C 的原则就是「完全相信使用者」，因此你可以用 C 实现几乎所有操作，非常自由。但是为了安全，必须人为设计一些规范来进行约束。
• Rust 的原则则是「完全不相信使用者」，所以你会发现 Rust 的很多语法都是为了约束程序员，强迫程序员写出安全的代码。但是，有些时候编译器还是不够聪明，或者说是无法进行判断，因此必须开点绿灯——unsafe。

在 Rust 身上可以找到很多为了弥补所有权机制而设计的语法，因此在学习的时候才会觉得 Rust 的语法很复杂。不过这种「语言规定好的规范」对于多人之间的项目合作，特别是开源来说，就是一种优势了。相比于 C 语言项目之间可能存在代码风格相差巨大的情况，Rust 写出来的代码基本上不会有太大的风格差异，这样在参考别人的代码，以及贡献代码的时候就会更为轻松。

rust第一阶段总结：
第一阶段主要是对rust语言进行一个系统的学习，并进行rustlings习题的完成，其实前一百道题还好，对于我来说更像完形填空一样，对我来说后十道算法题比较有难度
本来算法就比较薄弱，再用不熟悉的语言进行数学，挑战还是相当大的（，不过在第一阶段中，我对于rust的理解有了深一层的概念。相信可以在第二阶段更进一步

#前言

这并不是我第一次参加了，正如我去年结营仪式上说的，我今年又来了。时光匆匆，下半年就要考研了，目前我依然在猛刷各种竞赛，希望今年能更上一步，有所收获！

#第一阶段的总结：
由于之前已经参加过了，因此前100题非常轻松的就刷掉了，今年多出来了10题算法题，我一直很喜欢用rust写算法，写起来是真的爽，llvm的优化也很爽，甚至能硬生生的将$n^2$的算法给优化成$n*log(n)$的级别，非常逆天。这10道算法题我只在第八题上卡了一会，疑似是workflow评测的bug？反正我本地跑的单元测试都能通过，最终还是整个重写了一遍才过，非常奇怪。于是顺利的在开始的第二天早上写完了110道题。
战斗，爽！

Begin

rust 有趣捏

Tips

所有权

关于所有权的规则：

1. Rust 中每一个值都被一个变量所拥有，该变量被称为值的所有者
2. 一个值同时只能被一个变量所拥有，或者说一个值只能拥有一个所有者
3. 当所有者(变量)离开作用域范围时，这个值将被丢弃(drop)
4. 当值不是可copy的,简单的= 做的是move
5. 如果想要多个变量指向一个值, 通过引用
6. mut引用只能有一个, 不可变引用可以很多,两者不能同时存在

tokio

貌似没涉及,但是觉得好玩捏

• 底层是线程池+调度器
• tokio::spawn 出来的task 类似一种协程, 可以被调度器调度
• 每个task 由诸多future组成, future实际上是一种trait, 实现了它的对象可以被poll, poll它的时候是不阻塞的,如果出现io,返回not ready
• 每个线程维护task队列, 用完时可以偷取其他线程的
• 非阻塞io的底层实现是epoll, 当epoll返回时,调度器会选择调度

End

谢谢THU捏

太喜欢rust 了