Struct PrefetchingCompressedArray 

pub struct PrefetchingCompressedArray<A: Clone + Copy + 'static + Send + Sync> { /* private fields */ }

Implementations

impl<A: Clone + Copy + 'static + Send + Sync> PrefetchingCompressedArray<A>

pub fn new(array: CompressedMemMappedArray<A>) -> Self

Create a new prefetching compressed array from an existing compressed memory-mapped array.

pub fn new_with_config( array: CompressedMemMappedArray<A>, config: PrefetchConfig, ) -> CoreResult<Self>

Create a new prefetching compressed array with the given configuration.

pub const fn inner(&self) -> &CompressedMemMappedArray<A>

Get access to the underlying compressed memory-mapped array.

pub fn inner_mut(&mut self) -> &mut CompressedMemMappedArray<A>

Get mutable access to the underlying compressed memory-mapped array.

impl<A: Clone + Copy + 'static + Send + Sync> PrefetchingCompressedArray<A>

pub fn get(&self, indices: &[usize]) -> CoreResult<A>

Get a specific element from the array, with prefetching support.

pub fn slice(&self, ranges: &[(usize, usize)]) -> CoreResult<Array<A, IxDyn>>

Slice the array with prefetching support.

Methods from Deref<Target = CompressedMemMappedArray<A>>

pub fn shape(&self) -> &[usize]

Get the shape of the array.

pub fn size(&self) -> usize

Get the total number of elements in the array.

pub fn ndim(&self) -> usize

Get the number of dimensions of the array.

pub fn metadata(&self) -> &CompressedFileMetadata

Get the metadata for the compressed file.

pub fn block_size(&self) -> usize

Get the block size.

pub fn num_blocks(&self) -> usize

Get the number of blocks.

pub fn preload_block(&self, blockidx: usize) -> CoreResult<()>

Load a specific block into memory.

This is useful for preloading blocks that will be accessed soon.

Arguments

• blockidx - The index of the block to load

Returns

Ok(()) if successful, or an error

pub fn readonly_array(&self) -> CoreResult<Array<A, IxDyn>>

Get a read-only view of the entire array.

This will decompress all blocks and load them into memory.

Returns

A read-only ndarray view of the data

pub fn get(&self, indices: &[usize]) -> CoreResult<A>

Get a specific element from the array.

This will decompress only the block containing the element.

Arguments

• indices - The indices of the element to get

Returns

The element at the specified indices

pub fn slice(&self, ranges: &[(usize, usize)]) -> CoreResult<Array<A, IxDyn>>

Get a subset of the array as a new array.

This will decompress only the blocks containing the subset.

Arguments

• ranges - The ranges of indices to get for each dimension

Returns

A new array containing the subset

pub fn process_blocks<F, R>(&self, f: F) -> CoreResult<Vec<R>>

where F: Fn(&[A], usize) -> R + Send + Sync + 'static, R: Send + 'static,

Process the array in blocks, with each block loaded and decompressed on demand.

This is useful for operations that can be performed on blocks independently.

Arguments

• f - A function that processes a block of elements

Returns

A vector of results, one for each block

pub fn process_blocks_with_size<F, R>( &self, blocksize: usize, f: F, ) -> CoreResult<Vec<R>>

where F: Fn(&[A], usize) -> R + Send + Sync + 'static, R: Send + 'static,

Process the array in blocks with a custom block size.

Arguments

• block_size - The block size to use (in elements)
• f - A function that processes a block of elements

Returns

A vector of results, one for each block

pub fn process_blocks_parallel<F, R>(&self, f: F) -> CoreResult<Vec<R>>

where F: Fn(&[A], usize) -> R + Send + Sync + 'static, R: Send + 'static,

Process the array in blocks in parallel.

Arguments

• f - A function that processes a block of elements

Returns

A vector of results, one for each block

pub fn process_blocks_parallel_with_size<F, R>( &self, block_size: usize, f: F, ) -> CoreResult<Vec<R>>

where F: Fn(&[A], usize) -> R + Send + Sync + 'static, R: Send + 'static,

Process the array in blocks in parallel with a custom block size.

Arguments

• block_size - The block size to use (in elements)
• f - A function that processes a block of elements

Returns

A vector of results, one for each block

Trait Implementations

impl<A: Debug + Clone + Copy + 'static + Send + Sync> Debug for PrefetchingCompressedArray<A>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<A> Deref for PrefetchingCompressedArray<A>

where A: Clone + Copy + 'static + Send + Sync,

Available on crate feature memory_compression only.

type Target = CompressedMemMappedArray<A>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<A: Clone + Copy + 'static + Send + Sync> Prefetching for PrefetchingCompressedArray<A>

Available on crate feature memory_compression only.

fn enable_prefetching(&mut self, config: PrefetchConfig) -> CoreResult<()>

Enable prefetching with the given configuration.

fn disable_prefetching(&mut self) -> CoreResult<()>

Disable prefetching.

fn prefetch_stats(&self) -> CoreResult<PrefetchStats>

Get the current prefetching statistics.

fn prefetch_block_by_idx_by_idx(&mut self, blockidx: usize) -> CoreResult<()>

Prefetch a specific block.

fn prefetch_indices(&mut self, indices: &[usize]) -> CoreResult<()>

Prefetch multiple blocks.

fn clear_prefetch_state(&mut self) -> CoreResult<()>

Clear the prefetching state.