use offlineasm::offlineasm;
offlineasm! {
settings {
backend = native
}
if X86_64
const a0 = t6
const a1 = t1
const a2 = t2
else
const a0 = t0
const a1 = t1
const a2 = t2
end
if X86_64
const FRAME = 48
const RETURN_SLOT = 48
macro forEachSaved(m, f)
m(0, csr0)
m(8, csr1)
m(16, csr2)
m(24, csr3)
m(32, csr4)
m(40, cfr)
end
elsif ARM64
const FRAME = 160
const RETURN_SLOT = 88
macro forEachSaved(m, f)
m(0, csr0)
m(8, csr1)
m(16, csr2)
m(24, csr3)
m(32, csr4)
m(40, csr5)
m(48, csr6)
m(56, csr7)
m(64, csr8)
m(72, csr9)
m(80, cfr)
m(88, lr)
f(96, csfr0)
f(104, csfr1)
f(112, csfr2)
f(120, csfr3)
f(128, csfr4)
f(136, csfr5)
f(144, csfr6)
f(152, csfr7)
end
elsif RISCV64
const FRAME = 208
const RETURN_SLOT = 96
macro forEachSaved(m, f)
m(0, csr0)
m(8, csr1)
m(16, csr2)
m(24, csr3)
m(32, csr4)
m(40, csr5)
m(48, csr6)
m(56, csr7)
m(64, csr8)
m(72, csr9)
m(80, csr10)
m(88, cfr)
m(96, lr)
f(104, %f8)
f(112, %f9)
f(120, %f18)
f(128, %f19)
f(136, %f20)
f(144, %f21)
f(152, %f22)
f(160, %f23)
f(168, %f24)
f(176, %f25)
f(184, %f26)
f(192, %f27)
end
end
macro saveGpr(offset, reg)
storeq offset[sp], reg
end
macro saveFpr(offset, reg)
stored offset[sp], reg
end
macro loadGpr(offset, reg)
loadq reg, offset[sp]
end
macro loadFpr(offset, reg)
loadd reg, offset[sp]
end
macro zeroGpr(offset, reg)
storeq offset[t0], t3
end
macro skipFpr(offset, reg)
end
global _coro_switch
_coro_switch:
subp sp, FRAME
forEachSaved(saveGpr, saveFpr)
move t2, sp
storeq 0[a0], t2
move sp, a1
forEachSaved(loadGpr, loadFpr)
addp sp, FRAME
ret
global _coro_init
_coro_init:
move t0, a0
if X86_64
subp t0, FRAME + 24
else
subp t0, FRAME
end
move t3, 0
forEachSaved(zeroGpr, skipFpr)
storeq 0[t0], a1
storeq 8[t0], a2
leap t3, _coro_trampoline
storeq RETURN_SLOT[t0], t3
ret
_coro_trampoline:
move a0, csr1
call csr0
break
}
extern "C" {
fn coro_switch(save_sp: *mut u64, load_sp: u64);
fn coro_init(stack_top: u64, entry: u64, arg: u64) -> u64;
}
struct Generator {
sp: u64,
caller_sp: u64,
value: Option<u64>,
finished: bool,
body: fn(&mut Yielder),
_stack: Vec<u128>,
}
struct Yielder(*mut Generator);
impl Yielder {
fn yield_(&mut self, value: u64) {
unsafe {
(*self.0).value = Some(value);
coro_switch(&mut (*self.0).sp, (*self.0).caller_sp);
}
}
}
extern "C" fn generator_entry(gen_: *mut Generator) {
unsafe {
let body = (*gen_).body;
body(&mut Yielder(gen_));
(*gen_).finished = true;
coro_switch(&mut (*gen_).sp, (*gen_).caller_sp);
}
unreachable!("a finished generator was resumed");
}
impl Generator {
fn new(body: fn(&mut Yielder)) -> Box<Self> {
let stack = vec![0u128; 64 * 1024 / 16];
let top = stack.as_ptr_range().end as u64;
let mut gen_ = Box::new(Self {
sp: 0,
caller_sp: 0,
value: None,
finished: false,
body,
_stack: stack,
});
let arg = &mut *gen_ as *mut Generator as u64;
gen_.sp = unsafe { coro_init(top, generator_entry as *const () as u64, arg) };
gen_
}
fn resume(&mut self) -> Option<u64> {
if self.finished {
return None;
}
unsafe { coro_switch(&mut self.caller_sp, self.sp) };
self.value.take()
}
}
fn fibonacci(y: &mut Yielder) {
let (mut a, mut b) = (0u64, 1u64);
loop {
y.yield_(a);
(a, b) = (b, a.wrapping_add(b));
}
}
fn primes(y: &mut Yielder) {
let mut found: Vec<u64> = Vec::new();
let mut n = 2u64;
loop {
if found.iter().all(|p| n % p != 0) {
found.push(n);
y.yield_(n);
}
n += 1;
}
}
fn countdown(y: &mut Yielder) {
for i in (1..=3).rev() {
y.yield_(i);
}
}
fn main() {
let mut fib = Generator::new(fibonacci);
let mut prime = Generator::new(primes);
let mut interleaved = Vec::new();
for _ in 0..10 {
interleaved.push(fib.resume().expect("fibonacci is endless"));
interleaved.push(prime.resume().expect("primes are endless"));
}
println!("fib/prime interleaved: {interleaved:?}");
assert_eq!(
interleaved,
[0, 2, 1, 3, 1, 5, 2, 7, 3, 11, 5, 13, 8, 17, 13, 19, 21, 23, 34, 29]
);
let mut count = Generator::new(countdown);
let drained: Vec<u64> = std::iter::from_fn(|| count.resume()).collect();
println!("countdown: {drained:?}");
assert_eq!(drained, [3, 2, 1]);
assert_eq!(count.resume(), None, "a finished generator stays finished");
let (mut a, mut b) = (55u64, 89u64);
for _ in 0..10_000 {
assert_eq!(fib.resume(), Some(a));
(a, b) = (b, a.wrapping_add(b));
}
println!("10000 more switches into the fibonacci generator: ok");
}