Concurrent Memory Allocator Benchmarks
Emery Berger <emery@cs.umass.edu>
http://www.cs.umass.edu/~emery
This is the suite of concurrent benchmarks used in the paper "Hoard: A
Scalable Memory Allocator for Multithreaded Applications". If you use
these benchmarks, please cite that paper as follows:
@inproceedings{Berger:2000:HSM:378993.379232,
author = {Berger, Emery D. and McKinley, Kathryn S. and Blumofe, Robert D. and Wilson, Paul R.},
title = {Hoard: a scalable memory allocator for multithreaded applications},
booktitle = {Proceedings of the ninth international conference on Architectural support for programming languages and operating systems},
series = {ASPLOS-IX},
year = {2000},
isbn = {1-58113-317-0},
location = {Cambridge, Massachusetts, United States},
pages = {117--128},
numpages = {12},
url = {http://doi.acm.org/10.1145/378993.379232},
doi = {http://doi.acm.org/10.1145/378993.379232},
acmid = {379232},
publisher = {ACM},
address = {New York, NY, USA},
}
Here is a brief description of the benchmarks, including usage and
sample parameters. P denotes the number of processors (cores) in your
system.
* cache-scratch:
This benchmark is referred to in the paper as "passive-false", and
tests resilience against passive false sharing (see the paper for
details).
Parameters: <threads> <inner-loop> <object-size> <iterations>
% cache-scratch 1 100 8 1000000
% cache-scratch P 100 8 1000000
* cache-thrash:
This benchmark is referred to in the paper as "active-false", and
also tests resilience against active false sharing (see the paper
for details).
It uses the same parameters as cache-scratch.
* larson:
This benchmark is courtesy of Paul Larson at Microsoft Research. It
simulates a server: each thread allocates and deallocates objects,
and then transfers some objects (randomly selected) to other threads
to be freed.
Parameters: (from the command line)
<seconds> <min-obj-size> <max-obj-size> <objects> <iterations> <rng seed> <num-threads>
Suggested parameters: ./larson 10 7 8 1000 10000 1 P
* shbench:
A benchmark where each thread allocates and randomly frees a number
of random-sized objects.
You may download the source from:
http://www.microquill.com/smartheap/shbench/bench.zip
NOTE: this benchmark differs from the one used in the Hoard paper,
but it is unfortunately not possible to include that code here.
* threadtest:
A basic benchmark that measures raw per-thread allocation
throughput: each thread repeatedly allocates and then deallocates
100,000/P objects.
Parameters: <number-of-threads> <iterations> <num-objects> <work-interval> <object-size>
% threadtest P 1000 10000 0 8
Additional benchmarks not in the original Hoard paper:
* linux-scalability:
This benchmark from the University of Michigan also tests allocator
throughput.
Parameters: <object-size> <iterations> <number-of-threads>
Example: 8 10000000 P