rcore-os Blog
0%

Posted on Edited on

2024 春夏季训练营记录

说明

本文为训练营的每日实践记录索引，主要为按日期较随意地写下每天的记录与想法。

同时还包含对其他资料、笔记的索引。

更详细的记录在 github 仓库里 https://github.com/hehepig166/2024-OS-camp-notes

工具与资料

训练营社区 https://opencamp.cn/os2edu/camp/2024spring/

Github LearningOS https://github.com/Learningos

Open-Source OS Training Comp 2024 https://github.com/LearningOS/rust-based-os-comp2024

日历

一 二 三 四 五 六 日
04-01 04-02 04-03 04-04 04-05 04-06 04-07 (开营)
04-08 (第一阶段) 04-09 04-10 04-11 04-12 04-13 04-14
04-15 04-16 04-17 04-18 04-19 04-20 04-21
04-22 04-23

04-07

群公告
欢迎大家加入春夏季操作系统训练营！
4月7日正式开营，已报名的同学请及时学习导学视频内容！
网址:https://opencamp.cn/os2edu/camp/2024spring/stage/0?tab=video

在训练营常见问题Q&A文档https://docs.qq.com/doc/DY3VMc0tOc29KTWZ5 中，对于本期训练营有一些基本问题的介绍，也可以在群里询问

2024春夏季训练营启动仪式回放
录制文件：https://meeting.tencent.com/v2/cloud-record/share?id=95ecb9c0-64f2-4934-a671-78474f735af2&from=3&record_type=2
密码：0407

  • 开营仪式

    • rustlings -> Rust 学习

    • rcore -> Rust 重写内核实验

    • ArceOS -> 组件化 OS 项目

之前几周已经开始学习 Rust，做了 rust-lang 下的 rustlings

rust-lang::rustlings https://github.com/rust-lang/rustlings

我的解答与极其简陋随性的学习日志 https://github.com/hehepig166/my-solution-to-rustlings

（主要是 Rust 资料实在是太多了，我就只写一点关键词提一下记忆即可）

配置了一下 wsl

04-08

@所有人  各位同学，第一阶段“Rust编程语言 & Rustlings答疑”第一次课程将于今晚8点开始，今晚的主要内容为Rustlings练习入门、基本数据类型，slice类型，所有权等，总共一个课时，请大家预留时间，按时进入课堂！！

上课方式：点击 https://opencamp.cn/os2edu/camp/2024spring/stage/1 链接，签到并进入课堂进行直播上课

https://learningos.cn/rust-rustlings-2024-spring-ranking/

https://github.com/LearningOS/rust-rustlings-2024-spring-hehepig166

使用 ssh 链接 clone，用 ssh 鉴权

wsl2 /mnt/ 下 rustlings 更新编译可能会出问题，开发最好不要在 /mnt 目录下操作

module 的 pub 关键字只往上 pub 一层

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
26
mod delicious_snacks {
    // TODO: Fix these use statements
    pub use self::fruits::PEAR as fruit;
    pub use self::veggies::CUCUMBER as veggie;

    mod fruits {
        pub const PEAR: &'static str = "Pear";
        pub const APPLE: &'static str = "Apple";
    }

    mod veggies {
        pub const CUCUMBER: &'static str = "Cucumber";
        pub const CARROT: &'static str = "Carrot";
    }
}

fn main() {
    println!(
        "favorite snacks: {} and {}",
        delicious_snacks::fruit,
        delicious_snacks::veggie
    );

    // let a = delicious_snacks::fruits::PEAR;     // 无法访问
    let b = delicious_snacks::fruit;               // 可以访问
}

04-09

std::f64::NAN

Rust 中两个 NAN 是不相等的，要判断一个浮点数是不是 NAN，可以用 .is_nan() 函数来判断。

完成了 rust-lang 里的 rustlings。

在 Rust 中，? 是一个简便的错误处理操作符，通常用于简化对 Result 或 Option 类型的值进行处理的代码。它的作用是在操作成功时返回成功的结果，如果遇到错误则将错误提早返回。

在函数中使用 ? 时，该函数的返回类型必须是 Result 或 Option。如果表达式的结果是 Ok（对于 Result 类型）或 Some（对于 Option 类型），则 ? 会将其中的值提取出来并返回；如果结果是 Err 或 None，则整个函数会提前返回并将 Err 或 None 作为整个函数的返回值。

04-10

@所有人 各位同学，第一阶段“Rust编程语言 & Rustlings答疑”第二次课程将于今晚8点开始，今晚的主要内容为Rustlings答疑，总共一个课时，请大家预留时间，按时进入课堂！！

上课方式：点击 https://opencamp.cn/os2edu/camp/2024spring/stage/1 链接，签到并进入课堂进行直播上课。

如果同学们有什么问题也可以在问题收集页面https://docs.qq.com/doc/DSXFzRkdodExxQUVO给老师提一下哦～

rustlings test 章节

  • 条件编译

#[cfg()]

cfg() 可以接受一些不同的条件，用于控制编译时的行为。这些条件可以是 Rust 编译器理解的一些特定标识符，也可以是自定义的条件。下面是一些常见的 cfg() 条件：

  • target_os: 目标操作系统，如 "windows", "linux", "macos" 等。
  • target_arch: 目标架构，如 "x86", "x86_64", "arm" 等。
  • target_env: 目标环境，如 "gnu", "msvc", "musl" 等。
  • target_pointer_width: 目标指针宽度，如 "32", "64" 等。
  • feature: 启用的特性，如 "myfeature"。
  • any(): 如果任一条件为真则为真，语法为 cfg(any(condition1, condition2, ...))。
  • all(): 如果所有条件为真则为真，语法为 cfg(all(condition1, condition2, ...))。
  • not(): 取反，语法为 cfg(not(condition))。
  • 自定义条件：你可以在 build.rs 或者 Cargo.toml 中定义自己的条件，然后在 cfg() 中使用。

这些条件可以根据实际需要组合使用，以便根据不同的情况编译不同的代码。

  • 外部链接 FFI(Foreign Function Interface)

extern

这段代码指定 my_demo_function 与 my_demo_function_alias 从符号表中找名字为my_demo_function的函数链接。

而在 Foo::my_demo_function 中又指定了 #[no_mangle] ，即在编译后的目标文件中的符号名称可见并保持不变，被上面两个 extern 找到并使用。

注意这里利用这个东西，使这个函数的的 private 属性失效了。 FFI

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
26
27
28
29
30
31
32
33
34
35
36
37
38
// tests9.rs


extern "Rust" {

    #[link_name = "my_demo_function"]
    fn my_demo_function(a: u32) -> u32;

    #[link_name = "my_demo_function"]
    fn my_demo_function_alias(a: u32) -> u32;
}

mod Foo {
    // No `extern` equals `extern "Rust"`.
    #[no_mangle]
    fn my_demo_function(a: u32) -> u32 {
        a
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_success() {
        // The externally imported functions are UNSAFE by default
        // because of untrusted source of other languages. You may
        // wrap them in safe Rust APIs to ease the burden of callers.
        //
        // SAFETY: We know those functions are aliases of a safe
        // Rust function.
        unsafe {
            my_demo_function(123);
            my_demo_function_alias(456);
        }
    }
}

  • 分析 traits

    parse() 返回一个 Result<i64, xxxErr> 类型的东西，然后 ? 操作符对它进行处理，要是是 i64，就传给 x 然后正常继续，要是是 Err 就提前结束当前 main() ，调用 from 方法把 Err 自动转成 Box 作为 main 的返回结果？

traits 类似 C++ 中的虚基类和虚函数

1
2
3
4
5
6
fn main() -> Result<(), Box<dyn error::Error>> {
    let pretend_user_input = "42";
    let x: i64 = pretend_user_input.parse()?;
    println!("output={:?}", PositiveNonzeroInteger::new(x)?);
    Ok(())
}
  • algorithm

区别 ref mut root 和 mut &root

04-11

rustlings algorithm5 bfs, algorithm6 dfs

“闭包”

04-12

@所有人 各位同学，第一阶段“Rust编程语言 & Rustlings答疑”第三次课程将于今晚8点开始，今晚的主要内容为crate，option，trait和泛型及生命周期，总共一个课时，请大家预留时间，按时进入课堂！！

上课方式：点击 https://opencamp.cn/os2edu/camp/2024spring/stage/1 链接，签到并进入课堂进行直播上课。

如果同学们有什么问题也可以在问题收集页面https://docs.qq.com/doc/DSXFzRkdodExxQUVO给老师提一下哦

rustlings algorithm7,8 stack, algorithm9 heap, algorithm10 graph

rustlings 完成了

继续学习rust生命周期

表达式 vs. 语句

super::

泛型, trait, 生命周期

trait 作为参数，可以指定多个trait

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
// 以下两个代码作用相同

pub fn notify(item: &impl Summary) {	// item 为包含了Summary trait的一个引用
    println!("Breaking news! {}", item.summarize());
}

pub fn notify<T: Summary>(item: T) {	// item 为包含了Summary trait的一个引用
    println!("Breaking news! {}", item.summarize());
}

// 多个 trait
pub fn notify(item: &(impl Summary + Display));
pub fn notify<T: Summary + Display>(item: &T);

// where
// 以下两个代码效果相同
fn fun<T: Display + Clone, U: Clone + Debug>(t: &U, u: &U) -> i32 {}

fn fun<T, U>(t: &T, u: &U) -> i32
where
	T:Display + Clone,
	U: Clone + Debug,
{
    
}

引用的生命周期

做一做 rust quiz

04-13

使用工具 rustfmt 可以自动将代码格式化。有助于分析代码。

代码分析

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
macro_rules! m {
    ($($s:stmt)*) => {
        $(
            { stringify!($s); 1 }
        )<<*
    };
}

fn main() {
    print!(
        "{}{}{}",
        m! { return || true },
        m! { (return) || true },
        m! { {return} || true },
    );
}

这个是纯秀语法，没实际意义。

上面定义了一个宏规则 m。

$()* 代表匹配一个或多个。

$s:stmt代表 s 是一个 statement。

=> {} 表示匹配到模式后要展开成的代码块规则。

$()<<* 表示对每个 statement 得到的代码块用 << 连接。

关键在于分析三行代码中各自有几个 statement。

第一个 return || true，是一个返回闭包 || true 的 return 语句。

第二个 (return) || true，是一个逻辑或语句。（虽然过不了编译，但是后面是转成字符串所以没事）。

第三个 {return} || true 是两个语句，一个是 {return} 语句块，另一个是 || true 闭包。

展开后，我的理解是这样：

1
2
3
4
5
6
7
8
fn main() {
    print!(
        "{}{}{}",
        { "return || true"; 1 },
        { "(return) || true"; 1 },
        { "{return}"; 1 }<<{ "|| true"; 1 },
    )
}

04-14

继续看看 rust quiz

04-16

去看了吉卜力展

04-17

rust quiz

rcore 实验一

学习：Rust 生命周期

  • 无界生命周期 unsafe

  • 生命周期约束 HRTB

    • 'a: 'b 表示 'a 至少活得跟 'b 一样久

    • T: 'a 类型 T 必须比 'a 活得久

  • 生命周期与子类型

    • 子类型至少比父类型大

  • 引用的生命周期：从借用处开始，直到最后一次使用的地方

  • reborrow

    • let mut p = Point {x: 0, y: 0};
let r = &mut p;
let rr: &Point = &*r;
<!--6-->

* >清空内存前，我们插入了一条奇怪的汇编指令 `fence.i` ，它是用来清理 i-cache 的。 我们知道， 缓存又分成 **数据缓存** (d-cache) 和 **指令缓存** (i-cache) 两部分，分别在 CPU 访存和取指的时候使用。 通常情况下， CPU 会认为程序的代码段不会发生变化，因此 i-cache 是一种只读缓存。 但在这里，我们会修改会被 CPU 取指的内存区域，使得 i-cache 中含有与内存不一致的内容， 必须使用 `fence.i` 指令手动清空 i-cache ，让里面所有的内容全部失效， 才能够保证程序执行正确性。

  • 特权级切换

    • 硬件机制
      • U/S 特权级
      • 相关 CSR
        • sstatus
        • spec
        • scause
        • stval
        • stvec
    • 用户栈、内核栈
    • trap 管理
  • 荣誉准则

  1. 在完成本次实验的过程（含此前学习的过程）中，我曾分别与 以下各位 就（与本次实验相关的）以下方面做过交流，还在代码中对应的位置以注释形式记录了具体的交流对象及内容：

    《你交流的对象说明》

  2. 此外，我也参考了 以下资料 ，还在代码中对应的位置以注释形式记录了具体的参考来源及内容：

    《你参考的资料说明》

  3. 我独立完成了本次实验除以上方面之外的所有工作，包括代码与文档。 我清楚地知道，从以上方面获得的信息在一定程度上降低了实验难度，可能会影响起评分。

  4. 我从未使用过他人的代码，不管是原封不动地复制，还是经过了某些等价转换。 我未曾也不会向他人（含此后各届同学）复制或公开我的实验代码，我有义务妥善保管好它们。 我提交至本实验的评测系统的代码，均无意于破坏或妨碍任何计算机系统的正常运转。 我清楚地知道，以上情况均为本课程纪律所禁止，若违反，对应的实验成绩将按“-100”分计。

04-23

Rust 学习

  • 闭包（匿名函数）

    • 本质：拥有可能关联上下文的匿名函数体

    • 允许捕获被定义时所在作用域中的值（不像函数，必须显式传参）

    • fn add_one_v1     (x: u32) -> u32 { x+1 }
let add_one_v2 =  |x: u32| -> u32 { x+1 };
let add_one_v3 =  |x|             { x+1 };
let add_one_v4 =  |x|               x+1  ;

      后面两个要编译必须使用。

    • 使用 move 强制获取所有权

    • Fn trait

      • FnOnce
      • FnMut
      • Fn

  • 智能指针

    • Box -> 将值放在堆上而非栈上
      • 针对编译时位置大小的类型
      • 有大量数据并确保数据不被拷贝的情况下转移所有权时
      • 拥有一个值并只关心它的类型是否实现了特定trait而非具体类型时
      • Deref trait
    • Rc -> 引用计数
      • 图
      • clone
      • 克隆 Rc<T> 会增加其引用计数
      • 不可变引用
    • RefCell -> 内部可变性指针
      • Interior mutability
        • 该数据结构中使用了 unsafe 代码来模糊 Rust 通常的可变性和借用规则
      • 任意时刻，只能拥有一个可变引用或任意数量的不可变引用之一
      • 引用必须总是有效的

  • async

Posted on Edited on In

Rust学习总结报告

Rust是一种注重安全、性能和并发性的系统编程语言。在过去的几周里，我深入学习了Rust语言，对其有了更深入的了解。本报告将总结我所学习的Rust知识点，包括所有权、借用、生命周期、类型系统、模式匹配、错误处理、并发编程等。

1. 所有权

Rust的核心特性之一是所有权（Ownership），它控制了程序中的资源分配和释放。所有权规则包括三条：每个值都有一个变量，称为其所有者；同一时间内只能有一个所有者；当所有者离开作用域时，值将被丢弃。所有权机制有助于避免内存泄漏和数据竞争问题。

2. 借用

借用（Borrowing）允许我们在不转移所有权的情况下访问数据。Rust通过两种借用方式来实现：可变借用（&mut T）和不可变借用（&T）。借用规则包括：同一时间内只能有一个可变借用或多个不可变借用；借用者不能超过所有者的生命周期。

3. 生命周期

生命周期（Lifetimes）是Rust确保引用有效性的关键概念。Rust通过生命周期参数（如’a、’b等）来标注引用的存活时间。生命周期的主要作用是防止悬垂引用和数据竞争。在函数和结构体定义中，我们需要为引用参数和字段指定生命周期参数，以告诉编译器引用之间的关系。

4. 类型系统

Rust的类型系统非常丰富，包括标量类型、复合类型、自定义类型等。标量类型包括整数、浮点数、布尔值和字符；复合类型包括元组、数组、切片和字符串；自定义类型包括结构体、枚举和联合。Rust还提供了类型推导、类型别名、泛型等特性，方便开发者编写灵活、可重用的代码。

5. 模式匹配

模式匹配（Pattern Matching）是Rust中一个强大的控制流和数据处理工具。通过模式匹配，我们可以检查数据类型、解构复合数据、绑定变量等。Rust支持模式匹配的语法包括匹配守卫（match guard）、模式绑定（@）和模式切片等。模式匹配让我们的代码更加简洁、易读和健壮。

6. 错误处理

Rust的错误处理机制主要包括两种：可恢复错误（Result<T, E>）和不可恢复错误（panic!宏）。可恢复错误用于处理可能失败的运算，如文件操作、网络请求等；不可恢复错误用于处理无法恢复的场景，如程序逻辑错误。Rust还提供了?运算符，简化了错误处理的代码编写。

7. 并发编程

Rust提供了丰富的并发编程支持，包括线程、通道、互斥锁等。Rust的线程安全特性得益于所有权和借用机制，使得在多线程环境中共享数据变得简单。通道（Channel）是Rust中的一种并发数据结构，用于线程之间的消息传递。Rust还提供了跨线程共享数据的同步机制，如Arc和Mutex。
总之，Rust是一门具有高性能、内存安全和并发性的编程语言。通过学习Rust，我掌握了所有权、借用、生命周期、类型系统、模式匹配、错误处理和并发编程等知识点。这些知识点不仅让我对Rust有了更深入的了解，还提高了我的编程水平。在未来的工作中，我会继续学习和实践Rust，为我国软件产业的发展贡献力量。

Posted on Edited on

Rust一阶段总结

零、个人照片

随便放张生活照吧，很久之前拍的了，呵呵~时间过得真快

一、本次参赛情况概述

本人也是上届训练营参营成员，不过那时候是和一个水友组的队，基本只有我一个人在努力写题。想起上次训练营我啥也不会，也没看过《Rust语言程序设计》，抱着《Rust圣经》+ChatGPT硬啃，勉强过了一阶段的100题，后面由于二阶段实在是有点复杂，迫于学业和项目组项目压力，勉强做了两个就做不下去了。

这次拉了两个工作室成员，都是有一定工程基础的，有一位成员在此之前接触过Rust，所以这次一阶段至少还算轻松，不会了线下相互请教一下，最终也是慢悠悠地过了一阶段。当然这次总结我倒不打算主要讲Rust代码上的东西，哈哈，相比较于程序设计，我倒感觉思想上的收获更多。

二、rustlings任务完成心得

这次任务，我将之前的（多）线程、外部导入函数、裸指针、所有权与借用以及模式匹配更层次地理解了一遍。想起我上次都是靠GPT撑过来的，属实确实有点搞笑了，这里我总结一下如何跟着这个Rust训练营的学习方法：

2.1看官方文档

这里的官方有多个含义。

首先是训练营官方给出的环境搭建文档，跑软件不可避免要进行环境搭建，最简单也得学会用docker，学会了搭建最基础的环境，才能整式开始学习之旅。

然后是看《Rust程序设计》这本mdbook，一阶段很多知识点，其实可以从这本书找到答案，换句话说，这本书相当于rustlings的提示手册了，仔细钻研这本书，还是可以学到很多东西的，如果直接去看《Rust圣经》 对没有基础的同学来说还是容易劝退

最后就是看Rust语言的官方文档了，有中英双语版本，可以看到每个函数的具体解释，这里我推荐使用zeal这个软件安装Rust的文档进行查看，不需要联网，支持全局查找，还是很不错的

2.2看他人博客

虽然很多文档都有，但是大部分都是英文的，可惜我们一组3个成员英语都不太好，只能硬啃文档。另一种好的方法是去找别人学习源码的笔记，一遍写得好的笔记也是能传递很多知识的，我在仔细翻阅他们的笔记之后，加深了对所有权和一些陷阱的理解

2.3多动手实验

当然，理工科的东西还是以动手为主。我们由于本身有工程基础，于是乎就开始拉几台服务器自己装下环境，在ubuntu装，在windows装，在WSL装，在classroom装，都装一遍，写好通用的执行流程和坑点，加深对Rust的理解。

不过说实话，如果操作系统训练营要成为一门面向大众的训练营，以目前的文档详细程度来说，其实在文档上面下的功夫依旧不够，代入一个新手的视角来看，配置gitHub秘钥是陌生的，github进在线classroom运行时陌生的，git是陌生的，如果仅仅只有LInux基础还是很容易劝退，这就必须要个人有一点自主学习，热爱钻研的能力才能坚持下去，很多工程新手要完成这个阶段也得两三天。就我个人刚入门工程项目的时候，我自学git就很容易犯低级错误，或者进行不规范的操作，我觉得训练营至少要给出一遍基础操作，这样就能带动更广泛的学生参与进来。只要过了环境配置，后面通过一阶段那就只是坚持下去就能完成的事情了。

三、完成rustlings过程中遇到的困难

3.1语法不熟悉

其实环顾rustlings和《Rust语言程序设计》，这两者都没有重点讲Option是什么，Result是什么，unwarp()是什么，都需要自己去找额外的文档进行理解，很多需要的函数，不如trip(),insert(),get_mut(),as_mut(),as_ref()这些奇怪的函数，但是其实这些挺基础的，如果不会这些，不知道某些函数的返回值是什么类型，OPtion有什么用，其实是很难写下去的。鉴于以往学C++的经验，我自己重新学习了一下Rust的基本数据结构，以及基本数据结构的内置方法，还有一些通用方法和获取指针的方法，这些都是比较重要的。

3.2STL不会用

这次新增了一些算法题，颇有种使用C构建数据结构写算法的感觉，不过还好是填空的模式，对于没有掌握全部数据结构的我来说，还是能勉强接受的。致辞的算法题都是基于基本的容器进行操作的，比如bfs就是基于queue，算法里面使用deque，还有后面使用vec充当邻接表，还用到了hashMap当做node进行映射，不会使用容器做这些还是稍微有些困难的，当然，稍微学学容器方法还是可以写出来的

四、本次一阶段的收获

这次一阶段，我个人和另外的成员承担的项目任务更轻松了一点，拉了两个人来一起学习，还是蛮不错的

掌握了更多的学习途径和方法，从“正确的方向”巩固了Rust的语言基础，我现在感觉Rust+cargo越来越好用了，中途踩了几个小坑，每犯一次错误都能学到东西，嘿嘿~

五、自己找的学习资源汇总

权当分享啦~

5.1Rust 程序设计语言 - Rust 程序设计语言 中文版 (rustwiki.org)

5.2std - Rust (rustwiki.org)

5.3Rust 中文文档 | Rust 文档网 (rustwiki.org)

5.4关于本书 - Rust语言圣经(Rust Course)

5.5Rust入门第一课 - Rust入门秘籍 (junmajinlong.com)

5.6介绍 - Rust精选 (rustmagazine.github.io)

5.7简介 - 通过例子学 Rust 中文版 (rustwiki.org)

Posted on Edited on In

呼~ 第一阶段就这样结束了呀！

自打去年从群友们那里了解到这个训练营之后就一直在关注了，
因为我对操作系统本身就很感兴趣，
加上又是使用 Rust 语言还能有一群小伙伴一起努力何尝不是一个很好的学习机会。
其实去年秋季也有报名过一次，惭愧的是因为各种原因第一阶段都没写完 uwu

对于 Rust 这么个频繁被推荐的语言，难免是有些好奇的，
常常是拿出 《Rust 权威指南》然后翻过前几章与别的语言相差不大的那些部分后打算狠狠一顿学习，
但又是惭愧的是每次品鉴 “生命周期”、“所有权”、“动态分配 Trait” 等几个词语后便急忙把书塞回它该在的地方了。
可恶！怎么这么点字就是看不懂了 ——

于是今年刚报名完春季的训练营后便暗自地赌气：我要一晚上做完第一阶段

（是的，真的第一天晚上就做完了，鉴定为太能熬夜了）

除了 Rustlings 外今年还添加了一部分数据结构和算法的内容，包括常见的队列、链表、二叉树和排序等，
而且比较有意思的是因为 Rust 对安全性要求很严苛，找出一种写法不使用 unsafe 也是一种很不错的挑战。

三分时间写七分时间对付编译器那种（雾）

后续的三周就比较空闲了，我终于找到了一个机会和理由把《Rust 权威指南》看完了，
后来还发现一本《Effective Rust》类似是《Effective Java》或是 C/C++ 版本一样，通过一些案例说明什么写法是好的什么写法不太完美。
期间留下一些小笔记：https://blog.hanbings.io/posts/effective-rust/

总的来说，还是很感谢社区以一个这样的形式提供了一个这么好的学习机会，希望后续的学习还能够坚持下去吧！
那么… 第二阶段见！

Posted on Edited on

前言

2022年在和同事聊天的时候了解到了Rust，在他的推荐下“投资未来”，学习了Rust这门语言。前期确实困难重重，Rust的
学习曲线确实比较陡峭，在三本Rust著作（《Rust权威指南》，《Rust实战》，《Rust程序设计》）和极客时间《陈天 · Rust编程第一课》的帮助下算是成功入门。

2023年参加了“第三界中国Rust开发者大会”，收益破丰，也是在这里第一次了解到“操作系统训练营”，今年在公众号“Rust语言中文社区”
了解到2024训练营要开办了，果断报名。

希望通过训练营的学习与实践能进一步夯实Rust语言功底，掌握操作系统知识，拓展知识面。

第一阶段总结

第一阶段主要是Rust的基础学习部分，110道题目巩固了不少基础语法知识。让我感觉最有收获的是后面的
10道算法题，之前有用Rust刷过一些LeetCode,但用Rust来实现栈，堆，队列等经典数据结构却是从没做过的，这一次有了了解。
除了实现数据结构外，这次做题也第一次编写“有意义的”unsafe代码，它终于不再那么神秘莫测了。

RISC-V

参加训练营是第一次接触RISC-V，目前正在学习《RISC-V-Reader》。RISC-V有一个很鲜明的特点是模块化，这似乎是技术发展的未来趋势，各种现代编程语言都
在使自己模块化，如Java，生活中常用的设备也在模块化，如笔记本电脑，手机，甚至我这个月刚买的小米鱼缸，RISC-V走在了ISA模块化的前沿。

下一步

目前打算在第二阶段开始前看完《RISC-V-Reader》，之后再补充一些操作系统的知识，为第二阶段的学习做好准备。

Posted on Edited on

开端

从同学听到有关这个开源夏令营的事情，一方面对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学习一个操作系统的基础实现。

Posted on Edited on

学习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死灵书》

Posted on Edited on

始于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等结构，收获颇丰！

Posted on Edited on
avetar

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]
  1. 惰性求值与及早求值：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，防止出现所有权问题。

Posted on Edited on

#第一阶段

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

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