Crate bevy_tasks
source ·Expand description
§Bevy Tasks
A refreshingly simple task executor for bevy. :)
This is a simple threadpool with minimal dependencies. The main usecase is a scoped fork-join, i.e. spawning tasks from
a single thread and having that thread await the completion of those tasks. This is intended specifically for
bevy
as a lighter alternative to rayon
for this specific usecase. There are also utilities for
generating the tasks from a slice of data. This library is intended for games and makes no attempt to ensure fairness
or ordering of spawned tasks.
It is based on async-executor
, a lightweight executor that allows the end user to manage their own threads.
async-executor
is based on async-task, a core piece of async-std.
§Usage
In order to be able to optimize task execution in multi-threaded environments, bevy provides three different thread pools via which tasks of different kinds can be spawned. (The same API is used in single-threaded environments, even if execution is limited to a single thread. This currently applies to WASM targets.) The determining factor for what kind of work should go in each pool is latency requirements:
-
For CPU-intensive work (tasks that generally spin until completion) we have a standard
ComputeTaskPool
and anAsyncComputeTaskPool
. Work that does not need to be completed to present the next frame should go to theAsyncComputeTaskPool
. -
For IO-intensive work (tasks that spend very little time in a “woken” state) we have an
IoTaskPool
whose tasks are expected to complete very quickly. Generally speaking, they should just await receiving data from somewhere (i.e. disk) and signal other systems when the data is ready for consumption. (likely via channels)
Re-exports§
pub use futures_lite;
Modules§
Structs§
- A newtype for a task pool for CPU-intensive work that may span across multiple frames
- A newtype for a task pool for CPU-intensive work that must be completed to deliver the next frame
- An empty task used in single-threaded contexts.
- A newtype for a task pool for IO-intensive work (i.e. tasks that spend very little time in a “woken” state)
- A
TaskPool
scope for running one or more non-'static
futures. - Wraps
async_executor::Task
, a spawned future. - 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.
- Used to create a
TaskPool
. - This is a dummy struct for wasm support to provide the same api as with the multithreaded task pool. In the case of the multithreaded task pool this struct is used to spawn tasks on a specific thread. But the wasm task pool just calls
wasm_bindgen_futures::spawn_local
for spawning which just runs tasks on the main thread and so theThreadExecutor
does nothing.
Traits§
ParallelIterator
closely emulates thestd::iter::Iterator
interface. However, it usesbevy_task
to compute batches in parallel.- Provides functions for mapping read-only slices across a provided
TaskPool
. - Provides functions for mapping mutable slices across a provided
TaskPool
.
Functions§
- Gets the logical CPU core count available to the current process.
- Blocks the current thread on a future.
- Polls a future just once and returns an
Option
with the result. - A function used by
bevy_core
to tick the global tasks pools on the main thread. This will run a maximum of 100 local tasks per executor per call to this function.