Crate bevy_tasks

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 an AsyncComputeTaskPool. Work that does not need to be completed to present the next frame should go to the AsyncComputeTaskPool.

• 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)

no_std Support

To enable no_std support in this crate, you will need to disable default features, and enable the edge_executor and critical-section features.

Modules

futures

Utilities for working with Futures.

futures_lite

Futures, streams, and async I/O combinators.

prelude

The tasks prelude.

Structs

AsyncComputeTaskPool

A newtype for a task pool for CPU-intensive work that may span across multiple frames

ComputeTaskPool

A newtype for a task pool for CPU-intensive work that must be completed to deliver the next frame

IoTaskPool

A newtype for a task pool for IO-intensive work (i.e. tasks that spend very little time in a “woken” state)

Scope

A TaskPool scope for running one or more non-'static futures.

Task

Wraps async_executor::Task, a spawned future.

TaskPool

A thread pool for executing tasks.

TaskPoolBuilder

Used to create a TaskPool

ThreadExecutor

An executor that can only be ticked on the thread it was instantiated on. But can spawn Send tasks from other threads.

ThreadExecutorTicker

Used to tick the ThreadExecutor. The executor does not make progress unless it is manually ticked on the thread it was created on.

Traits

ConditionalSend

Use ConditionalSend to mark an optional Send trait bound. Useful as on certain platforms (eg. Wasm), futures aren’t Send.

ConditionalSendFuture

Use ConditionalSendFuture for a future with an optional Send trait bound, as on certain platforms (eg. Wasm), futures aren’t Send.

ParallelIterator

ParallelIterator closely emulates the std::iter::Iterator interface. However, it uses bevy_task to compute batches in parallel.

ParallelSlice

Provides functions for mapping read-only slices across a provided TaskPool.

ParallelSliceMut

Provides functions for mapping mutable slices across a provided TaskPool.

Functions

available_parallelism

Gets the logical CPU core count available to the current process.

block_on

Blocks the current thread on a future.

poll_once

Polls a future just once and returns an Option with the result.

tick_global_task_pools_on_main_thread

A function used by bevy_app 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.

Type Aliases

BoxedFuture

An owned and dynamically typed Future used when you can’t statically type your result or need to add some indirection.