GitLab

Sometimes, converting from long to double could cause errors. We added
an assertion to avoid that, but my test didn't always trigger the
issue. So I disabled it.

Mistakenly, the previous version would write the wrong event value in
the case of overflow.

I want to have it included because it's what we would like to do
regression against!

If there's an overflow, the counter is silently reset. I added a test
that should trigger. Running another experiment afterwards should
still work!

It's generated and machine specific, so we should not track it.

We test the libraries that we use work as we expect them.

I guess these tests might probably be in the dependencies repos
themselves but I just don't know how to do that.

Added tests to expose bugs in running experiments several times in a
row, and fixed them.

Some tests failed because the way we handle counters wasn't correct.

A bit more thorough, you test they start/stop correctly.

Fixed the tests and usage of PAPI so it works on timed collections.

Throws an exception if you start counting without initializing.

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

I updated the client code to use the new API.

Instead of just printing, we allow people to access the information
programmatically too.

The unsupported events are just dropped now.

No need to manually call "accept" on the features, that's kinda ugly

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).

The name of method selection strategy wasn't interned. Causing the
multiplication of strings containing "BRAINY".

I suspect a memory leak is due to that library not being updated.

I /think/ this helps with a memory leak, you can garbage collect the
results of an experiment as soon as you have consumed it, instead of
keeping it in memory. I'm not certain that's very important, though,
cause we don't store that many elements...

We don't want the stream to be parallel by mistake, that would destroy
the measurements.

There are a lot of strings which are actually the same string, except
the JVM stores the same data in two different objects. I used intern()
to try to make sure it's the same objects that is used if we've already
seen that string before.

I'm doing this, hoping that it prevents problems memory leaks in the
when writing the feature vectors to a file.

The sklearn original version doesn't take fresh benchmarks, while this
function does. It makes sure to use benchmarks in the test set which
are not present at all in the training set.

We still get roughly 70% accuracy with some small test data, that's encouraging!

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

We track my version instead, with fixes (memory leaks)

We forgot to free the eventSets we were creating, now when the EventSet
object is garbage collected, we also destroy the underlying PAPI
EventSet.

Brainy uses ANNs, so we should too. Note: Random Forest yield better
results.

We validate in the functions that use this data already.

We also expect the iteration number for the sample.

If you consider all the duplicates, of course it doesn't work.

If we used a "Tracer" collection, the name would end up in the printed
output. We implement a function that removes that, so that it looks like
we used one of the normal collections.

We don't need to clean the eventSets if we used the same set at the
previous Spec

Not strictly necessary, since we don't use the generated EventSet in
Experiment. But might be useful later.

This is better because you don't need to allocate ALL the benchmarks
before benchmarking them!

Otherwise, you also have the non-normalized features included, and you'd
have to filter them out when doing the training, which I don't really
want to do.

We want to run with a heap big enough, otherwise we just do garbage collection...