Property/inline performance

rcheney · August 6, 2020, 1:00pm

Hi there!

This is just a query of interest rather than an actual problem I’m having. I’ve been experimenting with Data Orientated Design and have a created a (very) rudimentary benchmark app for timing some different approaches to normalizing an array of 3D vectors (sorry its fairly long):

import java.util.concurrent.TimeUnit
import kotlin.random.Random
import kotlin.reflect.KProperty
import kotlin.time.Duration
import kotlin.time.DurationUnit
import kotlin.time.measureTime
import kotlin.time.toDuration

val rnd = Random(1234)

data class Vector(var x: Float, var y: Float, var z: Float) {
    fun normalize() {
        val l = x * x + y * y + z * z
        x /= l
        y /= l
        z /= l
    }
}

fun timeOop(count: Int): Duration {
    val vectors = Array(count) { Vector(rnd.nextFloat(), rnd.nextFloat(), rnd.nextFloat()) }
    return measureTime {
        for (vector in vectors) {
            vector.normalize()
        }
    }
}

private fun normalizeInArray(xs: FloatArray, ys: FloatArray, zs: FloatArray, i: Int) {
    val x = xs[i]
    val y = ys[i]
    val z = zs[i]
    val l = x * x + y * y + z * z
    xs[i] /= l
    ys[i] /= l
    zs[i] /= l
}

fun timeDod(count: Int): Duration {
    val xs = FloatArray(count) { rnd.nextFloat() }
    val ys = FloatArray(count) { rnd.nextFloat() }
    val zs = FloatArray(count) { rnd.nextFloat() }

    return measureTime {
        for (i in xs.indices) {
            normalizeInArray(xs, ys, zs, i)
        }
    }
}

class IntoArrayDelegate(val array: FloatArray, val index: Int) {
    operator fun getValue(thisRef: Any?, property: KProperty<*>): Float {
        return array[index]
    }

    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: Float) {
        array[index] = value
    }
}

class DelegatedVector(xs: FloatArray, ys: FloatArray, zs: FloatArray, index: Int) {
    var x: Float by IntoArrayDelegate(xs, index)
    var y: Float by IntoArrayDelegate(ys, index)
    var z: Float by IntoArrayDelegate(zs, index)

    fun normalize() {
        val l = x * x + y * y + z * z
        x /= l
        y /= l
        z /= l
    }
}

fun timeDodDelegated(count: Int): Duration {
    val xs = FloatArray(count) { rnd.nextFloat() }
    val ys = FloatArray(count) { rnd.nextFloat() }
    val zs = FloatArray(count) { rnd.nextFloat() }

    val vectors = Array(count) { i -> DelegatedVector(xs, ys, zs, i) }

    return measureTime {
        for (vector in vectors) {
            vector.normalize()
        }
    }
}

class PropertyVector(
    val xs: FloatArray,
    val ys: FloatArray,
    val zs: FloatArray,
    val index: Int
) {
    var x: Float
        get() = xs[index]
        set(value) {
            xs[index] = value
        }

    var y: Float
        get() = ys[index]
        set(value) {
            ys[index] = value
        }

    var z: Float
        get() = zs[index]
        set(value) {
            zs[index] = value
        }

    fun normalize() {
        val l = x * x + y * y + z * z
        x /= l
        y /= l
        z /= l
    }
}

class InlinedPropertyVector(
    val xs: FloatArray,
    val ys: FloatArray,
    val zs: FloatArray,
    val index: Int
) {
    var x: Float
        inline get() = xs[index]
        inline set(value) {
            xs[index] = value
        }

    var y: Float
        inline get() = ys[index]
        inline set(value) {
            ys[index] = value
        }

    var z: Float
        inline get() = zs[index]
        inline set(value) {
            zs[index] = value
        }

    inline fun normalize() {
        val l = x * x + y * y + z * z
        x /= l
        y /= l
        z /= l
    }
}


fun timeDodProps(count: Int): Duration {
    val xs = FloatArray(count) { rnd.nextFloat() }
    val ys = FloatArray(count) { rnd.nextFloat() }
    val zs = FloatArray(count) { rnd.nextFloat() }

    val vectors = Array(count) { i -> PropertyVector(xs, ys, zs, i) }

    return measureTime {
        for (vector in vectors) {
            vector.normalize()
        }
    }
}

fun timeDodPropsInlined(count: Int): Duration {
    val xs = FloatArray(count) { rnd.nextFloat() }
    val ys = FloatArray(count) { rnd.nextFloat() }
    val zs = FloatArray(count) { rnd.nextFloat() }

    val vectors = Array(count) { i -> InlinedPropertyVector(xs, ys, zs, i) }

    return measureTime {
        for (vector in vectors) {
            vector.normalize()
        }
    }
}

fun main() {
    println("%10s%10s%10s%10s%10s%10s".format("Count", "OOP", "DOD", "DODd", "DODp", "iDODp"))
    for (count in 1_000_000..10_000_000 step 1_000_000) {

        val oopDurations = ArrayList<Long>()
        val dodDurations = ArrayList<Long>()
        val dodDelegationDurations = ArrayList<Long>()
        val dodPropsDurations = ArrayList<Long>()
        val dodPropsInlinedDurations = ArrayList<Long>()

        for (iteration in 0..10) {
            System.gc()
            oopDurations += timeOop(count).toLong(DurationUnit.NANOSECONDS)
            dodDurations += timeDod(count).toLong(DurationUnit.NANOSECONDS)
            dodDelegationDurations += timeDodDelegated(count).toLong(TimeUnit.NANOSECONDS)
            dodPropsDurations += timeDodProps(count).toLong(DurationUnit.NANOSECONDS)
            dodPropsInlinedDurations += timeDodPropsInlined(count).toLong(DurationUnit.NANOSECONDS)
        }

        val oopDuration = oopDurations.average().toDuration(DurationUnit.NANOSECONDS)
        val dodDuration = dodDurations.average().toDuration(DurationUnit.NANOSECONDS)
        val dodDelegationDuration = dodDelegationDurations.average().toDuration(DurationUnit.NANOSECONDS)
        val dodPropsDuration = dodPropsDurations.average().toDuration(DurationUnit.NANOSECONDS)
        val dodPropsInlinedDuration = dodPropsInlinedDurations.average().toDuration(DurationUnit.NANOSECONDS)

        println("%10s%10s%10s%10s%10s%10s".format(count, oopDuration, dodDuration, dodDelegationDuration, dodPropsDuration, dodPropsInlinedDuration))
    }
}

The output from this code on my machine is:

   Count       OOP       DOD      DODd      DODp     iDODp
   1000000    3.01ms    1.60ms    10.9ms    6.46ms    5.81ms
   2000000    5.17ms    1.12ms    16.9ms    8.85ms    10.1ms
   3000000    7.73ms    1.86ms    26.4ms    14.3ms    15.1ms
   4000000    10.8ms    2.81ms    35.1ms    21.9ms    18.5ms
   5000000    13.7ms    3.82ms    43.6ms    23.1ms    25.2ms
   6000000    16.6ms    4.80ms    51.3ms    26.6ms    30.6ms
   7000000    19.3ms    5.19ms    61.0ms    32.8ms    34.1ms
   8000000    22.0ms    5.96ms    76.7ms    37.3ms    40.6ms
   9000000    24.8ms    6.62ms    79.2ms    45.9ms    40.7ms
  10000000    27.0ms    7.30ms    91.7ms    47.3ms    49.4ms

In summary I’m normalizing vectors:

[OOP] As an array of Vector (OOP data class) instances - timeOpp
[DOD] As X,Y and Z component float arrays - timeDod (4-5x faster than OOP )
[DODd] As component arrays with a Vector class facade using delegates - timeDodDelegated/IntoArrayDelegate/DelegatedVector
[DODp] As component arrays with a Vector class facade using property getters/setters - timeDodProps/PropertyVector
[iDODp] As component arrays with a Vector class facade using inline property getters/setters - timeDodPropsInlined/InlinedPropertyVector

My question is, why are the timings for the property and especially the inlined property facades so far off the vanilla DOD timings? I would have expected the inlined facade to give very similar results…

chipays · August 6, 2020, 3:07pm

Any benchmarking results that come out of a main function instead of a microbenchmark harness should be ignored. I strongly suggest you to set up your tests with JMH or other equivalent microbenchmarking tools and share the code and results here again.

rcheney · August 6, 2020, 8:31pm

My first play with micro bench-marking so I’ve no idea if this code is any good

package vectors

import org.openjdk.jmh.annotations.*
import java.util.concurrent.TimeUnit
import kotlin.random.Random
import kotlin.reflect.KProperty

val rnd = Random(1234)

data class Vector(var x: Float, var y: Float, var z: Float) {
    fun normalize() {
        val l = x * x + y * y + z * z
        x /= l
        y /= l
        z /= l
    }
}

class IntoArrayDelegate(val array: FloatArray, val index: Int) {
    operator fun getValue(thisRef: Any?, property: KProperty<*>): Float {
        return array[index]
    }

    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: Float) {
        array[index] = value
    }
}

class DelegatedVector(xs: FloatArray, ys: FloatArray, zs: FloatArray, index: Int) {
    var x: Float by IntoArrayDelegate(xs, index)
    var y: Float by IntoArrayDelegate(ys, index)
    var z: Float by IntoArrayDelegate(zs, index)

    fun normalize() {
        val l = x * x + y * y + z * z
        x /= l
        y /= l
        z /= l
    }
}

class PropertyVector(
    val xs: FloatArray,
    val ys: FloatArray,
    val zs: FloatArray,
    val index: Int
) {
    var x: Float
        get() = xs[index]
        set(value) {
            xs[index] = value
        }

    var y: Float
        get() = ys[index]
        set(value) {
            ys[index] = value
        }

    var z: Float
        get() = zs[index]
        set(value) {
            zs[index] = value
        }

    fun normalize() {
        val l = x * x + y * y + z * z
        x /= l
        y /= l
        z /= l
    }
}

class InlinedPropertyVector(
    val xs: FloatArray,
    val ys: FloatArray,
    val zs: FloatArray,
    val index: Int
) {
    var x: Float
        inline get() = xs[index]
        inline set(value) {
            xs[index] = value
        }

    var y: Float
        inline get() = ys[index]
        inline set(value) {
            ys[index] = value
        }

    var z: Float
        inline get() = zs[index]
        inline set(value) {
            zs[index] = value
        }

    inline fun normalize() {
        val l = x * x + y * y + z * z
        x /= l
        y /= l
        z /= l
    }
}

@State(Scope.Benchmark)
open class OopState {
    @Param("100000")
    var count: Int = 0

    var vectors: Array<Vector> = arrayOf()

    @Setup(Level.Invocation)
    fun init() {
        vectors = Array(count) { Vector(rnd.nextFloat(), rnd.nextFloat(), rnd.nextFloat()) }
    }
}

@State(Scope.Benchmark)
open class DodState {
    @Param("100000")
    var count: Int = 0

    val xs = FloatArray(count) { rnd.nextFloat() }
    val ys = FloatArray(count) { rnd.nextFloat() }
    val zs = FloatArray(count) { rnd.nextFloat() }

    @Setup(Level.Invocation)
    fun init() {

    }
}

@State(Scope.Benchmark)
open class DodDelegateState {
    @Param("100000")
    var count: Int = 0

    val xs = FloatArray(count) { rnd.nextFloat() }
    val ys = FloatArray(count) { rnd.nextFloat() }
    val zs = FloatArray(count) { rnd.nextFloat() }

    val vectors = Array(count) { i -> DelegatedVector(xs, ys, zs, i) }
}

@State(Scope.Benchmark)
open class DodPropertyState {
    @Param("10000000")
    var count: Int = 0

    val xs = FloatArray(count) { rnd.nextFloat() }
    val ys = FloatArray(count) { rnd.nextFloat() }
    val zs = FloatArray(count) { rnd.nextFloat() }

    val vectors = Array(count) { i -> PropertyVector(xs, ys, zs, i) }
}

@State(Scope.Benchmark)
open class DodInlinedPropertyState {
    @Param("10000000")
    var count: Int = 0

    val xs = FloatArray(count) { rnd.nextFloat() }
    val ys = FloatArray(count) { rnd.nextFloat() }
    val zs = FloatArray(count) { rnd.nextFloat() }

    val vectors = Array(count) { i -> InlinedPropertyVector(xs, ys, zs, i) }
}

@BenchmarkMode(Mode.All)
@Warmup(iterations = 3)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Measurement(iterations = 1, batchSize = 5)
@Fork(value = 1, warmups = 1)
open class Benchmarks {

    @Benchmark
    fun oopVectors(state: OopState) {
        for(vector in state.vectors) {
            vector.normalize()
        }
    }

    @Benchmark
    fun dodArrays(state: DodState) {
        for (i in state.xs.indices) {
            val x = state.xs[i]
            val y = state.ys[i]
            val z = state.zs[i]
            val l = x * x + y * y + z * z
            state.xs[i] /= l
            state.ys[i] /= l
            state.zs[i] /= l
        }
    }

    @Benchmark
    fun dodVectorDelegates(state: DodDelegateState) {
        for(vector in state.vectors) {
            vector.normalize()
        }
    }

    @Benchmark
    fun dodVectorProperties(state: DodPropertyState) {
        for(vector in state.vectors) {
            vector.normalize()
        }
    }

    @Benchmark
    fun dodVectorInlinedProperties(state: DodInlinedPropertyState) {
        for(vector in state.vectors) {
            vector.normalize()
        }
    }

}

Gives me…

Benchmark                                                                 (count)    Mode     Cnt        Score      Error   Units
Benchmarks.dodArrays                                                       100000   thrpt                0.014             ops/ns
Benchmarks.dodVectorDelegates                                              100000   thrpt                0.365             ops/ns
Benchmarks.dodVectorInlinedProperties                                      100000   thrpt                0.364             ops/ns
Benchmarks.dodVectorProperties                                             100000   thrpt                0.362             ops/ns
Benchmarks.oopVectors                                                      100000   thrpt               ≈ 10⁻⁶             ops/ns
Benchmarks.dodArrays                                                       100000    avgt               72.730              ns/op
Benchmarks.dodVectorDelegates                                              100000    avgt                2.765              ns/op
Benchmarks.dodVectorInlinedProperties                                      100000    avgt                2.714              ns/op
Benchmarks.dodVectorProperties                                             100000    avgt                2.714              ns/op
Benchmarks.oopVectors                                                      100000    avgt          1189224.866              ns/op
Benchmarks.dodArrays                                                       100000  sample  355407       19.277 ±    0.727   ns/op
Benchmarks.dodArrays:dodArrays·p0.00                                       100000  sample               15.000              ns/op
Benchmarks.dodArrays:dodArrays·p0.50                                       100000  sample               18.000              ns/op
Benchmarks.dodArrays:dodArrays·p0.90                                       100000  sample               19.000              ns/op
Benchmarks.dodArrays:dodArrays·p0.95                                       100000  sample               19.000              ns/op
Benchmarks.dodArrays:dodArrays·p0.99                                       100000  sample               20.000              ns/op
Benchmarks.dodArrays:dodArrays·p0.999                                      100000  sample               26.000              ns/op
Benchmarks.dodArrays:dodArrays·p0.9999                                     100000  sample             1325.613              ns/op
Benchmarks.dodArrays:dodArrays·p1.00                                       100000  sample            25792.000              ns/op
Benchmarks.dodVectorDelegates                                              100000  sample  251133       30.107 ±    1.280   ns/op
Benchmarks.dodVectorDelegates:dodVectorDelegates·p0.00                     100000  sample               16.000              ns/op
Benchmarks.dodVectorDelegates:dodVectorDelegates·p0.50                     100000  sample               29.000              ns/op
Benchmarks.dodVectorDelegates:dodVectorDelegates·p0.90                     100000  sample               34.000              ns/op
Benchmarks.dodVectorDelegates:dodVectorDelegates·p0.95                     100000  sample               35.000              ns/op
Benchmarks.dodVectorDelegates:dodVectorDelegates·p0.99                     100000  sample               40.000              ns/op
Benchmarks.dodVectorDelegates:dodVectorDelegates·p0.999                    100000  sample               57.000              ns/op
Benchmarks.dodVectorDelegates:dodVectorDelegates·p0.9999                   100000  sample            12854.928              ns/op
Benchmarks.dodVectorDelegates:dodVectorDelegates·p1.00                     100000  sample            27200.000              ns/op
Benchmarks.dodVectorInlinedProperties                                      100000  sample  227080       29.479 ±    1.721   ns/op
Benchmarks.dodVectorInlinedProperties:dodVectorInlinedProperties·p0.00     100000  sample               15.000              ns/op
Benchmarks.dodVectorInlinedProperties:dodVectorInlinedProperties·p0.50     100000  sample               27.000              ns/op
Benchmarks.dodVectorInlinedProperties:dodVectorInlinedProperties·p0.90     100000  sample               30.000              ns/op
Benchmarks.dodVectorInlinedProperties:dodVectorInlinedProperties·p0.95     100000  sample               35.000              ns/op
Benchmarks.dodVectorInlinedProperties:dodVectorInlinedProperties·p0.99     100000  sample               37.000              ns/op
Benchmarks.dodVectorInlinedProperties:dodVectorInlinedProperties·p0.999    100000  sample               58.000              ns/op
Benchmarks.dodVectorInlinedProperties:dodVectorInlinedProperties·p0.9999   100000  sample            14900.670              ns/op
Benchmarks.dodVectorInlinedProperties:dodVectorInlinedProperties·p1.00     100000  sample            24608.000              ns/op
Benchmarks.dodVectorProperties                                             100000  sample  252660       29.027 ±    1.092   ns/op
Benchmarks.dodVectorProperties:dodVectorProperties·p0.00                   100000  sample               15.000              ns/op
Benchmarks.dodVectorProperties:dodVectorProperties·p0.50                   100000  sample               29.000              ns/op
Benchmarks.dodVectorProperties:dodVectorProperties·p0.90                   100000  sample               33.000              ns/op
Benchmarks.dodVectorProperties:dodVectorProperties·p0.95                   100000  sample               34.000              ns/op
Benchmarks.dodVectorProperties:dodVectorProperties·p0.99                   100000  sample               38.000              ns/op
Benchmarks.dodVectorProperties:dodVectorProperties·p0.999                  100000  sample               48.000              ns/op
Benchmarks.dodVectorProperties:dodVectorProperties·p0.9999                 100000  sample             2241.648              ns/op
Benchmarks.dodVectorProperties:dodVectorProperties·p1.00                   100000  sample            25728.000              ns/op
Benchmarks.oopVectors                                                      100000  sample    5881  1056902.769 ± 1361.110   ns/op
Benchmarks.oopVectors:oopVectors·p0.00                                     100000  sample           991232.000              ns/op
Benchmarks.oopVectors:oopVectors·p0.50                                     100000  sample          1062912.000              ns/op
Benchmarks.oopVectors:oopVectors·p0.90                                     100000  sample          1083392.000              ns/op
Benchmarks.oopVectors:oopVectors·p0.95                                     100000  sample          1103872.000              ns/op
Benchmarks.oopVectors:oopVectors·p0.99                                     100000  sample          1138688.000              ns/op
Benchmarks.oopVectors:oopVectors·p0.999                                    100000  sample          1213267.968              ns/op
Benchmarks.oopVectors:oopVectors·p0.9999                                   100000  sample          1273856.000              ns/op
Benchmarks.oopVectors:oopVectors·p1.00                                     100000  sample          1273856.000              ns/op
Benchmarks.dodArrays                                                       100000      ss             1095.000              ns/op
Benchmarks.dodVectorDelegates                                              100000      ss            14374.000              ns/op
Benchmarks.dodVectorInlinedProperties                                      100000      ss             1736.000              ns/op
Benchmarks.dodVectorProperties                                             100000      ss             1674.000              ns/op
Benchmarks.oopVectors                                                      100000      ss          1186483.000              ns/op

Topic		Replies	Views
K/N IOS - IntArray Performance Issue Native	4	898	October 14, 2021
Performance Problem	8	3782	January 17, 2018
Kotlin-style properties for Java	0	774	April 14, 2021
Deep nested inline functions run slowly and can causes an error at compile	3	3420	January 20, 2016
Performant and elegant iterator over custom collection Support	10	9287	June 3, 2017

Property/inline performance

Related topics