public-collect/books-futures-explained
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Fixed error in green threads example. See: https://github.com/cfsamson/example-greenthreads/issues/20. Ugh... But it works now!

Browse Source
This commit is contained in:
Carl Fredrik Samson
2020-12-06 01:34:53 +01:00
parent 760fd57be3
commit e4b84bdd83
1 changed files with 78 additions and 58 deletions
Download Patch File Download Diff File Expand all files Collapse all files

136
src/0_background_information.md
View File

@@ -149,30 +149,32 @@ _**Press the expand icon in the top right corner to show the example code.**_
```rust, edition2018 ```rust, edition2018
# #![feature(llvm_asm, naked_functions)] # #![feature(llvm_asm, naked_functions)]
# # use std::ptr;
#
# const DEFAULT_STACK_SIZE: usize = 1024 * 1024 * 2; # const DEFAULT_STACK_SIZE: usize = 1024 * 1024 * 2;
# const MAX_THREADS: usize = 4; # const MAX_THREADS: usize = 4;
# static mut RUNTIME: usize = 0; # static mut RUNTIME: usize = 0;
# #
# pub struct Runtime { # pub struct Runtime {
# threads: Vec<Thread>, # threads: Vec<Thread>,
# current: usize, # current: usize,
# } # }
# #
# #[derive(PartialEq, Eq, Debug)] # #[derive(PartialEq, Eq, Debug)]
# enum State { # enum State {
# Available, # Available,
# Running, # Running,
# Ready, # Ready,
# } # }
# #
# struct Thread { # struct Thread {
# id: usize, # id: usize,
# stack: Vec<u8>, # stack: Vec<u8>,
# ctx: ThreadContext, # ctx: ThreadContext,
# state: State, # state: State,
# task: Option<Box<dyn Fn()>>,
# } # }
# #
# #[derive(Debug, Default)] # #[derive(Debug, Default)]
# #[repr(C)] # #[repr(C)]
# struct ThreadContext { # struct ThreadContext {
@@ -183,8 +185,9 @@ _**Press the expand icon in the top right corner to show the example code.**_
# r12: u64, # r12: u64,
# rbx: u64, # rbx: u64,
# rbp: u64, # rbp: u64,
# thread_ptr: u64,
# } # }
# #
# impl Thread { # impl Thread {
# fn new(id: usize) -> Self { # fn new(id: usize) -> Self {
# Thread { # Thread {
@@ -192,10 +195,11 @@ _**Press the expand icon in the top right corner to show the example code.**_
# stack: vec![0_u8; DEFAULT_STACK_SIZE], # stack: vec![0_u8; DEFAULT_STACK_SIZE],
# ctx: ThreadContext::default(), # ctx: ThreadContext::default(),
# state: State::Available, # state: State::Available,
# task: None,
# } # }
# } # }
# } # }
# #
# impl Runtime { # impl Runtime {
# pub fn new() -> Self { # pub fn new() -> Self {
# let base_thread = Thread { # let base_thread = Thread {
@@ -203,37 +207,39 @@ _**Press the expand icon in the top right corner to show the example code.**_
# stack: vec![0_u8; DEFAULT_STACK_SIZE], # stack: vec![0_u8; DEFAULT_STACK_SIZE],
# ctx: ThreadContext::default(), # ctx: ThreadContext::default(),
# state: State::Running, # state: State::Running,
# task: None,
# }; # };
# #
# let mut threads = vec![base_thread]; # 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(); # let mut available_threads: Vec<Thread> = (1..MAX_THREADS).map(|i| Thread::new(i)).collect();
# threads.append(&mut available_threads); # threads.append(&mut available_threads);
# #
# Runtime { # Runtime {
# threads, # threads,
# current: 0, # current: 0,
# } # }
# } # }
# #
# pub fn init(&self) { # pub fn init(&self) {
# unsafe { # unsafe {
# let r_ptr: *const Runtime = self; # let r_ptr: *const Runtime = self;
# RUNTIME = r_ptr as usize; # RUNTIME = r_ptr as usize;
# } # }
# } # }
# #
# pub fn run(&mut self) -> ! { # pub fn run(&mut self) -> ! {
# while self.t_yield() {} # while self.t_yield() {}
# std::process::exit(0); # std::process::exit(0);
# } # }
# #
# fn t_return(&mut self) { # fn t_return(&mut self) {
# if self.current != 0 { # if self.current != 0 {
# self.threads[self.current].state = State::Available; # self.threads[self.current].state = State::Available;
# self.t_yield(); # self.t_yield();
# } # }
# } # }
# #
# fn t_yield(&mut self) -> bool { # fn t_yield(&mut self) -> bool {
# let mut pos = self.current; # let mut pos = self.current;
# while self.threads[pos].state != State::Ready { # while self.threads[pos].state != State::Ready {
@@ -245,85 +251,99 @@ _**Press the expand icon in the top right corner to show the example code.**_
# return false; # return false;
# } # }
# } # }
# #
# if self.threads[self.current].state != State::Available { # if self.threads[self.current].state != State::Available {
# self.threads[self.current].state = State::Ready; # self.threads[self.current].state = State::Ready;
# } # }
# #
# self.threads[pos].state = State::Running; # self.threads[pos].state = State::Running;
# let old_pos = self.current; # let old_pos = self.current;
# self.current = pos; # self.current = pos;
# #
# unsafe { # unsafe {
# let old: *mut ThreadContext = &mut self.threads[old_pos].ctx; # let old: *mut ThreadContext = &mut self.threads[old_pos].ctx;
# let new: *const ThreadContext = &self.threads[pos].ctx; # let new: *const ThreadContext = &self.threads[pos].ctx;
# llvm_asm!( # llvm_asm!(
# "mov $0, %rdi # "mov $0, %rdi
# mov $1, %rsi"::"r"(old), "r"(new) # mov $1, %rsi"::"r"(old), "r"(new)
# ); # );
# switch(); # switch();
# } # }
# self.threads.len() > 0 # true
# } # }
# #
# pub fn spawn(&mut self, f: fn()) { # pub fn spawn<F: Fn() + 'static>(f: F){
# let available = self
# .threads
# .iter_mut()
# .find(|t| t.state == State::Available)
# .expect("no available thread.");
#
# let size = available.stack.len();
# unsafe { # 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().offset(size as isize); # let s_ptr = available.stack.as_mut_ptr().offset(size as isize);
# let s_ptr = (s_ptr as usize & !15) as *mut u8; # let s_ptr = (s_ptr as usize & !15) as *mut u8;
# 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);
# std::ptr::write(s_ptr.offset(-16) as *mut u64, guard as u64); # std::ptr::write(s_ptr.offset(-16) as *mut u64, guard as u64);
# std::ptr::write(s_ptr.offset(-24) as *mut u64, skip as u64); # std::ptr::write(s_ptr.offset(-24) as *mut u64, skip as u64);
# std::ptr::write(s_ptr.offset(-32) as *mut u64, f as u64); # std::ptr::write(s_ptr.offset(-32) as *mut u64, call as u64);
# available.ctx.rsp = s_ptr.offset(-32) as u64; # available.ctx.rsp = s_ptr.offset(-32) as u64;
# available.state = State::Ready;
# } # }
# available.state = State::Ready;
# } # }
# } # }
# #
# fn call(thread: u64) {
# let thread = unsafe { &*(thread as *const Thread) };
# if let Some(f) = &thread.task {
# f();
# }
# }
#
# #[naked] # #[naked]
# fn skip() { } # fn skip() { }
# #
# fn guard() { # fn guard() {
# unsafe { # unsafe {
# let rt_ptr = RUNTIME as *mut Runtime; # let rt_ptr = RUNTIME as *mut Runtime;
# (*rt_ptr).t_return(); # let rt = &mut *rt_ptr;
# println!("THREAD {} FINISHED.", rt.threads[rt.current].id);
# rt.t_return();
# }; # };
# } # }
# #
# pub fn yield_thread() { # pub fn yield_thread() {
# unsafe { # unsafe {
# let rt_ptr = RUNTIME as *mut Runtime; # let rt_ptr = RUNTIME as *mut Runtime;
# (*rt_ptr).t_yield(); # (*rt_ptr).t_yield();
# }; # };
# } # }
# #
# #[naked] # #[naked]
# #[inline(never)] # #[inline(never)]
# unsafe fn switch() { # unsafe fn switch() {
# llvm_asm!(" # llvm_asm!("
# mov %rsp, 0x00(%rdi) # mov %rsp, 0x00(%rdi)
# mov %r15, 0x08(%rdi) # mov %r15, 0x08(%rdi)
# mov %r14, 0x10(%rdi) # mov %r14, 0x10(%rdi)
# mov %r13, 0x18(%rdi) # mov %r13, 0x18(%rdi)
# mov %r12, 0x20(%rdi) # mov %r12, 0x20(%rdi)
# mov %rbx, 0x28(%rdi) # mov %rbx, 0x28(%rdi)
# mov %rbp, 0x30(%rdi) # mov %rbp, 0x30(%rdi)
# #
# mov 0x00(%rsi), %rsp # mov 0x00(%rsi), %rsp
# mov 0x08(%rsi), %r15 # mov 0x08(%rsi), %r15
# mov 0x10(%rsi), %r14 # mov 0x10(%rsi), %r14
# mov 0x18(%rsi), %r13 # mov 0x18(%rsi), %r13
# mov 0x20(%rsi), %r12 # mov 0x20(%rsi), %r12
# mov 0x28(%rsi), %rbx # mov 0x28(%rsi), %rbx
# mov 0x30(%rsi), %rbp # mov 0x30(%rsi), %rbp
# " # mov 0x38(%rsi), %rdi
# ); # "
# );
# } # }
# #[cfg(not(windows))] # #[cfg(not(windows))]
fn main() { fn main() {