Struct bevy_internal::tasks::TaskPool

pub struct TaskPool {}

A thread pool for executing tasks. Tasks are futures that are being automatically driven by the pool on threads owned by the pool. In this case - main thread only.

Implementations

impl TaskPool

pub fn get_thread_executor() -> Arc<ThreadExecutor<'static>>

Just create a new ThreadExecutor for wasm

pub fn new() -> TaskPool

Create a TaskPool with the default configuration.

pub fn thread_num(&self) -> usize

Return the number of threads owned by the task pool

pub fn scope<'env, F, T>(&self, f: F) -> Vec<T>

where F: for<'scope> FnOnce(&'env mut Scope<'scope, 'env, T>), T: Send + 'static,

Allows spawning non-'static futures on the thread pool. The function takes a callback, passing a scope object into it. The scope object provided to the callback can be used to spawn tasks. This function will await the completion of all tasks before returning.

This is similar to rayon::scope and crossbeam::scope

pub fn scope_with_executor<'env, F, T>( &self, _tick_task_pool_executor: bool, _thread_executor: Option<&ThreadExecutor<'_>>, f: F ) -> Vec<T>

where F: for<'scope> FnOnce(&'env mut Scope<'scope, 'env, T>), T: Send + 'static,

Allows spawning non-'static futures on the thread pool. The function takes a callback, passing a scope object into it. The scope object provided to the callback can be used to spawn tasks. This function will await the completion of all tasks before returning.

This is similar to rayon::scope and crossbeam::scope

pub fn spawn<T>(&self, future: impl Future<Output = T> + 'static) -> FakeTask

where T: 'static,

Spawns a static future onto the thread pool. The returned Task is a future. It can also be cancelled and “detached” allowing it to continue running without having to be polled by the end-user.

If the provided future is non-Send, TaskPool::spawn_local should be used instead.

pub fn spawn_local<T>( &self, future: impl Future<Output = T> + 'static ) -> FakeTask

where T: 'static,

Spawns a static future on the JS event loop. This is exactly the same as TaskPool::spawn.

pub fn with_local_executor<F, R>(&self, f: F) -> R

where F: FnOnce(&LocalExecutor<'_>) -> R,

Runs a function with the local executor. Typically used to tick the local executor on the main thread as it needs to share time with other things.

use bevy_tasks::TaskPool;

TaskPool::new().with_local_executor(|local_executor| {
    local_executor.try_tick();
});

Trait Implementations

impl Clone for TaskPool

fn clone(&self) -> TaskPool

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TaskPool

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for TaskPool

fn default() -> TaskPool

Returns the “default value” for a type.