Avoid using object pinning in native blackhole (#132)

Re-implemented native blackhole without using object pinning as  
it affects performance and leads to unstable results as each time GC
has to spend more and more time scanning all pinned values.

Instead, primitive values consumption is implemented as a comparison
of the value for equality with two fields and publishing the value in case
when comparison succeeds. The values themselves are never the same and
one of the fields is volatile, thus the condition is always false and it
could not be omitted because of volatility. That should prevent both
dead code elimination and movement of the code computing the consumed
value into an effectively unreachable branch.

For the objects, identifyHashCode is used to obtain an int-value that
is then passed into a regular consumption routine. That function is an
intrinsic that simply gets an address of the object, so it has no
performance impact, yet it requires an object.

Fixes #114

Author: fzhinkin

runtime/nativeMain/src/kotlinx/benchmark/NativeBlackhole.kt

@@ -1,35 +1,90 @@
 package kotlinx.benchmark
 
-import kotlinx.cinterop.pin
+import kotlinx.cinterop.toByte
+import kotlin.concurrent.Volatile
+import kotlin.native.identityHashCode
+import kotlin.random.Random
 
+@OptIn(ExperimentalStdlibApi::class)
 actual class Blackhole {
-    actual fun consume(obj: Any?) {
-        obj?.pin()
+    @Volatile
+    var i0: Int = Random.nextInt()
+    var i1 = i0 + 1
+
+    @Volatile
+    var l0 = Random.nextLong()
+    var l1 = l0 + 1L
+
+    @Volatile
+    var f0 = Random.nextFloat()
+    var f1 = f0 + 1.0f
+
+    @Volatile
+    var d0 = Random.nextDouble()
+    var d1 = d0 + 1.0
+
+    @Volatile
+    var bh: Blackhole? = null
+
+    actual inline fun consume(obj: Any?) {
+        // identityHashCode is an intrinsic function
+        // resolved into getting an object address, so there will be no call.
+        consume(obj.identityHashCode())
     }
-    actual fun consume(bool: Boolean) {
-        bool.pin()
+
+    actual inline fun consume(bool: Boolean) {
+        consume(bool.toByte())
     }
-    actual fun consume(c: Char) {
-        c.pin()
+
+    actual inline fun consume(c: Char) {
+        consume(c.code)
     }
-    actual fun consume(b: Byte) {
-        b.pin()
+
+    actual inline fun consume(b: Byte) {
+        consume(b.toInt())
     }
-    actual fun consume(s: Short) {
-        s.pin()
+
+    actual inline fun consume(s: Short) {
+       consume(s.toInt())
     }
-    actual fun consume(i: Int) {
-        i.pin()
+
+    actual inline fun consume(i: Int) {
+        // To ensure that i's value will not be removed by optimizations like dead code elimination,
+        // its value is compares with two value i0 and i1, such that i1 = i0 + 1.
+        // As long as i0 and i1 are different, the following condition should not ever be met
+        // and as the branch following it (note that if it is executed, then NPE will happen).
+        // To ensure that at least i0 value will be loaded on every call, it was annotated with Volatile.
+        //
+        // This approach has one drawback: in general, it should be compiled to a code with two branch instructions,
+        // and performance characteristics of a benchmark may not be stable if consumed value is sometimes equal to i0.
+        // In practice, there is almost no effect on the measured performance and
+        // the difference is within the error margin.
+        // However, if it becomes a problem one day, then the condition should be rewritten to something like:
+        // if (((i0 xor i) and (i1 xor i)) == -1) { ... }
+        // We can't simply compare xor results as it could be optimized to comparison of i0 and i1 and i's evaluation
+        // may be sunk into the unreachable branch.
+        if ((i0 == i) && (i1 == i)) {
+            bh!!.i0 = i
+        }
     }
-    actual fun consume(l: Long) {
-        l.pin()
+
+    actual inline fun consume(l: Long) {
+        if ((l0 == l) && (l1 == l)) {
+            bh!!.l0 = l
+        }
     }
-    actual fun consume(f: Float) {
-        f.pin()
+
+    actual inline fun consume(f: Float) {
+        if ((f0 == f) && (f1 == f)) {
+            bh!!.f0 = f
+        }
     }
-    actual fun consume(d: Double) {
-        d.pin()
+
+    actual inline fun consume(d: Double) {
+        if ((d0 == d) && (d1 == d)) {
+            bh!!.d0 = d
+        }
     }
 }
 
-actual fun Blackhole.flush() = Unit
+actual fun Blackhole.flush() = Unit