Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

bench: Add more bench cases #298

Merged
merged 1 commit into from
Dec 23, 2024
Merged

bench: Add more bench cases #298

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
166 changes: 162 additions & 4 deletions serde_amqp/benches/serialize.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -177,10 +177,6 @@ fn criterion_benchmark(c: &mut Criterion) {
b.iter(|| serde_amqp::to_vec(black_box(&value)).unwrap())
});

// Symbol is very similar to String, so we don't benchmark it.

// TODO: How to bench list, map, and array? Define number of items or bytes?

// 16 bytes of u64
let mut value = vec![0u64; 16 / std::mem::size_of::<u64>()];
rand::thread_rng().fill(&mut value[..]);
Expand Down Expand Up @@ -286,6 +282,168 @@ fn criterion_benchmark(c: &mut Criterion) {
c.bench_function("serialize List<String> 10x1MB", |b| {
b.iter(|| serde_amqp::to_vec(black_box(&value)).unwrap())
});

// 10 Random strings of size between 16B and 1kB
let value = (0..10)
.map(|_| {
let size = rand::thread_rng().gen_range(16..1024);
Alphanumeric.sample_string(&mut rand::thread_rng(), size)
})
.map(String::from)
.collect::<Vec<_>>();
c.bench_function("serialize List<String> 10x16B-10kB", |b| {
b.iter(|| serde_amqp::to_vec(black_box(&value)).unwrap())
});

// 100 Random strings of size between 16B and 1kB
let value = (0..100)
.map(|_| {
let size = rand::thread_rng().gen_range(16..1024);
Alphanumeric.sample_string(&mut rand::thread_rng(), size)
})
.map(String::from)
.collect::<Vec<_>>();
c.bench_function("serialize List<String> 100x16B-10kB", |b| {
b.iter(|| serde_amqp::to_vec(black_box(&value)).unwrap())
});

// 1000 Random strings of size between 16B and 1kB
let value = (0..1000)
.map(|_| {
let size = rand::thread_rng().gen_range(16..1024);
Alphanumeric.sample_string(&mut rand::thread_rng(), size)
})
.map(String::from)
.collect::<Vec<_>>();
c.bench_function("serialize List<String> 1000x16B-10kB", |b| {
b.iter(|| serde_amqp::to_vec(black_box(&value)).unwrap())
});

// Map of 10 u64 -> u64
let value = (0..10)
.map(|_| {
let key = rand::random::<u64>();
let value = rand::random::<u64>();
(key, value)
})
.collect::<std::collections::HashMap<_, _>>();
c.bench_function("serialize Map<u64, u64> 10", |b| {
b.iter(|| serde_amqp::to_vec(black_box(&value)).unwrap())
});

// Map of 100 u64 -> u64
let value = (0..100)
.map(|_| {
let key = rand::random::<u64>();
let value = rand::random::<u64>();
(key, value)
})
.collect::<std::collections::HashMap<_, _>>();
c.bench_function("serialize Map<u64, u64> 100", |b| {
b.iter(|| serde_amqp::to_vec(black_box(&value)).unwrap())
});

// Map of 1000 u64 -> u64
let value = (0..1000)
.map(|_| {
let key = rand::random::<u64>();
let value = rand::random::<u64>();
(key, value)
})
.collect::<std::collections::HashMap<_, _>>();
c.bench_function("serialize Map<u64, u64> 1000", |b| {
b.iter(|| serde_amqp::to_vec(black_box(&value)).unwrap())
});

// Map of 10 16B String -> 16B String
let value = (0..10)
.map(|_| {
let key = Alphanumeric.sample_string(&mut rand::thread_rng(), 16);
let key = String::from(key);
let value = Alphanumeric.sample_string(&mut rand::thread_rng(), 16);
let value = String::from(value);
(key, value)
})
.collect::<std::collections::HashMap<_, _>>();
c.bench_function("serialize Map<String, String> 10x16B", |b| {
b.iter(|| serde_amqp::to_vec(black_box(&value)).unwrap())
});

// Map of 100 16B String -> 16B String
let value = (0..100)
.map(|_| {
let key = Alphanumeric.sample_string(&mut rand::thread_rng(), 16);
let key = String::from(key);
let value = Alphanumeric.sample_string(&mut rand::thread_rng(), 16);
let value = String::from(value);
(key, value)
})
.collect::<std::collections::HashMap<_, _>>();
c.bench_function("serialize Map<String, String> 100x16B", |b| {
b.iter(|| serde_amqp::to_vec(black_box(&value)).unwrap())
});

// Map of 1000 16B String -> 16B String
let value = (0..1000)
.map(|_| {
let key = Alphanumeric.sample_string(&mut rand::thread_rng(), 16);
let key = String::from(key);
let value = Alphanumeric.sample_string(&mut rand::thread_rng(), 16);
let value = String::from(value);
(key, value)
})
.collect::<std::collections::HashMap<_, _>>();
c.bench_function("serialize Map<String, String> 1000x16B", |b| {
b.iter(|| serde_amqp::to_vec(black_box(&value)).unwrap())
});

// Map of 10 random String (16B-1kB) -> random String (16B-1kB)
let value = (0..10)
.map(|_| {
let key_size = rand::thread_rng().gen_range(16..1024);
let key = Alphanumeric.sample_string(&mut rand::thread_rng(), key_size);
let key = String::from(key);
let value_size = rand::thread_rng().gen_range(16..1024);
let value = Alphanumeric.sample_string(&mut rand::thread_rng(), value_size);
let value = String::from(value);
(key, value)
})
.collect::<std::collections::HashMap<_, _>>();
c.bench_function("serialize Map<String, String> 10x16B-1kB", |b| {
b.iter(|| serde_amqp::to_vec(black_box(&value)).unwrap())
});

// Map of 100 random String (16B-1kB) -> random String (16B-1kB)
let value = (0..100)
.map(|_| {
let key_size = rand::thread_rng().gen_range(16..1024);
let key = Alphanumeric.sample_string(&mut rand::thread_rng(), key_size);
let key = String::from(key);
let value_size = rand::thread_rng().gen_range(16..1024);
let value = Alphanumeric.sample_string(&mut rand::thread_rng(), value_size);
let value = String::from(value);
(key, value)
})
.collect::<std::collections::HashMap<_, _>>();
c.bench_function("serialize Map<String, String> 100x16B-1kB", |b| {
b.iter(|| serde_amqp::to_vec(black_box(&value)).unwrap())
});

// Map of 1000 random String (16B-1kB) -> random String (16B-1kB)
let value = (0..1000)
.map(|_| {
let key_size = rand::thread_rng().gen_range(16..1024);
let key = Alphanumeric.sample_string(&mut rand::thread_rng(), key_size);
let key = String::from(key);
let value_size = rand::thread_rng().gen_range(16..1024);
let value = Alphanumeric.sample_string(&mut rand::thread_rng(), value_size);
let value = String::from(value);
(key, value)
})
.collect::<std::collections::HashMap<_, _>>();
c.bench_function("serialize Map<String, String> 1000x16B-1kB", |b| {
b.iter(|| serde_amqp::to_vec(black_box(&value)).unwrap())
});
}

criterion_group!(benches, criterion_benchmark);
Expand Down
Loading