131 lines
3.9 KiB
Rust
131 lines
3.9 KiB
Rust
use bencher::{benchmark_group, benchmark_main};
|
|
|
|
use std::io::{Cursor, Read, Seek, Write};
|
|
|
|
use bencher::Bencher;
|
|
use getrandom::getrandom;
|
|
use zip::{result::ZipResult, write::SimpleFileOptions, ZipArchive, ZipWriter};
|
|
|
|
fn generate_random_archive(
|
|
num_entries: usize,
|
|
entry_size: usize,
|
|
options: SimpleFileOptions,
|
|
) -> ZipResult<(usize, ZipArchive<Cursor<Vec<u8>>>)> {
|
|
let buf = Cursor::new(Vec::new());
|
|
let mut zip = ZipWriter::new(buf);
|
|
|
|
let mut bytes = vec![0u8; entry_size];
|
|
for i in 0..num_entries {
|
|
let name = format!("random{}.dat", i);
|
|
zip.start_file(name, options)?;
|
|
getrandom(&mut bytes).unwrap();
|
|
zip.write_all(&bytes)?;
|
|
}
|
|
|
|
let buf = zip.finish()?.into_inner();
|
|
let len = buf.len();
|
|
|
|
Ok((len, ZipArchive::new(Cursor::new(buf))?))
|
|
}
|
|
|
|
fn perform_merge<R: Read + Seek, W: Write + Seek>(
|
|
src: ZipArchive<R>,
|
|
mut target: ZipWriter<W>,
|
|
) -> ZipResult<ZipWriter<W>> {
|
|
target.merge_archive(src)?;
|
|
Ok(target)
|
|
}
|
|
|
|
fn perform_raw_copy_file<R: Read + Seek, W: Write + Seek>(
|
|
mut src: ZipArchive<R>,
|
|
mut target: ZipWriter<W>,
|
|
) -> ZipResult<ZipWriter<W>> {
|
|
for i in 0..src.len() {
|
|
let entry = src.by_index(i)?;
|
|
target.raw_copy_file(entry)?;
|
|
}
|
|
Ok(target)
|
|
}
|
|
|
|
const NUM_ENTRIES: usize = 100;
|
|
const ENTRY_SIZE: usize = 1024;
|
|
|
|
fn merge_archive_stored(bench: &mut Bencher) {
|
|
let options = SimpleFileOptions::default().compression_method(zip::CompressionMethod::Stored);
|
|
let (len, src) = generate_random_archive(NUM_ENTRIES, ENTRY_SIZE, options).unwrap();
|
|
|
|
bench.bytes = len as u64;
|
|
|
|
bench.iter(|| {
|
|
let buf = Cursor::new(Vec::new());
|
|
let zip = ZipWriter::new(buf);
|
|
let zip = perform_merge(src.clone(), zip).unwrap();
|
|
let buf = zip.finish().unwrap().into_inner();
|
|
assert_eq!(buf.len(), len);
|
|
});
|
|
}
|
|
|
|
#[cfg(feature = "_deflate-any")]
|
|
fn merge_archive_compressed(bench: &mut Bencher) {
|
|
let options = SimpleFileOptions::default().compression_method(zip::CompressionMethod::Deflated);
|
|
let (len, src) = generate_random_archive(NUM_ENTRIES, ENTRY_SIZE, options).unwrap();
|
|
|
|
bench.bytes = len as u64;
|
|
|
|
bench.iter(|| {
|
|
let buf = Cursor::new(Vec::new());
|
|
let zip = ZipWriter::new(buf);
|
|
let zip = perform_merge(src.clone(), zip).unwrap();
|
|
let buf = zip.finish().unwrap().into_inner();
|
|
assert_eq!(buf.len(), len);
|
|
});
|
|
}
|
|
|
|
fn merge_archive_raw_copy_file_stored(bench: &mut Bencher) {
|
|
let options = SimpleFileOptions::default().compression_method(zip::CompressionMethod::Stored);
|
|
let (len, src) = generate_random_archive(NUM_ENTRIES, ENTRY_SIZE, options).unwrap();
|
|
|
|
bench.bytes = len as u64;
|
|
|
|
bench.iter(|| {
|
|
let buf = Cursor::new(Vec::new());
|
|
let zip = ZipWriter::new(buf);
|
|
let zip = perform_raw_copy_file(src.clone(), zip).unwrap();
|
|
let buf = zip.finish().unwrap().into_inner();
|
|
assert_eq!(buf.len(), len);
|
|
});
|
|
}
|
|
|
|
#[cfg(feature = "_deflate-any")]
|
|
fn merge_archive_raw_copy_file_compressed(bench: &mut Bencher) {
|
|
let options = SimpleFileOptions::default().compression_method(zip::CompressionMethod::Deflated);
|
|
let (len, src) = generate_random_archive(NUM_ENTRIES, ENTRY_SIZE, options).unwrap();
|
|
|
|
bench.bytes = len as u64;
|
|
|
|
bench.iter(|| {
|
|
let buf = Cursor::new(Vec::new());
|
|
let zip = ZipWriter::new(buf);
|
|
let zip = perform_raw_copy_file(src.clone(), zip).unwrap();
|
|
let buf = zip.finish().unwrap().into_inner();
|
|
assert_eq!(buf.len(), len);
|
|
});
|
|
}
|
|
|
|
#[cfg(feature = "_deflate-any")]
|
|
benchmark_group!(
|
|
benches,
|
|
merge_archive_stored,
|
|
merge_archive_compressed,
|
|
merge_archive_raw_copy_file_stored,
|
|
merge_archive_raw_copy_file_compressed,
|
|
);
|
|
|
|
#[cfg(not(feature = "_deflate-any"))]
|
|
benchmark_group!(
|
|
benches,
|
|
merge_archive_stored,
|
|
merge_archive_raw_copy_file_stored,
|
|
);
|
|
|
|
benchmark_main!(benches);
|