Struct MmapArray 

pub struct MmapArray<F: MmapElement> { /* private fields */ }

A zero-copy, file-backed ndarray with optional Copy-on-Write semantics.

The array is stored in a flat binary file with a 64-byte header. Array data is accessed via memmap2, so the OS manages paging automatically.

Type Parameter

F must implement MmapElement (currently: f32, f64, i32, i64).

Implementations

impl<F: MmapElement> MmapArray<F>

pub fn create(path: &Path, data: &Array<F, IxDyn>) -> Result<Self, MmapError>

Create a new memory-mapped file from an existing ndarray and return a read-write MmapArray backed by that file.

The input array must be in standard C-order (contiguous) layout. A 64-byte header is written first, followed immediately by the raw element bytes.

Errors

Returns MmapError::NonContiguous if data is not a contiguous array.

pub fn open_read_only(path: &Path) -> Result<Self, MmapError>

Open an existing .mmap file in read-only mode.

The returned array cannot be mutated; calls to view_mut will return MmapError::ReadOnly.

pub fn open_read_write(path: &Path) -> Result<Self, MmapError>

Open an existing .mmap file in read-write mode.

Mutations are written directly to the file (no buffering).

pub fn open_cow(path: &Path) -> Result<Self, MmapError>

Open an existing .mmap file in Copy-on-Write mode.

Reads are served zero-copy from the OS page cache. The first call to view_mut triggers a full copy of the data into RAM, after which all mutations happen in-memory. The original file is never modified unless you later call flush (which, in COW mode, is a no-op since there is no writable mapping to flush).

pub fn view(&self) -> Result<ArrayView<'_, F, IxDyn>, MmapError>

Return a read-only ndarray view.

For read-only and read-write modes, the view is zero-copy (backed by the mmap). For COW mode before any write, the view is also zero-copy. For COW mode after the first write, the view is backed by the in-RAM copy.

pub fn view_mut(&mut self) -> Result<ArrayViewMut<'_, F, IxDyn>, MmapError>

Return a mutable ndarray view.

• ReadOnly: always returns MmapError::ReadOnly.
• ReadWrite: the view is zero-copy and writes go directly to the file.
• COW: triggers a copy of the mmap data into RAM on the first call.

pub fn flush(&self) -> Result<(), MmapError>

Flush changes to disk.

• ReadWrite: calls MmapMut::flush().
• ReadOnly / COW: no-op (returns Ok(())).

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

Return the shape of the array.

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

Return the C-order strides (in element counts).

pub fn len(&self) -> usize

Return the total number of elements.

pub fn is_empty(&self) -> bool

Return true if the array has zero elements.

pub fn file_path(&self) -> &Path

Return the file path backing this array.

pub fn to_owned_array(&self) -> Result<Array<F, IxDyn>, MmapError>

Copy all elements into a heap-allocated Array<F, IxDyn>.

This always copies; it is equivalent to .view()?.to_owned().

Trait Implementations

impl<F: MmapElement> Debug for MmapArray<F>

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

Formats the value using the given formatter.