forked from M-Labs/libfringe
Completely rework fringe::Context and fringe::arch.
The new design concerns itself with one thing and exactly one thing: passing values back and forth with an extern "C" function. This allows to simplify fringe::arch into a single primitive, swap. Close #21
This commit is contained in:
parent
989b1d439c
commit
cbe136b762
13
Cargo.toml
13
Cargo.toml
|
@ -15,9 +15,16 @@ optional = true
|
||||||
git = "https://github.com/edef1c/libvalgrind"
|
git = "https://github.com/edef1c/libvalgrind"
|
||||||
rev = "9ef793e9549aabfd2d969615180b69d29ce28d88"
|
rev = "9ef793e9549aabfd2d969615180b69d29ce28d88"
|
||||||
|
|
||||||
[dependencies.void]
|
[dev-dependencies]
|
||||||
default-features = false
|
simd = "0.1"
|
||||||
version = "1"
|
|
||||||
|
|
||||||
[features]
|
[features]
|
||||||
default = ["valgrind"]
|
default = ["valgrind"]
|
||||||
|
|
||||||
|
# These apply only to tests within this library; assembly at -O0 is completely
|
||||||
|
# unreadable, so use -O1.
|
||||||
|
[profile.dev]
|
||||||
|
opt-level = 1
|
||||||
|
|
||||||
|
[profile.test]
|
||||||
|
opt-level = 1
|
||||||
|
|
|
@ -44,17 +44,10 @@ git = "https://github.com/edef1c/libfringe.git"
|
||||||
### Feature flags
|
### Feature flags
|
||||||
|
|
||||||
[Cargo's feature flags]: http://doc.crates.io/manifest.html#the-[features]-section
|
[Cargo's feature flags]: http://doc.crates.io/manifest.html#the-[features]-section
|
||||||
libfringe provides several optional features through [Cargo's feature flags].
|
libfringe provides some optional features through [Cargo's feature flags].
|
||||||
Currently, all of them are enabled by default.
|
Currently, all of them are enabled by default.
|
||||||
|
|
||||||
#### `valgrind`
|
#### `valgrind`
|
||||||
|
|
||||||
[Valgrind]: http://valgrind.org
|
[Valgrind]: http://valgrind.org
|
||||||
[Valgrind] integration. libfringe will register context stacks with Valgrind.
|
[Valgrind] integration. libfringe will register context stacks with Valgrind.
|
||||||
|
|
||||||
#### `os`
|
|
||||||
|
|
||||||
[Built-in stack allocator]: https://edef1c.github.io/libfringe/fringe/struct.OsStack.html
|
|
||||||
[Built-in stack allocator] using your your operating system's anonymous memory mapping facility.
|
|
||||||
Currently only available for Unix.
|
|
||||||
|
|
||||||
|
|
|
@ -1,41 +0,0 @@
|
||||||
// This file is part of libfringe, a low-level green threading library.
|
|
||||||
// Copyright (c) edef <edef@edef.eu>
|
|
||||||
// See the LICENSE file included in this distribution.
|
|
||||||
#![feature(test)]
|
|
||||||
extern crate test;
|
|
||||||
extern crate fringe;
|
|
||||||
use fringe::Context;
|
|
||||||
|
|
||||||
static mut ctx_slot: *mut Context<'static, SliceStack<'static>> = 0 as *mut Context<_>;
|
|
||||||
static mut stack_buf: [u8; 1024] = [0; 1024];
|
|
||||||
|
|
||||||
#[bench]
|
|
||||||
fn context_new(b: &mut test::Bencher) {
|
|
||||||
b.iter(|| unsafe {
|
|
||||||
let stack = SliceStack(&mut stack_buf);
|
|
||||||
|
|
||||||
let mut ctx = Context::new(stack, move || {
|
|
||||||
let ctx_ptr = ctx_slot;
|
|
||||||
loop {
|
|
||||||
Context::swap(ctx_ptr, ctx_ptr);
|
|
||||||
}
|
|
||||||
});
|
|
||||||
|
|
||||||
ctx_slot = &mut ctx;
|
|
||||||
|
|
||||||
Context::swap(ctx_slot, ctx_slot);
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
struct SliceStack<'a>(&'a mut [u8]);
|
|
||||||
impl<'a> fringe::Stack for SliceStack<'a> {
|
|
||||||
fn top(&mut self) -> *mut u8 {
|
|
||||||
unsafe {
|
|
||||||
self.0.as_mut_ptr().offset(self.0.len() as isize)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fn limit(&self) -> *const u8 {
|
|
||||||
self.0.as_ptr()
|
|
||||||
}
|
|
||||||
}
|
|
|
@ -1,31 +1,30 @@
|
||||||
// This file is part of libfringe, a low-level green threading library.
|
// This file is part of libfringe, a low-level green threading library.
|
||||||
// Copyright (c) edef <edef@edef.eu>
|
// Copyright (c) edef <edef@edef.eu>,
|
||||||
|
// whitequark <whitequark@whitequark.org>
|
||||||
// See the LICENSE file included in this distribution.
|
// See the LICENSE file included in this distribution.
|
||||||
#![feature(test)]
|
#![feature(test)]
|
||||||
#![cfg(feature = "os")]
|
|
||||||
extern crate test;
|
extern crate test;
|
||||||
extern crate fringe;
|
extern crate fringe;
|
||||||
|
|
||||||
use fringe::Context;
|
use fringe::Context;
|
||||||
|
|
||||||
static mut ctx_slot: *mut Context<'static, fringe::OsStack> = 0 as *mut Context<_>;
|
static mut ctx_slot: *mut Context<fringe::OsStack> = 0 as *mut Context<_>;
|
||||||
|
|
||||||
#[bench]
|
#[bench]
|
||||||
fn swap(b: &mut test::Bencher) {
|
fn swap(b: &mut test::Bencher) {
|
||||||
|
unsafe extern "C" fn loopback(mut arg: usize) -> ! {
|
||||||
|
// This deliberately does not ignore arg, to measure the time it takes
|
||||||
|
// to move the return value between registers.
|
||||||
|
let ctx_ptr = ctx_slot;
|
||||||
|
loop { arg = Context::swap(ctx_ptr, ctx_ptr, arg) }
|
||||||
|
}
|
||||||
|
|
||||||
unsafe {
|
unsafe {
|
||||||
let stack = fringe::OsStack::new(4 << 20).unwrap();
|
let stack = fringe::OsStack::new(4 << 20).unwrap();
|
||||||
|
let mut ctx = Context::new(stack, loopback);
|
||||||
let mut ctx = Context::new(stack, move || {
|
ctx_slot = &mut ctx;
|
||||||
let ctx_ptr = ctx_slot;
|
|
||||||
loop {
|
|
||||||
Context::swap(ctx_ptr, ctx_ptr);
|
|
||||||
}
|
|
||||||
});
|
|
||||||
|
|
||||||
let ctx_ptr = &mut ctx;
|
let ctx_ptr = &mut ctx;
|
||||||
ctx_slot = ctx_ptr;
|
b.iter(|| Context::swap(ctx_ptr, ctx_ptr, 0));
|
||||||
|
|
||||||
Context::swap(ctx_ptr, ctx_ptr);
|
|
||||||
|
|
||||||
b.iter(|| Context::swap(ctx_ptr, ctx_ptr));
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -4,11 +4,10 @@
|
||||||
#![cfg(target_os = "linux")]
|
#![cfg(target_os = "linux")]
|
||||||
#![feature(asm, test)]
|
#![feature(asm, test)]
|
||||||
extern crate test;
|
extern crate test;
|
||||||
use test::Bencher;
|
|
||||||
|
|
||||||
#[cfg(target_arch = "x86_64")]
|
#[cfg(target_arch = "x86_64")]
|
||||||
#[bench]
|
#[bench]
|
||||||
fn kernel_swap(b: &mut Bencher) {
|
fn syscall(b: &mut test::Bencher) {
|
||||||
b.iter(|| unsafe {
|
b.iter(|| unsafe {
|
||||||
asm!("movq $$102, %rax\n\
|
asm!("movq $$102, %rax\n\
|
||||||
syscall"
|
syscall"
|
||||||
|
@ -21,7 +20,7 @@ fn kernel_swap(b: &mut Bencher) {
|
||||||
|
|
||||||
#[cfg(target_arch = "x86")]
|
#[cfg(target_arch = "x86")]
|
||||||
#[bench]
|
#[bench]
|
||||||
fn kernel_swap(b: &mut Bencher) {
|
fn syscall(b: &mut test::Bencher) {
|
||||||
b.iter(|| unsafe {
|
b.iter(|| unsafe {
|
||||||
asm!("mov $$24, %eax\n\
|
asm!("mov $$24, %eax\n\
|
||||||
int $$0x80"
|
int $$0x80"
|
|
@ -1,34 +0,0 @@
|
||||||
// This file is part of libfringe, a low-level green threading library.
|
|
||||||
// Copyright (c) edef <edef@edef.eu>
|
|
||||||
// See the LICENSE file included in this distribution.
|
|
||||||
use core::mem::{size_of, align_of};
|
|
||||||
use core::cmp::max;
|
|
||||||
use core::ptr;
|
|
||||||
|
|
||||||
use void::{self, Void};
|
|
||||||
|
|
||||||
use super::imp::STACK_ALIGN;
|
|
||||||
|
|
||||||
pub unsafe extern "C" fn rust_trampoline<F>(f: *const F) -> !
|
|
||||||
where F: FnOnce() -> Void {
|
|
||||||
void::unreachable(ptr::read(f)())
|
|
||||||
}
|
|
||||||
|
|
||||||
pub unsafe fn push<T>(spp: &mut *mut usize, value: T) -> *mut T {
|
|
||||||
let mut sp = *spp as *mut T;
|
|
||||||
sp = offset_mut(sp, -1);
|
|
||||||
sp = align_down_mut(sp, max(align_of::<T>(), STACK_ALIGN));
|
|
||||||
ptr::write(sp, value); // does not attempt to drop old value
|
|
||||||
*spp = sp as *mut usize;
|
|
||||||
sp
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn align_down_mut<T>(sp: *mut T, n: usize) -> *mut T {
|
|
||||||
let sp = (sp as usize) & !(n - 1);
|
|
||||||
sp as *mut T
|
|
||||||
}
|
|
||||||
|
|
||||||
// ptr::offset_mut is positive ints only
|
|
||||||
pub fn offset_mut<T>(ptr: *mut T, count: isize) -> *mut T {
|
|
||||||
(ptr as isize + count * (size_of::<T>() as isize)) as *mut T
|
|
||||||
}
|
|
|
@ -1,16 +1,18 @@
|
||||||
// This file is part of libfringe, a low-level green threading library.
|
// This file is part of libfringe, a low-level green threading library.
|
||||||
// Copyright (c) edef <edef@edef.eu>
|
// Copyright (c) edef <edef@edef.eu>,
|
||||||
|
// whitequark <whitequark@whitequark.org>
|
||||||
// See the LICENSE file included in this distribution.
|
// See the LICENSE file included in this distribution.
|
||||||
pub use self::imp::Registers;
|
pub use self::imp::*;
|
||||||
|
|
||||||
unsafe impl Send for Registers {}
|
// rust-lang/rust#25544
|
||||||
|
// #[cfg_attr(target_arch = "x86", path = "x86.rs")]
|
||||||
mod common;
|
// #[cfg_attr(target_arch = "x86_64", path = "x86_64.rs")]
|
||||||
|
// mod imp;
|
||||||
#[cfg(target_arch = "x86_64")]
|
|
||||||
#[path = "x86_64/mod.rs"]
|
|
||||||
mod imp;
|
|
||||||
|
|
||||||
#[cfg(target_arch = "x86")]
|
#[cfg(target_arch = "x86")]
|
||||||
#[path = "x86/mod.rs"]
|
#[path = "x86.rs"]
|
||||||
|
mod imp;
|
||||||
|
|
||||||
|
#[cfg(target_arch = "x86_64")]
|
||||||
|
#[path = "x86_64.rs"]
|
||||||
mod imp;
|
mod imp;
|
||||||
|
|
|
@ -0,0 +1,105 @@
|
||||||
|
// This file is part of libfringe, a low-level green threading library.
|
||||||
|
// Copyright (c) edef <edef@edef.eu>,
|
||||||
|
// whitequark <whitequark@whitequark.org>
|
||||||
|
// See the LICENSE file included in this distribution.
|
||||||
|
|
||||||
|
//! To understand the code in this file, keep in mind this fact:
|
||||||
|
//! * i686 SysV C ABI requires the stack to be aligned at function entry,
|
||||||
|
//! so that `%esp+4` is a multiple of 16. Aligned operands are a requirement
|
||||||
|
//! of SIMD instructions, and making this the responsibility of the caller
|
||||||
|
//! avoids having to maintain a frame pointer, which is necessary when
|
||||||
|
//! a function has to realign the stack from an unknown state.
|
||||||
|
//! * i686 SysV C ABI passes the first argument on the stack. This is
|
||||||
|
//! unfortunate, because unlike every other architecture we can't reuse
|
||||||
|
//! `swap` for the initial call, and so we use a trampoline.
|
||||||
|
use stack::Stack;
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub struct StackPointer(*mut usize);
|
||||||
|
|
||||||
|
impl StackPointer {
|
||||||
|
unsafe fn new(stack: &Stack) -> StackPointer {
|
||||||
|
StackPointer(stack.top() as *mut usize)
|
||||||
|
}
|
||||||
|
|
||||||
|
unsafe fn push(&mut self, val: usize) {
|
||||||
|
self.0 = self.0.offset(-1);
|
||||||
|
*self.0 = val
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub unsafe fn init(stack: &Stack, f: unsafe extern "C" fn(usize) -> !) -> StackPointer {
|
||||||
|
let g: usize;
|
||||||
|
asm!(
|
||||||
|
r#"
|
||||||
|
# Push address of the trampoline.
|
||||||
|
call 1f
|
||||||
|
|
||||||
|
# Pop function.
|
||||||
|
popl %ebx
|
||||||
|
# Push argument.
|
||||||
|
pushl %eax
|
||||||
|
# Call it.
|
||||||
|
call *%ebx
|
||||||
|
|
||||||
|
1:
|
||||||
|
# Pop address of the trampoline.
|
||||||
|
popl %eax
|
||||||
|
"#
|
||||||
|
: "={eax}" (g)
|
||||||
|
:
|
||||||
|
: "memory"
|
||||||
|
: "volatile"
|
||||||
|
);
|
||||||
|
|
||||||
|
let mut sp = StackPointer::new(stack);
|
||||||
|
sp.push(0); // alignment
|
||||||
|
sp.push(0); // alignment
|
||||||
|
sp.push(0); // alignment
|
||||||
|
sp.push(f as usize); // function
|
||||||
|
sp.push(g as usize); // trampoline
|
||||||
|
sp
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline(always)]
|
||||||
|
pub unsafe fn swap(arg: usize, old_sp: &mut StackPointer, new_sp: &StackPointer) -> usize {
|
||||||
|
let ret: usize;
|
||||||
|
asm!(
|
||||||
|
r#"
|
||||||
|
# Save frame pointer explicitly; LLVM doesn't spill it even if it is
|
||||||
|
# marked as clobbered.
|
||||||
|
pushl %ebp
|
||||||
|
# Push instruction pointer of the old context and switch to
|
||||||
|
# the new context.
|
||||||
|
call 1f
|
||||||
|
# Restore frame pointer.
|
||||||
|
popl %ebp
|
||||||
|
# Continue executing old context.
|
||||||
|
jmp 2f
|
||||||
|
|
||||||
|
1:
|
||||||
|
# Remember stack pointer of the old context, in case %rdx==%rsi.
|
||||||
|
movl %esp, %ebx
|
||||||
|
# Load stack pointer of the new context.
|
||||||
|
movl (%edi), %esp
|
||||||
|
# Save stack pointer of the old context.
|
||||||
|
movl %ebx, (%esi)
|
||||||
|
|
||||||
|
# Pop instruction pointer of the new context (placed onto stack by
|
||||||
|
# the call above) and jump there; don't use `ret` to avoid return
|
||||||
|
# address mispredictions (~8ns on Ivy Bridge).
|
||||||
|
popl %ebx
|
||||||
|
jmpl *%ebx
|
||||||
|
2:
|
||||||
|
"#
|
||||||
|
: "={eax}" (ret)
|
||||||
|
: "{eax}" (arg)
|
||||||
|
"{esi}" (old_sp)
|
||||||
|
"{edi}" (new_sp)
|
||||||
|
: "eax", "ebx", "ecx", "edx", "esi", "edi", //"ebp", "esp",
|
||||||
|
"mmx0", "mmx1", "mmx2", "mmx3", "mmx4", "mmx5", "mmx6", "mmx7",
|
||||||
|
"xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
|
||||||
|
"cc", "fpsr", "flags", "memory"
|
||||||
|
: "volatile");
|
||||||
|
ret
|
||||||
|
}
|
|
@ -1 +0,0 @@
|
||||||
--32
|
|
|
@ -1,40 +0,0 @@
|
||||||
// This file is part of libfringe, a low-level green threading library.
|
|
||||||
// Copyright (c) edef <edef@edef.eu>
|
|
||||||
// See the LICENSE file included in this distribution.
|
|
||||||
|
|
||||||
//! initialise a new context
|
|
||||||
//! arguments:
|
|
||||||
//! * eax: stack pointer
|
|
||||||
//! * ebx: function pointer
|
|
||||||
//! * ecx: data pointer
|
|
||||||
//!
|
|
||||||
//! return values:
|
|
||||||
//! * eax: new stack pointer
|
|
||||||
|
|
||||||
// switch to the fresh stack
|
|
||||||
xchg %esp, %eax
|
|
||||||
|
|
||||||
// save the data pointer and the function pointer, respectively
|
|
||||||
pushl %ecx
|
|
||||||
pushl %ebx
|
|
||||||
|
|
||||||
// save the return address, control flow continues at label 1
|
|
||||||
call 1f
|
|
||||||
// we arrive here once this context is reactivated (see swap.s)
|
|
||||||
|
|
||||||
// restore the function pointer (the data pointer is the first argument, which lives at the top of the stack)
|
|
||||||
popl %eax
|
|
||||||
|
|
||||||
// initialise the frame pointer
|
|
||||||
movl $$0, %ebp
|
|
||||||
|
|
||||||
// call the function pointer with the data pointer (top of the stack is the first argument)
|
|
||||||
call *%eax
|
|
||||||
|
|
||||||
// crash if it ever returns
|
|
||||||
ud2
|
|
||||||
|
|
||||||
1:
|
|
||||||
// save our neatly-setup new stack
|
|
||||||
xchg %esp, %eax
|
|
||||||
// back into Rust-land we go
|
|
|
@ -1,33 +0,0 @@
|
||||||
// This file is part of libfringe, a low-level green threading library.
|
|
||||||
// Copyright (c) edef <edef@edef.eu>
|
|
||||||
// See the LICENSE file included in this distribution.
|
|
||||||
pub use self::common::*;
|
|
||||||
|
|
||||||
macro_rules! init {
|
|
||||||
($sp:expr, $f_ptr:expr, $tramp:expr) => {
|
|
||||||
asm!(include_str!("x86/init.s")
|
|
||||||
: "={eax}"($sp)
|
|
||||||
: "{eax}" ($sp),
|
|
||||||
"{ebx}" ($tramp),
|
|
||||||
"{ecx}" ($f_ptr)
|
|
||||||
:
|
|
||||||
: "volatile")
|
|
||||||
};
|
|
||||||
}
|
|
||||||
|
|
||||||
macro_rules! swap {
|
|
||||||
($out_spp:expr, $in_spp:expr) => {
|
|
||||||
asm!(include_str!("x86/swap.s")
|
|
||||||
:
|
|
||||||
: "{eax}" ($out_spp),
|
|
||||||
"{ebx}" ($in_spp)
|
|
||||||
: "eax", "ebx", "ecx", "edx", "esi", "edi", //"ebp", "esp",
|
|
||||||
"mmx0", "mmx1", "mmx2", "mmx3", "mmx4", "mmx5", "mmx6", "mmx7",
|
|
||||||
"xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
|
|
||||||
"cc", "fpsr", "eflags"
|
|
||||||
: "volatile")
|
|
||||||
};
|
|
||||||
}
|
|
||||||
|
|
||||||
#[path = "../x86_common.rs"]
|
|
||||||
mod common;
|
|
|
@ -1,37 +0,0 @@
|
||||||
// This file is part of libfringe, a low-level green threading library.
|
|
||||||
// Copyright (c) edef <edef@edef.eu>
|
|
||||||
// See the LICENSE file included in this distribution.
|
|
||||||
|
|
||||||
//! switch to a new context
|
|
||||||
//! arguments:
|
|
||||||
//! * eax: stack pointer out pointer
|
|
||||||
//! * ebx: stack pointer in pointer
|
|
||||||
|
|
||||||
// save the frame pointer
|
|
||||||
pushl %ebp
|
|
||||||
|
|
||||||
// save the return address to the stack, control flow continues at label 1
|
|
||||||
call 1f
|
|
||||||
// we arrive here once this context is reactivated
|
|
||||||
|
|
||||||
// restore the frame pointer
|
|
||||||
popl %ebp
|
|
||||||
|
|
||||||
// and we merrily go on our way, back into Rust-land
|
|
||||||
jmp 2f
|
|
||||||
|
|
||||||
1:
|
|
||||||
// retrieve the new stack pointer
|
|
||||||
movl (%eax), %edx
|
|
||||||
// save the old stack pointer
|
|
||||||
movl %esp, (%ebx)
|
|
||||||
// switch to the new stack pointer
|
|
||||||
movl %edx, %esp
|
|
||||||
|
|
||||||
// jump into the new context (return to the call point)
|
|
||||||
// doing this instead of a straight `ret` is 8ns slower,
|
|
||||||
// presumably because the branch predictor tries to be clever about it
|
|
||||||
popl %eax
|
|
||||||
jmpl *%eax
|
|
||||||
|
|
||||||
2:
|
|
|
@ -0,0 +1,92 @@
|
||||||
|
// This file is part of libfringe, a low-level green threading library.
|
||||||
|
// Copyright (c) edef <edef@edef.eu>,
|
||||||
|
// whitequark <whitequark@whitequark.org>
|
||||||
|
// See the LICENSE file included in this distribution.
|
||||||
|
|
||||||
|
//! To understand the code in this file, keep in mind these two facts:
|
||||||
|
//! * x86_64 SysV C ABI has a "red zone": 128 bytes under the top of the stack
|
||||||
|
//! that is defined to be unmolested by signal handlers, interrupts, etc.
|
||||||
|
//! Leaf functions can use the red zone without adjusting rsp or rbp.
|
||||||
|
//! * x86_64 SysV C ABI requires the stack to be aligned at function entry,
|
||||||
|
//! so that (%rsp+8) is a multiple of 16. Aligned operands are a requirement
|
||||||
|
//! of SIMD instructions, and making this the responsibility of the caller
|
||||||
|
//! avoids having to maintain a frame pointer, which is necessary when
|
||||||
|
//! a function has to realign the stack from an unknown state.
|
||||||
|
//! * x86_64 SysV C ABI passes the first argument in %rdi. We also use %rdi
|
||||||
|
//! to pass a value while swapping context; this is an arbitrary choice
|
||||||
|
//! (we clobber all registers and could use any of them) but this allows us
|
||||||
|
//! to reuse the swap function to perform the initial call.
|
||||||
|
|
||||||
|
use stack::Stack;
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub struct StackPointer(*mut usize);
|
||||||
|
|
||||||
|
impl StackPointer {
|
||||||
|
unsafe fn new(stack: &Stack) -> StackPointer {
|
||||||
|
StackPointer(stack.top() as *mut usize)
|
||||||
|
}
|
||||||
|
|
||||||
|
unsafe fn push(&mut self, val: usize) {
|
||||||
|
self.0 = self.0.offset(-1);
|
||||||
|
*self.0 = val
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub unsafe fn init(stack: &Stack, f: unsafe extern "C" fn(usize) -> !) -> StackPointer {
|
||||||
|
let mut sp = StackPointer::new(stack);
|
||||||
|
sp.push(0); // alignment
|
||||||
|
sp.push(f as usize);
|
||||||
|
sp
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline(always)]
|
||||||
|
pub unsafe fn swap(arg: usize, old_sp: &mut StackPointer, new_sp: &StackPointer) -> usize {
|
||||||
|
let ret: usize;
|
||||||
|
asm!(
|
||||||
|
r#"
|
||||||
|
# Save frame pointer explicitly; LLVM doesn't spill it even if it is
|
||||||
|
# marked as clobbered.
|
||||||
|
pushq %rbp
|
||||||
|
# Push instruction pointer of the old context and switch to
|
||||||
|
# the new context.
|
||||||
|
call 1f
|
||||||
|
# Restore frame pointer.
|
||||||
|
popq %rbp
|
||||||
|
# Continue executing old context.
|
||||||
|
jmp 2f
|
||||||
|
|
||||||
|
1:
|
||||||
|
# Remember stack pointer of the old context, in case %rdx==%rsi.
|
||||||
|
movq %rsp, %rax
|
||||||
|
# Load stack pointer of the new context.
|
||||||
|
movq (%rdx), %rsp
|
||||||
|
# Save stack pointer of the old context.
|
||||||
|
movq %rax, (%rsi)
|
||||||
|
|
||||||
|
# Pop instruction pointer of the new context (placed onto stack by
|
||||||
|
# the call above) and jump there; don't use `ret` to avoid return
|
||||||
|
# address mispredictions (~8ns on Ivy Bridge).
|
||||||
|
popq %rax
|
||||||
|
jmpq *%rax
|
||||||
|
2:
|
||||||
|
"#
|
||||||
|
: "={rdi}" (ret)
|
||||||
|
: "{rdi}" (arg)
|
||||||
|
"{rsi}" (old_sp)
|
||||||
|
"{rdx}" (new_sp)
|
||||||
|
: "rax", "rbx", "rcx", "rdx", "rsi", "rdi", //"rbp", "rsp",
|
||||||
|
"r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
|
||||||
|
"xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
|
||||||
|
"xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",
|
||||||
|
"xmm16", "xmm17", "xmm18", "xmm19", "xmm20", "xmm21", "xmm22", "xmm23",
|
||||||
|
"xmm24", "xmm25", "xmm26", "xmm27", "xmm28", "xmm29", "xmm30", "xmm31"
|
||||||
|
"cc", "fpsr", "flags", "memory"
|
||||||
|
// Ideally, we would set the LLVM "noredzone" attribute on this function
|
||||||
|
// (and it would be propagated to the call site). Unfortunately, rustc
|
||||||
|
// provides no such functionality. Fortunately, by a lucky coincidence,
|
||||||
|
// the "alignstack" LLVM inline assembly option does exactly the same
|
||||||
|
// thing on x86_64.
|
||||||
|
: "volatile", "alignstack");
|
||||||
|
ret
|
||||||
|
}
|
|
@ -1 +0,0 @@
|
||||||
--64
|
|
|
@ -1,41 +0,0 @@
|
||||||
// This file is part of libfringe, a low-level green threading library.
|
|
||||||
// Copyright (c) edef <edef@edef.eu>
|
|
||||||
// See the LICENSE file included in this distribution.
|
|
||||||
|
|
||||||
//! initialise a new context
|
|
||||||
//! arguments:
|
|
||||||
//! * rdi: stack pointer
|
|
||||||
//! * rsi: function pointer
|
|
||||||
//! * rdx: data pointer
|
|
||||||
//!
|
|
||||||
//! return values:
|
|
||||||
//! * rdi: new stack pointer
|
|
||||||
|
|
||||||
// switch to the fresh stack
|
|
||||||
xchg %rsp, %rdi
|
|
||||||
|
|
||||||
// save the function pointer the data pointer, respectively
|
|
||||||
pushq %rsi
|
|
||||||
pushq %rdx
|
|
||||||
|
|
||||||
// save the return address, control flow continues at label 1
|
|
||||||
call 1f
|
|
||||||
// we arrive here once this context is reactivated (see swap.s)
|
|
||||||
|
|
||||||
// restore the data pointer and the function pointer, respectively
|
|
||||||
popq %rdi
|
|
||||||
popq %rax
|
|
||||||
|
|
||||||
// initialise the frame pointer
|
|
||||||
movq $$0, %rbp
|
|
||||||
|
|
||||||
// call the function pointer with the data pointer (rdi is the first argument)
|
|
||||||
call *%rax
|
|
||||||
|
|
||||||
// crash if it ever returns
|
|
||||||
ud2
|
|
||||||
|
|
||||||
1:
|
|
||||||
// save our neatly-setup new stack
|
|
||||||
xchg %rsp, %rdi
|
|
||||||
// back into Rust-land we go
|
|
|
@ -1,36 +0,0 @@
|
||||||
// This file is part of libfringe, a low-level green threading library.
|
|
||||||
// Copyright (c) edef <edef@edef.eu>
|
|
||||||
// See the LICENSE file included in this distribution.
|
|
||||||
pub use self::common::*;
|
|
||||||
|
|
||||||
macro_rules! init {
|
|
||||||
($sp:expr, $f_ptr:expr, $tramp:expr) => {
|
|
||||||
asm!(include_str!("x86_64/init.s")
|
|
||||||
: "={rdi}"($sp)
|
|
||||||
: "{rdi}" ($sp),
|
|
||||||
"{rsi}" ($tramp),
|
|
||||||
"{rdx}" ($f_ptr)
|
|
||||||
:
|
|
||||||
: "volatile");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
macro_rules! swap {
|
|
||||||
($out_spp:expr, $in_spp:expr) => {
|
|
||||||
asm!(include_str!("x86_64/swap.s")
|
|
||||||
:
|
|
||||||
: "{rdi}" ($out_spp)
|
|
||||||
"{rsi}" ($in_spp)
|
|
||||||
: "rax", "rbx", "rcx", "rdx", "rsi", "rdi", //"rbp", "rsp",
|
|
||||||
"r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
|
|
||||||
"xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
|
|
||||||
"xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",
|
|
||||||
"xmm16", "xmm17", "xmm18", "xmm19", "xmm20", "xmm21", "xmm22", "xmm23",
|
|
||||||
"xmm24", "xmm25", "xmm26", "xmm27", "xmm28", "xmm29", "xmm30", "xmm31"
|
|
||||||
"cc", "fpsr", "eflags"
|
|
||||||
: "volatile");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[path = "../x86_common.rs"]
|
|
||||||
mod common;
|
|
|
@ -1,44 +0,0 @@
|
||||||
// This file is part of libfringe, a low-level green threading library.
|
|
||||||
// Copyright (c) edef <edef@edef.eu>
|
|
||||||
// See the LICENSE file included in this distribution.
|
|
||||||
|
|
||||||
//! switch to a new context
|
|
||||||
//! arguments:
|
|
||||||
//! * rdi: stack pointer out pointer
|
|
||||||
//! * rsi: stack pointer in pointer
|
|
||||||
|
|
||||||
// make sure we leave the red zone alone
|
|
||||||
sub $$128, %rsp
|
|
||||||
|
|
||||||
// save the frame pointer
|
|
||||||
pushq %rbp
|
|
||||||
|
|
||||||
// save the return address to the stack, control flow continues at label 1
|
|
||||||
call 1f
|
|
||||||
// we arrive here once this context is reactivated
|
|
||||||
|
|
||||||
// restore the frame pointer
|
|
||||||
popq %rbp
|
|
||||||
|
|
||||||
// give back the red zone
|
|
||||||
add $$128, %rsp
|
|
||||||
|
|
||||||
// and we merrily go on our way, back into Rust-land
|
|
||||||
jmp 2f
|
|
||||||
|
|
||||||
1:
|
|
||||||
// retrieve the new stack pointer
|
|
||||||
movq (%rsi), %rax
|
|
||||||
// save the old stack pointer
|
|
||||||
movq %rsp, (%rdi)
|
|
||||||
// switch to the new stack pointer
|
|
||||||
movq %rax, %rsp
|
|
||||||
|
|
||||||
// jump into the new context (return to the call point)
|
|
||||||
// doing this instead of a straight `ret` is 8ns faster,
|
|
||||||
// presumably because the branch predictor tries
|
|
||||||
// to be clever about it otherwise
|
|
||||||
popq %rax
|
|
||||||
jmpq *%rax
|
|
||||||
|
|
||||||
2:
|
|
|
@ -1,35 +0,0 @@
|
||||||
// This file is part of libfringe, a low-level green threading library.
|
|
||||||
// Copyright (c) 2015, edef <edef@edef.eu>
|
|
||||||
// See the LICENSE file included in this distribution.
|
|
||||||
use void::Void;
|
|
||||||
|
|
||||||
use stack::Stack;
|
|
||||||
use arch::common::{push, rust_trampoline};
|
|
||||||
|
|
||||||
pub const STACK_ALIGN: usize = 16;
|
|
||||||
|
|
||||||
#[derive(Debug)]
|
|
||||||
pub struct Registers {
|
|
||||||
stack_pointer: *mut usize
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Registers {
|
|
||||||
#[inline]
|
|
||||||
pub unsafe fn new<S, F>(stack: &mut S, f: F) -> Registers
|
|
||||||
where S: Stack, F: FnOnce() -> Void
|
|
||||||
{
|
|
||||||
let mut sp = stack.top() as *mut usize;
|
|
||||||
let f_ptr = push(&mut sp, f);
|
|
||||||
|
|
||||||
init!(sp, f_ptr, rust_trampoline::<F> as unsafe extern "C" fn(*const F) -> !);
|
|
||||||
|
|
||||||
Registers {
|
|
||||||
stack_pointer: sp,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[inline(always)]
|
|
||||||
pub unsafe fn swap(out_regs: *mut Registers, in_regs: *const Registers) {
|
|
||||||
swap!(&mut (*out_regs).stack_pointer, &(*in_regs).stack_pointer);
|
|
||||||
}
|
|
||||||
}
|
|
|
@ -1,13 +1,10 @@
|
||||||
// This file is part of libfringe, a low-level green threading library.
|
// This file is part of libfringe, a low-level green threading library.
|
||||||
// Copyright (c) edef <edef@edef.eu>
|
// Copyright (c) edef <edef@edef.eu>,
|
||||||
|
// whitequark <whitequark@whitequark.org>
|
||||||
// See the LICENSE file included in this distribution.
|
// See the LICENSE file included in this distribution.
|
||||||
use core::marker::PhantomData;
|
|
||||||
|
|
||||||
use void::Void;
|
|
||||||
|
|
||||||
use arch::Registers;
|
|
||||||
use stack;
|
use stack;
|
||||||
use debug::StackId;
|
use debug;
|
||||||
|
use arch;
|
||||||
|
|
||||||
/// Context is the heart of libfringe.
|
/// Context is the heart of libfringe.
|
||||||
/// A context represents a saved thread of execution, along with a stack.
|
/// A context represents a saved thread of execution, along with a stack.
|
||||||
|
@ -17,44 +14,41 @@ use debug::StackId;
|
||||||
/// Every operation is unsafe, because libfringe can't make any guarantees
|
/// Every operation is unsafe, because libfringe can't make any guarantees
|
||||||
/// about the state of the context.
|
/// about the state of the context.
|
||||||
#[derive(Debug)]
|
#[derive(Debug)]
|
||||||
pub struct Context<'a, Stack: stack::Stack> {
|
pub struct Context<Stack: stack::Stack> {
|
||||||
regs: Registers,
|
|
||||||
_stack_id: StackId,
|
|
||||||
stack: Stack,
|
stack: Stack,
|
||||||
_ref: PhantomData<&'a ()>
|
stack_id: debug::StackId,
|
||||||
|
stack_ptr: arch::StackPointer
|
||||||
}
|
}
|
||||||
|
|
||||||
unsafe impl<'a, Stack> Send for Context<'a, Stack>
|
unsafe impl<Stack> Send for Context<Stack>
|
||||||
where Stack: stack::Stack + Send {}
|
where Stack: stack::Stack + Send {}
|
||||||
|
|
||||||
impl<'a, Stack> Context<'a, Stack> where Stack: stack::Stack {
|
impl<Stack> Context<Stack> where Stack: stack::Stack {
|
||||||
/// Create a new Context. When it is swapped into,
|
/// Create a new Context. When it is swapped into, it will call
|
||||||
/// it will call the passed closure.
|
/// `f(arg)`, where `arg` is the argument passed to `swap`.
|
||||||
#[inline]
|
pub unsafe fn new(stack: Stack, f: unsafe extern "C" fn(usize) -> !) -> Context<Stack> {
|
||||||
pub unsafe fn new<F>(mut stack: Stack, f: F) -> Context<'a, Stack>
|
let stack_id = debug::StackId::register(&stack);
|
||||||
where F: FnOnce() -> Void + Send + 'a {
|
let stack_ptr = arch::init(&stack, f);
|
||||||
let stack_id = StackId::register(&mut stack);
|
|
||||||
let regs = Registers::new(&mut stack, f);
|
|
||||||
Context {
|
Context {
|
||||||
regs: regs,
|
|
||||||
_stack_id: stack_id,
|
|
||||||
stack: stack,
|
stack: stack,
|
||||||
_ref: PhantomData
|
stack_id: stack_id,
|
||||||
|
stack_ptr: stack_ptr
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Unwrap the context, returning the stack it contained.
|
/// Unwrap the context, returning the stack it contained.
|
||||||
#[inline]
|
|
||||||
pub unsafe fn unwrap(self) -> Stack {
|
pub unsafe fn unwrap(self) -> Stack {
|
||||||
self.stack
|
self.stack
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<'i, InStack> Context<'i, InStack> where InStack: stack::Stack {
|
impl<OldStack> Context<OldStack> where OldStack: stack::Stack {
|
||||||
/// Switch to in_ctx, saving the current thread of execution to out_ctx.
|
/// Switch to in_ctx, saving the current thread of execution to out_ctx.
|
||||||
#[inline(always)]
|
#[inline(always)]
|
||||||
pub unsafe fn swap<'o, OutStack>(out_ctx: *mut Context<'o, OutStack>, in_ctx: *const Context<'i, InStack>)
|
pub unsafe fn swap<NewStack>(old_ctx: *mut Context<OldStack>,
|
||||||
where OutStack: stack::Stack {
|
new_ctx: *const Context<NewStack>,
|
||||||
Registers::swap(&mut (*out_ctx).regs, &(*in_ctx).regs)
|
arg: usize) -> usize
|
||||||
|
where NewStack: stack::Stack {
|
||||||
|
arch::swap(arg, &mut (*old_ctx).stack_ptr, &(*new_ctx).stack_ptr)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -14,7 +14,7 @@ mod imp {
|
||||||
pub struct StackId;
|
pub struct StackId;
|
||||||
/// No-op since no valgrind
|
/// No-op since no valgrind
|
||||||
impl StackId {
|
impl StackId {
|
||||||
pub fn register<Stack: stack::Stack>(_stack: &mut Stack) -> StackId {
|
pub fn register<Stack: stack::Stack>(_stack: &Stack) -> StackId {
|
||||||
StackId
|
StackId
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -11,7 +11,7 @@ pub struct StackId(self::valgrind::Value);
|
||||||
|
|
||||||
impl StackId {
|
impl StackId {
|
||||||
#[inline(always)]
|
#[inline(always)]
|
||||||
pub fn register<Stack: stack::Stack>(stack: &mut Stack) -> StackId {
|
pub fn register<Stack: stack::Stack>(stack: &Stack) -> StackId {
|
||||||
StackId(stack_register(stack.limit(), stack.top()))
|
StackId(stack_register(stack.limit(), stack.top()))
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
13
src/lib.rs
13
src/lib.rs
|
@ -7,26 +7,17 @@
|
||||||
//! libfringe is a low-level green threading library.
|
//! libfringe is a low-level green threading library.
|
||||||
//! It provides only a context-swapping mechanism.
|
//! It provides only a context-swapping mechanism.
|
||||||
|
|
||||||
#[cfg(test)]
|
|
||||||
#[macro_use]
|
|
||||||
extern crate std;
|
|
||||||
|
|
||||||
extern crate void;
|
|
||||||
|
|
||||||
pub use context::Context;
|
pub use context::Context;
|
||||||
pub use stack::Stack;
|
pub use stack::Stack;
|
||||||
|
|
||||||
#[cfg(feature = "os")]
|
#[cfg(any(unix, windows))]
|
||||||
pub use os::Stack as OsStack;
|
pub use os::Stack as OsStack;
|
||||||
|
|
||||||
mod context;
|
mod context;
|
||||||
mod stack;
|
mod stack;
|
||||||
|
|
||||||
#[cfg(feature = "os")]
|
#[cfg(any(unix, windows))]
|
||||||
mod os;
|
mod os;
|
||||||
|
|
||||||
mod arch;
|
mod arch;
|
||||||
mod debug;
|
mod debug;
|
||||||
|
|
||||||
#[cfg(not(test))]
|
|
||||||
mod std { pub use core::*; }
|
|
||||||
|
|
|
@ -47,13 +47,13 @@ impl Stack {
|
||||||
}
|
}
|
||||||
|
|
||||||
impl stack::Stack for Stack {
|
impl stack::Stack for Stack {
|
||||||
fn top(&mut self) -> *mut u8 {
|
fn top(&self) -> *mut u8 {
|
||||||
unsafe {
|
unsafe {
|
||||||
self.ptr.offset(self.len as isize)
|
self.ptr.offset(self.len as isize)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn limit(&self) -> *const u8 {
|
fn limit(&self) -> *mut u8 {
|
||||||
unsafe {
|
unsafe {
|
||||||
self.ptr.offset(sys::page_size() as isize)
|
self.ptr.offset(sys::page_size() as isize)
|
||||||
}
|
}
|
||||||
|
|
|
@ -8,9 +8,9 @@ pub trait Stack {
|
||||||
/// Returns the top of the stack.
|
/// Returns the top of the stack.
|
||||||
/// On all modern architectures, the stack grows downwards,
|
/// On all modern architectures, the stack grows downwards,
|
||||||
/// so this is the highest address.
|
/// so this is the highest address.
|
||||||
fn top(&mut self) -> *mut u8;
|
fn top(&self) -> *mut u8;
|
||||||
/// Returns the bottom of the stack.
|
/// Returns the bottom of the stack.
|
||||||
/// On all modern architectures, the stack grows downwards,
|
/// On all modern architectures, the stack grows downwards,
|
||||||
/// so this is the lowest address.
|
/// so this is the lowest address.
|
||||||
fn limit(&self) -> *const u8;
|
fn limit(&self) -> *mut u8;
|
||||||
}
|
}
|
||||||
|
|
|
@ -1,26 +0,0 @@
|
||||||
// This file is part of libfringe, a low-level green threading library.
|
|
||||||
// Copyright (c) edef <edef@edef.eu>
|
|
||||||
// See the LICENSE file included in this distribution.
|
|
||||||
#![feature(thread_local)]
|
|
||||||
extern crate fringe;
|
|
||||||
use fringe::Context;
|
|
||||||
|
|
||||||
#[thread_local]
|
|
||||||
static mut ctx_slot: *mut Context<'static, fringe::OsStack> = 0 as *mut Context<_>;
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn main() {
|
|
||||||
unsafe {
|
|
||||||
let stack = fringe::OsStack::new(4 << 20).unwrap();
|
|
||||||
|
|
||||||
let mut ctx = Context::new(stack, move || {
|
|
||||||
println!("it's alive!");
|
|
||||||
Context::swap(ctx_slot, ctx_slot);
|
|
||||||
panic!("Do not come back!")
|
|
||||||
});
|
|
||||||
|
|
||||||
ctx_slot = &mut ctx;
|
|
||||||
|
|
||||||
Context::swap(ctx_slot, ctx_slot);
|
|
||||||
}
|
|
||||||
}
|
|
|
@ -0,0 +1,60 @@
|
||||||
|
// This file is part of libfringe, a low-level green threading library.
|
||||||
|
// Copyright (c) edef <edef@edef.eu>,
|
||||||
|
// whitequark <whitequark@whitequark.org>
|
||||||
|
// See the LICENSE file included in this distribution.
|
||||||
|
#![feature(thread_local)]
|
||||||
|
extern crate simd;
|
||||||
|
extern crate fringe;
|
||||||
|
|
||||||
|
use fringe::Context;
|
||||||
|
|
||||||
|
#[thread_local]
|
||||||
|
static mut ctx_slot: *mut Context<fringe::OsStack> = 0 as *mut Context<_>;
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn context() {
|
||||||
|
unsafe extern "C" fn adder(arg: usize) -> ! {
|
||||||
|
println!("it's alive! arg: {}", arg);
|
||||||
|
let arg = Context::swap(ctx_slot, ctx_slot, arg + 1);
|
||||||
|
println!("still alive! arg: {}", arg);
|
||||||
|
Context::swap(ctx_slot, ctx_slot, arg + 1);
|
||||||
|
panic!("i should be dead");
|
||||||
|
}
|
||||||
|
|
||||||
|
unsafe {
|
||||||
|
let stack = fringe::OsStack::new(4 << 20).unwrap();
|
||||||
|
let mut ctx = Context::new(stack, adder);
|
||||||
|
ctx_slot = &mut ctx;
|
||||||
|
|
||||||
|
let ret = Context::swap(ctx_slot, ctx_slot, 10);
|
||||||
|
assert_eq!(ret, 11);
|
||||||
|
let ret = Context::swap(ctx_slot, ctx_slot, 50);
|
||||||
|
assert_eq!(ret, 51);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn simd() {
|
||||||
|
unsafe extern "C" fn permuter(arg: usize) -> ! {
|
||||||
|
// This will crash if the stack is not aligned properly.
|
||||||
|
let x = simd::i32x4::splat(arg as i32);
|
||||||
|
let y = x * x;
|
||||||
|
println!("simd result: {:?}", y);
|
||||||
|
Context::swap(ctx_slot, ctx_slot, 0);
|
||||||
|
// And try again after a context switch.
|
||||||
|
let x = simd::i32x4::splat(arg as i32);
|
||||||
|
let y = x * x;
|
||||||
|
println!("simd result: {:?}", y);
|
||||||
|
Context::swap(ctx_slot, ctx_slot, 0);
|
||||||
|
panic!("i should be dead");
|
||||||
|
}
|
||||||
|
|
||||||
|
unsafe {
|
||||||
|
let stack = fringe::OsStack::new(4 << 20).unwrap();
|
||||||
|
let mut ctx = Context::new(stack, permuter);
|
||||||
|
ctx_slot = &mut ctx;
|
||||||
|
|
||||||
|
Context::swap(ctx_slot, ctx_slot, 10);
|
||||||
|
Context::swap(ctx_slot, ctx_slot, 20);
|
||||||
|
}
|
||||||
|
}
|
19
tests/fpe.rs
19
tests/fpe.rs
|
@ -12,7 +12,7 @@ use fringe::Context;
|
||||||
use test::black_box;
|
use test::black_box;
|
||||||
|
|
||||||
#[thread_local]
|
#[thread_local]
|
||||||
static mut ctx_slot: *mut Context<'static, fringe::OsStack> = 0 as *mut Context<_>;
|
static mut ctx_slot: *mut Context<fringe::OsStack> = 0 as *mut Context<_>;
|
||||||
|
|
||||||
const FE_DIVBYZERO: i32 = 0x4;
|
const FE_DIVBYZERO: i32 = 0x4;
|
||||||
extern {
|
extern {
|
||||||
|
@ -22,21 +22,20 @@ extern {
|
||||||
#[test]
|
#[test]
|
||||||
#[ignore]
|
#[ignore]
|
||||||
fn fpe() {
|
fn fpe() {
|
||||||
unsafe {
|
unsafe extern "C" fn universe_destroyer(_arg: usize) -> ! {
|
||||||
let stack = fringe::OsStack::new(4 << 20).unwrap();
|
|
||||||
|
|
||||||
let mut ctx = Context::new(stack, move || {
|
|
||||||
println!("it's alive!");
|
|
||||||
loop {
|
loop {
|
||||||
println!("{:?}", 1.0/black_box(0.0));
|
println!("{:?}", 1.0/black_box(0.0));
|
||||||
Context::swap(ctx_slot, ctx_slot);
|
Context::swap(ctx_slot, ctx_slot, 0);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
});
|
|
||||||
|
|
||||||
|
unsafe {
|
||||||
|
let stack = fringe::OsStack::new(4 << 20).unwrap();
|
||||||
|
let mut ctx = Context::new(stack, universe_destroyer);
|
||||||
ctx_slot = &mut ctx;
|
ctx_slot = &mut ctx;
|
||||||
|
|
||||||
Context::swap(ctx_slot, ctx_slot);
|
Context::swap(ctx_slot, ctx_slot, 0);
|
||||||
feenableexcept(FE_DIVBYZERO);
|
feenableexcept(FE_DIVBYZERO);
|
||||||
Context::swap(ctx_slot, ctx_slot);
|
Context::swap(ctx_slot, ctx_slot, 0);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
Loading…
Reference in New Issue