Native (Kotlin): improve performance

dkhalanskyjb · dkhalanskyjb · commit ef0a90255e0a · 2020-04-23T09:51:45.000+03:00
Fixes include: * The system timezone is only queried once, after that, it's cached for the whole life of the thread; Java does something similar, as, according to https://docs.oracle.com/javase/7/docs/api/java/util/TimeZone.html#setDefault(java.util.TimeZone), the system timezone is only queried at the start of the VM, if ever. * Most common `ZoneOffset` instances are now cached, which saves a lot of time due to not having to recompute their string representation, which is costly in aggregate due to how common getting anonymous offsets is for operations on datetimes. * Strings are not converted between UTF-16 and UTF-8 when querying offsets for a particular timezone (the `noStringConversion` cinterop parameter handles this). * Comparators have been rewritten not to use `compareBy`, which is comparatively slow. * `LocalDate` no longer uses `Month` as its main representation of months, as it is an enum, which are surprisingly slow. * `LocalDate` used to calculate many additional fields which may never be required but were nonetheless computed for each instance of the class. Now, instantiating `LocalDate` is much cheaper at the cost of several additional fields being computed on each call. After these fixes, on my machine tests run in 25 seconds instead of 56.
diff --git a/core/nativeMain/cinterop/cpp/cdate.cpp b/core/nativeMain/cinterop/cpp/cdate.cpp
@@ -107,6 +107,10 @@ int offset_at_datetime(const char *zone_name, int64_t epoch_sec, int *offset)
                 if (info.second.offset.count() != *offset)
                     *offset = info.first.offset.count();
                 return 0;
+            default:
+                // the pattern matching above is supposedly exhaustive
+                *offset = INT_MAX;
+                return 0;
         }
     } catch (std::runtime_error e) {
         *offset = INT_MAX;
diff --git a/core/nativeMain/cinterop/date.def b/core/nativeMain/cinterop/date.def
@@ -3,3 +3,5 @@ package = kotlinx.datetime
 # requirements of the `date` library: https://howardhinnant.github.io/date/tz.html#Installation
 linkerOpts.mingw_x64 = -lole32
 linkerOpts.linux_x64 = -lpthread
+
+noStringConversion = offset_at_instant offset_at_datetime
diff --git a/core/nativeMain/cinterop/public/cdate.h b/core/nativeMain/cinterop/public/cdate.h
@@ -3,6 +3,7 @@
  * Use of this source code is governed by the Apache 2.0 License that can be found in the LICENSE.txt file.
  */
 // This file specifies the native interface for datetime information queries.
+#pragma once
 #include <time.h>
 #include <stdint.h>
 #include <stdbool.h>
diff --git a/core/nativeMain/cinterop/public/helper_macros.hpp b/core/nativeMain/cinterop/public/helper_macros.hpp
@@ -2,6 +2,7 @@
  * Copyright 2016-2020 JetBrains s.r.o.
  * Use of this source code is governed by the Apache 2.0 License that can be found in the LICENSE.txt file.
  */
+#pragma once
 
 /* Frees an array of allocated pointers. `array` is the array to free,
    and `length_var` is a variable that holds the current amount of
diff --git a/core/nativeMain/src/Instant.kt b/core/nativeMain/src/Instant.kt
@@ -90,8 +90,13 @@ public actual class Instant internal constructor(internal val epochSeconds: Long
         (this.epochSeconds - other.epochSeconds).seconds + // won't overflow given the instant bounds
             (this.nanos - other.nanos).nanoseconds
 
-    actual override fun compareTo(other: Instant): Int =
-        compareBy<Instant>({ it.epochSeconds }, { it.nanos }).compare(this, other)
+    actual override fun compareTo(other: Instant): Int {
+        val s = epochSeconds.compareTo(other.epochSeconds)
+        if (s != 0) {
+            return s
+        }
+        return nanos.compareTo(other.nanos)
+    }
 
     override fun equals(other: Any?): Boolean =
         this === other || other is Instant && this.epochSeconds == other.epochSeconds && this.nanos == other.nanos
diff --git a/core/nativeMain/src/LocalDate.kt b/core/nativeMain/src/LocalDate.kt
@@ -23,7 +23,19 @@ internal val localDateParser: Parser<LocalDate>
             LocalDate(year, month, day)
         }
 
-public actual class LocalDate private constructor(actual val year: Int, actual val month: Month, actual val dayOfMonth: Int) : Comparable<LocalDate> {
+public actual class LocalDate actual constructor(actual val year: Int, actual val monthNumber: Int, actual val dayOfMonth: Int) : Comparable<LocalDate> {
+
+    init {
+        // org.threeten.bp.LocalDate#create
+        if (dayOfMonth > 28 && dayOfMonth > monthNumber.monthLength(isLeapYear(year))) {
+            if (dayOfMonth == 29) {
+                throw IllegalArgumentException("Invalid date 'February 29' as '$year' is not a leap year")
+            } else {
+                throw IllegalArgumentException("Invalid date '${month.name} $dayOfMonth'")
+            }
+        }
+    }
+
     actual companion object {
         actual fun parse(isoString: String): LocalDate =
             localDateParser.parse(isoString)
@@ -61,17 +73,6 @@ public actual class LocalDate private constructor(actual val year: Int, actual v
         }
     }
 
-    // org.threeten.bp.LocalDate#create
-    actual constructor(year: Int, monthNumber: Int, dayOfMonth: Int) : this(year, Month(monthNumber), dayOfMonth) {
-        if (dayOfMonth > 28 && dayOfMonth > month.length(isLeapYear(year))) {
-            if (dayOfMonth == 29) {
-                throw IllegalArgumentException("Invalid date 'February 29' as '$year' is not a leap year")
-            } else {
-                throw IllegalArgumentException("Invalid date '${month.name} $dayOfMonth'")
-            }
-        }
-    }
-
     // org.threeten.bp.LocalDate#toEpochDay
     internal fun toEpochDay(): Long {
         val y = year
@@ -96,23 +97,36 @@ public actual class LocalDate private constructor(actual val year: Int, actual v
 
     internal fun withYear(newYear: Int): LocalDate = LocalDate(newYear, monthNumber, dayOfMonth)
 
-    actual val monthNumber: Int = month.number
+    actual val month: Month
+        get() = Month(monthNumber)
 
     // org.threeten.bp.LocalDate#getDayOfWeek
-    actual val dayOfWeek: DayOfWeek = run {
-        val dow0 = floorMod(toEpochDay() + 3, 7).toInt()
-        DayOfWeek(dow0 + 1)
-    }
+    actual val dayOfWeek: DayOfWeek
+        get() {
+            val dow0 = floorMod(toEpochDay() + 3, 7).toInt()
+            return DayOfWeek(dow0 + 1)
+        }
 
     // org.threeten.bp.LocalDate#getDayOfYear
-    actual val dayOfYear: Int = month.firstDayOfYear(isLeapYear(year)) + dayOfMonth - 1
-
-    actual override fun compareTo(other: LocalDate): Int =
-        compareBy<LocalDate>({ it.year }, { it.monthNumber }, { it.dayOfMonth }).compare(this, other)
+    actual val dayOfYear: Int
+        get() = month.firstDayOfYear(isLeapYear(year)) + dayOfMonth - 1
+
+    // Several times faster than using `compareBy`
+    actual override fun compareTo(other: LocalDate): Int {
+        val y = year.compareTo(other.year)
+        if (y != 0) {
+            return y
+        }
+        val m = monthNumber.compareTo(other.monthNumber)
+        if (m != 0) {
+            return m
+        }
+        return dayOfMonth.compareTo(dayOfMonth)
+    }
 
     // org.threeten.bp.LocalDate#resolvePreviousValid
-    private fun resolvePreviousValid(year: Int, month: Month, day: Int): LocalDate {
-        val newDay = min(day, month.length(isLeapYear(year)))
+    private fun resolvePreviousValid(year: Int, month: Int, day: Int): LocalDate {
+        val newDay = min(day, month.monthLength(isLeapYear(year)))
         return LocalDate(year, month, newDay)
     }
 
@@ -122,7 +136,7 @@ public actual class LocalDate private constructor(actual val year: Int, actual v
             this
         } else {
             val newYear = safeAdd(year.toLong(), yearsToAdd).toInt()
-            resolvePreviousValid(newYear, month, dayOfMonth)
+            resolvePreviousValid(newYear, monthNumber, dayOfMonth)
         }
 
     // org.threeten.bp.LocalDate#plusMonths
@@ -133,7 +147,7 @@ public actual class LocalDate private constructor(actual val year: Int, actual v
         val monthCount: Long = year * 12L + (monthNumber - 1)
         val calcMonths = monthCount + monthsToAdd // safe overflow
         val newYear: Int = /* YEAR.checkValidIntValue( */ floorDiv(calcMonths, 12).toInt()
-        val newMonth = Month(floorMod(calcMonths, 12).toInt() + 1)
+        val newMonth = floorMod(calcMonths, 12).toInt() + 1
         return resolvePreviousValid(newYear, newMonth, dayOfMonth)
     }
 
diff --git a/core/nativeMain/src/LocalDateTime.kt b/core/nativeMain/src/LocalDateTime.kt
@@ -38,8 +38,14 @@ public actual class LocalDateTime internal constructor(
     actual val second: Int get() = time.second
     actual val nanosecond: Int get() = time.nanosecond
 
-    actual override fun compareTo(other: LocalDateTime): Int =
-        compareBy<LocalDateTime>({ it.date }, { it.time }).compare(this, other)
+    // Several times faster than using `compareBy`
+    actual override fun compareTo(other: LocalDateTime): Int {
+        val d = date.compareTo(other.date)
+        if (d != 0) {
+            return d
+        }
+        return time.compareTo(other.time)
+    }
 
     override fun equals(other: Any?): Boolean =
         this === other || (other is LocalDateTime && compareTo(other) == 0)
diff --git a/core/nativeMain/src/LocalTime.kt b/core/nativeMain/src/LocalTime.kt
@@ -61,8 +61,22 @@ internal class LocalTime(val hour: Int, val minute: Int, val second: Int, val na
         }
     }
 
-    override fun compareTo(other: LocalTime): Int =
-        compareBy<LocalTime>({ it.hour }, { it.minute }, { it.second }, { it.nanosecond }).compare(this, other)
+    // Several times faster than using `compareBy`
+    override fun compareTo(other: LocalTime): Int {
+        val h = hour.compareTo(other.hour)
+        if (h != 0) {
+            return h
+        }
+        val m = minute.compareTo(other.minute)
+        if (m != 0) {
+            return m
+        }
+        val s = second.compareTo(other.second)
+        if (s != 0) {
+            return s
+        }
+        return nanosecond.compareTo(other.nanosecond)
+    }
 
     override fun hashCode(): Int {
         val nod: Long = toNanoOfDay()
diff --git a/core/nativeMain/src/Month.kt b/core/nativeMain/src/Month.kt
@@ -29,10 +29,10 @@ internal fun Month.firstDayOfYear(leapYear: Boolean): Int {
 }
 
 // From threetenbp
-internal fun Month.length(leapYear: Boolean): Int {
+internal fun Int.monthLength(leapYear: Boolean): Int {
     return when (this) {
-        Month.FEBRUARY -> if (leapYear) 29 else 28
-        Month.APRIL, Month.JUNE, Month.SEPTEMBER, Month.NOVEMBER -> 30
+        2 -> if (leapYear) 29 else 28
+        4, 6, 9, 11 -> 30
         else -> 31
     }
 }
diff --git a/core/nativeMain/src/TimeZone.kt b/core/nativeMain/src/TimeZone.kt
@@ -10,18 +10,33 @@ package kotlinx.datetime
 
 import kotlinx.cinterop.*
 import platform.posix.*
+import kotlin.native.concurrent.*
 
 class DateTimeException(str: String? = null) : Exception(str)
 
 public actual open class TimeZone internal constructor(actual val id: String) {
 
+    private val asciiName = id.cstr
+
+    @ThreadLocal
     actual companion object {
+
+        private var systemTimeZoneCached: TimeZone? = null
+
         actual val SYSTEM: TimeZone
-            get() = memScoped {
-                val string = get_system_timezone() ?: throw RuntimeException("Failed to get the system timezone.")
-                val kotlinString = string.toKString()
-                free(string)
-                TimeZone(kotlinString)
+            get() {
+                val cached = systemTimeZoneCached
+                if (cached != null) {
+                    return cached
+                }
+                val systemTimeZone = memScoped {
+                    val string = get_system_timezone() ?: throw RuntimeException("Failed to get the system timezone.")
+                    val kotlinString = string.toKString()
+                    free(string)
+                    TimeZone(kotlinString)
+                }
+                systemTimeZoneCached = systemTimeZone
+                return systemTimeZone
             }
 
         actual val UTC: TimeZone = ZoneOffset.UTC
@@ -92,11 +107,11 @@ public actual open class TimeZone internal constructor(actual val id: String) {
 
     actual open val Instant.offset: ZoneOffset
         get() {
-            val offset = offset_at_instant(id, epochSeconds)
+            val offset = offset_at_instant(asciiName, epochSeconds)
             if (offset == INT_MAX) {
                 throw RuntimeException("Unable to acquire the offset at instant $this for zone ${this@TimeZone}")
             }
-            return ZoneOffset(offset)
+            return ZoneOffset.ofSeconds(offset)
         }
 
     actual fun LocalDateTime.toInstant(): Instant {
@@ -105,15 +120,15 @@ public actual open class TimeZone internal constructor(actual val id: String) {
     }
 
     internal open fun LocalDateTime.atZone(preferred: ZoneOffset? = null): ZonedDateTime = memScoped {
-        val epochSeconds = toEpochSecond(ZoneOffset(0))
+        val epochSeconds = toEpochSecond(ZoneOffset.UTC)
         val offset = alloc<IntVar>()
         offset.value = preferred?.totalSeconds ?: INT_MAX
-        val transitionDuration = offset_at_datetime(id, epochSeconds, offset.ptr)
+        val transitionDuration = offset_at_datetime(asciiName, epochSeconds, offset.ptr)
         if (offset.value == INT_MAX) {
             throw RuntimeException("Unable to acquire the offset at ${this@atZone} for zone ${this@TimeZone}")
         }
         val dateTime = this@atZone.plusSeconds(transitionDuration.toLong())
-        ZonedDateTime(dateTime, this@TimeZone, ZoneOffset(offset.value))
+        ZonedDateTime(dateTime, this@TimeZone, ZoneOffset.ofSeconds(offset.value))
     }
 
     // org.threeten.bp.ZoneId#equals
@@ -128,12 +143,14 @@ public actual open class TimeZone internal constructor(actual val id: String) {
 
 }
 
-public actual class ZoneOffset internal constructor(actual val totalSeconds: Int, id: String? = null) : TimeZone(id
-    ?: zoneIdByOffset(totalSeconds)) {
+@ThreadLocal
+private var zoneOffsetCache: MutableMap<Int, ZoneOffset> = mutableMapOf()
+
+public actual class ZoneOffset internal constructor(actual val totalSeconds: Int, id: String) : TimeZone(id) {
 
     companion object {
         // org.threeten.bp.ZoneOffset#UTC
-        val UTC = ZoneOffset(0)
+        val UTC = ZoneOffset(0, "Z")
 
         // org.threeten.bp.ZoneOffset#of
         internal fun of(offsetId: String): ZoneOffset {
@@ -219,7 +236,20 @@ public actual class ZoneOffset internal constructor(actual val totalSeconds: Int
         internal fun ofHoursMinutesSeconds(hours: Int, minutes: Int, seconds: Int): ZoneOffset {
             validate(hours, minutes, seconds)
             return if (hours == 0 && minutes == 0 && seconds == 0) UTC
-            else ZoneOffset(hours * SECONDS_PER_HOUR + minutes * SECONDS_PER_MINUTE + seconds)
+            else ofSeconds(hours * SECONDS_PER_HOUR + minutes * SECONDS_PER_MINUTE + seconds)
+        }
+
+        // org.threeten.bp.ZoneOffset#ofTotalSeconds
+        internal fun ofSeconds(seconds: Int): ZoneOffset {
+            if (seconds % (15 * SECONDS_PER_MINUTE) == 0) {
+                val cached = zoneOffsetCache[seconds]
+                return if (cached != null) {
+                    cached
+                } else {
+                    ZoneOffset(seconds, zoneIdByOffset(seconds)).also { zoneOffsetCache[seconds] = it }
+                }
+            }
+            return ZoneOffset(seconds, zoneIdByOffset(seconds))
         }
 
         // org.threeten.bp.ZoneOffset#parseNumber
diff --git a/core/nativeTest/src/ThreeTenBpInstantTest.kt b/core/nativeTest/src/ThreeTenBpInstantTest.kt
@@ -6,8 +6,9 @@
  * Copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos
  */
 
-package kotlinx.datetime
+package kotlinx.datetime.test
 
+import kotlinx.datetime.*
 import kotlin.test.*
 
 class ThreeTenBpInstantTest {
diff --git a/core/nativeTest/src/ThreeTenBpLocalDateTest.kt b/core/nativeTest/src/ThreeTenBpLocalDateTest.kt
@@ -6,8 +6,9 @@
  * Copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos
  */
 
-package kotlinx.datetime
+package kotlinx.datetime.test
 
+import kotlinx.datetime.*
 import kotlin.test.*
 
 class ThreeTenBpLocalDateTest {
@@ -31,9 +32,9 @@ class ThreeTenBpLocalDateTest {
 
     @Test
     fun toEpochDay() {
-        val date_0000_01_01 = -678941 - 40587.toLong()
+        val date_0000_01_01 = -678941 - 40587L
 
-        var test: LocalDate = LocalDate(0, 1, 1)
+        var test = LocalDate(0, 1, 1)
         for (i in date_0000_01_01..699999) {
             assertEquals(i, test.toEpochDay())
             test = next(test)
@@ -54,10 +55,10 @@ class ThreeTenBpLocalDateTest {
     @Test
     fun dayOfWeek() {
         var dow = DayOfWeek.MONDAY
-        for (month in Month.values()) {
-            val length = month.length(false)
+        for (month in 1..12) {
+            val length = month.monthLength(false)
             for (i in 1..length) {
-                val d = LocalDate(2007, month.number, i)
+                val d = LocalDate(2007, month, i)
                 assertSame(d.dayOfWeek, dow)
                 dow = DayOfWeek(dow.number % 7 + 1)
             }
@@ -77,7 +78,7 @@ class ThreeTenBpLocalDateTest {
             val a: LocalDate = LocalDate(y, m, d)
             var total = 0
             for (i in 1 until m) {
-                total += Month(i).length(isLeapYear(y))
+                total += i.monthLength(isLeapYear(y))
             }
             val doy = total + d
             assertEquals(a.dayOfYear, doy)
@@ -178,7 +179,7 @@ class ThreeTenBpLocalDateTest {
     private fun next(localDate: LocalDate): LocalDate {
         var date = localDate
         val newDayOfMonth: Int = date.dayOfMonth + 1
-        if (newDayOfMonth <= date.month.length(isLeapYear(date.year))) {
+        if (newDayOfMonth <= date.monthNumber.monthLength(isLeapYear(date.year))) {
             return LocalDate(date.year, date.monthNumber, newDayOfMonth)
         }
         date = LocalDate(date.year, date.monthNumber, 1)
@@ -198,6 +199,6 @@ class ThreeTenBpLocalDateTest {
         if (date.month === Month.DECEMBER) {
             date = date.withYear(date.year - 1)
         }
-        return LocalDate(date.year, date.monthNumber, date.month.length(isLeapYear(date.year)))
+        return LocalDate(date.year, date.monthNumber, date.monthNumber.monthLength(isLeapYear(date.year)))
     }
 }
diff --git a/core/nativeTest/src/ThreeTenBpLocalDateTimeTest.kt b/core/nativeTest/src/ThreeTenBpLocalDateTimeTest.kt
diff --git a/core/nativeTest/src/ThreeTenBpLocalTimeTest.kt b/core/nativeTest/src/ThreeTenBpLocalTimeTest.kt
diff --git a/core/nativeTest/src/ThreeTenBpTimeZoneTest.kt b/core/nativeTest/src/ThreeTenBpTimeZoneTest.kt
diff --git a/core/nativeTest/src/ThreeTenBpUtilTest.kt b/core/nativeTest/src/ThreeTenBpUtilTest.kt

Original file line number	Diff line number	Diff line change
`@@ -29,10 +29,10 @@ internal fun Month.firstDayOfYear(leapYear: Boolean): Int {`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`// From threetenbp`
`32`		`-internal fun Month.length(leapYear: Boolean): Int {`
	`32`	`+internal fun Int.monthLength(leapYear: Boolean): Int {`
`33`	`33`	`return when (this) {`
`34`		`- Month.FEBRUARY -> if (leapYear) 29 else 28`
`35`		`- Month.APRIL, Month.JUNE, Month.SEPTEMBER, Month.NOVEMBER -> 30`
	`34`	`+ 2 -> if (leapYear) 29 else 28`
	`35`	`+ 4, 6, 9, 11 -> 30`
`36`	`36`	`else -> 31`
`37`	`37`	`}`
`38`	`38`	`}`