all examples in ch10 finished!

Author: cfsamson

ch10/x-pin-experiments/.vscode/launch.json renamed to ch10/d-pin/.vscode/launch.json

@@ -0,0 +1,109 @@
+use std::{
+    marker::PhantomPinned,
+    pin::{pin, Pin},
+};
+
+fn main() {
+    // heap_pinning();
+    //stack_pinning_manual();
+    //stack_pinning_manual_problem();
+    //stack_pinning_macro();
+    //pin_projection();
+}
+
+fn heap_pinning() {
+    let mut x = Box::pin(MaybeSelfRef::default());
+    x.as_mut().init();
+    println!("{}", x.as_ref().a);
+    *x.as_mut().b().unwrap() = 2;
+    println!("{}", x.as_ref().a);
+}
+
+// Pinning stack
+fn stack_pinning_manual() {
+    let mut x = MaybeSelfRef::default();
+    let mut x = unsafe { Pin::new_unchecked(&mut x) };
+    x.as_mut().init();
+    println!("{}", x.as_ref().a);
+    *x.as_mut().b().unwrap() = 2;
+    println!("{}", x.as_ref().a);
+}
+
+use std::mem::swap;
+fn stack_pinning_manual_problem() {
+    let mut x = MaybeSelfRef::default();
+    let mut y = MaybeSelfRef::default();
+
+    {
+        let mut x = unsafe { Pin::new_unchecked(&mut x) };
+        x.as_mut().init();
+        *x.as_mut().b().unwrap() = 2;
+    }
+    swap(&mut x, &mut y);
+    println!("
+     x: {{
+  +----->a: {:p},
+  |      b: {:?},
+  |  }}
+  |
+  |  y: {{
+  |      a: {:p},
+  +-----|b: {:?},
+     }}",
+        &x.a,
+        x.b,
+        &y.a,
+        y.b,
+    );
+}
+
+fn stack_pinning_macro() {
+    let mut x = pin!(MaybeSelfRef::default());
+    MaybeSelfRef::init(x.as_mut());
+    println!("{}", x.as_ref().a);
+    *x.as_mut().b().unwrap() = 2;
+    println!("{}", x.as_ref().a);
+}
+
+fn pin_projection() {
+    #[derive(Default)]
+    struct Foo {
+        a: MaybeSelfRef,
+        b: String,
+    }
+
+    impl Foo {
+        fn a(self: Pin<&mut Self>) -> Pin<&mut MaybeSelfRef> {
+            unsafe {
+                self.map_unchecked_mut(|s| &mut s.a)
+            }
+        }
+
+        fn b(self: Pin<&mut Self>) -> &mut String {
+            unsafe {
+                &mut self.get_unchecked_mut().b
+            }
+        }
+    }
+}
+
+
+#[derive(Default, Debug)]
+struct MaybeSelfRef {
+    a: usize,
+    b: Option<*mut usize>,
+    _pin: PhantomPinned,
+}
+
+impl MaybeSelfRef {
+    fn init(self: Pin<&mut Self>) {
+        unsafe {
+            let Self { a, b, .. } = self.get_unchecked_mut();
+            *b = Some(a);
+        }
+    }
+
+    fn b(self: Pin<&mut Self>) -> Option<&mut usize> {
+        unsafe { self.get_unchecked_mut().b.map(|b| &mut *b) }
+    }
+}

ch10/x-pin-experiments/Cargo.toml renamed to ch10/d-pin/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "e-coroutines-pin"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+mio = { version = "0.8", features = ["net", "os-poll"] }

ch10/d-pin/src/main.rs

@@ -0,0 +1,56 @@
+// NEW
+use std::pin::Pin;
+
+use crate::runtime::Waker;
+
+
+pub trait Future {
+    type Output;
+
+    fn poll(self: Pin<&mut Self>, waker: &Waker) -> PollState<Self::Output>;
+}
+
+pub enum PollState<T> {
+    Ready(T),
+    NotReady,
+}
+
+pub fn join_all<F: Future>(futures: Vec<F>) -> JoinAll<F> {
+        let futures = futures.into_iter().map(|f| (false, Box::pin(f))).collect();
+        JoinAll {
+            futures,
+            finished_count: 0,
+        }
+    }
+
+    pub struct JoinAll<F: Future> {
+        futures: Vec<(bool, Pin<Box<F>>)>,
+        finished_count: usize,
+    }
+
+    impl<F: Future> Future for JoinAll<F> {
+        type Output = String;
+        fn poll(self: Pin<&mut Self>, waker: &Waker) -> PollState<Self::Output> {
+            let Self { futures, finished_count} = self.get_mut();
+            for (finished, fut) in futures.iter_mut() {
+                if *finished {
+                    continue;
+                }
+
+                match fut.as_mut().poll(waker) {
+                    PollState::Ready(_) => {
+                        *finished = true;
+                        *finished_count += 1;
+                    }
+
+                    PollState::NotReady => continue,
+                }
+            }
+
+            if *finished_count == futures.len() {
+                PollState::Ready(String::new())
+            } else {
+                PollState::NotReady
+            }
+        }
+    }

ch10/x-pin-experiments/step1.rs renamed to ch10/d-pin/step1.rs

@@ -0,0 +1,95 @@
+use std::{io::{ErrorKind, Read, Write}, pin::Pin};
+
+use mio::{Interest, Registry, Token};
+
+use crate::{
+    future::PollState,
+    runtime::{self, reactor, Waker},
+    Future,
+};
+
+fn get_req(path: &str) -> String {
+    format!(
+        "GET {path} HTTP/1.1\r\n\
+             Host: localhost\r\n\
+             Connection: close\r\n\
+             \r\n"
+    )
+}
+
+pub struct Http;
+
+impl Http {
+    pub fn get(path: &str) -> impl Future<Output = String> {
+        HttpGetFuture::new(path.to_string())
+    }
+}
+struct HttpGetFuture {
+    stream: Option<mio::net::TcpStream>,
+    buffer: Vec<u8>,
+    path: String,
+    id: usize,
+}
+
+impl HttpGetFuture {
+    fn new(path: String) -> Self {
+        let id = reactor().next_id();
+        Self {
+            stream: None,
+            buffer: vec![],
+            path,
+            id,
+        }
+    }
+
+    fn write_request(&mut self) {
+        let stream = std::net::TcpStream::connect("127.0.0.1:8080").unwrap();
+        stream.set_nonblocking(true).unwrap();
+        let mut stream = mio::net::TcpStream::from_std(stream);
+        stream.write_all(get_req(&self.path).as_bytes()).unwrap();
+        self.stream = Some(stream);
+    }
+}
+
+impl Future for HttpGetFuture {
+    type Output = String;
+
+    fn poll(self: Pin<&mut Self>, waker: &Waker) -> PollState<Self::Output> {
+        // If this is first time polled, start the operation
+        // see: https://users.rust-lang.org/t/is-it-bad-behaviour-for-a-future-or-stream-to-do-something-before-being-polled/61353
+        // Avoid dns lookup this time
+        let this = self.get_mut();
+
+        if this.stream.is_none() {
+            println!("FIRST POLL - START OPERATION");
+            this.write_request();
+            // CHANGED
+            let stream = this.stream.as_mut().unwrap();
+            runtime::reactor().register(stream, Interest::READABLE, this.id);
+            runtime::reactor().set_waker(waker, this.id);
+            // ============
+        }
+
+        let mut buff = vec![0u8; 147];
+        loop {
+            match this.stream.as_mut().unwrap().read(&mut buff) {
+                Ok(0) => {
+                    let s = String::from_utf8_lossy(&this.buffer).to_string();
+                    runtime::reactor().deregister(this.stream.as_mut().unwrap(), this.id);
+                    break PollState::Ready(s.to_string());
+                }
+                Ok(n) => {
+                    this.buffer.extend(&buff[0..n]);
+                    continue;
+                }
+                Err(e) if e.kind() == ErrorKind::WouldBlock => {
+                    // always store the last given Waker
+                    runtime::reactor().set_waker(waker, this.id);
+                    break PollState::NotReady;
+                }
+
+                Err(e) => panic!("{e:?}"),
+            }
+        }
+    }
+}