Add infrastructure to allow slf4j debugging from native code
Add some caching to doTransactionally, and disabled API for the time being

There are still some issues with warmup of called methods during a transaction, so for the time
being doTransactionally is being disabled, as it never works with the buffers available on
current haswell hw.
Warmup JNI methods before usage

With this change, using begin()/commit() works on haswell hw buffers.
Accout for capacity aborts in Test, and also tweak output
gitignore updates
Added some extra tests
Started test migration to junit
Bugfix: Do not warmup methods if RTM is not available
Improve warmup of javartm methods

Added enough warmup iterations to also give the JVM a chance to JIT the methods inside Transaction.
Switch native code to c99
Add rtm flags to javartm_rtm_intrin.h
Modify begin to retry transactions that failed due to conflicts with another processor

Not entirely sure about the approach itself, see the comments in the code for more details.
Add class to help track transaction success statistics
Enhancements to Test5
Compile native code with -march=core-avx2

We're going to be running on (at least) haswell anyway.
Make javartm usage safe on non-rtm cpus

One of the use cases of javartm is that any app may use it, and use the Transaction.RTM_AVAILABLE
flag to trigger execution with javartm, or to decide how to fallback onto something else.

Nevertheless, if the application ignored the RTM_AVAILABLE flag and mistakenly invoked the javartm
functions, it would result in a VM segfault.

To avoid this, the native code part of javartm has been split into three libraries. The first is
libtestrtmsupport.so, that only includes the code that checks for rtm usage.
After checking for rtm support, the code decides if either libjavartm-dummy.so or libjavartm.so
are loaded; libjavartm-dummy.so just includes dummy implementations of the native code functions
that throw exceptions whenever they are used.

This way, older machines can never trigger the execution of rtm instructions on older machines,
making javartm usage safe.
Added missing copyright headers
Add new API with doTransactionally that relies on warming up transactions before use

Warming up transactions allows the JVM to JIT and do some initializations before code is run inside
a rtm transaction. Using this technique, we can call multiple methods inside a transaction and
still successfully commit on haswell's smallish rtm buffer.

API still work in progress.
Tweak doTransactionally API to retry transactions up to 10 times and return true if successful
Introduce new doTransactionally API, and port existing examples to use it