zipatch-rs 1.5.0

Parser for FFXIV ZiPatch patch files
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178

//! CPU-bound benchmark for `ZiPatchReader` chunk parsing.
//!
//! Builds a synthetic in-memory patch once outside the timed region and
//! measures the cost of iterating it to completion. The patch mixes several
//! chunk tags (FHDR, APLY, ADIR, DDIR, four SQPK sub-commands, EOF_) to
//! exercise the dispatcher rather than a single hot path. CRC32 verification
//! is left enabled so the bench reflects the default `apply_to` workload.
//!
//! Run with `cargo bench --bench parse --all-features`.

use std::hint::black_box;
use std::io::Cursor;

use criterion::{BenchmarkId, Criterion, Throughput, criterion_group, criterion_main};
use zipatch_rs::ZiPatchReader;
use zipatch_rs::test_utils::{make_chunk, make_patch};

/// How many copies of the mixed-chunk block to repeat in each synthetic patch.
///
/// One iteration of `mixed_chunks` produces eight non-EOF chunks; the patch
/// frames a multiple of that, terminated by a single EOF_. The sweep covers
/// small, medium, and large in-memory streams without slipping into
/// allocator-noise territory.
const REPEATS: &[usize] = &[1, 16, 256];

/// Build one round of mixed chunk frames covering the dispatch arms most
/// commonly seen in real patch files (FHDR/APLY/SQPK) plus the rarer
/// directory-management tags (ADIR/DDIR).
fn mixed_chunks() -> Vec<Vec<u8>> {
    vec![
        make_chunk(b"FHDR", &fhdr_v2_body()),
        make_chunk(b"APLY", &aply_body(1, false)),
        make_chunk(b"ADIR", &dir_body(b"sqpack/ffxiv")),
        make_chunk(b"DELD", &dir_body(b"sqpack/ex1")),
        make_chunk(b"SQPK", &sqpk_target_info_body()),
        make_chunk(b"SQPK", &sqpk_delete_data_body()),
        make_chunk(b"SQPK", &sqpk_expand_data_body()),
        make_chunk(b"SQPK", &sqpk_file_makedir_body(b"sqpack/ex2")),
    ]
}

/// FHDR v2 body. The 32-bit version word is little-endian; the v2 fields are
/// big-endian. The trailing 8 zero bytes are bounded by the body slice and
/// ignored by the parser.
fn fhdr_v2_body() -> Vec<u8> {
    let mut out = Vec::with_capacity(20);
    // version = 2 lives in bits 16..23 of a little-endian u32: 0x0002_0000.
    out.extend_from_slice(&0x0002_0000u32.to_le_bytes());
    out.extend_from_slice(b"D000"); // patch_type
    out.extend_from_slice(&1u32.to_be_bytes()); // entry_files
    out.extend_from_slice(&[0u8; 8]); // trailing zeros — ignored
    out
}

/// APLY body: `[kind: u32 BE] [pad: 4] [value: u32 BE, non-zero = true]`.
fn aply_body(kind: u32, value: bool) -> Vec<u8> {
    let mut out = Vec::with_capacity(12);
    out.extend_from_slice(&kind.to_be_bytes());
    out.extend_from_slice(&[0u8; 4]);
    out.extend_from_slice(&u32::from(value).to_be_bytes());
    out
}

/// Shared `[name_len: u32 BE] [name]` body used by both ADIR and DELD.
fn dir_body(name: &[u8]) -> Vec<u8> {
    let mut out = Vec::with_capacity(4 + name.len());
    let name_len = u32::try_from(name.len()).expect("bench name fits in u32");
    out.extend_from_slice(&name_len.to_be_bytes());
    out.extend_from_slice(name);
    out
}

/// SQPK chunk body wrapping a `T` (target info) sub-command.
fn sqpk_target_info_body() -> Vec<u8> {
    let mut cmd = Vec::with_capacity(27);
    cmd.extend_from_slice(&[0u8; 3]); // reserved
    cmd.extend_from_slice(&0u16.to_be_bytes()); // platform_id = Win32
    cmd.extend_from_slice(&(-1i16).to_be_bytes()); // region = Global
    cmd.extend_from_slice(&0i16.to_be_bytes()); // is_debug = false
    cmd.extend_from_slice(&0u16.to_be_bytes()); // version
    cmd.extend_from_slice(&0u64.to_le_bytes()); // deleted_data_size (LE)
    cmd.extend_from_slice(&0u64.to_le_bytes()); // seek_count (LE)
    wrap_sqpk(b'T', &cmd)
}

/// SQPK `D` (delete data) sub-command body.
fn sqpk_delete_data_body() -> Vec<u8> {
    let mut cmd = Vec::with_capacity(23);
    cmd.extend_from_slice(&[0u8; 3]); // alignment
    cmd.extend_from_slice(&0u16.to_be_bytes()); // main_id
    cmd.extend_from_slice(&0u16.to_be_bytes()); // sub_id
    cmd.extend_from_slice(&0u32.to_be_bytes()); // file_id
    cmd.extend_from_slice(&0u32.to_be_bytes()); // block_offset_raw
    cmd.extend_from_slice(&1u32.to_be_bytes()); // block_count
    cmd.extend_from_slice(&[0u8; 4]); // reserved
    wrap_sqpk(b'D', &cmd)
}

/// SQPK `E` (expand data) sub-command body — same layout as `D`.
fn sqpk_expand_data_body() -> Vec<u8> {
    let mut cmd = Vec::with_capacity(23);
    cmd.extend_from_slice(&[0u8; 3]);
    cmd.extend_from_slice(&0u16.to_be_bytes());
    cmd.extend_from_slice(&0u16.to_be_bytes());
    cmd.extend_from_slice(&0u32.to_be_bytes());
    cmd.extend_from_slice(&0u32.to_be_bytes());
    cmd.extend_from_slice(&1u32.to_be_bytes());
    cmd.extend_from_slice(&[0u8; 4]);
    wrap_sqpk(b'E', &cmd)
}

/// SQPK `F` (file) sub-command with operation `M` (make-dir-tree) — no inline
/// block payloads, so the body stays small and the parser stays on the
/// dispatch path rather than block decoding.
fn sqpk_file_makedir_body(path: &[u8]) -> Vec<u8> {
    let mut path_bytes = path.to_vec();
    path_bytes.push(0); // NUL terminator
    let path_len = u32::try_from(path_bytes.len()).expect("bench path fits in u32");

    let mut cmd = Vec::with_capacity(27 + path_bytes.len());
    cmd.push(b'M'); // operation = MakeDirTree
    cmd.extend_from_slice(&[0u8; 2]); // alignment
    cmd.extend_from_slice(&0u64.to_be_bytes()); // file_offset
    cmd.extend_from_slice(&0u64.to_be_bytes()); // file_size
    cmd.extend_from_slice(&path_len.to_be_bytes());
    cmd.extend_from_slice(&0u16.to_be_bytes()); // expansion_id
    cmd.extend_from_slice(&[0u8; 2]); // padding
    cmd.extend_from_slice(&path_bytes);
    wrap_sqpk(b'F', &cmd)
}

/// Frame an SQPK sub-command into the outer chunk body: 4-byte `inner_size`
/// BE prefix + 1-byte command tag + sub-command bytes.
fn wrap_sqpk(command: u8, cmd_body: &[u8]) -> Vec<u8> {
    let inner_size = 5 + cmd_body.len();
    let inner_size_u32 = u32::try_from(inner_size).expect("bench SQPK body fits in u32");
    let mut out = Vec::with_capacity(inner_size);
    out.extend_from_slice(&inner_size_u32.to_be_bytes());
    out.push(command);
    out.extend_from_slice(cmd_body);
    out
}

/// Assemble `repeat` copies of the mixed chunk block, terminated by `EOF_`.
fn build_patch(repeat: usize) -> Vec<u8> {
    let one_round = mixed_chunks();
    let mut chunks: Vec<Vec<u8>> = Vec::with_capacity(one_round.len() * repeat + 1);
    for _ in 0..repeat {
        chunks.extend(one_round.iter().cloned());
    }
    chunks.push(make_chunk(b"EOF_", &[]));
    make_patch(&chunks)
}

fn bench_parse(c: &mut Criterion) {
    let mut group = c.benchmark_group("parse/mixed");
    for &repeat in REPEATS {
        let patch = build_patch(repeat);
        group.throughput(Throughput::Bytes(patch.len() as u64));
        group.bench_with_input(BenchmarkId::from_parameter(repeat), &patch, |b, patch| {
            b.iter(|| {
                let reader =
                    ZiPatchReader::new(Cursor::new(patch.as_slice())).expect("magic is valid");
                let mut count = 0usize;
                for chunk in reader {
                    let chunk = chunk.expect("synthetic patch parses cleanly");
                    black_box(&chunk);
                    count += 1;
                }
                black_box(count);
            });
        });
    }
    group.finish();
}

criterion_group!(benches, bench_parse);
criterion_main!(benches);