Struct File 

pub struct File { /* private fields */ }

A file opened collectively by a communicator (MPI_File).

Implementations

impl File

pub fn open<C: Communicator>( comm: &C, path: impl AsRef<Path>, mode: u32, ) -> Result<File>

Collectively open path with the given mode flags (MPI_File_open).

Examples found in repository

examples/parallel_io.rs (lines 16-20)

fn main() {
    let universe = mpi::initialize().unwrap();
    let world = universe.world();
    let rank = world.rank();
    let size = world.size();

    // Path depends on world size so concurrent jobs of different sizes don't
    // collide; identical across the ranks of a single job.
    let path = std::env::temp_dir().join(format!("mpi_no_c_io_{size}.bin"));
    let mut f = File::open(
        &world,
        &path,
        MODE_CREATE | MODE_RDWR | MODE_DELETE_ON_CLOSE,
    )
    .expect("File::open failed");

    let block = [rank * 100, rank * 100 + 1, rank * 100 + 2, rank * 100 + 3];
    f.write_at_all(rank as u64 * 16, &block)
        .expect("write failed");

    if rank == 0 {
        for r in 0..size {
            let mut buf = [0i32; 4];
            f.read_at(r as u64 * 16, &mut buf).expect("read failed");
            assert_eq!(
                buf,
                [r * 100, r * 100 + 1, r * 100 + 2, r * 100 + 3],
                "I/O block mismatch"
            );
        }
        println!("IO PASS: parallel write/read verified on {size} ranks.");
    }

    world.barrier();
    // File is deleted on close (drop).
}

pub fn write_at<T: Equivalence>( &mut self, offset: u64, data: &[T], ) -> Result<()>

Write data at byte offset (MPI_File_write_at).

pub fn read_at<T: Equivalence>( &mut self, offset: u64, buf: &mut [T], ) -> Result<()>

Read into buf from byte offset (MPI_File_read_at).

Examples found in repository

examples/parallel_io.rs (line 30)

fn main() {
    let universe = mpi::initialize().unwrap();
    let world = universe.world();
    let rank = world.rank();
    let size = world.size();

    // Path depends on world size so concurrent jobs of different sizes don't
    // collide; identical across the ranks of a single job.
    let path = std::env::temp_dir().join(format!("mpi_no_c_io_{size}.bin"));
    let mut f = File::open(
        &world,
        &path,
        MODE_CREATE | MODE_RDWR | MODE_DELETE_ON_CLOSE,
    )
    .expect("File::open failed");

    let block = [rank * 100, rank * 100 + 1, rank * 100 + 2, rank * 100 + 3];
    f.write_at_all(rank as u64 * 16, &block)
        .expect("write failed");

    if rank == 0 {
        for r in 0..size {
            let mut buf = [0i32; 4];
            f.read_at(r as u64 * 16, &mut buf).expect("read failed");
            assert_eq!(
                buf,
                [r * 100, r * 100 + 1, r * 100 + 2, r * 100 + 3],
                "I/O block mismatch"
            );
        }
        println!("IO PASS: parallel write/read verified on {size} ranks.");
    }

    world.barrier();
    // File is deleted on close (drop).
}

pub fn write_at_all<T: Equivalence>( &mut self, offset: u64, data: &[T], ) -> Result<()>

Collective write at an explicit offset (MPI_File_write_at_all).

Examples found in repository

examples/parallel_io.rs (line 24)

fn main() {
    let universe = mpi::initialize().unwrap();
    let world = universe.world();
    let rank = world.rank();
    let size = world.size();

    // Path depends on world size so concurrent jobs of different sizes don't
    // collide; identical across the ranks of a single job.
    let path = std::env::temp_dir().join(format!("mpi_no_c_io_{size}.bin"));
    let mut f = File::open(
        &world,
        &path,
        MODE_CREATE | MODE_RDWR | MODE_DELETE_ON_CLOSE,
    )
    .expect("File::open failed");

    let block = [rank * 100, rank * 100 + 1, rank * 100 + 2, rank * 100 + 3];
    f.write_at_all(rank as u64 * 16, &block)
        .expect("write failed");

    if rank == 0 {
        for r in 0..size {
            let mut buf = [0i32; 4];
            f.read_at(r as u64 * 16, &mut buf).expect("read failed");
            assert_eq!(
                buf,
                [r * 100, r * 100 + 1, r * 100 + 2, r * 100 + 3],
                "I/O block mismatch"
            );
        }
        println!("IO PASS: parallel write/read verified on {size} ranks.");
    }

    world.barrier();
    // File is deleted on close (drop).
}

pub fn read_at_all<T: Equivalence>( &mut self, offset: u64, buf: &mut [T], ) -> Result<()>

Collective read at an explicit offset (MPI_File_read_at_all).

pub fn size(&self) -> Result<u64>

The current file size in bytes (MPI_File_get_size).

pub fn set_size(&mut self, size: u64) -> Result<()>

Set the file size in bytes (MPI_File_set_size).

pub fn sync(&mut self) -> Result<()>

Flush buffered data to storage (MPI_File_sync).

pub fn close(self) -> Result<()>

Collectively close the file (MPI_File_close), deleting it if it was opened with MODE_DELETE_ON_CLOSE.

Trait Implementations

impl Drop for File

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.