Skip to content
This repository was archived by the owner on Jan 20, 2023. It is now read-only.

Commit 3b8687d

Browse files
k163377k163377
authored
Merge pull request #12 from k163377/add_single_benchmark
Add single benchmark.
2 parents 26f5879 + 66d1ab8 commit 3b8687d

10 files changed

+356
-5
lines changed

‎build.gradle.kts

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -63,5 +63,8 @@ jmh {
6363
warmupBatchSize = 3
6464
warmupIterations = 3
6565

66+
failOnError = true
67+
isIncludeTests = false
68+
6669
resultFormat = "CSV"
6770
}

‎src/jmh/kotlin/com/mapk/fastkfunction/fastkfunction/CallInstanceMethodBenchmark.kt

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -39,7 +39,8 @@ open class CallInstanceMethodBenchmark {
3939
fun fastKFunctionWithoutInstanceCall(): Constructor5 = fastKFunctionWithoutInstance.call(1, 2, 3, 4, 5)
4040

4141
@Benchmark
42-
fun fastKFunctionWithoutInstanceCallByCollection(): Constructor5 = fastKFunctionWithoutInstance.call(collection)
42+
fun fastKFunctionWithoutInstanceCallByCollection(): Constructor5 =
43+
fastKFunctionWithoutInstance.callByCollection(collection)
4344

4445
@Benchmark
4546
fun fastKFunctionWithoutInstanceCallBy(): Constructor5 = fastKFunctionWithoutInstance.callBy(argumentBucket)

‎src/jmh/kotlin/com/mapk/fastkfunction/fastkfunction/CallObjectMethodBenchmark.kt

Lines changed: 5 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -23,6 +23,9 @@ open class CallObjectMethodBenchmark {
2323
.first { it.name == "companionObjectFun5" } as KFunction<Constructor5>
2424

2525
private val argumentMap: Map<KParameter, Any?> = functionByMethodReference.parameters.associateWith { it.index + 1 }
26+
private val argumentMapWithInstance: Map<KParameter, Any?> = functionByReflection.parameters.associateWith {
27+
if (it.kind == KParameter.Kind.INSTANCE) objectInstance else it.index + 1
28+
}
2629

2730
private val javaMethod: Method = functionByMethodReference.javaMethod!!
2831

@@ -50,10 +53,10 @@ open class CallObjectMethodBenchmark {
5053
fun functionByMethodReferenceCallBy(): Constructor5 = functionByMethodReference.callBy(argumentMap)
5154

5255
@Benchmark
53-
fun functionByReflectionCall(): Constructor5 = functionByReflection.call(1, 2, 3, 4, 5)
56+
fun functionByReflectionCall(): Constructor5 = functionByReflection.call(objectInstance, 1, 2, 3, 4, 5)
5457

5558
@Benchmark
56-
fun functionByReflectionCallBy(): Constructor5 = functionByReflection.callBy(argumentMap)
59+
fun functionByReflectionCallBy(): Constructor5 = functionByReflection.callBy(argumentMapWithInstance)
5760

5861
@Benchmark
5962
fun javaMethod(): Constructor5 = javaMethod.invoke(objectInstance, 1, 2, 3, 4, 5) as Constructor5

‎src/jmh/kotlin/com/mapk/fastkfunction/fastkfunction/CallTopLevelExtensionFunBenchmark.kt

Lines changed: 5 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -18,6 +18,9 @@ open class CallTopLevelExtensionFunBenchmark {
1818
private val functionFromClass: KFunction<Constructor5> = Constructor5::topLevelExtensionFun5
1919

2020
private val argumentMap: Map<KParameter, Any?> = functionByMethodReference.parameters.associateWith { it.index + 1 }
21+
private val argumentMapWithInstance: Map<KParameter, Any?> = functionFromClass.parameters.associateWith {
22+
if (it.kind == KParameter.Kind.EXTENSION_RECEIVER) receiverInstance else it.index + 1
23+
}
2124

2225
private val javaMethod: Method = functionByMethodReference.javaMethod!!
2326

@@ -43,10 +46,10 @@ open class CallTopLevelExtensionFunBenchmark {
4346
fun functionByMethodReferenceCallBy(): Constructor5 = functionByMethodReference.callBy(argumentMap)
4447

4548
@Benchmark
46-
fun functionFromClassCall(): Constructor5 = functionFromClass.call(1, 2, 3, 4, 5)
49+
fun functionFromClassCall(): Constructor5 = functionFromClass.call(receiverInstance, 1, 2, 3, 4, 5)
4750

4851
@Benchmark
49-
fun functionFromClassCallBy(): Constructor5 = functionFromClass.callBy(argumentMap)
52+
fun functionFromClassCallBy(): Constructor5 = functionFromClass.callBy(argumentMapWithInstance)
5053

5154
@Benchmark
5255
fun javaMethod(): Constructor5 = javaMethod.invoke(null, receiverInstance, 1, 2, 3, 4, 5) as Constructor5

‎src/jmh/kotlin/com/mapk/fastkfunction/singleargfastkfunction/BenchmarkTargets.kt

Lines changed: 13 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,13 @@
1+
package com.mapk.fastkfunction.singleargfastkfunction
2+
3+
data class Constructor1(val arg: Int) {
4+
fun instanceFun1(arg: Int) = Constructor1(this.arg + arg)
5+
6+
companion object {
7+
fun companionObjectFun1(arg: Int) = Constructor1(arg)
8+
}
9+
}
10+
11+
fun topLevelFun1(arg: Int) = Constructor1(arg)
12+
13+
fun Constructor1.topLevelExtensionFun1(arg: Int) = Constructor1(this.arg + arg)

‎src/jmh/kotlin/com/mapk/fastkfunction/singleargfastkfunction/CallConstructorBenchmark.kt

Lines changed: 41 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,41 @@
1+
package com.mapk.fastkfunction.singleargfastkfunction
2+
3+
import com.mapk.fastkfunction.FastKFunction
4+
import com.mapk.fastkfunction.SingleArgFastKFunction
5+
import org.openjdk.jmh.annotations.Benchmark
6+
import org.openjdk.jmh.annotations.Scope
7+
import org.openjdk.jmh.annotations.State
8+
import java.lang.reflect.Constructor
9+
import kotlin.reflect.KFunction
10+
import kotlin.reflect.KParameter
11+
import kotlin.reflect.jvm.javaConstructor
12+
13+
@State(Scope.Benchmark)
14+
open class CallConstructorBenchmark {
15+
private val argument = 1
16+
17+
private val function: KFunction<Constructor1> = ::Constructor1
18+
private val argumentMap: Map<KParameter, Any?> = mapOf(function.parameters.single() to argument)
19+
20+
private val javaConstructor: Constructor<Constructor1> = function.javaConstructor!!
21+
private val fastKFunction: FastKFunction<Constructor1> = FastKFunction.of(function)
22+
private val singleArgFastKFunction: SingleArgFastKFunction<Constructor1> = SingleArgFastKFunction.of(function)
23+
24+
@Benchmark
25+
fun normalCall(): Constructor1 = Constructor1(argument)
26+
27+
@Benchmark
28+
fun kFunctionCall(): Constructor1 = function.call(argument)
29+
30+
@Benchmark
31+
fun kFunctionCallBy(): Constructor1 = function.callBy(argumentMap)
32+
33+
@Benchmark
34+
fun javaConstructor(): Constructor1 = javaConstructor.newInstance(argument)
35+
36+
@Benchmark
37+
fun fastKFunctionCall(): Constructor1 = fastKFunction.call(argument)
38+
39+
@Benchmark
40+
fun singleArgFastKFunctionCall(): Constructor1 = singleArgFastKFunction.call(argument)
41+
}

‎src/jmh/kotlin/com/mapk/fastkfunction/singleargfastkfunction/CallInstanceMethodBenchmark.kt

Lines changed: 52 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,52 @@
1+
package com.mapk.fastkfunction.singleargfastkfunction
2+
3+
import com.mapk.fastkfunction.FastKFunction
4+
import com.mapk.fastkfunction.SingleArgFastKFunction
5+
import org.openjdk.jmh.annotations.Benchmark
6+
import org.openjdk.jmh.annotations.Scope
7+
import org.openjdk.jmh.annotations.State
8+
import java.lang.reflect.Method
9+
import kotlin.reflect.KFunction
10+
import kotlin.reflect.KParameter
11+
import kotlin.reflect.jvm.javaMethod
12+
13+
@State(Scope.Benchmark)
14+
open class CallInstanceMethodBenchmark {
15+
private val argument = 1
16+
17+
private val instance = Constructor1(1)
18+
private val function: KFunction<Constructor1> = instance::instanceFun1
19+
private val argumentMap: Map<KParameter, Any?> = mapOf(function.parameters.single() to argument)
20+
21+
private val javaMethod: Method = function.javaMethod!!
22+
private val fastKFunctionWithoutInstance: FastKFunction<Constructor1> = FastKFunction.of(function, null)
23+
private val fastKFunctionWithInstance: FastKFunction<Constructor1> = FastKFunction.of(function, instance)
24+
private val singleArgFastKFunctionWithoutInstance: SingleArgFastKFunction<Constructor1> =
25+
SingleArgFastKFunction.of(function, null)
26+
private val singleArgFastKFunctionWithInstance: SingleArgFastKFunction<Constructor1> =
27+
SingleArgFastKFunction.of(function, instance)
28+
29+
@Benchmark
30+
fun normalCall(): Constructor1 = instance.instanceFun1(argument)
31+
32+
@Benchmark
33+
fun kFunctionCall(): Constructor1 = function.call(argument)
34+
35+
@Benchmark
36+
fun kFunctionCallBy(): Constructor1 = function.callBy(argumentMap)
37+
38+
@Benchmark
39+
fun javaMethod(): Constructor1 = javaMethod.invoke(instance, argument) as Constructor1
40+
41+
@Benchmark
42+
fun fastKFunctionWithoutInstanceCall(): Constructor1 = fastKFunctionWithoutInstance.call(argument)
43+
44+
@Benchmark
45+
fun fastKFunctionWithInstanceCall(): Constructor1 = fastKFunctionWithInstance.call(argument)
46+
47+
@Benchmark
48+
fun singleArgFastKFunctionWithoutInstanceCall(): Constructor1 = singleArgFastKFunctionWithoutInstance.call(argument)
49+
50+
@Benchmark
51+
fun singleArgFastKFunctionWithInstanceCall(): Constructor1 = singleArgFastKFunctionWithInstance.call(argument)
52+
}

‎src/jmh/kotlin/com/mapk/fastkfunction/singleargfastkfunction/CallObjectMethodBenchmark.kt

Lines changed: 106 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,106 @@
1+
package com.mapk.fastkfunction.singleargfastkfunction
2+
3+
import com.mapk.fastkfunction.FastKFunction
4+
import com.mapk.fastkfunction.SingleArgFastKFunction
5+
import org.openjdk.jmh.annotations.Benchmark
6+
import org.openjdk.jmh.annotations.Scope
7+
import org.openjdk.jmh.annotations.State
8+
import java.lang.reflect.Method
9+
import kotlin.reflect.KFunction
10+
import kotlin.reflect.KParameter
11+
import kotlin.reflect.full.companionObjectInstance
12+
import kotlin.reflect.full.functions
13+
import kotlin.reflect.jvm.javaMethod
14+
15+
@State(Scope.Benchmark)
16+
open class CallObjectMethodBenchmark {
17+
private val argument = 1
18+
19+
private val objectInstance = Constructor1::class.companionObjectInstance!!
20+
21+
private val functionByMethodReference: KFunction<Constructor1> = (Constructor1)::companionObjectFun1
22+
@Suppress("UNCHECKED_CAST")
23+
private val functionByReflection: KFunction<Constructor1> = objectInstance::class
24+
.functions
25+
.first { it.name == "companionObjectFun1" } as KFunction<Constructor1>
26+
27+
private val argumentMap: Map<KParameter, Any?> = mapOf(functionByMethodReference.parameters.single() to argument)
28+
private val argumentMapWithInstance: Map<KParameter, Any?> = functionByReflection.parameters.let {
29+
mapOf(
30+
it[0] to objectInstance,
31+
it[1] to argument
32+
)
33+
}
34+
35+
private val javaMethod: Method = functionByMethodReference.javaMethod!!
36+
37+
private val fastKFunctionByMethodReferenceWithoutInstance: FastKFunction<Constructor1> =
38+
FastKFunction.of(functionByMethodReference)
39+
private val fastKFunctionByMethodReferenceWithInstance: FastKFunction<Constructor1> =
40+
FastKFunction.of(functionByMethodReference, objectInstance)
41+
42+
private val fastKFunctionByReflectionWithoutInstance: FastKFunction<Constructor1> =
43+
FastKFunction.of(functionByReflection)
44+
private val fastKFunctionByReflectionWithInstance: FastKFunction<Constructor1> =
45+
FastKFunction.of(functionByReflection, objectInstance)
46+
47+
private val singleArgFastKFunctionByMethodReferenceWithoutInstance: SingleArgFastKFunction<Constructor1> =
48+
SingleArgFastKFunction.of(functionByMethodReference)
49+
private val singleArgFastKFunctionByMethodReferenceWithInstance: SingleArgFastKFunction<Constructor1> =
50+
SingleArgFastKFunction.of(functionByMethodReference, objectInstance)
51+
52+
private val singleArgFastKFunctionByReflectionWithoutInstance: SingleArgFastKFunction<Constructor1> =
53+
SingleArgFastKFunction.of(functionByReflection)
54+
private val singleArgFastKFunctionByReflectionWithInstance: SingleArgFastKFunction<Constructor1> =
55+
SingleArgFastKFunction.of(functionByReflection, objectInstance)
56+
57+
@Benchmark
58+
fun normalCall(): Constructor1 = Constructor1.companionObjectFun1(argument)
59+
60+
@Benchmark
61+
fun functionByMethodReferenceCall(): Constructor1 = functionByMethodReference.call(argument)
62+
63+
@Benchmark
64+
fun functionByMethodReferenceCallBy(): Constructor1 = functionByMethodReference.callBy(argumentMap)
65+
66+
@Benchmark
67+
fun functionByReflectionCall(): Constructor1 = functionByReflection.call(objectInstance, argument)
68+
69+
@Benchmark
70+
fun functionByReflectionCallBy(): Constructor1 = functionByReflection.callBy(argumentMapWithInstance)
71+
72+
@Benchmark
73+
fun javaMethod(): Constructor1 = javaMethod.invoke(objectInstance, argument) as Constructor1
74+
75+
@Benchmark
76+
fun fastKFunctionByMethodReferenceWithoutInstanceCall(): Constructor1 =
77+
fastKFunctionByMethodReferenceWithoutInstance.call(argument)
78+
79+
@Benchmark
80+
fun fastKFunctionByMethodReferenceWithInstanceCall(): Constructor1 =
81+
fastKFunctionByMethodReferenceWithInstance.call(argument)
82+
83+
@Benchmark
84+
fun fastKFunctionByReflectionWithoutInstanceCall(): Constructor1 =
85+
fastKFunctionByReflectionWithoutInstance.call(argument)
86+
87+
@Benchmark
88+
fun fastKFunctionByReflectionWithInstanceCall(): Constructor1 =
89+
fastKFunctionByReflectionWithInstance.call(argument)
90+
91+
@Benchmark
92+
fun singleArgFastKFunctionByMethodReferenceWithoutInstanceCall(): Constructor1 =
93+
singleArgFastKFunctionByMethodReferenceWithoutInstance.call(argument)
94+
95+
@Benchmark
96+
fun singleArgFastKFunctionByMethodReferenceWithInstanceCall(): Constructor1 =
97+
singleArgFastKFunctionByMethodReferenceWithInstance.call(argument)
98+
99+
@Benchmark
100+
fun singleArgFastKFunctionByReflectionWithoutInstanceCall(): Constructor1 =
101+
singleArgFastKFunctionByReflectionWithoutInstance.call(argument)
102+
103+
@Benchmark
104+
fun singleArgFastKFunctionByReflectionWithInstanceCall(): Constructor1 =
105+
singleArgFastKFunctionByReflectionWithInstance.call(argument)
106+
}

‎src/jmh/kotlin/com/mapk/fastkfunction/singleargfastkfunction/CallTopLevelExtensionFunBenchmark.kt

Lines changed: 87 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,87 @@
1+
package com.mapk.fastkfunction.singleargfastkfunction
2+
3+
import com.mapk.fastkfunction.FastKFunction
4+
import com.mapk.fastkfunction.SingleArgFastKFunction
5+
import org.openjdk.jmh.annotations.Benchmark
6+
import org.openjdk.jmh.annotations.Scope
7+
import org.openjdk.jmh.annotations.State
8+
import java.lang.reflect.Method
9+
import kotlin.reflect.KFunction
10+
import kotlin.reflect.KParameter
11+
import kotlin.reflect.jvm.javaMethod
12+
13+
@State(Scope.Benchmark)
14+
open class CallTopLevelExtensionFunBenchmark {
15+
private val argument = 1
16+
17+
private val receiverInstance = Constructor1(argument)
18+
19+
private val functionByMethodReference: KFunction<Constructor1> = receiverInstance::topLevelExtensionFun1
20+
private val functionFromClass: KFunction<Constructor1> = Constructor1::topLevelExtensionFun1
21+
22+
private val argumentMap: Map<KParameter, Any?> = mapOf(functionByMethodReference.parameters.single() to argument)
23+
private val argumentMapWithInstance: Map<KParameter, Any?> = functionFromClass.parameters.let {
24+
mapOf(
25+
it[0] to receiverInstance,
26+
it[1] to argument
27+
)
28+
}
29+
30+
private val javaMethod: Method = functionByMethodReference.javaMethod!!
31+
32+
private val fastKFunctionByMethodReferenceWithoutInstance: FastKFunction<Constructor1> =
33+
FastKFunction.of(functionByMethodReference)
34+
private val fastKFunctionByMethodReferenceWithInstance: FastKFunction<Constructor1> =
35+
FastKFunction.of(functionByMethodReference, receiverInstance)
36+
37+
private val fastKFunctionFromClass: FastKFunction<Constructor1> =
38+
FastKFunction.of(functionFromClass, receiverInstance)
39+
40+
private val singleArgFastKFunctionByMethodReferenceWithoutInstance: SingleArgFastKFunction<Constructor1> =
41+
SingleArgFastKFunction.of(functionByMethodReference)
42+
private val singleArgFastKFunctionByMethodReferenceWithInstance: SingleArgFastKFunction<Constructor1> =
43+
SingleArgFastKFunction.of(functionByMethodReference, receiverInstance)
44+
45+
private val singleArgFastKFunctionFromClass: SingleArgFastKFunction<Constructor1> =
46+
SingleArgFastKFunction.of(functionFromClass, receiverInstance)
47+
48+
@Benchmark
49+
fun normalCall(): Constructor1 = receiverInstance.topLevelExtensionFun1(argument)
50+
51+
@Benchmark
52+
fun functionByMethodReferenceCall(): Constructor1 = functionByMethodReference.call(argument)
53+
54+
@Benchmark
55+
fun functionByMethodReferenceCallBy(): Constructor1 = functionByMethodReference.callBy(argumentMap)
56+
57+
@Benchmark
58+
fun functionFromClassCall(): Constructor1 = functionFromClass.call(receiverInstance, argument)
59+
60+
@Benchmark
61+
fun functionFromClassCallBy(): Constructor1 = functionFromClass.callBy(argumentMapWithInstance)
62+
63+
@Benchmark
64+
fun javaMethod(): Constructor1 = javaMethod.invoke(null, receiverInstance, argument) as Constructor1
65+
66+
@Benchmark
67+
fun fastKFunctionByMethodReferenceWithoutInstanceCall(): Constructor1 =
68+
fastKFunctionByMethodReferenceWithoutInstance.call(argument)
69+
70+
@Benchmark
71+
fun fastKFunctionByMethodReferenceWithInstanceCall(): Constructor1 =
72+
fastKFunctionByMethodReferenceWithInstance.call(argument)
73+
74+
@Benchmark
75+
fun fastKFunctionFromClassCall(): Constructor1 = fastKFunctionFromClass.call(argument)
76+
77+
@Benchmark
78+
fun singleArgFastKFunctionByMethodReferenceWithoutInstanceCall(): Constructor1 =
79+
singleArgFastKFunctionByMethodReferenceWithoutInstance.call(argument)
80+
81+
@Benchmark
82+
fun singleArgFastKFunctionByMethodReferenceWithInstanceCall(): Constructor1 =
83+
singleArgFastKFunctionByMethodReferenceWithInstance.call(argument)
84+
85+
@Benchmark
86+
fun singleArgFastKFunctionFromClassCall(): Constructor1 = singleArgFastKFunctionFromClass.call(argument)
87+
}

0 commit comments

Comments
 (0)