1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
use std::borrow::Borrow;
use std::cell::{Ref, Cell, RefCell};
use std::collections::HashMap;
use std::collections::vec_deque::VecDeque;
use std::convert::From;
use std::fs::File;
use std::io::{self, Read, Write};
use std::marker::Sync;
use std::ops::{Deref};
use fringe::generator::Yielder;
use fringe::{OsStack, Generator};
use ::runtime::Runtime;
use ::system::{SharedMainFnRef, MainFnRef, MainFn};
#[derive(Debug, Clone, Hash, Eq, PartialEq, Serialize)]
pub enum ThreadModel {
OsThreads,
GreenThreads,
}
pub trait Thread<'a> {
fn start(&self, rt: &Runtime) -> i64;
fn run<'b>(&self, rt: &'b Runtime) -> i64;
}
pub struct Pthread<'a> {
pub func: MainFnRef<'a>
}
impl<'a> Thread<'a> for Pthread<'a> {
fn start(&self, rt: &Runtime) -> i64 {
self.run(&rt)
}
fn run<'b>(&self, rt: &'b Runtime) -> i64 {
let func = self.func.clone();
func(rt)
}
}
pub struct GreenThread<'a> {
pub func: SharedMainFnRef<'a>
}
impl<'a> Thread<'a> for GreenThread<'a> {
fn start(&self, rt: &Runtime) -> i64 {
self.run(&rt)
}
#[allow(unused_variables)]
fn run<'b>(&self, rt: &'b Runtime) -> i64 {
let stack = OsStack::new(1 << 12).unwrap();
let mut gen = Generator::new(stack, move |yielder, ()| {
let main_thread = Greenlet {
yielder: yielder,
func: self.func.clone()
};
let rt = Runtime::new();
main_thread.start(&rt);
});
let mut prev: Option<i64> = None;
loop {
let out = gen.resume(());
match out {
None => { break },
_ => (),
};
prev = out;
}
prev.unwrap_or(0)
}
}
struct Greenlet<'a> {
yielder: &'a mut Yielder<(), i64>,
func: SharedMainFnRef<'a>,
}
impl<'a> Thread<'a> for Greenlet<'a> {
fn start(&self, rt: &Runtime) -> i64 {
self.run(&rt)
}
fn run(&self, rt: &Runtime) -> i64 {
let func = self.func.0.clone();
self.yielder.suspend(func(rt));
0
}
}