UTBotJava/utbot-instrumentation-tests/src/test/kotlin/org/utbot/examples/benchmark/BenchmarkFibonacci.kt at 3ebc51cbda1a13c69a7835458fdac5624f013694 · UnitTestBot/UTBotJava · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
package org.utbot.examples.benchmark

import org.utbot.examples.samples.benchmark.Fibonacci
import org.utbot.framework.plugin.api.util.UtContext
import org.utbot.framework.plugin.api.util.withUtContext
import org.utbot.instrumentation.ConcreteExecutor
import org.utbot.instrumentation.instrumentation.InvokeInstrumentation
import org.utbot.instrumentation.instrumentation.coverage.InstructionCoverageInstrumentation
import org.utbot.instrumentation.instrumentation.coverage.collectCoverage
import org.utbot.instrumentation.util.Isolated
import kotlin.system.measureNanoTime

fun getBasicCoverageTime_fib(count: Int): Double {
    var time: Long
    ConcreteExecutor(
        InstructionCoverageInstrumentation.Factory,
        Fibonacci::class.java.protectionDomain.codeSource.location.path
    ).use {
        val fib = Isolated(Fibonacci::calc, it)
        for (i in 0..20_000) {
            fib(1, 1, 13)
        }

        time = measureNanoTime {
            for (i in 0..count) {
                fib(1, 1, 13)
            }
            it.collectCoverage(Fibonacci::class.java)
        }
    }
    return time / 1e6
}

fun getNativeCallTime_fib(count: Int): Double {
    for (i in 0..20_000) {
        Fibonacci.calc(1, 1, 13)

    }
    val time = measureNanoTime {
        for (i in 0..count) {
            Fibonacci.calc(1, 1, 13)
        }
    }
    return time / 1e6
}

fun getJustResultTime_fib(count: Int): Double {
    var time: Long
    ConcreteExecutor(
        InvokeInstrumentation.Factory,
        Fibonacci::class.java.protectionDomain.codeSource.location.path
    ).use {
        val fib = Isolated(Fibonacci::calc, it)

        for (i in 0..20_000) {
            fib(1, 1, 13)
        }

        time = measureNanoTime {
            for (i in 0..count) {
                fib(1, 1, 13)
            }
        }
    }
    return time / 1e6
}

fun main() {
    withUtContext(UtContext(ClassLoader.getSystemClassLoader())) {
        val callsCount = 300_000

        val nativeCallTime = getNativeCallTime_fib(callsCount)
        val basicCoverageTime = getBasicCoverageTime_fib(callsCount)
        val justResultTime = getJustResultTime_fib(callsCount)

        println("Running results on $callsCount method calls")
        println("nativeCall: $nativeCallTime ms")
        println("basicCoverage: $basicCoverageTime ms, overhead per call: ${(basicCoverageTime - nativeCallTime) / callsCount} ms")
        println("justResult: $justResultTime ms, overhead per call: ${(justResultTime - nativeCallTime) / callsCount} ms")
    }
}