南京大学 吴奕胜训练营第一阶段的学习过程中，我初步掌握了一门新的编程语言 rust。这是我第一次接触到一门比较”新鲜”的编程语言，相较于课堂上学习的 C/C++，这无疑是一门更加现代也更加复杂的编程语言，拥有不少闻所未闻的新概念，新特性，当然，这也导致 rust 的学习并没有那么轻松。
余观夫 rust 之难，在”所有权”之义。入门阶段所以为惑者，所有权占十之八九。
C/C++ 中，一个变量名被映射到唯一一个内存中有实际含义的内容，反之不成立，我们可以使用指针很轻松地做到这一点。rust 所做的，正是保证这个”反之”的成立，将一块内容唯一对应于一个所有者，当所有者生命周期结束时，内存也被回收，这就保证了内存安全。
这样做的好处很明显，我们可以断言在满足所有权规则的前提下，内存的使用总是安全的；但是坏处也很明显，由于所有权机制的存在，不少在 C/C++ 中可以很简单地实现的数据结构或者函数，在 rust 可能需要费一番功夫。
把我们所学的 rust 的新特性做个分类，大致也就是两类：
去年秋季已经参加过一次训练营，完成了第一阶段和第二阶段的一半，因此这次训练营的第一阶段完成得很快，只用了两三天左右，感知到的最显著的变化是后面算法题的加入：
这一点很好地体现在智能指针、unsafe rust 之类的概念里，虽然这可能造成很多麻烦，但长期来看终究是利大于弊，rust 严格得看起来有些偏执的编译器在教会我们，一个优秀的程序员应该在编程的过程中注意什么，不是吗？
初学 rust，其中的枚举类型让我赞叹不已。我之前只学习了 C/C++ 语言，并且实际上只是学习了 C 和部分的 C++，C 中的枚举类型让程序员可以赋予某些值以现实的语义，但是并不好用。
在某个课程中，我们被要求实现一个游戏，游戏要求实现一个可以在地图中上下左右移动的人物，人物还需要可以执行诸如放炸弹之类的功能，部分动作可能有附带的属性。对于每一个动作，我们当然可以实现一个类，用以表示指令，但是这样做显然是不够简洁的，而用 rust 中的枚举功能，则可以优雅地实现。
再比如编译原理课程中，我们要实现类型检查，那么很自然的就是要实现一个结构体，用以表示各种类型。在这个结构体中，一个枚举类型用以表示当前类型，一个 union 中保存了该种类型附加的信息。即使使用到了 union 这样的关键字减少冗余的部分，也并不优雅，如果换成 rust，则可以用一个枚举类型实现类型系统，相当简洁明了，且优雅。
说到底，枚举类型好用还是其成员可以附带一些信息，这是一般的枚举做不到的，并且即使用结构体或类等实现了类似的功能，也远不如 rust 中枚举的实现优雅。
说模式匹配是优雅版本的 switch 其实也有失偏颇，毕竟模式匹配的功能要比后者多多了，但更多的时候（至少在入门学习阶段），主要的用法还是这两种：
先来说说 switch 让我感觉最不舒服的地方，就是每个分支后面需要加上一个 break，在编译原理课程实验中，对语法树进行语义分析的过程中，时常需要根据产生式的类型实现不同的功能，由于某些稀奇古怪的原因，在写代码的时候会漏掉 break，这会导致比漏掉 break 的原因还稀奇古怪的结果。
相比之下，rust 中的模式匹配就避免了这个问题，同时也让逻辑一致的情况可以使用 | 合并到同一个分支，相较于 switch 中省略 break 的写法，可以消除很多潜在的问题。
Option<T> 和 Result<T, U>在以往的编程经验中，我常常碰到需要表达”没有”的语义的情况，这时候可能会使用一个极大值或者 $0$ 等约定的值来表达。比如在我们在表示一个无权图中不存在的边时，可以使用 $0$ 来表示，但如果是一个有权图呢？根据我们要解决的问题不同，用 $0$ 或者极大值的情况都有，这就造成了一些潜在的麻烦。Option<T> 就很好地解决了这个问题。我知道，其实 C++ 中已经有类似的功能了，但是就使用方便程度来讲，模式匹配加上 Option<T> 可以称得上是一个大杀器了。
而错误处理也很自然地解决了需要调用者自行处理问题的情况。以往的编程经验中，遇到需要传递错误信息的情况往往是通过某些约定的值，这些值被假设不在函数返回值的域中，通过这些值来告诉调用者出现了什么问题。Result<T, U> 显然是更好的实现方法。
说到底，我们想要表达的”空”的语义和”幺元”的语义并不总是一致的，又或者在函数返回的域中并没有不会用到的值，这就导致了”空”的语义不好表达，这个情况下，带值的枚举真香。
-上面提到的内容，大体上就是所有 rust 给我带来最印象深刻的地方了，当然，rust 还有不少精心设计的语言特性，不过由于我的编程经验不够，并不能直接说出这些特性好在哪，也并没有被这些特性震撼到，不过，我心里也埋下了这样一颗种子，如果在将来的学习工作中遇到了什么问题，再回过头来看如今所学，或许就能有更深刻的理解了。
这是我第一次学习一门”课外语言”，这样的体验是很有价值的，不管是对我学习使用这门语言本身来说，还是对我更深入理解以前学习过的语言来说。前面所写的几节内容都是我在学习比较 rust 过程中的切身体会，比学习优秀的设计更重要的是，我知道了一个没那么优秀的设计不好在哪里。
无论怎样，第一阶段的学习落下帷幕，接下来需要进入第二阶段攻克更加困难的主题，这是十分激动人心的。祈祷中……
+NonNull在尝试解决这些问题的过程中，我查阅了许多资料，了解到了很多未曾听说过的概念，希望在第二阶段里也能跟上进度，一路披荆斩棘。
--have done the orginal rustlings test before, try again and also get something to learn
-not only the tech an trick experience , but also the design philosophy behind the language.
-
shadowing: use let[elment; times]** way, now prefer the map wayselfmatch
1 | match expr1 { |
match allows us to compare a value to a series of patterns and execute the code based on the matching pattern
+南京大学 吴奕胜训练营第一阶段的学习过程中，我初步掌握了一门新的编程语言 rust。这是我第一次接触到一门比较”新鲜”的编程语言，相较于课堂上学习的 C/C++，这无疑是一门更加现代也更加复杂的编程语言，拥有不少闻所未闻的新概念，新特性，当然，这也导致 rust 的学习并没有那么轻松。
余观夫 rust 之难，在”所有权”之义。入门阶段所以为惑者，所有权占十之八九。
C/C++ 中，一个变量名被映射到唯一一个内存中有实际含义的内容，反之不成立，我们可以使用指针很轻松地做到这一点。rust 所做的，正是保证这个”反之”的成立，将一块内容唯一对应于一个所有者，当所有者生命周期结束时，内存也被回收，这就保证了内存安全。
这样做的好处很明显，我们可以断言在满足所有权规则的前提下，内存的使用总是安全的；但是坏处也很明显，由于所有权机制的存在，不少在 C/C++ 中可以很简单地实现的数据结构或者函数，在 rust 可能需要费一番功夫。
把我们所学的 rust 的新特性做个分类，大致也就是两类：
the return value of one branch is the return value of the whole match expection
-pubuse xx as xxxuse xx :: {yy, zz}entry() and or_insert()if let statement and while let statement--Bind by reference during pattern matching.
-
ref annotates pattern bindings to make them borrow rather than move.
It is not a part of the pattern as far as matching is concerned: it does not affect whether a value is matched,
only how it is matched.
? – match
---If the value of Result is OK, the expression will return the value in OK and the program will continue.
-
If the value is Err, Err is used as the return value for the entire function,
as if the return keyword were used, so that the error value is propagated to the caller.
() to present nothing needed<T>should_panic.map(), collect()into_iter() and fold(): e.g. iterator.fold(initial_value, |acc, x | { acc + x })
--The fold() method is similar to the iterator’s forEach() method, but it returns a value.
-
--Folds every element into an accumulator by applying an operation, returning the final result.
-
--fold() takes two arguments: an initial value, and a closure with two arguments: an ‘accumulator’, and an element.
-
The closure returns the value that the accumulator should have for the next iteration.
--The initial value is the value the accumulator will have on the first call.
-
--After applying this closure to every element of the iterator, fold() returns the accumulator.
-
--This operation is sometimes called ‘reduce’ or ‘inject’.
-
--
iter(), map() and fold()Box: a smart pointer used to store data on the heap, which also allows us to wrap a recursive type.Rc<T>: used for multiple ownersclone(), Rc::clone() and drop()clone()Cow::Owned() and Cow::Borrowed()thread::spawn(): create a new thread and run the closure in it; -> JoinHandlemove: move the value into the closurejoin(): wait for the thread to finish, return the resultMutex<T>: A mutex is a mutual exclusion primitive that can be used to protect shared datalock() : -> LockResult<MutexGuard<’_, T>>Arc<T>:std::sync::mpsc: multi-producer, single-consumer channel, sending end and receiving endclone()The term macro refers to a family of features in Rust:
这一点很好地体现在智能指针、unsafe rust 之类的概念里，虽然这可能造成很多麻烦，但长期来看终究是利大于弊，rust 严格得看起来有些偏执的编译器在教会我们，一个优秀的程序员应该在编程的过程中注意什么，不是吗？
初学 rust，其中的枚举类型让我赞叹不已。我之前只学习了 C/C++ 语言，并且实际上只是学习了 C 和部分的 C++，C 中的枚举类型让程序员可以赋予某些值以现实的语义，但是并不好用。
在某个课程中，我们被要求实现一个游戏，游戏要求实现一个可以在地图中上下左右移动的人物，人物还需要可以执行诸如放炸弹之类的功能，部分动作可能有附带的属性。对于每一个动作，我们当然可以实现一个类，用以表示指令，但是这样做显然是不够简洁的，而用 rust 中的枚举功能，则可以优雅地实现。
再比如编译原理课程中，我们要实现类型检查，那么很自然的就是要实现一个结构体，用以表示各种类型。在这个结构体中，一个枚举类型用以表示当前类型，一个 union 中保存了该种类型附加的信息。即使使用到了 union 这样的关键字减少冗余的部分，也并不优雅，如果换成 rust，则可以用一个枚举类型实现类型系统，相当简洁明了，且优雅。
说到底，枚举类型好用还是其成员可以附带一些信息，这是一般的枚举做不到的，并且即使用结构体或类等实现了类似的功能，也远不如 rust 中枚举的实现优雅。
说模式匹配是优雅版本的 switch 其实也有失偏颇，毕竟模式匹配的功能要比后者多多了，但更多的时候（至少在入门学习阶段），主要的用法还是这两种：
macro_rules! andprocedural macros:#\[derive\] macros that specify code added with the derive attribute used on structs and enums[macro_use]; to separate the macro armsconstant slet Some(x) = optionstd::mem::swap, vec.clear()as operator: type casting and renaming importsimpl From\<T\> for Uiterators: next(), last()parse::\<T\>()TryFrom and TryInto traits are provided by the standard library to support this conversion.impl TryFrom\<From\> for To and -> Result\<T, E\>tuple and array will be checked at compile time, struct will be checked at runtime,slice implementation needs to check the slice length,trait bound: AsRef\<T\> and AsMut\<T\>unsafe: item declaration and code blockunsafe keyword has two uses:Box: Box::into_raw() and Box::from_raw()build.rsextern "C" fn funcName()impl<T: PartialOrd + Clone>: a trait bound that specifies requirements for the type T.the trait OrdVecDeque, bfs, visited, Adjacency matrixVecDeque, solved quickly(i - 1) / 2, the left child’s index 2 * i + 1, the right child’s index 2 * i + 2, start from 0add: after push, use heapify_upheapify_up: continuous swap until the parent is smaller(or greater, depending on the heap type) than the childsmallest_child_idx: the smallest child idxnext: iterate to get the smallest element先来说说 switch 让我感觉最不舒服的地方，就是每个分支后面需要加上一个 break，在编译原理课程实验中，对语法树进行语义分析的过程中，时常需要根据产生式的类型实现不同的功能，由于某些稀奇古怪的原因，在写代码的时候会漏掉 break，这会导致比漏掉 break 的原因还稀奇古怪的结果。
相比之下，rust 中的模式匹配就避免了这个问题，同时也让逻辑一致的情况可以使用 | 合并到同一个分支，相较于 switch 中省略 break 的写法，可以消除很多潜在的问题。
Option<T> 和 Result<T, U>在以往的编程经验中，我常常碰到需要表达”没有”的语义的情况，这时候可能会使用一个极大值或者 $0$ 等约定的值来表达。比如在我们在表示一个无权图中不存在的边时，可以使用 $0$ 来表示，但如果是一个有权图呢？根据我们要解决的问题不同，用 $0$ 或者极大值的情况都有，这就造成了一些潜在的麻烦。Option<T> 就很好地解决了这个问题。我知道，其实 C++ 中已经有类似的功能了，但是就使用方便程度来讲，模式匹配加上 Option<T> 可以称得上是一个大杀器了。
而错误处理也很自然地解决了需要调用者自行处理问题的情况。以往的编程经验中，遇到需要传递错误信息的情况往往是通过某些约定的值，这些值被假设不在函数返回值的域中，通过这些值来告诉调用者出现了什么问题。Result<T, U> 显然是更好的实现方法。
说到底，我们想要表达的”空”的语义和”幺元”的语义并不总是一致的，又或者在函数返回的域中并没有不会用到的值，这就导致了”空”的语义不好表达，这个情况下，带值的枚举真香。
+上面提到的内容，大体上就是所有 rust 给我带来最印象深刻的地方了，当然，rust 还有不少精心设计的语言特性，不过由于我的编程经验不够，并不能直接说出这些特性好在哪，也并没有被这些特性震撼到，不过，我心里也埋下了这样一颗种子，如果在将来的学习工作中遇到了什么问题，再回过头来看如今所学，或许就能有更深刻的理解了。
这是我第一次学习一门”课外语言”，这样的体验是很有价值的，不管是对我学习使用这门语言本身来说，还是对我更深入理解以前学习过的语言来说。前面所写的几节内容都是我在学习比较 rust 过程中的切身体会，比学习优秀的设计更重要的是，我知道了一个没那么优秀的设计不好在哪里。
无论怎样，第一阶段的学习落下帷幕，接下来需要进入第二阶段攻克更加困难的主题，这是十分激动人心的。祈祷中……
两年前就有听说过rust了，但是只是简单的看了下the rust book，并没有实际使用rust进行编程。这次打算借着rcore进一步实践rust。
+目前的感受是rust的设计给了很多的限制，同时rust似乎也和cpp一样算是多范式的语言？就比如迭代一个列表既可以写成下面的形式
+1 | for ... in something.iter() { |
写可以写成
+1 | something.iter().sum(); |
这样的形式。说实话，我不是很喜欢多范式的编程语言。因为选择太多了，对于我来说阅读别人的代码就会很麻烦。所以这里我更喜欢go的设计。
+此外我用rust刷了一些leetcode上的简单的算法题，感觉挺头疼的。需要关注特别多的细节，而且leetcode特别喜欢给i32类型数据，而rust中访问容器用的下标都是usize类型的。导致代码写起来一点也不美观。有特别多的xx as usize
此外，感觉rust的标准库看起来是提供了很多方法来代替本来可用指针操作的方法。比如vector的swap，一般情况下其它语言里可能是这样写
+1 | a,b = b,a |
rust对数据类型还特别敏感，只要有越界就会报错，必须得用饱和减法saturating_sub之类的方式来处理。
总之，我感觉rust的限制太多了，这让我对写好一个rust程序来说感觉心智负担很重。对于不依靠编辑器写完整程序没有信心。
+希望接下来的rcore能改变我当前对rust的看法。
+ + +从同学听到有关这个开源夏令营的事情，一方面对rust这种新兴语言颇为感兴趣，另一方面也正巧学习计算机系统知识，认识到计算机系统的精妙，也希望借此机会提高自己对计算机系统的理解，获得一定的开源经验。
-主要的笔记都记录在notion中，主要包含我rustlings过程中的思考和体会，记录比较精简。
https://ash-chair-1e2.notion.site/193e1434faf44e5587e71865fc9614af?v=6e2890c3bd084a77b864410b009d9706&pvs=4
这一阶段主要是熟悉rust语法以及相关知识。在我的学习中看来，rust主要有以下几个难点：
-接下来，主要就是学习riscv指令集，同时准备把更多时间花在系统课程上，配合CSAPP学习一个操作系统的基础实现。
- - -从同学听到有关这个开源夏令营的事情，一方面对rust这种新兴语言颇为感兴趣，另一方面也正巧学习计算机系统知识，认识到计算机系统的精妙，也希望借此机会提高自己对计算机系统的理解，获得一定的开源经验。
+主要的笔记都记录在notion中，主要包含我rustlings过程中的思考和体会，记录比较精简。
https://ash-chair-1e2.notion.site/193e1434faf44e5587e71865fc9614af?v=6e2890c3bd084a77b864410b009d9706&pvs=4
这一阶段主要是熟悉rust语法以及相关知识。在我的学习中看来，rust主要有以下几个难点：
+接下来，主要就是学习riscv指令集，同时准备把更多时间花在系统课程上，配合CSAPP学习一个操作系统的基础实现。
+ + +谢谢
-
-
-
- 首先非常有幸参加了本次开源操作系统训练营,感谢诸位讲师的无私奉献和合作平台的支持,提供了一次深入探索操作系统内部机制与Rust编程语言应用的宝贵机会.在近期的学习中，我深入了解了Rust程序设计语言，主要参考了《Rust程序设计语言》和rust圣经以及训练营课程。 对rust语言初步了解,能使用rust语言完成rustlings练习 Rust基础语法与特性：详细学习了Rust的基本语法结构，包括变量、数据类型、控制流、函数等。重点掌握了Rust的所有权系统、借用检查器和生命周期等核心特性，这些特性确保了Rust的内存安全性。 1.rust的所有权系统和借用检查器有效地避免了空指针解引用、数据竞争等常见的内存错误，和以往学过的c语言相比减少了因程序员的疏忽而导致的bug 1.对理论知识只是粗浅的了解，写练习时仍需翻阅资料 1.在进行第二阶段的学习过程中不断复习学过的知识避免遗忘
-
- 2024开源操作系统训练营第一阶段总结报告-chenhao
-
-
-
-
-
-
-
-
-
-
-
-
- 一、引言
第一阶段学习目标
学习内容概述
并发与异步编程：学习了如何使用线程、协程和异步I/O进行高效并发处理。深入了解了互斥锁、通道等如何用rust进行实现。
模块与包管理：了解了如何创建模块和包，对Cargo管理项目的依赖和构建过程有了初步的了解。学习体会与收获
2.rust采用多线程与 async/await 相结合，使用复杂度换取可控性和性能，通过对锁和atomic的了解，为接下来在操作系统中的lab实现打下了坚实基础
3.理解了rust的生命周期机制，有助于避免悬垂引用等内存安全问题，写出安全的代码问题与不足
2.知识遗忘速度过快，只是有了全体框架，具体内容往往停留纸上谈兵，无法学以致用
3.做练习只是听从编译器的指挥，无法自主解决问题接下来的打算
2.根据oj题目，使用rust语言完成练习，加深对语言的印象
3.重写rustlings，不再是简单的通过，再完成的同时注释实现题目的思路。
首先非常有幸参加了本次开源操作系统训练营,感谢诸位讲师的无私奉献和合作平台的支持,提供了一次深入探索操作系统内部机制与Rust编程语言应用的宝贵机会.在近期的学习中，我深入了解了Rust程序设计语言，主要参考了《Rust程序设计语言》和rust圣经以及训练营课程。
+对rust语言初步了解,能使用rust语言完成rustlings练习
+Rust基础语法与特性：详细学习了Rust的基本语法结构，包括变量、数据类型、控制流、函数等。重点掌握了Rust的所有权系统、借用检查器和生命周期等核心特性，这些特性确保了Rust的内存安全性。
并发与异步编程：学习了如何使用线程、协程和异步I/O进行高效并发处理。深入了解了互斥锁、通道等如何用rust进行实现。
模块与包管理：了解了如何创建模块和包，对Cargo管理项目的依赖和构建过程有了初步的了解。
1.rust的所有权系统和借用检查器有效地避免了空指针解引用、数据竞争等常见的内存错误，和以往学过的c语言相比减少了因程序员的疏忽而导致的bug
2.rust采用多线程与 async/await 相结合，使用复杂度换取可控性和性能，通过对锁和atomic的了解，为接下来在操作系统中的lab实现打下了坚实基础
3.理解了rust的生命周期机制，有助于避免悬垂引用等内存安全问题，写出安全的代码
1.对理论知识只是粗浅的了解，写练习时仍需翻阅资料
2.知识遗忘速度过快，只是有了全体框架，具体内容往往停留纸上谈兵，无法学以致用
3.做练习只是听从编译器的指挥，无法自主解决问题
1.在进行第二阶段的学习过程中不断复习学过的知识避免遗忘
2.根据oj题目，使用rust语言完成练习，加深对语言的印象
3.重写rustlings，不再是简单的通过，再完成的同时注释实现题目的思路。
本人就读于新加坡南洋理工大学，参加这个夏令营的目的是为了弥补本科时候的遗憾。在本科期间，听说了AI多么高大上，挣钱多么多，于是把目标放在了AI方向，任何的课程和科研都是围绕着AI方向。但是后面大四发现实在是卷论文卷不动了，而且其实干的很多事情都是调参，找一组好的参数发论文，这并不是我想要的生活，也不是想干的方向。于是我开始想试试开发，因为传统开发上面我毫无经验和优势，于是便去学习小众的区块链开发，发现了Rust这门宝藏语言。顺利的学习这门语言，好好读书背八股找到了大厂的工作（今年入职），但是其实操作系统等底层的知识，在本科上课的时候都是糊弄过去的，所以一直有这个遗憾。借着这个夏令营的机会，我的目标是一阶段巩固一下Rust细节知识，为后面转向区块链开发做铺垫（参加过Solana链相关的黑客松），第二个是真正的非纸上谈兵地去用喜欢的Rust语言做一下操作系统相关的开发，希望可以坚持到最后。
+Rust 是一种安全的系统编程语言，它为程序员提供了实现安全的途径，而无需担心所有的实现细节。所以这里的动机是，基本上C++是不安全的。这也是 Rust 出现的原因。
这里的安全性指的是，如果你用Rust编写了一个程序，并且它满足了某些条件，那么当你将该程序编译成汇编程序时，就可以保证汇编程序不会出错。编译器和类型系统保证了这一点。与此同时，它还实现了控制，因为它支持编程中所需的所有底层功能，例如操作系统的构建，目前Linux和Windows中的系统内核中很多部分都用Rust进行了重构。尤其是C和C++在编写并发程序的时候，无法自动检测到内存的不安全性，而Rust的所有权和生命周期抓住了并发的本质，其本质上关于安全的共享资源。
下面讨论一下系统编程里面的内存模型。我认为一个编程语言，尤其是系统编程语言，或者说比较低级别的编程语言中间最重要的实际上有两件事儿，一个就是它的内存模型，或者说你的变量在内存中是如何交互的和如何表示的。另一个就是多线程的事情，就是多个线程如何操作这些内存。
首先在系统编程领域唯三的编程语言，就是C，C++和Rust。因为Rust它实际上是有很多比较新的理念，可以视为它从C++中间去抽取了很多比较精华的部分，并且它又长出来自己独有的一些东西。
因为C++里面的特性非常多，而且有很多很复杂很融坠，很多还是由于历史原因造成的。因为 C++非常强调兼容性，所以他以前的一些设计的问题，它是没有办法在未来改变的，它只能把它保留或者是把它遮蔽起来。就像你有堆垃圾，你没有办法倒到外面，你只能拿被子先盖起来，然后在这个垃圾上面去建立一些新的东西，所以很多人都觉得C++不如C语言使用起来那样舒服。那么从Rust角度来讲的话，它就没有这个历史负担，它出现的比较晚，所以他从不管从C还是从C++，还是从 Python等等其他的语言中去抽取了很多好的东西集成起来。从整体上来看的话，共性化的部分肯定是各个语言都比较重要的部分，个性化的部分的话，Rust的部分的好处多于坏，它的坏处主要是它的带来的额外的编程和编译的复杂性。
第三阶段从十一月出开始到12月2号结束，历时1个月。就个人情况来说，由于杂事比较多，从第一周周六（11.11）开始学习Arceos到第三周周三（11.22）完成了ArceOS unikernel项目的基本任务，后面的一周半没能抽出时间探索一下最终任务还是有些遗憾（不过我希望在本次训练营结束后再花点时间实现一下最终任务的若干个Idea）。
+就难度来说，个人认为ArceOS比rCore更为复杂，刚打开ArceOS工作目录就感受到了很强的压迫感，但是得益于ArceOS优秀的组件化设计思路（点赞）将内核开发的难度局限再一个模块之内大大降低了实验过程的复杂度。
+第一周的early内存分配器和dtb解析比较麻烦，首先实现early内存分配器时没有考虑到需要对分配指针的地址和分配的内存块大小对齐，这个造成了许多bug，对于dtb解析需要额外学习dtb的数据格式和解析库。
+第二周的主要工作量在于设计img的头部用于加载多个应用，然后在练习5遇到了一些问题卡了一段时间，主要是内联汇编的某些写法有问题导致编译器直接没有生成这部分代码（一步一步调试找到了相对靠谱的写法）。
+总得来说，由于ArceOS的模块化设计，对其其中一个修改造成的影响也尽量地限制在模块内，对于其他的模块可以不用了解其实现细节而使用其暴露的api接口（通过在Cargo.toml中指定依赖路径），这样简化了开发难度。
+最后感谢全体rCore开发者的努力，创造了我认为最棒的OS入门教程╰(°▽°)╯。
+ + +练习 1：
main 函数中，固定设置 app_size = 32，这个显然是不合理甚至危险的。
请为 image 设计一个头结构，包含应用的长度信息，loader 在加载应用时获取它的实际大小。
执行通过。
练习 2：
在练习 1 的基础上，扩展 image 头结构，让 image 可以包含两个应用。
第二个应用包含唯一的汇编代码是 ebreak 。
如实验 1 的方式，打印出每一个应用的二进制代码。
根据练习一、二的要求设计 image 结构如下图所示。
-
image 文件中的首 0-7 的字节用于存放 ‘app 数量’，用以告诉加载器整个 image 中包含有多少个 app。后续的内容以 ‘app 数量’ 个的 app 结构块组成，每个 app 结构块 的首个 32 字节存放当前 app 的块数量，第二个 32 字节存放不满足块大小的 ‘余量’。
‘app 块大小’ 默认定义为 1024 ，即一个块大小为 1024 字节。app 的 ‘块数量’ 则为 ‘app 二进制文件大小除以 app 块大小’。’余量’定义为不满足一个块大小的剩余长度，表示为 ‘app 二进制文件大小除以 app 块大小的余数’。
跟据上述的定义，将 app 二进制文件修改为以 ‘.app’ 后缀结尾的文件，依托于 rust 的构建脚本 build.rs 查找指定目录下的 app 文件，生成上述格式的 image 文件，同时使用 dd 命令完成文件合并，需要保证 * pflash 文件必须为 32MB 大小*。
后续在 loader 中完成对 image 的解析，并在 app 需要执行时将 app 字节码内容拷贝到指定地址后，跳转到相应地址执行 app 内容。 app 结构定义 如下：
1 | struct App<'a> { |
练习 3：
批处理方式执行两个单行代码应用，第一个应用的单行代码是 nop，第二个的是 wfi。
根据上一节的练习添加第二个应用，在第一个应用执行完成后并没有返回到 loader 执行下一个下一个应用，根据调试分析，在第一个应用中并没有返回到 loader 的相关代码，需要添加添加相关代码才能返回到 loader 执行下一个 app。在每个 app 的代码中添加 ‘ret’ 指令，并删除 ‘options(noreturn)’ 以及函数的 ‘永不返回’ 标识 ‘!’，以完成在 app 执行结束后跳转回 loader。同时在构建 image 的时候需要注意 app 的顺序。
-1 |
|
练习 4：
本实验已经实现了1 号调用 - SYS_HELLO，2 号调用 - SYS_PUTCHAR，请实现 3 号调用 - SYS_TERMINATE 功能调用，作用是让 ArceOS 退出，相当于 OS 关机。
仿照 SYS_PUTCHAR 的实现，调用 axhstd 提供的 exit 函数完成相关功能个即可。
-练习 5：
按照如下要求改造应用 hello_app：
1.把三个功能调用的汇编实现封装为函数，以普通函数方式调用。例如，SYS_PUTCHAR 封装为 fn putchar(c: char)。
2.基于打印字符函数 putchar 实现一个高级函数 fn puts(s: &str)，可以支持输出字符串。
3.应用 hello_app 的执行顺序是：Hello 功能、打印字符串功能、退出功能。
根据实验文档，ABI_TABLE 的基地址保存在 a7 寄存器中，在进入 app 时将 a7 寄存器的内容保。同时将 ABI 函数的调用逻辑封装为函数 ‘abi_call’，需要注意使用 ‘clobber_abi(“C”)’ 完成对寄存器的保存，同时指定 app 的 链接文件，以指定字符串存放位置。
-1 | /// abi 调用函数 |
练习 6：
1.仿照 hello_app 再实现一个应用，唯一功能是打印字符 ‘D’
2.现在有两个应用，让它们分别有自己的地址空间。
3.让 loader 顺序加载、执行这两个应用。这里有个问题，第一个应用打印后，不能进行无限循环之类的阻塞，想办法让控制权回到 loader，再由 loader 执行下一个应用。
在练习五的基础上，仿照 ‘hell_app’ 实现另一个 app，同时需要避免 app 中的 ‘wif’ 和无限循环等阻塞操作，避免不能返回 ‘loader’ 执行下一个 app。
-本次实验和练习加深了我对操作系统的理解，同时也学习了组件化操作系统 unikernel 的相关知识、对 qemu 的使用更加熟练的同时也学习了 pflash 相关的知识。对 rust 的嵌入式汇编及相关知识的掌握更加深入。同时也感谢各位老师的对本次课程的知识讲解，也感谢各位同学在群里提出的的问题以及解决方案。
- - -练习 1：
main 函数中，固定设置 app_size = 32，这个显然是不合理甚至危险的。
请为 image 设计一个头结构，包含应用的长度信息，loader 在加载应用时获取它的实际大小。
执行通过。
练习 2：
在练习 1 的基础上，扩展 image 头结构，让 image 可以包含两个应用。
第二个应用包含唯一的汇编代码是 ebreak 。
如实验 1 的方式，打印出每一个应用的二进制代码。
根据练习一、二的要求设计 image 结构如下图所示。
+
image 文件中的首 0-7 的字节用于存放 ‘app 数量’，用以告诉加载器整个 image 中包含有多少个 app。后续的内容以 ‘app 数量’ 个的 app 结构块组成，每个 app 结构块 的首个 32 字节存放当前 app 的块数量，第二个 32 字节存放不满足块大小的 ‘余量’。
‘app 块大小’ 默认定义为 1024 ，即一个块大小为 1024 字节。app 的 ‘块数量’ 则为 ‘app 二进制文件大小除以 app 块大小’。’余量’定义为不满足一个块大小的剩余长度，表示为 ‘app 二进制文件大小除以 app 块大小的余数’。
跟据上述的定义，将 app 二进制文件修改为以 ‘.app’ 后缀结尾的文件，依托于 rust 的构建脚本 build.rs 查找指定目录下的 app 文件，生成上述格式的 image 文件，同时使用 dd 命令完成文件合并，需要保证 * pflash 文件必须为 32MB 大小*。
后续在 loader 中完成对 image 的解析，并在 app 需要执行时将 app 字节码内容拷贝到指定地址后，跳转到相应地址执行 app 内容。 app 结构定义 如下：
1 | struct App<'a> { |
练习 3：
批处理方式执行两个单行代码应用，第一个应用的单行代码是 nop，第二个的是 wfi。
根据上一节的练习添加第二个应用，在第一个应用执行完成后并没有返回到 loader 执行下一个下一个应用，根据调试分析，在第一个应用中并没有返回到 loader 的相关代码，需要添加添加相关代码才能返回到 loader 执行下一个 app。在每个 app 的代码中添加 ‘ret’ 指令，并删除 ‘options(noreturn)’ 以及函数的 ‘永不返回’ 标识 ‘!’，以完成在 app 执行结束后跳转回 loader。同时在构建 image 的时候需要注意 app 的顺序。
+1 |
|
练习 4：
本实验已经实现了1 号调用 - SYS_HELLO，2 号调用 - SYS_PUTCHAR，请实现 3 号调用 - SYS_TERMINATE 功能调用，作用是让 ArceOS 退出，相当于 OS 关机。
仿照 SYS_PUTCHAR 的实现，调用 axhstd 提供的 exit 函数完成相关功能个即可。
+练习 5：
按照如下要求改造应用 hello_app：
1.把三个功能调用的汇编实现封装为函数，以普通函数方式调用。例如，SYS_PUTCHAR 封装为 fn putchar(c: char)。
2.基于打印字符函数 putchar 实现一个高级函数 fn puts(s: &str)，可以支持输出字符串。
3.应用 hello_app 的执行顺序是：Hello 功能、打印字符串功能、退出功能。
根据实验文档，ABI_TABLE 的基地址保存在 a7 寄存器中，在进入 app 时将 a7 寄存器的内容保。同时将 ABI 函数的调用逻辑封装为函数 ‘abi_call’，需要注意使用 ‘clobber_abi(“C”)’ 完成对寄存器的保存，同时指定 app 的 链接文件，以指定字符串存放位置。
+1 | /// abi 调用函数 |
练习 6：
1.仿照 hello_app 再实现一个应用，唯一功能是打印字符 ‘D’
2.现在有两个应用，让它们分别有自己的地址空间。
3.让 loader 顺序加载、执行这两个应用。这里有个问题，第一个应用打印后，不能进行无限循环之类的阻塞，想办法让控制权回到 loader，再由 loader 执行下一个应用。
在练习五的基础上，仿照 ‘hell_app’ 实现另一个 app，同时需要避免 app 中的 ‘wif’ 和无限循环等阻塞操作，避免不能返回 ‘loader’ 执行下一个 app。
+本次实验和练习加深了我对操作系统的理解，同时也学习了组件化操作系统 unikernel 的相关知识、对 qemu 的使用更加熟练的同时也学习了 pflash 相关的知识。对 rust 的嵌入式汇编及相关知识的掌握更加深入。同时也感谢各位老师的对本次课程的知识讲解，也感谢各位同学在群里提出的的问题以及解决方案。
+ + +不知不觉，ArceOS Unikernel 课程的学习已经过去了一半。回顾过去这两周，我深感学习过程中的磨砺与成长。感谢石磊老师的细心指导，从基础概念入手，让我们逐渐掌握 Unikernel 的奥秘。谁曾想到，Unikernel 的设计竟如此强大。每次回顾这个过程，我都会重新阅读陈渝老师的著作《像开发应用一样开发操作系统》，从中汲取启示。我对操作系统可以如同应用一般，通过组件化思维实现感到震惊。过去曾听说过鸿蒙分布式部署等新闻，也阅读过一些关于鸿蒙的相关文章，但亲身参与组件化操作系统的学习，完全是不同于以往的体验。
+++第一周练习主要包含以下内容：
+
通过本周学习对 ArceOS 的整体架构、内存分配及调度算法有更深入的了解。
+ + + + + +我是一名工作了五年的社畜，先后用过php、go语言开发应用端的程序，尽管接触过一些操作系统的知识，但都是二手资料，只了解个大概。
-我对问题都会追本溯源，想了解得更深一点，这样才能更好的总结归纳。
-工作中用的很多工具以及知识底层都涉及到操作系统，只有了解了操作系统内核才能更好的理解整个计算机体系结构。
-国庆节前在网上冲浪时，无意中看到Rust语言中文社区有关于开展开源操作系统训练营的公告，了解后，竟然是免费教程，太让人惊喜。
-机不可失失不再来就立马报名参加了。
-这一阶段的题相对比较简单，我花了一周的时间就刷完了。但也发现了自己的盲点，比如高级生命周期这块，是从没了解过。
-顺带一提，我承接了队长的工作，解答队员不懂的知识点，队员都很争气，基本都没这么问我，都能完成rustlings100道题，到第一阶段截至，8名队员有7名晋级，
还有一名太忙了，没时间做，也不参加后续的了。
也就是完成rustling之后，我开始摸索搭建实验环境的搭建和看第零章的内容，到第一周开始，环境已经搭好和看到第一章
-发现第三章才是第一个实验，奋起直追，主要的时间都发在阅读文档中，我看的是详情书，看到周六才到第三章末。
-周六才是完成实验，实验不是很难，主要在于理解两个异常控制流的转换，all_trap和switch,理解特权级切换硬件都干了什么，软件如何衔接。
-最终在周日完成了第一个实验。
-第四章比前面三章要理解的东西都多，而且也很难。可能对于我来说，操作系统这块内容比较陌生，没有一个概念，做起来就有点畏手畏脚。
-如何将用户态的一个变量赋值，这个变量还可能分散到两个实际不相连的物理页，实在想不到如何下手。群里的大佬支招，让我把结构体的字段拆开分别赋值，
这个方法可行，但不通用，每个结构体字段都不一样，每个都要根据它的字段分别赋值，很麻烦。
最终我想到的方法是，写一个通用的方法，根据用户态的指针查到对应物理页面，在内核态实例化一个和用户态一样对象，转化成字节数组，将字节数组拷贝到物理页面中。
这个方法收到拷贝应用数据的方法的启示，我不用管对象是什么，只需要当成字节数组来看，逐页拷贝就行。
只要理解了虚拟地址空间和物业页帧之间的关系，mmap和munmap都是比较好实现。
-前面两周只做到了实验2，接下来的一周虽然很快看完了第五章，但是完全没有时间完成实验，只能到周末完成。
-实验3相对于实验2算比较简单的，前面抽象的概念都已经展开，实验3只不过增加了fork、exec之类的系统调用，用于生成新的进程。
-spawn只需要获取pid和从elf中获取堆栈等信息，组装成一个taskControlBlock，并加入到任务队列即可。
-stride算法的实现需要扩充两个字段stride和priority,并在每次进程切换时stride加上pass,pass= big_stride/priority。之后是修改任务管理器的fetch方法，
实现fetch能获取最小stride进程，我将VecQueue改成LinkedList，为了好从中间去掉某个节点。
我是一名工作了五年的社畜，先后用过php、go语言开发应用端的程序，尽管接触过一些操作系统的知识，但都是二手资料，只了解个大概。
+我对问题都会追本溯源，想了解得更深一点，这样才能更好的总结归纳。
+工作中用的很多工具以及知识底层都涉及到操作系统，只有了解了操作系统内核才能更好的理解整个计算机体系结构。
+国庆节前在网上冲浪时，无意中看到Rust语言中文社区有关于开展开源操作系统训练营的公告，了解后，竟然是免费教程，太让人惊喜。
+机不可失失不再来就立马报名参加了。
+这一阶段的题相对比较简单，我花了一周的时间就刷完了。但也发现了自己的盲点，比如高级生命周期这块，是从没了解过。
+顺带一提，我承接了队长的工作，解答队员不懂的知识点，队员都很争气，基本都没这么问我，都能完成rustlings100道题，到第一阶段截至，8名队员有7名晋级，
还有一名太忙了，没时间做，也不参加后续的了。
也就是完成rustling之后，我开始摸索搭建实验环境的搭建和看第零章的内容，到第一周开始，环境已经搭好和看到第一章
+发现第三章才是第一个实验，奋起直追，主要的时间都发在阅读文档中，我看的是详情书，看到周六才到第三章末。
+周六才是完成实验，实验不是很难，主要在于理解两个异常控制流的转换，all_trap和switch,理解特权级切换硬件都干了什么，软件如何衔接。
+最终在周日完成了第一个实验。
+第四章比前面三章要理解的东西都多，而且也很难。可能对于我来说，操作系统这块内容比较陌生，没有一个概念，做起来就有点畏手畏脚。
+如何将用户态的一个变量赋值，这个变量还可能分散到两个实际不相连的物理页，实在想不到如何下手。群里的大佬支招，让我把结构体的字段拆开分别赋值，
这个方法可行，但不通用，每个结构体字段都不一样，每个都要根据它的字段分别赋值，很麻烦。
最终我想到的方法是，写一个通用的方法，根据用户态的指针查到对应物理页面，在内核态实例化一个和用户态一样对象，转化成字节数组，将字节数组拷贝到物理页面中。
这个方法收到拷贝应用数据的方法的启示，我不用管对象是什么，只需要当成字节数组来看，逐页拷贝就行。
只要理解了虚拟地址空间和物业页帧之间的关系，mmap和munmap都是比较好实现。
+前面两周只做到了实验2，接下来的一周虽然很快看完了第五章，但是完全没有时间完成实验，只能到周末完成。
+实验3相对于实验2算比较简单的，前面抽象的概念都已经展开，实验3只不过增加了fork、exec之类的系统调用，用于生成新的进程。
+spawn只需要获取pid和从elf中获取堆栈等信息，组装成一个taskControlBlock，并加入到任务队列即可。
+stride算法的实现需要扩充两个字段stride和priority,并在每次进程切换时stride加上pass,pass= big_stride/priority。之后是修改任务管理器的fetch方法，
实现fetch能获取最小stride进程，我将VecQueue改成LinkedList，为了好从中间去掉某个节点。
ch5其
-
-
-
- 在同学的推荐下，我报名参加了训练营。这次经历让我有了第一次通过代码来理解操作系统的感觉。在之前学校的课程中，我对操作系统的认识仅限于文字概念，如进程、页表和文件系统等。 在具体的实验过程中，因为是第一次编写这类 Lab，一开始感觉非常难，但是完成后巩固和掌握了很多 OS 的知识，并且在实践中得到了很大的收益。 Lab1 需要完善系统调用。 对于 可能存在精度问题，这里我使用了 这部分的内容中，为 Rcore 引入了虚拟内存。 因为 Rcore 中分为内核页表和用户态页表，因此对于 然后是实现 MMap，通过 VMA 实现。 VMA 记录有关连续虚拟内存地址段信息。对每个 section ，都有一个 VMA 对象。 例如对于 memory mapped file，存在一个 VMA 与之对应，其中包含了文件信息等 mmap 收到范围和 在此实验中，测试数据稍弱，并没有要求实现 VMA 分裂的操作。 Lab3 需要实现优先级调度和 优先级调度较为简单，在 PCB 中维护 因为不要求性能，我们可以简单的遍历的选择当前
-
- 2023秋冬季开源操作系统训练营总结-lieck
-
-
-
-
-
-
-
-
-
-
-
-
- 023秋冬季开源操作系统训练营总结-lieck
Lab1
sys_task_info 系统调用，我们在 TCP 添加相应字段处理即可。get_time_us 计算时间。
-
-
-1
2
3
4let us = get_time_us();
let sec = us / 1_000_000;
let usec = us % 1_000_000;
let t = (sec & 0xffff) * 1000 + usec / 1000;Lab2
sys_task_info 系统调用我们不能直接通过修改参数来完成传值。需要将其转换为物理地址，而内核页表中的虚拟地址和内核地址是对应的。
-
-port 后，判断是否冲突或参数错误，然后放入 VMA 数据结构中映射物理页。mummap 也是类似的操作。Lab3
spawn 系统调用。spawn 系统调用是 fork 和 exec 的结合。可以分为两部分：
-
-task.execstride 和 pass 。
-
-suspend_current_and_run_next 时增加当前进程的 stridefetch 会选择下一个要运行的进程，找到当前 stride 最小的进程即可。stride 的值。
++have done the orginal rustlings test before, try again and also get something to learn
+not only the tech an trick experience , but also the design philosophy behind the language.
+
shadowing: use let[elment; times]** way, now prefer the map wayselfmatch
1 | match expr1 { |
match allows us to compare a value to a series of patterns and execute the code based on the matching pattern
+the return value of one branch is the return value of the whole match expection
+pubuse xx as xxxuse xx :: {yy, zz}entry() and or_insert()if let statement and while let statement++Bind by reference during pattern matching.
+
ref annotates pattern bindings to make them borrow rather than move.
It is not a part of the pattern as far as matching is concerned: it does not affect whether a value is matched,
only how it is matched.
? – match
+++If the value of Result is OK, the expression will return the value in OK and the program will continue.
+
If the value is Err, Err is used as the return value for the entire function,
as if the return keyword were used, so that the error value is propagated to the caller.
() to present nothing needed<T>should_panic.map(), collect()into_iter() and fold(): e.g. iterator.fold(initial_value, |acc, x | { acc + x })
++The fold() method is similar to the iterator’s forEach() method, but it returns a value.
+
++Folds every element into an accumulator by applying an operation, returning the final result.
+
++fold() takes two arguments: an initial value, and a closure with two arguments: an ‘accumulator’, and an element.
+
The closure returns the value that the accumulator should have for the next iteration.
++The initial value is the value the accumulator will have on the first call.
+
++After applying this closure to every element of the iterator, fold() returns the accumulator.
+
++This operation is sometimes called ‘reduce’ or ‘inject’.
+
++
iter(), map() and fold()Box: a smart pointer used to store data on the heap, which also allows us to wrap a recursive type.Rc<T>: used for multiple ownersclone(), Rc::clone() and drop()clone()Cow::Owned() and Cow::Borrowed()thread::spawn(): create a new thread and run the closure in it; -> JoinHandlemove: move the value into the closurejoin(): wait for the thread to finish, return the resultMutex<T>: A mutex is a mutual exclusion primitive that can be used to protect shared datalock() : -> LockResult<MutexGuard<’_, T>>Arc<T>:std::sync::mpsc: multi-producer, single-consumer channel, sending end and receiving endclone()The term macro refers to a family of features in Rust:
macro_rules! andprocedural macros:#\[derive\] macros that specify code added with the derive attribute used on structs and enums[macro_use]; to separate the macro armsconstant slet Some(x) = optionstd::mem::swap, vec.clear()as operator: type casting and renaming importsimpl From\<T\> for Uiterators: next(), last()parse::\<T\>()TryFrom and TryInto traits are provided by the standard library to support this conversion.impl TryFrom\<From\> for To and -> Result\<T, E\>tuple and array will be checked at compile time, struct will be checked at runtime,slice implementation needs to check the slice length,trait bound: AsRef\<T\> and AsMut\<T\>unsafe: item declaration and code blockunsafe keyword has two uses:Box: Box::into_raw() and Box::from_raw()build.rsextern "C" fn funcName()impl<T: PartialOrd + Clone>: a trait bound that specifies requirements for the type T.the trait OrdVecDeque, bfs, visited, Adjacency matrixVecDeque, solved quickly(i - 1) / 2, the left child’s index 2 * i + 1, the right child’s index 2 * i + 2, start from 0add: after push, use heapify_upheapify_up: continuous swap until the parent is smaller(or greater, depending on the heap type) than the childsmallest_child_idx: the smallest child idxnext: iterate to get the smallest element在这个开源操作系统训练营的第一阶段，我经历了一段充实而挑战性的学习过程。对于 Rust 这门新兴的编程语言，我抱着好奇和兴奋的心态开始了探索。尽管之前有一些编程经验，但 Rust 的独特特性和高度安全性的承诺，让我怀着期待和一些担忧开始了这段学习之旅。
-过程还是比较曲折的，其实在配环境的时候就出现了一些问题，比如用用ssh去clone的时候都出问题了。后来也是看群友的把ssh端口改成使用443以后才好。
-rustlings更是酸爽，看了圣经和rust语言设计那本书还是有很多理解不到位的地方，导致做题的时候经常会出现需要调半天的bug。而且rust里面有很多概念对我来说比较新，比如说所有权和一些特性之类的，使用上又是重重限制。导致我用c/c++可能一下就能写完的题，换成rust得调bug半个小时。多亏生成式ai的帮助，否则可能一直要卡在这个阶段了。
-在第一阶段的学习中，我对 Rust 的理解和应用有了显著的提升。通过不断地实践和探索，我逐渐适应了 Rust 的编程风格。不过，这110道题做下来其实只能算有个概念，有些东西肯定已经忘了。打算再回去二刷rust圣经，看完以后就等遇到不会的再查吧。
- - -在同学的推荐下，我报名参加了训练营。这次经历让我有了第一次通过代码来理解操作系统的感觉。在之前学校的课程中，我对操作系统的认识仅限于文字概念，如进程、页表和文件系统等。
+在具体的实验过程中，因为是第一次编写这类 Lab，一开始感觉非常难，但是完成后巩固和掌握了很多 OS 的知识，并且在实践中得到了很大的收益。
+Lab1 需要完善系统调用。
+对于 sys_task_info 系统调用，我们在 TCP 添加相应字段处理即可。
可能存在精度问题，这里我使用了 get_time_us 计算时间。
1 | let us = get_time_us(); |
这部分的内容中，为 Rcore 引入了虚拟内存。
+因为 Rcore 中分为内核页表和用户态页表，因此对于sys_task_info 系统调用我们不能直接通过修改参数来完成传值。需要将其转换为物理地址，而内核页表中的虚拟地址和内核地址是对应的。
然后是实现 MMap，通过 VMA 实现。
+++VMA 记录有关连续虚拟内存地址段信息。对每个 section ，都有一个 VMA 对象。
+例如对于 memory mapped file，存在一个 VMA 与之对应，其中包含了文件信息等
+
mmap 收到范围和 port 后，判断是否冲突或参数错误，然后放入 VMA 数据结构中映射物理页。mummap 也是类似的操作。
在此实验中，测试数据稍弱，并没有要求实现 VMA 分裂的操作。
+Lab3 需要实现优先级调度和 spawn 系统调用。
spawn 系统调用是 fork 和 exec 的结合。可以分为两部分：
task.exec优先级调度较为简单，在 PCB 中维护 stride 和 pass 。
suspend_current_and_run_next 时增加当前进程的 stridefetch 会选择下一个要运行的进程，找到当前 stride 最小的进程即可。因为不要求性能，我们可以简单的遍历的选择当前 stride 的值。
有一年私有云平台开发经验的 Go 开发工程师，有些许的 Rust 基础， 没有 Rust 相关的项目，对操作系统相关的东西一知不解。
-在群友的闲聊下发现有 “Linux 源码趣读” 的系列文章，趁空闲的时间过了一遍，对操作系统的整体结构有一定认识，群友说这个讲的蛮浅显的，但是感觉对我这种没有啥操作系统基础的还是有很大的帮助的。
-一章一章的剥开操作系统的面纱，硬件机制、操作系统理论整体联络起来，渐渐实现一个可用的操作系统。
-就目前完成到 ch5 来讲，Guide 的 ch4、ch5 的这部分内容不怎么连贯，基础比较差的我就只能硬读了。听说 rCore-Tutorial V3 的内容更全一点，等后面也对照这学习一下每章节的内容。
-似乎任何事情都逃不过这句话：“会者不难， 难者不会”，真正的难其实是对未知的恐惧。目前算是完成了这次训练营的基本过线目标：完成前三个作业。现在回头来看，都无非是对操作系统概念的学习和理解，并把这些理解到的概念真正转化成工程代码的一个过程。例如实验中你本就拥有一个完整的模拟环境，运算设备、硬件机制、目前标准的系统调用接口参考、经典理论(SV39 分页机制)等等，需要用自己理解操作系统概念去把这些东西组合在一起，最终提供一个基于底层基础设备提供的机制，为上层用户提供一个可靠的、安全的运行环境。
-未知的事物并不可怕，可怕的是你认为它是永远无法被理解的。
-这一部分是构建实验环境：本质上就是安装 Rust 工具链和编译安装 Qemu 模拟器。在尝试使用 classroom 在线环境失败后，决定本地部署环境。据目前所了解到的虚拟环境模拟工具来看(需要一个 Ubuntu 的系统环境)，有传统虚拟机软件(Parallel、VMWare 等)、MutilPass(Ubuntu 系统特供)以及更加流行的 Docker 容器模拟，由于对桌面环境不是强需便直接排除了，、MutilPass 和 Docker 自己都比较熟悉，因更倾向于 MutilPass 的使用方式，所以最开始拿 MutilPass 创建的 Ubuntu 虚拟机安装环境，通过 VSCode 的 ssh 插件直接远程虚拟机开始基础环境部署，运行第一个 “Hello World！”。
-后续训练营的群友有推荐使用 Orbstack 这款软件，了解之下发现确实好用，随而更换到这个软件，它的优势：
1、共享宿主机内核：CPU 全部共享到虚拟机、内存几乎接近全部也是给到虚拟机，创建一个 Ubuntu 虚拟机只要十几秒。
2、提供 Docker 命令：可以替换掉 Docker， 又可以少装一个软件了。
3、提供单节点 K8s 集群：像 Docker 一样，更加轻量、启动快。
4、唯一缺点：目前只支持了 MacOS 系统(刚好是 Mac)，可能是因为是使用 Swift 开发的，看后续是否会支持 Linux。
这一部分主要是一步一步的讲解了如何从零开始构建一个可以运行在 Qemu 上的 Rust 操作系统程序：Hello World！，接触到了一些基础概念：系统级标准输出、系统级异常处理、内存基本布局，这些在具体的代码转化后是如何展现的，以及操作系统的入口：entry.asm 文件。
-简单来讲，系统加电后会固定去读区特定的位置，也就是操作系统入口文件里的这部分内容，从而就进入了我们编写的 Rust 操作系统程序的 rust_main 入口，当然固定读取的操作是硬件提供的。
-这一部分实现一个最简单的批处理系统。电脑内存本质上就只一个线性的存储结构：这一部分将系统程序需要占用的部分之外的存储结构以固定的布局方式排列在内存上，通过一个程序一个程序的加载执行来达到一次运行可以完成多个任务的系统。这部分也涉及到了 SU 态相关的东西。
-操作系统在一定程度来讲算是一个处于“死循环”的程序，因为各种“中断”操作将读写设备、CPU 计算、任务处理等灵活的控制起来。这部分主要利用了“时钟中断”和任务切换这两部分内容来完成了一个分时多任务系统，通过时钟控制 CPU 不被某个程序长时间占用，这也是最基本的任务调度实现。
-这一章的作业是提供一个系统调用来获取当前执行任务的基本信息，不考虑其他影响因素：也就是记录任务的启动时间、各种系统调用的次数和状态，当前已经存在“任务”的存储模型 Task，在其中记录信息并在状态流转处记录即可。
-这一章介绍了 SV39 多级页表机制理论，基于该理论实现了实验里的多级页表，物理地址、虚拟地址的基本定义和对应的基本操作，以及 MMU 机制和 sapt 的理论定义模型，包含了对多级页表的重要解释，同时也通过图介绍了整个内存中操作系统和用户程序的布局。
-这一章的作业是在开启多级页表机制下，适配 ch3 的作业实现，并完成 内存分配 mmap、和内存释放 mummap 系统调用： 基本的思路就是如何在多级分页开启的时候从内存获取到对应数据结构的地址并赋值，有物理地址和虚拟地址间的转换、页表的访问权限设置相关的内容。
-这一章基于多级页表机制对任务执行这块进行再次抽象，加入了任务编号、任务队列管理，主要是对任务抽象的部分是需要花些时间需要理解理解。
-这一章的作业是老作业迁移适配外，在实现 spawm 和 priority 系统调用接口功能：最主要的还是在对分级页表比较熟悉的情况下，对已经实现的任务管理功能，如 exec、fork 等实现的理解后，spawn 其实就是创建一个新的 TaskControlBlock 并添加到任务队列，并绑定给当前 TaskControlBlock 的 child 下，但同时也别忘记了给这个新的 TaskControlBlock 绑定 parent。另一个 priority 就用户可以设置这个值来简单的控制下程序执行的顺序，来让某些程序优先执行。
-看时间情况继续学习后续的 ch6、ch7、ch8 的内容，完成整个训练营任务。
- - -有一年私有云平台开发经验的 Go 开发工程师，有些许的 Rust 基础， 没有 Rust 相关的项目，对操作系统相关的东西一知不解。
+在群友的闲聊下发现有 “Linux 源码趣读” 的系列文章，趁空闲的时间过了一遍，对操作系统的整体结构有一定认识，群友说这个讲的蛮浅显的，但是感觉对我这种没有啥操作系统基础的还是有很大的帮助的。
+一章一章的剥开操作系统的面纱，硬件机制、操作系统理论整体联络起来，渐渐实现一个可用的操作系统。
+就目前完成到 ch5 来讲，Guide 的 ch4、ch5 的这部分内容不怎么连贯，基础比较差的我就只能硬读了。听说 rCore-Tutorial V3 的内容更全一点，等后面也对照这学习一下每章节的内容。
+似乎任何事情都逃不过这句话：“会者不难， 难者不会”，真正的难其实是对未知的恐惧。目前算是完成了这次训练营的基本过线目标：完成前三个作业。现在回头来看，都无非是对操作系统概念的学习和理解，并把这些理解到的概念真正转化成工程代码的一个过程。例如实验中你本就拥有一个完整的模拟环境，运算设备、硬件机制、目前标准的系统调用接口参考、经典理论(SV39 分页机制)等等，需要用自己理解操作系统概念去把这些东西组合在一起，最终提供一个基于底层基础设备提供的机制，为上层用户提供一个可靠的、安全的运行环境。
+未知的事物并不可怕，可怕的是你认为它是永远无法被理解的。
+这一部分是构建实验环境：本质上就是安装 Rust 工具链和编译安装 Qemu 模拟器。在尝试使用 classroom 在线环境失败后，决定本地部署环境。据目前所了解到的虚拟环境模拟工具来看(需要一个 Ubuntu 的系统环境)，有传统虚拟机软件(Parallel、VMWare 等)、MutilPass(Ubuntu 系统特供)以及更加流行的 Docker 容器模拟，由于对桌面环境不是强需便直接排除了，、MutilPass 和 Docker 自己都比较熟悉，因更倾向于 MutilPass 的使用方式，所以最开始拿 MutilPass 创建的 Ubuntu 虚拟机安装环境，通过 VSCode 的 ssh 插件直接远程虚拟机开始基础环境部署，运行第一个 “Hello World！”。
+后续训练营的群友有推荐使用 Orbstack 这款软件，了解之下发现确实好用，随而更换到这个软件，它的优势：
1、共享宿主机内核：CPU 全部共享到虚拟机、内存几乎接近全部也是给到虚拟机，创建一个 Ubuntu 虚拟机只要十几秒。
2、提供 Docker 命令：可以替换掉 Docker， 又可以少装一个软件了。
3、提供单节点 K8s 集群：像 Docker 一样，更加轻量、启动快。
4、唯一缺点：目前只支持了 MacOS 系统(刚好是 Mac)，可能是因为是使用 Swift 开发的，看后续是否会支持 Linux。
这一部分主要是一步一步的讲解了如何从零开始构建一个可以运行在 Qemu 上的 Rust 操作系统程序：Hello World！，接触到了一些基础概念：系统级标准输出、系统级异常处理、内存基本布局，这些在具体的代码转化后是如何展现的，以及操作系统的入口：entry.asm 文件。
+简单来讲，系统加电后会固定去读区特定的位置，也就是操作系统入口文件里的这部分内容，从而就进入了我们编写的 Rust 操作系统程序的 rust_main 入口，当然固定读取的操作是硬件提供的。
+这一部分实现一个最简单的批处理系统。电脑内存本质上就只一个线性的存储结构：这一部分将系统程序需要占用的部分之外的存储结构以固定的布局方式排列在内存上，通过一个程序一个程序的加载执行来达到一次运行可以完成多个任务的系统。这部分也涉及到了 SU 态相关的东西。
+操作系统在一定程度来讲算是一个处于“死循环”的程序，因为各种“中断”操作将读写设备、CPU 计算、任务处理等灵活的控制起来。这部分主要利用了“时钟中断”和任务切换这两部分内容来完成了一个分时多任务系统，通过时钟控制 CPU 不被某个程序长时间占用，这也是最基本的任务调度实现。
+这一章的作业是提供一个系统调用来获取当前执行任务的基本信息，不考虑其他影响因素：也就是记录任务的启动时间、各种系统调用的次数和状态，当前已经存在“任务”的存储模型 Task，在其中记录信息并在状态流转处记录即可。
+这一章介绍了 SV39 多级页表机制理论，基于该理论实现了实验里的多级页表，物理地址、虚拟地址的基本定义和对应的基本操作，以及 MMU 机制和 sapt 的理论定义模型，包含了对多级页表的重要解释，同时也通过图介绍了整个内存中操作系统和用户程序的布局。
+这一章的作业是在开启多级页表机制下，适配 ch3 的作业实现，并完成 内存分配 mmap、和内存释放 mummap 系统调用： 基本的思路就是如何在多级分页开启的时候从内存获取到对应数据结构的地址并赋值，有物理地址和虚拟地址间的转换、页表的访问权限设置相关的内容。
+这一章基于多级页表机制对任务执行这块进行再次抽象，加入了任务编号、任务队列管理，主要是对任务抽象的部分是需要花些时间需要理解理解。
+这一章的作业是老作业迁移适配外，在实现 spawm 和 priority 系统调用接口功能：最主要的还是在对分级页表比较熟悉的情况下，对已经实现的任务管理功能，如 exec、fork 等实现的理解后，spawn 其实就是创建一个新的 TaskControlBlock 并添加到任务队列，并绑定给当前 TaskControlBlock 的 child 下，但同时也别忘记了给这个新的 TaskControlBlock 绑定 parent。另一个 priority 就用户可以设置这个值来简单的控制下程序执行的顺序，来让某些程序优先执行。
+看时间情况继续学习后续的 ch6、ch7、ch8 的内容，完成整个训练营任务。
+ + +参加本次rcore训练营的原因是希望找人和我一起写课程来督促我成长，因为本人做事很容易烂尾。
-之前做过类似的操作系统lab，并且也用过rust，所以前三个实验还是比较顺利完成了，这次报名也是希望能进一步参与后面的项目。
-下面简单总结一下在第二阶段我完成的各个实验情况。
-rcore 的前几个实验难度不是很大，读懂代码结构，按照需求去实现就行了。
-本次实验在要实现一个当前任务信息查询调用。
-而这个系统调用sys_task_info调用的实现建立在对TaskManager的修改的基础上。
-我们只需要在TaskManagerInner中的TaskControlBlock里添加syscall_times来统计该任务的各个系统调用次数的统计，并在系统调用时，以及任务切换时进行相应数据的修改就行了。
-本次实验是在有了分页机制的前提下，重写了ch3中的sys_write和sys_task_info。
-由于我们引入了虚拟存储机制，所以要把数据写到任务地址空间需要根据我们的页表得到其实际物理地址再写入。mmp与munmap都已在memroy_set中帮我们实现，我们只需要简单封装一下即可，同时我们要注意访问权限的管理。
-本次实验任务简单，spawn一个新任务就是创建一个空白子进程然后加载对应程序即可，
-通过这个阶段的学习，我巩固和掌握了很多操作系统的知识，并且在实践中得到了很大的收益。
-实验的逐步进行让我能够在已经写好的代码基础上增加对系统的理解并进行修改，从而使我的思维得到不断蜕变。此外，采用增加功能的实验方式让我感觉像在编写自己的操作系统，因此更加认真地学习，从中获取更多知识，并得到积极的反馈。
-此外，第二阶段的实践使我的 Rust 编程技能得到了进一步提升。
- - -参加本次rcore训练营的原因是希望找人和我一起写课程来督促我成长，因为本人做事很容易烂尾。
+之前做过类似的操作系统lab，并且也用过rust，所以前三个实验还是比较顺利完成了，这次报名也是希望能进一步参与后面的项目。
+下面简单总结一下在第二阶段我完成的各个实验情况。
+rcore 的前几个实验难度不是很大，读懂代码结构，按照需求去实现就行了。
+本次实验在要实现一个当前任务信息查询调用。
+而这个系统调用sys_task_info调用的实现建立在对TaskManager的修改的基础上。
+我们只需要在TaskManagerInner中的TaskControlBlock里添加syscall_times来统计该任务的各个系统调用次数的统计，并在系统调用时，以及任务切换时进行相应数据的修改就行了。
+本次实验是在有了分页机制的前提下，重写了ch3中的sys_write和sys_task_info。
+由于我们引入了虚拟存储机制，所以要把数据写到任务地址空间需要根据我们的页表得到其实际物理地址再写入。mmp与munmap都已在memroy_set中帮我们实现，我们只需要简单封装一下即可，同时我们要注意访问权限的管理。
+本次实验任务简单，spawn一个新任务就是创建一个空白子进程然后加载对应程序即可，
+通过这个阶段的学习，我巩固和掌握了很多操作系统的知识，并且在实践中得到了很大的收益。
+实验的逐步进行让我能够在已经写好的代码基础上增加对系统的理解并进行修改，从而使我的思维得到不断蜕变。此外，采用增加功能的实验方式让我感觉像在编写自己的操作系统，因此更加认真地学习，从中获取更多知识，并得到积极的反馈。
+此外，第二阶段的实践使我的 Rust 编程技能得到了进一步提升。
+ + +第一次知道 rcore 这个项目是在一个 CS 的开源交流群里，因为一直是开发小白，想要找一些项目来写，提升自己的实力。
+暑假开始学 xv6，但是因为旅游计划搁置了，刚好开学后听闻 rcore 的项目，脑袋一拍就想参与，并也是进入以后才了解到 rust 语言。
+起初参加的原因只是希望找人和我一起写课程来督促我成长，因为本人很容易分心。但是这个问题在开始写 lab 以后就眼小云散了，发现自己在写实验的时候还是很专注，能够投入时间的。
+在学习了第一阶段的 rustlings 后，我了解到了很多独属于 rust 本身的魅力，比如所有权，又比如unsafe，同时 rust 的编译器比较严格，能够在编译层面上杜绝一大部分难以在代码层面上发现的 BUG，
+同样的，riscv 架构是一个新兴架构，指令集简洁且开源，易于掌握和学习。
+下面简单总结一下在第二阶段我完成的各个实验情况。
+本次实验在一个分时多任务系统架构的基础上实现了一个当前任务信息查询调用。
+从系统调用的层面上（S态）实现了该功能。
+sys_task_info调用的实现建立在对TaskManager的修改的基础上。
+我在TaskManagerInner中的TaskControlBlock里添加了syscall_times来统计该任务的各个系统调用次数的统计（在Trap_handler中增加贡献），并且在Inner中添加start_time来计算Task开启的时间长度，任务块实现函数中统计。
+由于本次实验框架基于数组的实现方式，是建立在系统体量较小的基础上，所以能够理解。但是如果系统逐渐庞大，系统调用和任务数量的增加，会导致TaskManager内存部分乘法增长（因为是数组套数组）。
+任务数量应该远小于系统调用的情况下使用HashMap来替代TaskControlBlock内部的统计数组会好一些。
+本次实验重写了ch3中的sys_write和sys_task_info，因为在分页机制启用的基础上原有代码不再可用。
+上面两个系统调用涉及到用户空间中的内存使用，所以我设计了一个modify_byte_buffer函数，用于将src(启用分页的内核空间地址)中的len长度的内容拷贝到ptr(启用分页的内核用户地址)相同长度的物理内存中去。
+本次实验还实现了sys_mmap和sys_mummap的匿名映射的内存申请和解绑系统调用。
+这两个函数都需要对所映射的地址范围进行检查，其中有一个关键点在于框架内所有的区间都使用左闭右开的形式。而且在使用虚拟地址来找到对应的物理地址时，框架(mm::page_table::find_pte)在第0和第1层遇到没有下一层映射的情况时返回None，但是到第2层时会直接返回，所以我们在返回值不是None的情况下也要判断是否Vaild。
+上面这个 Vaild 的问题我真的是调了两个小时才发现的，真的需要知道每一块代码的运行方式和功能。
+本次实验继承了ch4中的所有功能。
+同时实现了spawn创建进程以及通过设置priority优先级和stride参数来对进程进行调度。
+本次实验较为简单，使用 git cherry-pick 能简单的得到前面提交的代码，方便了功能的继承。
+同时这次实验的调试也并不容易，其中在 syscall 统计其次数时，我像之前一样获取了TaskManager的所有权后增加，但是这样导致我在 waitpid 中的一个 assert 一直未能通过，后才发现改正。
+本次 rcore-os 训练营的第二阶段，让我巩固和学习掌握了很多操作系统的知识，并且亲身实践了功能，受益匪浅。
+第二阶段将较难的一些概念和功能拆分，让我们不至于对一个东西很难上手，同时实验循序渐进，能够在原来写好东西的基础上增加对系统的理解修改代码，让我们的思维不断蜕变；而且增加功能的实验方式让我感觉像是在写自己的系统，就会更认真的写，学到更多东西，有强烈的正反馈。
+同时第二阶段的实践也让我的 rust 语言熟练读更上一层楼。
+如果还有时间我将继续学习 ch6 和 ch8 两个实验。
+ + +本次训练营对我最大的帮助在于，让我深入了解了操作系统底层的工作原理，通过教程的辅助和源码的阅读，我了解到了操作系统在进程线程管理、任务调度、内存分配、文件系统管理等方面的知识，对其实现的机制有了初步的认识。
+从操作系统环境的搭建开始，我不断的给系统增加功能，引入进程、页表、地址空间、文件系统、同步机制，让操作系统能够运行一个个进程与线程，处理并发场景的任务，这是一场具有挑战却又精彩的旅程。
+从进程或线程的创建和调度角度来说，我了解到了操作系统如何把一个elf格式的文件转换为一个进程，为它分配地址空间、栈空间等，以及如何在进程中执行任务，以及创建新的线程。
+elf文件中定义了程序的内存布局，而操作系统将为它创建地址空间，给它分配进程号并将各个逻辑段存放在合适的位置，之后将进程添加到调度队列中，由CPU执行。其中很重要的数据结构为TrapContext，它记录了进程或者线程的上下文信息，在切换任务时发挥着巨大的作用。而其中又涉及到了内存的分配，当进程需要分配内存时，由页表完成从虚拟地址到物理地址的映射，整个映射的过程也是我学习过程的一个重难点，从分配物理页号到创建多级页表进行映射，以及如何使用虚拟地址向物理内存中写入数据，通过思考、绘图去展示整个过程，我慢慢的理解了其中的所以然，感受到了虚拟内存系统的精妙的哲思。
+文件系统部分，我学习到了一个简易文件系统的实现，对于文件系统如何管理磁盘文件、以及如何在内核中使用文件有了一个新的认识。首先最令我费解的是描述文件的一系列数据结构，难点在于DiskINode和INode的关系和作用。经过一遍遍理解和梳理，我认识磁盘上的第一个分块将会用于存储整个磁盘的元信息，包括各类块的数量，之后的块分别记录索引位图、索引、数据位图和数据。索引中记录了一个文件的类型、大小以及在磁盘上的块号，通过索引可以找到文件所在的位置，对文件进行读写，这个索引即是DiskINode，而INode用于记录DiskINode的位置，该数据结构将暴露给内核，方便在内核中对文件进行操作。
+在并发的学习过程中，我对锁的实现机制有了更多的了解。当某个线程去访问被上锁的临界区时，线程将会从任务调度队列中移入到等待队列，由此陷入等待（休眠），在锁释放的时候再从等待队列中唤醒线程，以达到同步的效果，从而避免数据不一致问题。也试着去实现了一个简单的死锁检测机制，但对该机制的原理理解的还不够，无法证明为何该算法能够实现死锁检测。
+教程和练习引导着我的学习与进步，让我对操作系统有了更多的理解，但它们无法为我解释所有的问题，也无法让我看懂所有的代码。当前的学习虽说已告一段落，但整个项目中还有很多细节值得我去细细品味。那些我未阅读或未理解的源码，以及关于os的设计原理–为什么要这样设计，是否有更加合适的设计方式，这对于我来说都是未完成的任务，也是将来需要探索的。
+最后，我想感谢训练营，能提供这么好的机会和资料来帮助我学习os，今后我也希望能有更多的机会去深入理解系统级别的设计与开发，加油！
+ + +