2022 Daily schedule of OS Tranining Camp

Timeline

November

Mon	Tues	Wed	Thur	Fri	Sat	Sun
	1 (D1)	2 (D2)	3 (D3)	4 (D4)	5 (D5)	6 (D6)
7 (D11)	8 (D8)	9 (D9)	10 (D10)	11 (D11)	12 (D12)	13 (D13)
14 (D14)	15 (D15)	16 (D16)	17 (D17)	18 (D18)	19 (D19)	20 (D20)
21 (D21)	22 (D22)	23 (D23)	24 (D24)	25 (D25)	26 (D26)	27 (D27)
28 (D28)	29 (D29)	30 (D30)

---

Day 1 2022/11/1

OS Tranining Camp

今天听了老师们的报告，感触颇多，之前学习过一段时间的Rust，同时又想对OS有较为深入的了解，包括riscv、qemu等知识，遂决定报名参加秋冬季OS训练营。

希望通过本次的训练营，在前辈们的帮助下，能够对Rust和OS有更进一步的认识。虽然去年就入坑了Rust，当时是啃的官方社区的TRPL，虽然过程很艰难，但是rust的配置实在是比c++配置起来好太多了，之后又看了rust官方社区的一些文档，但总是感觉缺少一点实践。因此从OS的项目做起，希望能够对Rust又更深入的理解。

首先从Rustlings开始学习，计划在一周之内完成rustling。与此同时，在WSL2中配置相应的实验环境。

Day 2 2022/11/2

OS Training Camp

今天完成了Rust实验环境的配置。于此同时，开始完成rustlings的实验，目前已经完成1/3，在Rust的移动语义部分还是较为卡壳，因此还需要对Rust的move semantic进行进一步的学习以加深对移动语义的理解。

Notes:

在quiz1中，我们实现了一个最为基础的计算价格的函数，但是注意该函数只能返回类型为i32的值，因此不能用于处理较复杂的情形，比如当输入值不合法（例如负数），后续会学到利用Result来处理结果。

在primitive_types中，注意只有char类型的变量才能够使用is_numeric()和is_alphabetical() API. 具体可以参考link

vector initialization:

let a = vec![1, 2, 3, 4]; // create vector with 4 values
let b = vec![1; 100]; // in Rust, value first, create a vector with size of 100 and all values equal to 1
let c: Vec<i32> = Vec::new(); // this is also a way to creat the vector

fn zeros(size: u32) -> Vec<i32> {
    let mut zero_vec: Vec<i32> = Vec::with_capacity(size as usize); // this is another way to init vec
    for i in 0..size {
        zero_vec.push(0);
    }
    zero_vec
}

在Rust中，有Vec和slice类型，在上例的vector a中，可以通过&a[1..=3]取出其中特定的切片

let a = vec![1, 2, 3, 4, 5];
let new_slice = &a[1..=3];
assert_eq!([2, 3, 4], new_slice);

在vec2中，有两种方法批量修改vec的值：

fn vec_loop(mut v: Vec<i32>) -> Vec<i32> {
    for in in v.iter_mut() {
        *i *= 2;
    }
}

fn vec_map(v: &Vec<i32>) -> Vec<i32> {
    v.iter().map(|num| {
        num * 2 // closure of this
    }).collect()
}

在Rust中，对string进行操作，trim()用于删除空格，类似于Python中的strip() link to strings3

fn trim_me(input: &str) -> String {
    input.trim().to_string()
}

fn compose_me(input: &str) -> String {
    input.to_string() + " world!"
}

fn replace_me(input: &str) -> String {
    input.replace("cars", "balloons")
}

// there is also another way to replace the string, that is, use regex
use regex::Regex;
fn replace_regex(input: &str) -> String {
    let re = Regex::new(r"[cars]").unwrap();
    let res = re.replace_all(input, "balloons");
    res
}

Rust中，String和string_slice傻傻分不清：

fn string_slice(arg: &str) {
    println!("{}", arg);
}
fn string(arg: String) {
    println!("{}", arg);
}

fn main() {
    string_slice("blue");
    string("red".to_string());
    string("red".into());
    string("red".to_owned()); // 需要注意的是，在类型转换时，最好使用`to_owned()`,仅仅分配一个buffer。
    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", "Fri"));
    string("mY sHiFt KeY iS sTicKY".to_lowercase());
}

需要注意的是，在类型转换时，最好使用to_owned(),仅仅分配一个buffer。参考

Day 3 2022/11/3

OS Training Camp

今日进度：今天完成了Rustlings的enums，structs，options等小节.

HashMap in Rust. link to hashmap

let map: HashMap<String, i32> = HashMap::new();
map.insert(String::from("apple"), 3);
map.insert(String::from("mongo"), 2);


// remember the following
for fruit in fruit_kinds {
    if !map.contains_key(&fruit) {
        map.insert(fruit, 11);   // [link to hashmap2]
    }
}

上述代码段中的第二部分。link to hashmap2

I don't know how to implement HashMap3, so just reference to reddit.[link to hashmap3] [reddit refer] [stackoverflow refer]

在Rust中，当处理Options时，为了方便得到Ok()中的值，通常使用unwrap()来获得。此处对unwrap方法存疑。

link to options3中，完全依靠编译器编程。

Rust中的errors handling较难。

fn main() -> Result<(), Box<dyn error::error>> {
    let pretend_user_input = "32";
    let x: i32 = pretend_user_input.parse()?;
    println!("output={:?}", PositiveNonzeroInteger::new(x)?);
    Ok(())
}

There are two different possible Result types produced within main(), which are propagated using ? operators. ? mark

Under the hood, the ? operator calls From::from on the error value to convert it to a boxed trait object, a Box<dyn error::Error>. This boxed trait object is polymorphic, and since all errors implement the error::Error trait, we can capture lots of different errors in one "Box" object. boxing errors

Day 4 2022/11/4

Rustlings

今天需要完成rustlings中的所有练习题，与此同时，尝试完成rustlings的所有总结。

Day 6 2022/11/6

Rustlings

今天完成了Rustlings中thread章节之前的所有内容。对Trait，以及一些智能指针有了一定的认识。

In macro chapters, remeber the macro should be declared before call. To a certain extent, this is just like C/C++ function call. :)

#[macro_use] // notice the use of #[macro_use]
mod macros {
    macro_rules! my_macro {
        () => {
            println!("Check out my macro!");
        };
    }
}

fn main() {
    my_macro!();
}

Day 7 2022/11/7

Rustlings

Rust中的iterator真的让人头大。

fn count_iter(map: &HashMap<String, Progress>, value: Progress) -> usize {
    map.values().into_iter().filter(|&v| v == &value).count()
}

fn count_collection_for(collection: &[HashMap<String, Progress>], value: Progress) -> usize {
    let mut count = 0;
    for map in collection {
        for val in map.values() {
            if val == &value {
                count += 1;
            }
        }
    }
    count
}

fn count_collection_iterator(collection: &[HashMap<String, Progress>], value: Progress) -> usize {
    collection.iter().map(|m| count_iterator(&m, value)).sum()
}

Day 8 2022/11/8

Rust feature(OOP: T): where T: encapsulation + polymorphism + (inheritance)

1. encapsulation
   • We have structs and enums to have the
2. polymorphism
   • Like the trait

🎉 All exercises completed! 🎉

+----------------------------------------------------+
|          You made it to the Fe-nish line!          |
+--------------------------  ------------------------+
                          \\/
     ▒▒          ▒▒▒▒▒▒▒▒      ▒▒▒▒▒▒▒▒          ▒▒
   ▒▒▒▒  ▒▒    ▒▒        ▒▒  ▒▒        ▒▒    ▒▒  ▒▒▒▒
   ▒▒▒▒  ▒▒  ▒▒            ▒▒            ▒▒  ▒▒  ▒▒▒▒
 ░░▒▒▒▒░░▒▒  ▒▒            ▒▒            ▒▒  ▒▒░░▒▒▒▒
   ▓▓▓▓▓▓▓▓  ▓▓      ▓▓██  ▓▓  ▓▓██      ▓▓  ▓▓▓▓▓▓▓▓
     ▒▒▒▒    ▒▒      ████  ▒▒  ████      ▒▒░░  ▒▒▒▒
       ▒▒  ▒▒▒▒▒▒        ▒▒▒▒▒▒        ▒▒▒▒▒▒  ▒▒
         ▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▒▒▒▒▒▒▒▒▓▓▒▒▓▓▒▒▒▒▒▒▒▒
           ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒
             ▒▒▒▒▒▒▒▒▒▒██▒▒▒▒▒▒██▒▒▒▒▒▒▒▒▒▒
           ▒▒  ▒▒▒▒▒▒▒▒▒▒██████▒▒▒▒▒▒▒▒▒▒  ▒▒
         ▒▒    ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒    ▒▒
       ▒▒    ▒▒    ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒    ▒▒    ▒▒
       ▒▒  ▒▒    ▒▒                  ▒▒    ▒▒  ▒▒
           ▒▒  ▒▒                      ▒▒  ▒▒

We hope you enjoyed learning about the various aspects of Rust!
If you noticed any issues, please don't hesitate to report them to our repo.
You can also contribute your own exercises to help the greater community!

Day 9 2022/11/9

Read the xv6 book, Here are some notes of xv6.