Struct Manager 

pub struct Manager<'a>(/* private fields */);

A wrapper type that adapts any type implementing Allocator_trait to the standard Rust GlobalAlloc trait.

This enables custom allocators that implement the Xila-specific Allocator_trait to be used as the global memory allocator for Rust’s allocation system.

Implementations

impl<'a> Manager<'a>

pub const fn new(allocator: &'a dyn ManagerTrait) -> Self

Creates a new instance of Allocator_type wrapping the provided allocator.

Parameters

• Allocator - The allocator to wrap

Returns

A new instance of Allocator_type containing the provided allocator.

pub unsafe fn allocate( &self, capabilities: CapabilityFlags, layout: Layout, ) -> *mut u8

Allocates memory with the specified capabilities and layout.

Parameters

• Capabilities - Specific requirements for the allocation
• Layout - Size and alignment requirements for the allocation

Returns

A pointer to the allocated memory, or a null pointer if allocation failed.

Safety

This function is unsafe because the caller must ensure that:

pub unsafe fn deallocate(&self, pointer: *mut u8, layout: Layout)

Deallocates memory previously allocated by this allocator.

Parameters

• Pointer - Pointer to the memory to deallocate
• Layout - The layout that was used to allocate the memory

Safety

This function is unsafe because the caller must ensure that:

• The pointer was allocated by this allocator
• The layout matches the layout used for allocation

pub unsafe fn reallocate( &self, pointer: *mut u8, layout: Layout, new_size: usize, ) -> *mut u8

Reallocates memory with a new layout.

This method changes the size or alignment of a previously allocated memory block. If the pointer is None, this behaves like a normal allocation. If reallocation is successful, the contents of the old memory are preserved up to the minimum of the old and new sizes.

Parameters

• Pointer - Pointer to the memory to reallocate. If null, acts as a new allocation
• Old_layout - The layout that was used for the original allocation
• New_size - The new size for the memory

Returns

A pointer to the reallocated memory with the new layout, or a null pointer if reallocation failed.

Safety

This function is unsafe because the caller must ensure that:

• If Pointer is not null, it was allocated by this allocator
• The Old_layout matches the one used for the original allocation
• The old memory is not used after successful reallocation
• The returned memory is properly initialized before use

pub fn get_page_size(&self) -> usize

pub fn flush_data_cache(&self)

pub unsafe fn flush_instruction_cache(&self, address: *const u8, size: usize)

Flushes the instruction cache for the specified memory region.

Parameters

• Address - Starting address of the memory region
• Size - Size of the memory region in bytes

Safety

This function is unsafe because the caller must ensure that:

• The address is valid and points to a memory region of at least size bytes
• The memory region is not being modified while the instruction cache is being flushed

pub fn get_used(&self) -> usize

Returns the amount of memory currently used.

Returns

The number of bytes currently allocated.

pub fn get_free(&self) -> usize

Returns the amount of memory currently available.

Returns

The number of bytes available for allocation.

pub fn get_total_size(&self) -> usize

Returns the total size of the memory managed by this allocator.

Returns

The total number of bytes managed by the allocator.

Trait Implementations

impl<'a> GlobalAlloc for Manager<'a>

Implementation of the standard library’s GlobalAlloc trait for any wrapped type that implements Allocator_trait.

This implementation delegates the standard allocation operations to the wrapped allocator’s methods, converting between Rust’s and Xila’s allocation types.

Safety

The implementation upholds the safety guarantees required by GlobalAlloc:

• Memory is properly aligned according to the layout
• Deallocation uses the same layout that was used for allocation

unsafe fn alloc(&self, layout: Layout) -> *mut u8

Allocates memory as described by the given layout.

unsafe fn dealloc(&self, pointer: *mut u8, layout: Layout)

Deallocates the block of memory at the given ptr pointer with the given layout.

unsafe fn realloc( &self, pointer: *mut u8, layout: Layout, new_size: usize, ) -> *mut u8

Shrinks or grows a block of memory to the given new_size in bytes. The block is described by the given ptr pointer and layout.

unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8

Behaves like alloc, but also ensures that the contents are set to zero before being returned.