Struct SharedBytesAllocationController 

pub struct SharedBytesAllocationController { /* private fields */ }

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

This enables zero-copy tensor loading by referencing data directly from the source buffer without copying into heap-allocated memory.

Safety

This implementation uses an UnsafeCell to lazily copy the content into an in-memory buffer using [NativeAllocationController] when mutable access is requested. It is safe because the controller can’t be cloned or synced between multiple threads. You can duplicate the shared bytes allocator, but every version of it will have its own buffer.

Notes

• Read access via memory() is zero-copy as long as no mutable access has been requested.
• Mutable access via memory_mut() triggers a copy of the data into heap memory (copy-on-write semantics).
• The underlying bytes::Bytes remains valid for the lifetime of this controller. This is ensured by bytes::Bytes using reference counting internally.

Implementations

impl SharedBytesAllocationController

pub fn new( bytes: Bytes, property: AllocationProperty, ) -> SharedBytesAllocationController

Create a new controller from a bytes::Bytes buffer with a specific allocation property.

The allocation property is used by GPU backends to optimize data transfers:

• AllocationProperty::File: Uses pinned memory staging buffers for faster DMA transfers (useful for memory-mapped files)
• AllocationProperty::Native: Data is in heap memory
• AllocationProperty::Other: Unknown backing storage

Example

use cubecl_common::bytes::{SharedBytesAllocationController, AllocationProperty};

// From static data (zero-copy, no heap allocation)
let static_bytes = bytes::Bytes::from_static(&[1, 2, 3, 4]);
let controller = SharedBytesAllocationController::new(static_bytes, AllocationProperty::Other);

// Memory-mapped file data - use File property for optimized GPU transfers
let mmap_bytes = bytes::Bytes::from_static(&[1, 2, 3, 4]); // pretend this is mmap
let controller = SharedBytesAllocationController::new(mmap_bytes, AllocationProperty::File);

Trait Implementations

impl AllocationController for SharedBytesAllocationController

fn alloc_align(&self) -> usize

The alignment this allocation was created with.

fn property(&self) -> AllocationProperty

Returns memory property for the current allocation.

fn memory(&self) -> &[MaybeUninit<u8>]

Returns a view of the memory of the whole allocation

unsafe fn memory_mut(&mut self) -> &mut [MaybeUninit<u8>]

Returns a mutable view of the memory of the whole allocation

fn split( &mut self, offset: usize, ) -> Result<(Box<dyn AllocationController>, Box<dyn AllocationController>), SplitError>

Splits the current allocation in multiple separate allocations.

fn duplicate(&self) -> Option<Box<dyn AllocationController>>

Duplicates the current allocation with a clone on write strategy if the allocation controller supports it.

unsafe fn copy_into(&self, buf: &mut [u8])

Reads the data from the current allocation controller and copy its content into the provided buffer.

fn grow(&mut self, _size: usize, _align: usize) -> Result<(), AllocationError>

Extends the provided [Allocation] to a new size with specified alignment.

fn try_detach(&mut self) -> Option<NonNull<u8>>

Indicates whether the allocation uses the Rust alloc crate and can be safely managed by another data structure.