final audit pass

src/0_background_information.md

@@ -136,8 +136,7 @@ second as you read this.
 4. Complicated to implement correctly if you want to support many different
    platforms.
 
-If you were to implement green threads in Rust, it could look something like
-this:
+A green threads example could look something like this:
 
 > The example presented below is an adapted example from an earlier gitbook I
 > wrote about green threads called [Green Threads Explained in 200 lines of Rust.](https://cfsamson.gitbook.io/green-threads-explained-in-200-lines-of-rust/)
@@ -146,198 +145,199 @@ this:
 > It's not in any way meant to showcase "best practice". Just so we're on
 > the same page.
 
+_**Press the expand icon in the top right corner to show the example code.**_ 
 ```rust, edition2018
-#![feature(asm, naked_functions)]
-use std::ptr;
-
-const DEFAULT_STACK_SIZE: usize = 1024 * 1024 * 2;
-const MAX_THREADS: usize = 4;
-static mut RUNTIME: usize = 0;
-
-pub struct Runtime {
-    threads: Vec<Thread>,
-    current: usize,
-}
-
-#[derive(PartialEq, Eq, Debug)]
-enum State {
-    Available,
-    Running,
-    Ready,
-}
-
-struct Thread {
-    id: usize,
-    stack: Vec<u8>,
-    ctx: ThreadContext,
-    state: State,
-    task: Option<Box<dyn Fn()>>,
-}
-
-#[derive(Debug, Default)]
-#[repr(C)]
-struct ThreadContext {
-    rsp: u64,
-    r15: u64,
-    r14: u64,
-    r13: u64,
-    r12: u64,
-    rbx: u64,
-    rbp: u64,
-    thread_ptr: u64,
-}
-
-impl Thread {
-    fn new(id: usize) -> Self {
-        Thread {
-            id,
-            stack: vec![0_u8; DEFAULT_STACK_SIZE],
-            ctx: ThreadContext::default(),
-            state: State::Available,
-            task: None,
-        }
-    }
-}
-
-impl Runtime {
-    pub fn new() -> Self {
-        let base_thread = Thread {
-            id: 0,
-            stack: vec![0_u8; DEFAULT_STACK_SIZE],
-            ctx: ThreadContext::default(),
-            state: State::Running,
-            task: None,
-        };
-
-        let mut threads = vec![base_thread];
-        threads[0].ctx.thread_ptr = &threads[0] as *const Thread as u64;
-        let mut available_threads: Vec<Thread> = (1..MAX_THREADS).map(|i| Thread::new(i)).collect();
-        threads.append(&mut available_threads);
-
-        Runtime {
-            threads,
-            current: 0,
-        }
-    }
-
-    pub fn init(&self) {
-        unsafe {
-            let r_ptr: *const Runtime = self;
-            RUNTIME = r_ptr as usize;
-        }
-    }
-
-    pub fn run(&mut self) -> ! {
-        while self.t_yield() {}
-        std::process::exit(0);
-    }
-
-    fn t_return(&mut self) {
-        if self.current != 0 {
-            self.threads[self.current].state = State::Available;
-            self.t_yield();
-        }
-    }
-
-    fn t_yield(&mut self) -> bool {
-        let mut pos = self.current;
-        while self.threads[pos].state != State::Ready {
-            pos += 1;
-            if pos == self.threads.len() {
-                pos = 0;
-            }
-            if pos == self.current {
-                return false;
-            }
-        }
-        
-        if self.threads[self.current].state != State::Available {
-            self.threads[self.current].state = State::Ready;
-        }
-
-        self.threads[pos].state = State::Running;
-        let old_pos = self.current;
-        self.current = pos;
-
-        unsafe {
-            switch(&mut self.threads[old_pos].ctx, &self.threads[pos].ctx);
-        }
-        true
-    }
-
-    pub fn spawn<F: Fn() + 'static>(f: F){
-        unsafe {
-            let rt_ptr = RUNTIME as *mut Runtime;
-            let available = (*rt_ptr)
-                .threads
-                .iter_mut()
-                .find(|t| t.state == State::Available)
-                .expect("no available thread.");
-                
-            let size = available.stack.len();
-            let s_ptr = available.stack.as_mut_ptr();
-            available.task = Some(Box::new(f));
-            available.ctx.thread_ptr = available as *const Thread as u64;
-            ptr::write(s_ptr.offset((size - 8) as isize) as *mut u64, guard as u64);
-            ptr::write(s_ptr.offset((size - 16) as isize) as *mut u64, call as u64);
-            available.ctx.rsp = s_ptr.offset((size - 16) as isize) as u64;
-            available.state = State::Ready;
-        }
-    }
-}
-
-fn call(thread: u64) {
-    let thread = unsafe { &*(thread as *const Thread) };
-    if let Some(f) = &thread.task {
-        f();
-    }
-}
-
-#[naked]
-fn guard() {
-    unsafe {
-        let rt_ptr = RUNTIME as *mut Runtime;
-        let rt = &mut *rt_ptr;
-        println!("THREAD {} FINISHED.", rt.threads[rt.current].id);
-        rt.t_return();
-    };
-}
-
-pub fn yield_thread() {
-    unsafe {
-        let rt_ptr = RUNTIME as *mut Runtime;
-        (*rt_ptr).t_yield();
-    };
-}
-
-#[naked]
-#[inline(never)]
-unsafe fn switch(old: *mut ThreadContext, new: *const ThreadContext) {
-    asm!("
-        mov     %rsp, 0x00($0)
-        mov     %r15, 0x08($0)
-        mov     %r14, 0x10($0)
-        mov     %r13, 0x18($0)
-        mov     %r12, 0x20($0)
-        mov     %rbx, 0x28($0)
-        mov     %rbp, 0x30($0)
-
-        mov     0x00($1), %rsp
-        mov     0x08($1), %r15
-        mov     0x10($1), %r14
-        mov     0x18($1), %r13
-        mov     0x20($1), %r12
-        mov     0x28($1), %rbx
-        mov     0x30($1), %rbp
-        mov     0x38($1), %rdi
-        ret
-        "
-    :
-    : "r"(old), "r"(new)
-    :
-    : "alignstack"
-    );
-}
+# #![feature(asm, naked_functions)]
+# use std::ptr;
+# 
+# const DEFAULT_STACK_SIZE: usize = 1024 * 1024 * 2;
+# const MAX_THREADS: usize = 4;
+# static mut RUNTIME: usize = 0;
+# 
+# pub struct Runtime {
+#     threads: Vec<Thread>,
+#     current: usize,
+# }
+# 
+# #[derive(PartialEq, Eq, Debug)]
+# enum State {
+#     Available,
+#     Running,
+#     Ready,
+# }
+# 
+# struct Thread {
+#     id: usize,
+#     stack: Vec<u8>,
+#     ctx: ThreadContext,
+#     state: State,
+#     task: Option<Box<dyn Fn()>>,
+# }
+# 
+# #[derive(Debug, Default)]
+# #[repr(C)]
+# struct ThreadContext {
+#     rsp: u64,
+#     r15: u64,
+#     r14: u64,
+#     r13: u64,
+#     r12: u64,
+#     rbx: u64,
+#     rbp: u64,
+#     thread_ptr: u64,
+# }
+# 
+# impl Thread {
+#     fn new(id: usize) -> Self {
+#         Thread {
+#             id,
+#             stack: vec![0_u8; DEFAULT_STACK_SIZE],
+#             ctx: ThreadContext::default(),
+#             state: State::Available,
+#             task: None,
+#         }
+#     }
+# }
+# 
+# impl Runtime {
+#     pub fn new() -> Self {
+#         let base_thread = Thread {
+#             id: 0,
+#             stack: vec![0_u8; DEFAULT_STACK_SIZE],
+#             ctx: ThreadContext::default(),
+#             state: State::Running,
+#             task: None,
+#         };
+# 
+#         let mut threads = vec![base_thread];
+#         threads[0].ctx.thread_ptr = &threads[0] as *const Thread as u64;
+#         let mut available_threads: Vec<Thread> = (1..MAX_THREADS).map(|i| Thread::new(i)).collect();
+#         threads.append(&mut available_threads);
+# 
+#         Runtime {
+#             threads,
+#             current: 0,
+#         }
+#     }
+# 
+#     pub fn init(&self) {
+#         unsafe {
+#             let r_ptr: *const Runtime = self;
+#             RUNTIME = r_ptr as usize;
+#         }
+#     }
+# 
+#     pub fn run(&mut self) -> ! {
+#         while self.t_yield() {}
+#         std::process::exit(0);
+#     }
+# 
+#     fn t_return(&mut self) {
+#         if self.current != 0 {
+#             self.threads[self.current].state = State::Available;
+#             self.t_yield();
+#         }
+#     }
+# 
+#     fn t_yield(&mut self) -> bool {
+#         let mut pos = self.current;
+#         while self.threads[pos].state != State::Ready {
+#             pos += 1;
+#             if pos == self.threads.len() {
+#                 pos = 0;
+#             }
+#             if pos == self.current {
+#                 return false;
+#             }
+#         }
+#         
+#         if self.threads[self.current].state != State::Available {
+#             self.threads[self.current].state = State::Ready;
+#         }
+# 
+#         self.threads[pos].state = State::Running;
+#         let old_pos = self.current;
+#         self.current = pos;
+# 
+#         unsafe {
+#             switch(&mut self.threads[old_pos].ctx, &self.threads[pos].ctx);
+#         }
+#         true
+#     }
+# 
+#     pub fn spawn<F: Fn() + 'static>(f: F){
+#         unsafe {
+#             let rt_ptr = RUNTIME as *mut Runtime;
+#             let available = (*rt_ptr)
+#                 .threads
+#                 .iter_mut()
+#                 .find(|t| t.state == State::Available)
+#                 .expect("no available thread.");
+#                 
+#             let size = available.stack.len();
+#             let s_ptr = available.stack.as_mut_ptr();
+#             available.task = Some(Box::new(f));
+#             available.ctx.thread_ptr = available as *const Thread as u64;
+#             ptr::write(s_ptr.offset((size - 8) as isize) as *mut u64, guard as u64);
+#             ptr::write(s_ptr.offset((size - 16) as isize) as *mut u64, call as u64);
+#             available.ctx.rsp = s_ptr.offset((size - 16) as isize) as u64;
+#             available.state = State::Ready;
+#         }
+#     }
+# }
+# 
+# fn call(thread: u64) {
+#     let thread = unsafe { &*(thread as *const Thread) };
+#     if let Some(f) = &thread.task {
+#         f();
+#     }
+# }
+# 
+# #[naked]
+# fn guard() {
+#     unsafe {
+#         let rt_ptr = RUNTIME as *mut Runtime;
+#         let rt = &mut *rt_ptr;
+#         println!("THREAD {} FINISHED.", rt.threads[rt.current].id);
+#         rt.t_return();
+#     };
+# }
+# 
+# pub fn yield_thread() {
+#     unsafe {
+#         let rt_ptr = RUNTIME as *mut Runtime;
+#         (*rt_ptr).t_yield();
+#     };
+# }
+# 
+# #[naked]
+# #[inline(never)]
+# unsafe fn switch(old: *mut ThreadContext, new: *const ThreadContext) {
+#     asm!("
+#         mov     %rsp, 0x00($0)
+#         mov     %r15, 0x08($0)
+#         mov     %r14, 0x10($0)
+#         mov     %r13, 0x18($0)
+#         mov     %r12, 0x20($0)
+#         mov     %rbx, 0x28($0)
+#         mov     %rbp, 0x30($0)
+# 
+#         mov     0x00($1), %rsp
+#         mov     0x08($1), %r15
+#         mov     0x10($1), %r14
+#         mov     0x18($1), %r13
+#         mov     0x20($1), %r12
+#         mov     0x28($1), %rbx
+#         mov     0x30($1), %rbp
+#         mov     0x38($1), %rdi
+#         ret
+#         "
+#     :
+#     : "r"(old), "r"(new)
+#     :
+#     : "alignstack"
+#     );
+# }
 # #[cfg(not(windows))]
 fn main() {
     let mut runtime = Runtime::new();