The suffix mt=<value> refers to the measurement time used for the
benchmark.

Attempt at sampling much smaller measurement times to check the theoretical
lower limit.

The "runner" annotation is not necessary.

Replaced tabs with spaces

Makes it easier to get the configuration back when looking at data
files.

Benchmarks are ran with different measurement times, to compare how
error scales with measurement time.

Trying to investigate how measurement time influences the error of benchmarks

Enabled compilation with Java 9 to get nicer functions for manipulating
IntStreams.

The data file contains data for benchmark runs over seeds [0..100], for
all available data types.

Required to do some comparison.

This configuration was the one used previously for benchmarking with the JMH
plugin.

We are only interested in which data structure was the best for a given seed, so
we only keep the name of the data structure that gave the maximum throughput.

The ./gradle jmh task now runs the se.lth.cs.jmh.Main class instead of the usual
main class.

Test generates smaller applications so they run faster.

Package for the jmh-related components

Go with manual configuration instead

Link pointing the a file without the jmh plugin

This change is most likely temporary

The original jmhJar task did not work as expected.

Only methods which name starts with "run" are called during benchmarking.

Collection.remove() has two signatures, a toss-coin used to decide which one to
pick. Instead we use a method runRemove2 that runs the remove method, making the
conditional unnecessary.

Some methods of the Collection where never called during the benchmarks. Added
run* methods that do run the missing methods.

I wanted to initialize data structures with different sizes before running the
benchmark, so I implemented a method populate() that initialises a data
structure of the right size filled with random values.

'resultFormat' is the format in which the results are saved
'resultsFile' is the file in which the results are saved

This main does not seem to be accessible.

The benchmarks run generated applications for sets and maps.

The configuration used to be about gathering performance counters, but we now
use it for gathering running times, we therefore update the configuration of the
jmh benchmark harness, this configuration is temporary.

- Added parameters to the benchmark, did not rely on application generator
    - size: Size of the application, in number of method calls
    - seed: The seed to use for the random number generator for applications.
    - datastructure: The data structure to use.

This is done so that we can leverage JMH handling of parameters for running the
benchmarks.

- Added a blackhole object to avoid dead code elimination of the benchmark
  results

Changed return type of the benchmark() method to return to the blackhole object

Removed unnecessary imports

Moved Kotlin code from src/main/java to src/main/kotlin

Running the benchmarks many times gives different results, which stabilize
eventually.

Running the benchmarks twice gives different results.

The test was not deterministic.

The results of this test were not deterministic

Index generation for maps generated uniform random values on a massive range
that meant that Map applications would almost never call get() and get a result.
We generate index on twice the size of the map, so some get() calls find a
result, and some do not, which is slightly more realistic.

Previously, the samples of running time for each run of an application were
recorded in different columns. Instead we now use a column for the number of the
sample, and a column for the value of the sample. This requires copying data
over several lines, one for each sample of the application.

We have three runs of warmup before recording the data.

1000 runs was too many for benchmarking an application.
20 runs is a more "usual" value.

Benchmarks used to clear() the datastructure on which they were running, but now
they only create a new data structure to use instead. The existing one will be
garbage collected.