Struct fibers::ThreadPoolExecutor

pub struct ThreadPoolExecutor { /* fields omitted */ }

An executor that executes spawned fibers on pooled threads.

Examples

An example to calculate fibonacci numbers:

use fibers::{Spawn, Executor, ThreadPoolExecutor};
use futures::{Async, Future};

fn fib<H: Spawn + Clone>(n: usize, handle: H) -> Box<Future<Item=usize, Error=()> + Send> {
    if n < 2 {
        Box::new(futures::finished(n))
    } else {
        let f0 = handle.spawn_monitor(fib(n - 1, handle.clone()));
        let f1 = handle.spawn_monitor(fib(n - 2, handle.clone()));
        Box::new(f0.join(f1).map(|(a0, a1)| a0 + a1).map_err(|_| ()))
    }
}

let mut executor = ThreadPoolExecutor::new().unwrap();
let monitor = executor.spawn_monitor(fib(7, executor.handle()));
let answer = executor.run_fiber(monitor).unwrap();
assert_eq!(answer, Ok(13));

Methods

impl ThreadPoolExecutor

pub fn new() -> Result<Self>

Creates a new instance of ThreadPoolExecutor.

This is equivalent to ThreadPoolExecutor::with_thread_count(num_cpus::get() * 2).

pub fn with_thread_count(count: usize) -> Result<Self>

Creates a new instance of ThreadPoolExecutor with the specified size of thread pool.

Implementation Details

Note that current implementation is very naive and should be improved in future releases.

Internally, count threads are assigned to each of the scheduler (i.e., fibers::fiber::Scheduler) and the I/O poller (i.e., fibers::io::poll::Poller).

When spawn function is called, the executor will assign a scheduler (thread) for the fiber in simple round robin fashion.

If any of those threads are aborted, the executor will return an error as a result of run_once method call after that.

Trait Implementations

impl Debug for ThreadPoolExecutor

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Executor for ThreadPoolExecutor

type Handle = ThreadPoolExecutorHandle

The handle type of the executor.

fn handle(&self) -> Self::Handle

Returns the handle of the executor.

fn run_once(&mut self) -> Result<()>

Runs one one unit of works.

fn run_fiber<T, E>(     &mut self,     monitor: Monitor<T, E> ) -> Result<Result<T, MonitorError<E>>>

Runs until the monitored fiber exits.

fn run_future<F: Future>(     &mut self,     future: F ) -> Result<Result<F::Item, F::Error>>

Runs until the future is ready.

fn run(self) -> Result<()>

Runs infinitely until an error happens.

impl Spawn for ThreadPoolExecutor

fn spawn_boxed(&self, fiber: Box<Future<Item = (), Error = ()> + Send>)

Spawns a fiber which will execute given boxed future.

fn spawn<F>(&self, fiber: F) where     F: Future<Item = (), Error = ()> + Send + 'static,

Spawns a fiber which will execute given future.

fn spawn_fn<F, T>(&self, f: F) where     F: FnOnce() -> T + Send + 'static,     T: IntoFuture<Item = (), Error = ()> + Send + 'static,     T::Future: Send,

Equivalent to self.spawn(futures::lazy(|| f())).

fn spawn_monitor<F, T, E>(&self, f: F) -> Monitor<T, E> where     F: Future<Item = T, Error = E> + Send + 'static,     T: Send + 'static,     E: Send + 'static,

Spawns a fiber and returns a future to monitor it's execution result.

fn spawn_link<F, T, E>(&self, f: F) -> Link<(), (), T, E> where     F: Future<Item = T, Error = E> + Send + 'static,     T: Send + 'static,     E: Send + 'static,

Spawns a linked fiber.

fn boxed(self) -> BoxSpawn where     Self: Sized + Send + 'static,

Converts this instance into a boxed object.