Crate burn_std 

Burn Standard Library

Core types and utilities shared across the Burn crates.

• Shape, slicing (s!) and indexing helpers.
• DType, the element traits and conversions, and TensorData, the backend-independent representation of tensor contents.
• Distribution for random tensor initialization.
• DeviceSettings, per-device defaults such as dtypes.
• Quantization schemes, Bytes, identifiers and errors.
• config: runtime configuration read from burn.toml.
• network: file downloads with a progress bar (network feature).

Applications use these through burn::tensor. The crate supports no_std with alloc.

Feature flags

• std (default): standard library support.
• network: file downloads.
• tracing: instrument operations with the tracing crate.

Re-exports

pub use tensor::*;

pub use data::*;

pub use distribution::*;

pub use element::*;

pub use runtime_kind::*;

pub use ops::*;

Modules

arenastd

A circular, allocation-free arena for reusable memory blocks.

backtrace

Backtrace module to build error reports.

benchmark

Module for benchmark timings

bytes

Utilities module to manipulate bytes.

config

Burn runtime configurations.

data

Tensor data representation and helpers.

device

Device module.

device_handle

Device handle module.

distributed

Distributed configurations.

distribution

Random value distributions. Random value distributions used to initialize and populate tensor data.

element

Traits for tensor element types and conversions. Traits and helpers for working with element types and conversions.

errors

Common Errors.

format

Format utilities.

future

Future utils with a compatible API for native, non-std and wasm environments.

id

Id module contains types for unique identifiers.

ops

Configuration types for tensor operations (conv, pool, interpolate, pad, etc). Configuration types for tensor operations.

pool

A dynamically-growing pool that leases exclusive, reusable single-cell items. A dynamically-growing pool of single-cell items handed out as exclusive, non-cloneable handles.

profile

Module for profiling any executable part

quant

Quantization primitives required outside of cubecl-quant

rand

Rand module contains types for random number generation for non-std environments and for std environments.

reader

Read async data without having to decorate each function with async notation.

runtime_kind

Runtime kind of the host program (async / sync / no-std). Runtime kind of the host program.

self

Common Errors.

stream

Stream identity, policies and manual stream management. Stream identity, policies and manual stream management.

sync

Synchronization primitives working across std, no-std and wasm environments.

tensor

Tensor utilities.

work

The work a benchmark or a kernel performs, for scoring against measured peaks.

Macros

make_element

Macro to implement the element trait for a type.

obfuscate

Generate a type-erased, inline wrapper for a single value.

s

Slice argument constructor for tensor indexing.

Structs

AccessPolicy

What an access is allowed to do to satisfy a read/write of a Bytes.

Bytes

A buffer similar to Box<[u8]> that supports custom memory alignment and allows trailing uninitialized bytes.

ComptimeFloat

A finite float usable as a comptime kernel parameter.

DeviceHandle

A handle to one service, reached as S.

DeviceSettings

Settings controlling the default data types for a specific device.

FileReadCounterstd

The bytes read from one file through file-backed Bytes while this counter is alive.

InvalidComptimeFloat

A float value that cannot be used as a ComptimeFloat because it is infinite or NaN.

Ratio

An exact ratio of two integers, reduced to lowest terms on construction.

Reader

Configures a read of a Bytes.

SharedAllocationController

Allocation controller that shares a view into another Bytes behind an Arc.

SharedBytesAllocationControllershared-bytes

Allocation controller backed by bytes::Bytes for zero-copy access.

StrideRecord

Common Errors. Collected shape/stride record.

Writer

Configures a mutable access of a Bytes.

bf16

A 16-bit floating point type implementing the bfloat16 format.

e2m1

A 4-bit floating point type with 2 exponent bits and 1 mantissa bit.

e2m3

A 6-bit floating point type with 2 exponent bits and 3 mantissa bits.

e2m1x2

A 4-bit floating point type with 2 exponent bits and 1 mantissa bit. Packed with two elements per value, to allow for conversion to/from bytes. Care must be taken to ensure the shape is adjusted appropriately.

e3m2

A 6-bit floating point type with 3 exponent bits and 2 mantissa bits.

e4m3fp8

A 8-bit floating point type with 4 exponent bits and 3 mantissa bits.

e5m2fp8

A 8-bit floating point type with 5 exponent bits and 2 mantissa bits.

f16

A 16-bit floating point type implementing the IEEE 754-2008 standard binary16 a.k.a “half” format.

flex32

A floating point type with relaxed precision, minimum f16, max f32.

tf32

A 19-bit floating point type implementing the tfloat32 format.

ue8m0

An 8-bit unsigned floating point type with 8 exponent bits and no mantissa bits. Used for scaling factors.

Enums

AccessError

Error returned when accessing a Bytes.

AllocationError

Errors that may occur during memory allocation operations.

AllocationProperty

The kind of allocation behind the Bytes type.

BoundsError

Common Errors. Access Bounds Error.

DeviceError

Errors returned by device-related operations.

ExecutionError

An error that can happen when syncing a device.

ExpressionError

Common Errors. Common Expression Error.

IndexKind

Common Errors. Describes the kind of an index.

SplitError

Error when splitting an allocation.

SplitPolicy

Controls how Bytes::split behaves when the allocation can’t be split in place.

StrideError

Common Errors. Error describing striding issues.

ViewError

Error when taking a view into an allocation.

Traits

AllocationController

Defines how an Allocation can be controlled.

FloatBits

A float type whose bit representation can stand in for PartialEq/Eq/Hash.

Functions

powi_portable

Rust’s powi returns mathematically incorrect results on Windows for large negative exponents. This is an implementation of the standard exponentiation by squaring algorithm used by compilers on most platforms to implement accurate powi. Should be bit-identical to the one in LLVM’s compiler-rt.