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.

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), behind a Once so the copy happens exactly once even under concurrent access.
• 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 capacity(&self) -> usize

The total byte capacity of the allocation, WITHOUT materializing lazy storage.

fn memory( &self, policy: AccessPolicy, ) -> Result<&[MaybeUninit<u8>], AccessError>

Returns a view of the memory of the whole allocation, subject to policy.

unsafe fn memory_mut( &mut self, policy: AccessPolicy, ) -> Result<&mut [MaybeUninit<u8>], AccessError>

Returns a mutable view of the memory of the whole allocation, subject to policy.

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

Splits the current allocation in multiple separate allocations.

fn view( &self, start: usize, end: usize, ) -> Option<Box<dyn AllocationController>>

Returns a zero-copy controller over the sub-range [start, end) of this allocation when the backend supports cheap sub-views (files and shared buffers), borrowing &self. Returns None otherwise.

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.