add the chapter 4

Author: smallnest

.DS_Store

@@ -14,5 +14,7 @@ bytes = "1.2.1"
 futures = { version = "0.3.24", features = ["executor", "thread-pool"] } 
 futures-lite = "1.12.0"
 futures-util = "0.3.24"
+monoio = "0.1.9"
 smol = "1.2.5"
 tokio = { version = "1.21.2", features = ["full"] }
+value-bag = "1.4.1"

asyncwait/Cargo.toml

@@ -1,15 +1,21 @@
 #![feature(type_alias_impl_trait)]
+#![feature(impl_trait_in_assoc_type)]
+
+
 // #![feature(return_position_impl_trait_in_trait)]
 
-pub mod asyncio;
-pub mod future;
-pub mod runtimes;
-pub mod gat;
-pub mod async_trait_example;
+mod asyncio;
+mod future;
+mod runtimes;
+mod gat;
+mod async_trait_example;
+mod monoio_example;
 
 pub use asyncio::*;
 pub use future::*;
 pub use runtimes::*;
 pub use gat::*;
 pub use async_trait_example::*; 
+pub use monoio_example::*;
+
 

asyncwait/src/lib.rs

@@ -5,17 +5,25 @@ fn main() {
     futures_async();
     futures_lite_async();
     async_std();
+    async_std_task();
     smol_async();
 
     timefuture_async();
 
+    try_join();
     join();
     select();
     futures_select();
+    smol_zip();
 
     stream();
 
     kviterator_example();
 
     async_trait_example();
+
+    match monoio_example() {
+        Ok(_) => println!("monoio_example: Ok"),
+        Err(e) => println!("monoio_example: Err: {}", e),
+    }
 }

asyncwait/src/main.rs

@@ -0,0 +1,25 @@
+
+use monoio::fs::File;
+
+
+pub fn monoio_example() -> Result<(), Box<dyn std::error::Error>>{
+    monoio::start::<monoio::LegacyDriver, _>(async {
+        println!("monoio_example: Hello world!");
+
+        // Open a file
+        let file = File::open("LICENSE").await?;
+
+        let buf = vec![0; 4096];
+        // Read some data, the buffer is passed by ownership and
+        // submitted to the kernel. When the operation completes,
+        // we get the buffer back.
+        let (res, buf) = file.read_at(buf, 0).await;
+        let n = res?;
+
+        // Display the contents
+        println!("monoio_example: {:?}", &buf[..n]);
+
+        Ok(())
+    })
+}
+  

asyncwait/src/monoio_example.rs

@@ -4,10 +4,13 @@ use futures::try_join;
 use futures::StreamExt;
 use futures::{
     future::FutureExt, // for `.fuse()`
+    join,
     pin_mut,
     select,
 };
 
+use async_std::task;
+
 pub fn tokio_async() {
     let rt = tokio::runtime::Runtime::new().unwrap();
     rt.block_on(async {
@@ -54,11 +57,22 @@ pub fn async_std() {
     async_std::task::block_on(async { println!("Hello from async_std") })
 }
 
+pub fn async_std_task() {
+    task::block_on(async {
+        task::spawn(get_book());
+        task::spawn(get_music());
+
+        println!("in async_std_task");
+    });
+}
+
 pub fn smol_async() {
-    smol::block_on(async { println!("Hello from smol") })
+    smol::block_on(async { println!("Hello from smol") });
 }
 
+#[derive(Debug)]
 struct Book();
+#[derive(Debug)]
 struct Music();
 
 async fn get_book() -> Result<Book, String> {
@@ -69,14 +83,24 @@ async fn get_music() -> Result<Music, String> {
     println!("in get_music");
     Ok(Music())
 }
-async fn get_book_and_music() -> Result<(Book, Music), String> {
-    let book_fut = get_book();
-    let music_fut = get_music();
-    try_join!(book_fut, music_fut)
+
+pub fn try_join() {
+    futures_lite::future::block_on(async {
+        let book_fut = get_book();
+        let music_fut = get_music();
+        println!("try_join: {:?}", try_join!(book_fut, music_fut));
+    });
 }
 
 pub fn join() {
-    futures_lite::future::block_on(async { get_book_and_music().await }).unwrap();
+    let a = async { 1 };
+    let b = async { 2 };
+    let c = async { 3 };
+
+    futures_lite::future::block_on(async {
+        println!("join: {:?}", join!(get_book(), get_music()));
+        println!("join: {:?}", join!(a, b, c));
+    });
 }
 
 pub fn select() {
@@ -112,3 +136,21 @@ pub fn futures_select() {
         assert_eq!(total, 10);
     });
 }
+
+pub fn smol_zip() {
+    smol::block_on(async {
+        use smol::future::{try_zip, zip, FutureExt};
+
+        let future1 = async { 1 };
+        let future2 = async { 2 };
+
+        let result = zip(future1, future2);
+        println!("smol_zip: {:?}", result.await);
+
+        let future1 = async { Ok::<i32, i32>(1) };
+        let future2 = async { Err::<i32, i32>(2) };
+
+        let result = try_zip(future1, future2).await;
+        println!("smol_try_zip: {:?}", result);
+    });
+}

asyncwait/src/runtimes.rs

@@ -6,3 +6,4 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+beef = "0.5.2"

book_cn/rust_concurrency_cookbook.pdf

@@ -1,3 +1,4 @@
+use std::boxed::ThinBox;
 // Box<T>, casually referred to as a ‘box’, provides the simplest form of heap allocation in Rust. 
 // Boxes provide ownership for this allocation, and drop their contents when they go out of scope. 
 // Boxes also ensure that they never allocate more than isize::MAX bytes.
@@ -17,3 +18,18 @@ pub fn box_example2() {
     println!("{list:?}");
 }
 
+pub fn thin_box_example() {
+    use std::mem::{size_of, size_of_val};
+    let size_of_ptr = size_of::<*const ()>();
+
+    let box_five = Box::new(5);
+    let box_slice = Box::<[i32]>::new_zeroed_slice(5);
+    assert_eq!(size_of_ptr, size_of_val(&box_five));
+    assert_eq!(size_of_ptr * 2, size_of_val(&box_slice));
+
+
+    let five = ThinBox::new(5);
+    let thin_slice = ThinBox::<[i32]>::new_unsize([1, 2, 3, 4]);
+    assert_eq!(size_of_ptr, size_of_val(&five));
+    assert_eq!(size_of_ptr, size_of_val(&thin_slice));
+}

container_primitive/Cargo.toml

@@ -2,7 +2,7 @@
 
 use std::cell::*;
 use std::collections::HashMap;
-use std::rc::Rc;
+use std::sync::LazyLock;
 
 // Shareable mutable containers.
 // Shareable mutable containers exist to permit mutability in a controlled manner, even in the presence of aliasing.
@@ -27,6 +27,8 @@ pub fn cell_example() {
     let _ = my_struct.regular_field;
     // my_struct.regular_field = 100;
     my_struct.special_field.set(100);
+
+    my_struct.special_field.update(|v| v + 1);
 }
 
 pub fn refcell_example() {
@@ -53,23 +55,7 @@ pub fn refcell_example() {
     println!("special_field = {}", my_struct.special_field.borrow());
 }
 
-pub fn rc_refcell_example() {
-    let shared_map: Rc<RefCell<_>> = Rc::new(RefCell::new(HashMap::new()));
-    // Create a new block to limit the scope of the dynamic borrow
-    {
-        let mut map: RefMut<_> = shared_map.borrow_mut();
-        map.insert("africa", 92388);
-        map.insert("kyoto", 11837);
-        map.insert("piccadilly", 11826);
-        map.insert("marbles", 38);
-    }
 
-    // Note that if we had not let the previous borrow of the cache fall out
-    // of scope then the subsequent borrow would cause a dynamic thread panic.
-    // This is the major hazard of using `RefCell`.
-    let total: i32 = shared_map.borrow().values().sum();
-    println!("{total}");
-}
 
 pub fn once_cell_example() {
     let cell = OnceCell::new();
@@ -90,78 +76,18 @@ pub fn lazy_cell_example() {
     println!("{}", *lazy);
 }
 
-pub fn myrc_example() {
-    let s = example::Rc::new("hello world");
-    let s1 = s.clone();
-
-    let v = s1.value();
-    println!("myrc value: {}", v);
-}
-
-pub mod example {
-    use std::cell::Cell;
-    use std::marker::PhantomData;
-    use std::process::abort;
-    use std::ptr::NonNull;
-
-    pub struct Rc<T: ?Sized> {
-        ptr: NonNull<RcBox<T>>,
-        phantom: PhantomData<RcBox<T>>,
-    }
-
-    impl<T> Rc<T> {
-        pub fn new(t: T) -> Self {
-            let ptr = Box::new(RcBox {
-                strong: Cell::new(1),
-                refcount: Cell::new(1),
-                value: t,
-            });
-            let ptr = NonNull::new(Box::into_raw(ptr)).unwrap();
-            Self {
-                ptr: ptr,
-                phantom: PhantomData,
-            }
-        }
-
-        pub fn value(&self) -> &T {
-            &self.inner().value
-        }
-    }
-
-
-    struct RcBox<T: ?Sized> {
-        strong: Cell<usize>,
-        refcount: Cell<usize>,
-        value: T,
-    }
-
-    impl<T: ?Sized> Clone for Rc<T> {
-        fn clone(&self) -> Rc<T> {
-            self.inc_strong();
-            Rc {
-                ptr: self.ptr,
-                phantom: PhantomData,
-            }
-        }
-    }
-
-    trait RcBoxPtr<T: ?Sized> {
-        fn inner(&self) -> &RcBox<T>;
-
-        fn strong(&self) -> usize {
-            self.inner().strong.get()
-        }
-
-        fn inc_strong(&self) {
-            self.inner()
-                .strong
-                .set(self.strong().checked_add(1).unwrap_or_else(|| abort()));
-        }
-    }
-
-    impl<T: ?Sized> RcBoxPtr<T> for Rc<T> {
-        fn inner(&self) -> &RcBox<T> {
-            unsafe { self.ptr.as_ref() }
-        }
-    }
-}
+static HASHMAP: LazyLock<HashMap<i32, String>> = LazyLock::new(|| {
+    println!("initializing");
+    let mut m = HashMap::new();
+    m.insert(13, "Spica".to_string());
+    m.insert(74, "Hoyten".to_string());
+    m
+});
+
+pub fn lazy_lock() {
+    println!("ready");
+    std::thread::spawn(|| {
+        println!("{:?}", HASHMAP.get(&13));
+    }).join().unwrap();
+    println!("{:?}", HASHMAP.get(&74));
+}

container_primitive/src/box.rs

@@ -1,17 +1,20 @@
 use std::borrow::Cow;
+use std::mem::size_of;
 
-// The type Cow is a smart pointer providing clone-on-write functionality: 
-// it can enclose and provide immutable access to borrowed data, 
-// and clone the data lazily when mutation or ownership is required. 
+// The type Cow is a smart pointer providing clone-on-write functionality:
+// it can enclose and provide immutable access to borrowed data,
+// and clone the data lazily when mutation or ownership is required.
 pub fn cow_example() {
     let origin = "hello world";
-    let mut cow = Cow::from(origin);
+    let mut cow = Cow::from(origin); // Cow::Borrowed
     assert_eq!(cow, "hello world");
 
     // Cow can be borrowed as a str
     let s: &str = &cow;
     assert_eq!(s, "hello world");
 
+    assert_eq!(s.len(), cow.len());
+
     // Cow can be borrowed as a mut str
     let s: &mut str = cow.to_mut();
     s.make_ascii_uppercase();
@@ -54,4 +57,19 @@ pub fn cow_example2() {
     // No clone occurs because `input` is already owned.
     let mut input = Cow::from(vec![-1, 0, 1]);
     abs_all(&mut input);
-}
+
+}
+
+pub fn beef_cow() {
+    let borrowed: beef::Cow<str> = beef::Cow::borrowed("Hello");
+    let owned: beef::Cow<str> = beef::Cow::owned(String::from("World"));
+    let _ = beef::Cow::from("Hello");
+
+    assert_eq!(format!("{} {}!", borrowed, owned), "Hello World!",);
+
+    const WORD: usize = size_of::<usize>();
+
+    assert_eq!(size_of::<std::borrow::Cow<str>>(), 3 * WORD);
+    assert_eq!(size_of::<beef::Cow<str>>(), 3 * WORD);
+    assert_eq!(size_of::<beef::lean::Cow<str>>(), 2 * WORD);
+}

container_primitive/src/cell.rs

@@ -1,4 +1,7 @@
-#![feature(once_cell)]
+#![feature(lazy_cell)]
+#![feature(thin_box)]
+#![feature(new_uninit)]
+#![feature(cell_update)]
 
 pub mod cow;
 pub mod r#box;