Implement Blackhole

Author: Abduqodiri Qurbonzoda

examples/kotlin-multiplatform/src/commonMain/kotlin/CommonBenchmark.kt

@@ -50,4 +50,10 @@ class CommonBenchmark {
         return value
     }
 
+    @Benchmark
+    fun longBlackholeBenchmark(bh: Blackhole) {
+        repeat(1000) {
+            bh.consume(text.length)
+        }
+    }
 }

plugin/main/src/kotlinx/benchmark/gradle/SuiteSourceGenerator.kt

@@ -21,6 +21,7 @@ class SuiteSourceGenerator(val title: String, val module: ModuleDescriptor, val
         val setupFunctionName = "setUp"
         val teardownFunctionName = "tearDown"
         val parametersFunctionName = "parametrize"
+        val bindBlackholeFunctionName = "bind"
 
         val externalConfigurationFQN = "kotlinx.benchmark.ExternalConfiguration"
         val benchmarkAnnotationFQN = "kotlinx.benchmark.Benchmark"
@@ -36,6 +37,8 @@ class SuiteSourceGenerator(val title: String, val module: ModuleDescriptor, val
         val measureAnnotationFQN = "kotlinx.benchmark.Measurement"
         val paramAnnotationFQN = "kotlinx.benchmark.Param"
 
+        val blackholeFQN = "kotlinx.benchmark.Blackhole"
+
         val mainBenchmarkPackage = "kotlinx.benchmark.generated"
 
         val suppressUnusedParameter = AnnotationSpec.builder(Suppress::class).addMember("\"UNUSED_PARAMETER\"").build()
@@ -179,6 +182,28 @@ class SuiteSourceGenerator(val title: String, val module: ModuleDescriptor, val
                     }
                 }
 
+                val bhClass = ClassName.bestGuess(blackholeFQN)
+
+                /*
+                    private fun bind(function: CommonBenchmark.(Blackhole) -> Any?, bh: Blackhole): CommonBenchmark.() -> Any? {
+                        return { function(bh) }
+                    }
+                */
+                function(bindBlackholeFunctionName) {
+                    addModifiers(KModifier.PRIVATE)
+
+                    val bhParam = ParameterSpec.unnamed(bhClass)
+                    val bhBenchType = LambdaTypeName.get(originalClass, listOf(bhParam), ANY.copy(nullable = true))
+                    val boundBenchType = LambdaTypeName.get(originalClass, emptyList(), ANY.copy(nullable = true))
+
+                    addParameter("function", bhBenchType)
+                    addParameter("bh", bhClass)
+                    returns(boundBenchType)
+
+                    addStatement("return { function(bh) }")
+                }
+
+
                 val defaultParameters = parameterProperties.associateBy({ it.name }, {
                     val annotation = it.annotations.findAnnotation(FqName(paramAnnotationFQN))!!
                     val constant = annotation.argumentValue("value") 
@@ -241,13 +266,29 @@ class SuiteSourceGenerator(val title: String, val module: ModuleDescriptor, val
                     addStatement("")
                     for (fn in benchmarkFunctions) {
                         val functionName = fn.name.toString()
-                        addStatement(
-                            "descriptor.add(%T(%S, descriptor, %T::%N))",
-                            benchmarkDescriptorType,
-                            "${originalClass.canonicalName}.$functionName",
-                            originalClass,
-                            functionName
-                        )
+
+                        val hasABlackholeParameter = fn.valueParameters.singleOrNull()?.type.toString() == "Blackhole"
+                        if (hasABlackholeParameter) {
+                            println("WARNING: Blackhole works correctly only on JVM")
+
+                            addStatement(
+                                "descriptor.add(%T(%S, descriptor, %N(%T::%N, %T())))",
+                                benchmarkDescriptorType,
+                                "${originalClass.canonicalName}.$functionName",
+                                bindBlackholeFunctionName,
+                                originalClass,
+                                functionName,
+                                bhClass
+                            )
+                        }
+                        else
+                            addStatement(
+                                "descriptor.add(%T(%S, descriptor, %T::%N))",
+                                benchmarkDescriptorType,
+                                "${originalClass.canonicalName}.$functionName",
+                                originalClass,
+                                functionName
+                            )
                     }
                     addStatement("return descriptor")
                 }

runtime/commonMain/src/kotlinx/benchmark/Blackhole.kt

@@ -0,0 +1,13 @@
+package kotlinx.benchmark
+
+expect class Blackhole {
+    fun consume(obj: Any?)
+    fun consume(bool: Boolean)
+    fun consume(c: Char)
+    fun consume(b: Byte)
+    fun consume(s: Short)
+    fun consume(i: Int)
+    fun consume(l: Long)
+    fun consume(f: Float)
+    fun consume(d: Double)
+}

runtime/jsMain/src/kotlinx/benchmark/JsBlackhole.kt

@@ -0,0 +1,13 @@
+package kotlinx.benchmark
+
+actual class Blackhole {
+    actual fun consume(obj: Any?) {}
+    actual fun consume(bool: Boolean) {}
+    actual fun consume(c: Char) {}
+    actual fun consume(b: Byte) {}
+    actual fun consume(s: Short) {}
+    actual fun consume(i: Int) {}
+    actual fun consume(l: Long) {}
+    actual fun consume(f: Float) {}
+    actual fun consume(d: Double) {}
+}

runtime/jvmMain/src/kotlinx/benchmark/JvmBlackhole.kt

@@ -0,0 +1,3 @@
+package kotlinx.benchmark
+
+actual typealias Blackhole = org.openjdk.jmh.infra.Blackhole

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

@@ -0,0 +1,13 @@
+package kotlinx.benchmark
+
+actual class Blackhole {
+    actual fun consume(obj: Any?) {}
+    actual fun consume(bool: Boolean) {}
+    actual fun consume(c: Char) {}
+    actual fun consume(b: Byte) {}
+    actual fun consume(s: Short) {}
+    actual fun consume(i: Int) {}
+    actual fun consume(l: Long) {}
+    actual fun consume(f: Float) {}
+    actual fun consume(d: Double) {}
+}