Enum ParallelDecode 

#[non_exhaustive]
pub enum ParallelDecode {
    Sequential,
    Bounded(NonZeroU64),
}

How much extra memory a 7z block may use to decode LZMA2 runs ahead on worker threads.

An LZMA2 stream written with multiple threads (7-Zip’s default for large inputs) consists of independent runs, so several can be decoded at once. Decoded runs wait in memory until the consumer reaches them, so the lookahead is bounded: Bounded(n) lets in-flight runs hold at most n bytes on top of the decoder window that max_decoder_memory already admits. Sequential decodes on the calling thread only.

Archives written with runs of a few MiB decode within about 10% of an unbounded multi-threaded reader at the default; a stock 7-Zip archive has 64 MiB runs and needs about 100 MiB of lookahead per extra concurrent run.

A valid archive decodes to the same bytes in either mode, and a corrupt one fails the same file with the same error kind; only how many leading bytes that file received can differ.

Concurrency

The limit applies to one extraction or verification. Each call may start up to 16 worker threads and hold its own lookahead, so concurrent calls (for example from several Python threads or Node promises) multiply both the threads and the memory. Size the setting for the number of calls that can run at once, or use Sequential.

Examples

use std::num::NonZeroU64;

use exarch_core::ParallelDecode;
use exarch_core::SecurityConfig;

assert_eq!(
    SecurityConfig::default().parallel_decode,
    ParallelDecode::Bounded(NonZeroU64::new(128 * 1024 * 1024).unwrap())
);
let config = SecurityConfig::default().with_parallel_decode(ParallelDecode::Sequential);
assert_eq!(config.parallel_decode, ParallelDecode::Sequential);

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Sequential

Decode on the calling thread only

Bounded(NonZeroU64)

Decode runs ahead on worker threads, holding at most this many bytes

Implementations

impl ParallelDecode

pub const DEFAULT_BYTES: NonZeroU64

Default lookahead: 128 MiB.

pub const fn lookahead(self) -> Option<NonZeroU64>

The lookahead memory in bytes, or None for Sequential.

Examples

use std::num::NonZeroU64;

use exarch_core::ParallelDecode;

assert_eq!(ParallelDecode::Sequential.lookahead(), None);
let bytes = NonZeroU64::new(1 << 20).unwrap();
assert_eq!(ParallelDecode::Bounded(bytes).lookahead(), Some(bytes));

Trait Implementations

impl Clone for ParallelDecode

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for ParallelDecode

impl Debug for ParallelDecode

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

Formats the value using the given formatter.

impl Default for ParallelDecode

fn default() -> Self

Returns the “default value” for a type.

impl Eq for ParallelDecode

impl From<Option<NonZero<u64>>> for ParallelDecode

fn from(lookahead: Option<NonZeroU64>) -> Self

None is ParallelDecode::Sequential.

impl PartialEq for ParallelDecode

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for ParallelDecode