内容简介：As of stableA very basic simple coroutine library contains only an event-less 'yield' primitive, which stops execution of the current coroutine so that other coroutines can run. This is the kind of library that I chose to demonstrate in this post to provid
As of stable Rust
1.39.0, it is possible to
implement a very basic and safe coroutine
library using Rust's
async
/ await
support, and
in under 100 lines of code. The implementation depends solely on std
and is
stack-less (meaning, not depending on an separate CPU architecture stack).
A very basic simple coroutine library contains only an event-less 'yield' primitive, which stops execution of the current coroutine so that other coroutines can run. This is the kind of library that I chose to demonstrate in this post to provide the most concise example.
Yielder
To the coroutine we pass a Fib
struct that only contains a simple binary
state. This Fib
struct has a waiter
method that creates a
Future
that the
coroutine can use in order to be await
ed upon.
use std::future::Future;
use std::pin::Pin;
use std::task::{Poll, Context};
enum State {
Halted,
Running,
}
struct Fib {
state: State,
}
impl Fib {
fn waiter<'a>(&'a mut self) -> Waiter<'a> {
Waiter { fib: self }
}
}
struct Waiter<'a> {
fib: &'a mut Fib,
}
impl<'a> Future for Waiter<'a> {
type Output = ();
fn poll(mut self: Pin<&mut Self>, _cx: &mut Context) -> Poll<Self::Output> {
match self.fib.state {
State::Halted => {
self.fib.state = State::Running;
Poll::Ready(())
}
State::Running => {
self.fib.state = State::Halted;
Poll::Pending
}
}
}
}
Executor
Our executor keeps a vector of uncompleted futures, where the state of each
future is located on the heap. As a very basic executor, it only supports
adding futures to it before actual execution takes place and not afterward.
The push
method adds a closure to the list of futures, and the run
method
performs interlaced execution of futures until all of them complete.
use std::collections::VecDeque;
struct Executor {
fibs: VecDeque<Pin<Box<dyn Future<Output=()>>>>,
}
impl Executor {
fn new() -> Self {
Executor {
fibs: VecDeque::new(),
}
}
fn push<C, F>(&mut self, closure: C)
where
F: Future<Output=()> + 'static,
C: FnOnce(Fib) -> F,
{
let fib = Fib { state: State::Running };
self.fibs.push_back(Box::pin(closure(fib)));
}
fn run(&mut self) {
let waker = waker::create();
let mut context = Context::from_waker(&waker);
while let Some(mut fib) = self.fibs.pop_front() {
match fib.as_mut().poll(&mut context) {
Poll::Pending => {
self.fibs.push_back(fib);
},
Poll::Ready(()) => {},
}
}
}
}
Null Waker
For the executor implementation above, we need a null Waker , similar to the one used in genawaiter ( link ).
use std::task::{RawWaker, RawWakerVTable, Waker},
pub fn create() -> Waker {
// Safety: The waker points to a vtable with functions that do nothing. Doing
// nothing is memory-safe.
unsafe { Waker::from_raw(RAW_WAKER) }
}
const RAW_WAKER: RawWaker = RawWaker::new(std::ptr::null(), &VTABLE);
const VTABLE: RawWakerVTable = RawWakerVTable::new(clone, wake, wake_by_ref, drop);
unsafe fn clone(_: *const ()) -> RawWaker { RAW_WAKER }
unsafe fn wake(_: *const ()) { }
unsafe fn wake_by_ref(_: *const ()) { }
unsafe fn drop(_: *const ()) { }
Giving it a go
We can test the library using a program such as the following:
pub fn main() {
let mut exec = Executor::new();
for instance in 1..=3 {
exec.push(move |mut fib| async move {
println!("{} A", instance);
fib.waiter().await;
println!("{} B", instance);
fib.waiter().await;
println!("{} C", instance);
fib.waiter().await;
println!("{} D", instance);
});
}
println!("Running");
exec.run();
println!("Done");
}
The output is as follows:
Running 1 A 2 A 3 A 1 B 2 B 3 B 1 C 2 C 3 C 1 D 2 D 3 D Done
Performance
Timing the following program compiled with lto = true
, I have seen that it
takes about 5 nanoseconds for each iteration of the internal loop, on an Intel
i7-7820X CPU.
pub fn bench() {
let mut exec = Executor::new();
for _ in 1..=2 {
exec.push(move |mut fib| async move {
for _ in 0..100_000_000 {
fib.waiter().await;
}
});
}
println!("Running");
exec.run();
println!("Done");
}
End notes
One of the nice things about the async
/ await
support in the Rust compiler
is that it does not depend on any specific run-time. Thus, if you commit to
certain run-time, you are free to implement your own executor.
Independency of run-time has its downsides. For example, the library presented
here is not compatible with other run-times such as
async-std
. And in fact, the implementation
violates the interface intended for the Future
's poll
function by assuming
that the Future
will always be Ready
after it was Pending
.
Combined uses of several run-times in a single program is possible but requires extra care (see Reddit discussion ).
以上就是本文的全部内容，希望本文的内容对大家的学习或者工作能带来一定的帮助，也希望大家多多支持 码农网
猜你喜欢:
本站部分资源来源于网络，本站转载出于传递更多信息之目的，版权归原作者或者来源机构所有，如转载稿涉及版权问题，请联系我们。
Head First JavaScript Programming
Eric T. Freeman、Elisabeth Robson / O'Reilly Media / 2014-4-10 / USD 49.99
This brain-friendly guide teaches you everything from JavaScript language fundamentals to advanced topics, including objects, functions, and the browser’s document object model. You won’t just be read......一起来看看 《Head First JavaScript Programming》 这本书的介绍吧!
