Struct IoTransferWindow 

pub struct IoTransferWindow<'session, 'board> { /* private fields */ }

A rolling VeriComm pipeline that keeps up to capacity transfers in flight.

All transfers in one window have the same word length chosen up front. Submit frames with Self::submit and retire them in order with Self::receive_into. Dropping the window cancels any remaining transfers and recycles their buffers back into the parent IoSession.

Implementations

impl<'session, 'board> IoTransferWindow<'session, 'board>

pub fn words(&self) -> usize

pub fn capacity(&self) -> usize

pub fn pending(&self) -> usize

pub fn available(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn is_full(&self) -> bool

pub fn submit(&mut self, tx: &[u16]) -> Result<()>

Queues one transfer into the rolling window.

Examples found in repository

examples/bench_transfer.rs (line 185)

fn run_device_bench(options: &Options) -> Result<(), Box<dyn Error>> {
    let mut board = Board::open_with_transport(options.transport)?;
    let max_cycles_per_transfer = usize::from(board.config().fifo_size_words()) / WORDS_PER_CYCLE;
    let mut io = board.configure_io(&IoConfig {
        clock_high_delay: options.clock_high_delay,
        clock_low_delay: options.clock_low_delay,
        ..IoConfig::default()
    })?;

    if options.window == 0 {
        return Err("window must be at least 1".into());
    }

    let template = vec![0x1234u16; options.words];
    let mut rx = vec![0u16; options.words];
    let mut outputs = vec![vec![0u16; options.words]; options.window];
    let mut stage_profile = TransferStageProfile::default();

    let started = Instant::now();
    if options.window == 1 {
        if options.profile_stages {
            for _ in 0..options.iterations {
                let profile = io.transfer_profiled_into(&template, &mut rx)?;
                stage_profile.merge(&profile);
            }
        } else {
            for _ in 0..options.iterations {
                io.transfer(&template, &mut rx)?;
            }
        }
    } else {
        let mut window = io.transfer_window(options.words, options.window)?;
        let initial = options.iterations.min(options.window);
        for _ in 0..initial {
            if options.profile_stages {
                let profile = window.submit_profiled(&template)?;
                stage_profile.merge(&profile);
            } else {
                window.submit(&template)?;
            }
        }

        let mut submitted = initial;
        let mut completed = 0usize;
        while completed < options.iterations {
            let output = outputs[completed % options.window].as_mut_slice();
            if options.profile_stages {
                let profile = window.receive_into_profiled(output)?;
                stage_profile.merge(&profile);
            } else {
                window.receive_into(output)?;
            }
            completed += 1;

            if submitted < options.iterations {
                if options.profile_stages {
                    let profile = window.submit_profiled(&template)?;
                    stage_profile.merge(&profile);
                } else {
                    window.submit(&template)?;
                }
                submitted += 1;
            }
        }
    }
    let elapsed = started.elapsed();
    io.finish()?;

    print_summary(
        "device",
        options.words,
        options.iterations,
        elapsed,
        Some(max_cycles_per_transfer),
    );
    if options.profile_stages {
        print_stage_profile(&stage_profile, elapsed);
    }
    Ok(())
}

examples/stress_abort.rs (line 74)

fn real_main() -> Result<(), Box<dyn Error>> {
    let mut iterations = 10usize;
    let mut words = 512usize;
    let mut window = 4usize;
    let mut clock_high = 4u16;
    let mut clock_low = 4u16;
    let mut settle_ms = 0u64;

    let mut args = env::args().skip(1);
    while let Some(flag) = args.next() {
        match flag.as_str() {
            "--iterations" => {
                iterations = args
                    .next()
                    .ok_or("missing value for --iterations")?
                    .parse()?
            }
            "--words" => words = args.next().ok_or("missing value for --words")?.parse()?,
            "--window" => window = args.next().ok_or("missing value for --window")?.parse()?,
            "--clock-high" => {
                clock_high = args
                    .next()
                    .ok_or("missing value for --clock-high")?
                    .parse()?
            }
            "--clock-low" => {
                clock_low = args
                    .next()
                    .ok_or("missing value for --clock-low")?
                    .parse()?
            }
            "--settle-ms" => {
                settle_ms = args
                    .next()
                    .ok_or("missing value for --settle-ms")?
                    .parse()?
            }
            other => return Err(format!("unknown flag `{other}`").into()),
        }
    }

    let tx = vec![0x1234u16; words];

    for iteration in 0..iterations {
        println!("iter={iteration} phase=open");
        let mut board = Board::open()?;
        println!(
            "iter={iteration} config programmed={} fifo_words={} version=0x{:04x}",
            board.config().is_programmed(),
            board.config().fifo_size_words(),
            board.config().smims_version_raw()
        );

        let mut io = board.configure_io(&IoConfig {
            clock_high_delay: clock_high,
            clock_low_delay: clock_low,
            ..IoConfig::default()
        })?;

        {
            let mut rolling = io.transfer_window(words, window)?;
            for submit_index in 0..window {
                rolling.submit(&tx)?;
                println!("iter={iteration} submit={submit_index}");
            }
            if settle_ms > 0 {
                thread::sleep(Duration::from_millis(settle_ms));
            }
        }

        io.finish()?;
        board.close()?;

        println!("iter={iteration} phase=reopen");
        let reopened = Board::open()?;
        println!(
            "iter={iteration} reopened programmed={} fifo_words={} version=0x{:04x}",
            reopened.config().is_programmed(),
            reopened.config().fifo_size_words(),
            reopened.config().smims_version_raw()
        );
        reopened.close()?;
    }

    Ok(())
}

pub fn submit_profiled(&mut self, tx: &[u16]) -> Result<TransferStageProfile>

Queues one transfer and returns a stage profile for that submission.

Examples found in repository

examples/bench_transfer.rs (line 182)

fn run_device_bench(options: &Options) -> Result<(), Box<dyn Error>> {
    let mut board = Board::open_with_transport(options.transport)?;
    let max_cycles_per_transfer = usize::from(board.config().fifo_size_words()) / WORDS_PER_CYCLE;
    let mut io = board.configure_io(&IoConfig {
        clock_high_delay: options.clock_high_delay,
        clock_low_delay: options.clock_low_delay,
        ..IoConfig::default()
    })?;

    if options.window == 0 {
        return Err("window must be at least 1".into());
    }

    let template = vec![0x1234u16; options.words];
    let mut rx = vec![0u16; options.words];
    let mut outputs = vec![vec![0u16; options.words]; options.window];
    let mut stage_profile = TransferStageProfile::default();

    let started = Instant::now();
    if options.window == 1 {
        if options.profile_stages {
            for _ in 0..options.iterations {
                let profile = io.transfer_profiled_into(&template, &mut rx)?;
                stage_profile.merge(&profile);
            }
        } else {
            for _ in 0..options.iterations {
                io.transfer(&template, &mut rx)?;
            }
        }
    } else {
        let mut window = io.transfer_window(options.words, options.window)?;
        let initial = options.iterations.min(options.window);
        for _ in 0..initial {
            if options.profile_stages {
                let profile = window.submit_profiled(&template)?;
                stage_profile.merge(&profile);
            } else {
                window.submit(&template)?;
            }
        }

        let mut submitted = initial;
        let mut completed = 0usize;
        while completed < options.iterations {
            let output = outputs[completed % options.window].as_mut_slice();
            if options.profile_stages {
                let profile = window.receive_into_profiled(output)?;
                stage_profile.merge(&profile);
            } else {
                window.receive_into(output)?;
            }
            completed += 1;

            if submitted < options.iterations {
                if options.profile_stages {
                    let profile = window.submit_profiled(&template)?;
                    stage_profile.merge(&profile);
                } else {
                    window.submit(&template)?;
                }
                submitted += 1;
            }
        }
    }
    let elapsed = started.elapsed();
    io.finish()?;

    print_summary(
        "device",
        options.words,
        options.iterations,
        elapsed,
        Some(max_cycles_per_transfer),
    );
    if options.profile_stages {
        print_stage_profile(&stage_profile, elapsed);
    }
    Ok(())
}

pub fn receive_into(&mut self, output: &mut [u16]) -> Result<()>

Retires the oldest in-flight transfer into output.

Examples found in repository

examples/bench_transfer.rs (line 197)

fn run_device_bench(options: &Options) -> Result<(), Box<dyn Error>> {
    let mut board = Board::open_with_transport(options.transport)?;
    let max_cycles_per_transfer = usize::from(board.config().fifo_size_words()) / WORDS_PER_CYCLE;
    let mut io = board.configure_io(&IoConfig {
        clock_high_delay: options.clock_high_delay,
        clock_low_delay: options.clock_low_delay,
        ..IoConfig::default()
    })?;

    if options.window == 0 {
        return Err("window must be at least 1".into());
    }

    let template = vec![0x1234u16; options.words];
    let mut rx = vec![0u16; options.words];
    let mut outputs = vec![vec![0u16; options.words]; options.window];
    let mut stage_profile = TransferStageProfile::default();

    let started = Instant::now();
    if options.window == 1 {
        if options.profile_stages {
            for _ in 0..options.iterations {
                let profile = io.transfer_profiled_into(&template, &mut rx)?;
                stage_profile.merge(&profile);
            }
        } else {
            for _ in 0..options.iterations {
                io.transfer(&template, &mut rx)?;
            }
        }
    } else {
        let mut window = io.transfer_window(options.words, options.window)?;
        let initial = options.iterations.min(options.window);
        for _ in 0..initial {
            if options.profile_stages {
                let profile = window.submit_profiled(&template)?;
                stage_profile.merge(&profile);
            } else {
                window.submit(&template)?;
            }
        }

        let mut submitted = initial;
        let mut completed = 0usize;
        while completed < options.iterations {
            let output = outputs[completed % options.window].as_mut_slice();
            if options.profile_stages {
                let profile = window.receive_into_profiled(output)?;
                stage_profile.merge(&profile);
            } else {
                window.receive_into(output)?;
            }
            completed += 1;

            if submitted < options.iterations {
                if options.profile_stages {
                    let profile = window.submit_profiled(&template)?;
                    stage_profile.merge(&profile);
                } else {
                    window.submit(&template)?;
                }
                submitted += 1;
            }
        }
    }
    let elapsed = started.elapsed();
    io.finish()?;

    print_summary(
        "device",
        options.words,
        options.iterations,
        elapsed,
        Some(max_cycles_per_transfer),
    );
    if options.profile_stages {
        print_stage_profile(&stage_profile, elapsed);
    }
    Ok(())
}

pub fn receive_into_profiled( &mut self, output: &mut [u16], ) -> Result<TransferStageProfile>

Retires the oldest in-flight transfer and returns its stage profile.

Examples found in repository

examples/bench_transfer.rs (line 194)

fn run_device_bench(options: &Options) -> Result<(), Box<dyn Error>> {
    let mut board = Board::open_with_transport(options.transport)?;
    let max_cycles_per_transfer = usize::from(board.config().fifo_size_words()) / WORDS_PER_CYCLE;
    let mut io = board.configure_io(&IoConfig {
        clock_high_delay: options.clock_high_delay,
        clock_low_delay: options.clock_low_delay,
        ..IoConfig::default()
    })?;

    if options.window == 0 {
        return Err("window must be at least 1".into());
    }

    let template = vec![0x1234u16; options.words];
    let mut rx = vec![0u16; options.words];
    let mut outputs = vec![vec![0u16; options.words]; options.window];
    let mut stage_profile = TransferStageProfile::default();

    let started = Instant::now();
    if options.window == 1 {
        if options.profile_stages {
            for _ in 0..options.iterations {
                let profile = io.transfer_profiled_into(&template, &mut rx)?;
                stage_profile.merge(&profile);
            }
        } else {
            for _ in 0..options.iterations {
                io.transfer(&template, &mut rx)?;
            }
        }
    } else {
        let mut window = io.transfer_window(options.words, options.window)?;
        let initial = options.iterations.min(options.window);
        for _ in 0..initial {
            if options.profile_stages {
                let profile = window.submit_profiled(&template)?;
                stage_profile.merge(&profile);
            } else {
                window.submit(&template)?;
            }
        }

        let mut submitted = initial;
        let mut completed = 0usize;
        while completed < options.iterations {
            let output = outputs[completed % options.window].as_mut_slice();
            if options.profile_stages {
                let profile = window.receive_into_profiled(output)?;
                stage_profile.merge(&profile);
            } else {
                window.receive_into(output)?;
            }
            completed += 1;

            if submitted < options.iterations {
                if options.profile_stages {
                    let profile = window.submit_profiled(&template)?;
                    stage_profile.merge(&profile);
                } else {
                    window.submit(&template)?;
                }
                submitted += 1;
            }
        }
    }
    let elapsed = started.elapsed();
    io.finish()?;

    print_summary(
        "device",
        options.words,
        options.iterations,
        elapsed,
        Some(max_cycles_per_transfer),
    );
    if options.profile_stages {
        print_stage_profile(&stage_profile, elapsed);
    }
    Ok(())
}

Trait Implementations

impl Drop for IoTransferWindow<'_, '_>

fn drop(&mut self)

Executes the destructor for this type.