Christoph implemented some optimizations to avoid stopping counters when
it's not needed

I updated the client code to use the new API.

I would create several eventSets before, that were not needed. Now I pass
the FeatureSet, and we use the EvenSetBuilder to make an eventSet based
on the FeatureSet. The EventSetBuilder caches eventSets, so it should
not build unnecessary eventSets. It should create only one for a full
run (they don't change often).

We check the time spent to run benchmarks doesn't increase with the
number of iterations.

addCounter should do things the smart way, so we use that.

I removed the parameters numRuns and counters from the constructor of
PapiRunner, this parameter is passed in the specs instead and as a
parameter of the specific functions that need it.

This is so I can pass a PapiRunner without the number of runs to an
Experiment and run it. Otherwise you might have to check the papiRunner
has the same number of runs than the Experiment...

PapiBenchmarkAnalyzer.RunSpec doesn't take
the number of iterations as a parameter anymore, as that's a parameter
of the runner itself (it was always the same value used anyway).

We use the PAPICounter type for specifying list of counters and stuff,
instead of the map of strings. This makes the code _MUCH BETTER_.

We add some fields to BCBenchmarkPackage and a test to make sure we
don't run a benchmark more than 1 time per iteration.

That way, we try the test with several different seeds.

We removed the need of a StopWatchRunner by making sure we only run the
benchmark once, even for getting the number of cycles per operation
type.

The papiRunner class now gathers all the counters in one single run.
For that, we need to gather a limited number of counters: PAPI_TOT_CYC +
PAPI_TOT_INS + max 2 counters.

Because we don't do any aggregation either, I needed to change the
functions so they return a list of values for each iteration.

The test fails depending of the Java version. Works with Java 11, but
not java 8. I disabled it because I haven't found how to make IntelliJ
use Java 8, it keeps using java 11.

We have a map of cycles per operation type, and we use in a function
that will run specifications, aggregate the number of cycles per each
method of that type, and return a list of triplets (run#, opType,
cycles).

Not needed, since we re-implemented runSpec directly.

Works similarly to how runSpec runs for a regular PapiRunner.

Updated smrt.jar because there are some methods we needed to reset the
tracer and set it's counters dynamically.

This PapiTracerRunner shares similarities with PapiRunner, so we make
an interface that contains stuff that's common to the two classes.

This was a bit of a test to see if it feels nice, and it does!

That way, we're a bit more certain that the output does make sense.

I corrected the assertions to match what was given. That's not
necessarily how you should do, but the data looked reasonable to me.

We updated smrt.jar so that we can change the variable JPAPI and
JPAPI_COUNTERS dynamically (after class initialization).

We also initialize PAPI if it's not initialized yet, before running
the tests.

The tests still fail because the conditions are incorrect, but it runs!

Currently fails, because what's printed is more than an empty string.