Native (all): improve performance, fix SharedImmutable (#2)

Testing revealed that accessing even immutable global variables
concurrently is not supported out-of-the-box and instead crashes
the Kotlin Native runtime. Thus, `SharedImmutable` annotation was
added to every global variable.

Performance 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.
* Instead of passing strings between Kotlin and native parts,
  numeric ids are used. To have a sensible interpretation of such
  ids that prohibited their invalidation, Apple and Windows use
  additional memory to store the mapping. Moreover, it is assumed
  for Apple that the set of timezones and their rules never change,
  and for *nix, it is assumed that the timezone objects are always
  at the same memory location, which is true for now but will
  change if the implementation switches to use C++20 capabilities.
* 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.
* 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.
* Some Kotlin-style range checks were replaced with the
  corresponding simple comparisons due to a missing optimization
  in Kotlin/Native. See
  #5

After these fixes, on my machine tests run in 22 seconds instead of
56.

Author: dkhalanskyjb

core/build.gradle.kts

@@ -237,6 +237,13 @@ task("downloadWindowsZonesMapping") {
                 out.println("\t{ \"$windowsName\", \"$usualName\" },")
             }
             out.println("};")
+            out.println("""static const std::unordered_map<std::string, size_t> zone_ids = {""")
+            var i = 0
+            for ((usualName, windowsName) in mapping) {
+                out.println("\t{ \"$usualName\", $i },")
+                ++i
+            }
+            out.println("};")
         }
     }
 }

core/commonMain/src/DayOfWeek.kt

@@ -5,6 +5,8 @@
 
 package kotlinx.datetime
 
+import kotlin.native.concurrent.*
+
 public expect enum class DayOfWeek {
     MONDAY,
     TUESDAY,
@@ -17,6 +19,7 @@ public expect enum class DayOfWeek {
 
 public val DayOfWeek.number: Int get() = ordinal + 1
 
+@SharedImmutable
 private val allDaysOfWeek = DayOfWeek.values().asList()
 public fun DayOfWeek(number: Int): DayOfWeek {
     require(number in 1..7)

core/commonMain/src/Month.kt

@@ -5,6 +5,8 @@
 
 package kotlinx.datetime
 
+import kotlin.native.concurrent.*
+
 public expect enum class Month {
     JANUARY,
     FEBRUARY,
@@ -24,7 +26,9 @@ public expect enum class Month {
 
 public val Month.number: Int get() = ordinal + 1
 
+@SharedImmutable
 private val allMonths = Month.values().asList()
+
 public fun Month(number: Int): Month {
     require(number in 1..12)
     return allMonths[number - 1]

core/nativeMain/cinterop/cpp/apple.mm

@@ -12,6 +12,7 @@
 #import <Foundation/NSDate.h>
 #import <Foundation/NSCalendar.h>
 #import <limits.h>
+#import <vector>
 #import <set>
 #import <string>
 #include "helper_macros.hpp"
@@ -29,26 +30,63 @@
 
 extern "C" {
 #include "cdate.h"
+}
 
-char * get_system_timezone()
+static std::vector<NSTimeZone *> populate()
+{
+    std::vector<NSTimeZone *> v;
+    auto names = NSTimeZone.knownTimeZoneNames;
+    for (size_t i = 0; i < names.count; ++i) {
+        v.push_back([NSTimeZone timeZoneWithName: names[i]]);
+    }
+    return v;
+}
+
+static std::vector<NSTimeZone *> zones_cache = populate();
+
+static TZID id_by_name(NSString *zone_name)
+{
+    auto abbreviations = NSTimeZone.abbreviationDictionary;
+    auto true_name = [abbreviations valueForKey: zone_name];
+    const NSString *name = zone_name;
+    if (true_name != nil) {
+        name = true_name;
+    }
+    for (size_t i = 0; i < zones_cache.size(); ++i) {
+        if ([name isEqualToString:zones_cache[i].name]) {
+            return i;
+        }
+    }
+    return TZID_INVALID;
+}
+
+static NSTimeZone *timezone_by_id(TZID id)
+{
+    try {
+        return zones_cache.at(id);
+    } catch (std::out_of_range e) {
+        return nullptr;
+    }
+}
+
+extern "C" {
+
+char * get_system_timezone(TZID *tzid)
 {
     CFTimeZoneRef zone = CFTimeZoneCopySystem(); // always succeeds
     auto name = CFTimeZoneGetName(zone);
+    *tzid = id_by_name((__bridge NSString *)name);
     CFIndex bufferSize = CFStringGetLength(name) + 1;
     char * buffer = (char *)malloc(sizeof(char) * bufferSize);
     if (buffer == nullptr) {
         CFRelease(zone);
         return nullptr;
     }
     // only fails if the name is not UTF8-encoded, which is an anomaly.
-    if (CFStringGetCString(name, buffer, bufferSize, kCFStringEncodingUTF8))
-    {
-        CFRelease(zone);
-        return buffer;
-    }
+    auto result = CFStringGetCString(name, buffer, bufferSize, kCFStringEncodingUTF8);
+    assert(result);
     CFRelease(zone);
-    free(buffer);
-    return nullptr;
+    return buffer;
 }
 
 char ** available_zone_ids()
@@ -77,25 +115,22 @@
     return zones_copy;
 }
 
-int offset_at_instant(const char *zone_name, int64_t epoch_sec)
+int offset_at_instant(TZID zone_id, int64_t epoch_sec)
 {
-    auto zone_name_nsstring = [NSString stringWithUTF8String: zone_name];
-    auto zone = zone_by_name(zone_name_nsstring);
+    auto zone = timezone_by_id(zone_id);
+    if (zone == nil) { return INT_MAX; }
     auto date = [NSDate dateWithTimeIntervalSince1970: epoch_sec];
     return (int32_t)[zone secondsFromGMTForDate: date];
 }
 
-bool is_known_timezone(const char *zone_name) {
-    auto zone_name_nsstring = [NSString stringWithUTF8String: zone_name];
-    return (zone_by_name(zone_name_nsstring) != nil);
+TZID timezone_by_name(const char *zone_name) {
+    return id_by_name([NSString stringWithUTF8String: zone_name]);
 }
 
-int offset_at_datetime(const char *zone_name, int64_t epoch_sec, int *offset) {
+int offset_at_datetime(TZID zone_id, int64_t epoch_sec, int *offset) {
     *offset = INT_MAX;
-    // timezone name
-    auto zone_name_nsstring = [NSString stringWithUTF8String: zone_name];
     // timezone
-    auto zone = zone_by_name(zone_name_nsstring);
+    auto zone = timezone_by_id(zone_id);
     if (zone == nil) { return 0; }
     /* a date in an unspecified timezone, defined by the number of seconds since
        the start of the epoch in *that* unspecified timezone */

core/nativeMain/cinterop/cpp/cdate.cpp

@@ -15,6 +15,10 @@
 using namespace date;
 using namespace std::chrono;
 
+extern "C" {
+#include "cdate.h"
+}
+
 template <class T>
 static char * timezone_name(const T& zone)
 {
@@ -26,17 +30,44 @@ static char * timezone_name(const T& zone)
     return name_copy;
 }
 
-extern "C" {
+static const time_zone *zone_by_id(TZID id)
+{
+    /* The `date` library provides a linked list of `tzdb` objects. `get_tzdb()`
+       always returns the head of that list. For now, the list never changes:
+       a call to `reload_tzdb()` would be required to load the updated version
+       of the timezone database. We never do this because for now (with use of
+       `date`) this operation is not even present for the configuration that
+       uses the system timezone database. If we move to C++20 support for this,
+       it may be feasible to call `reload_tzdb()` and construct a more elaborate
+       ID scheme. */
+    auto& tzdb = get_tzdb();
+    try {
+        return &tzdb.zones.at(id);
+    } catch (std::out_of_range e) {
+        throw std::runtime_error("Invalid timezone id");
+    }
+}
 
-#include "cdate.h"
+static TZID id_by_zone(const tzdb& db, const time_zone* tz)
+{
+    size_t id = tz - &db.zones[0];
+    if (id >= db.zones.size()) {
+        throw std::runtime_error("The time zone is not part of the tzdb");
+    }
+    return id;
+}
 
-char * get_system_timezone()
+extern "C" {
+
+char * get_system_timezone(TZID * id)
 {
     try {
         auto& tzdb = get_tzdb();
         auto zone = tzdb.current_zone();
+        *id = id_by_zone(tzdb, zone);
         return timezone_name(*zone);
     } catch (std::runtime_error e) {
+        *id = TZID_INVALID;
         return nullptr;
     }
 }
@@ -59,38 +90,35 @@ char ** available_zone_ids()
     }
 }
 
-int offset_at_instant(const char *zone_name, int64_t epoch_sec)
+int offset_at_instant(TZID zone_id, int64_t epoch_sec)
 {
     try {
-        auto& tzdb = get_tzdb();
         /* `sys_time` is usually Unix time (UTC, not counting leap seconds).
            Starting from C++20, it is specified in the standard. */
         auto stime = sys_time<std::chrono::seconds>(
             std::chrono::seconds(epoch_sec));
-        auto zone = tzdb.locate_zone(zone_name);
+        auto zone = zone_by_id(zone_id);
         auto info = zone->get_info(stime);
         return info.offset.count();
     } catch (std::runtime_error e) {
         return INT_MAX;
     }
 }
 
-bool is_known_timezone(const char *zone_name)
+TZID timezone_by_name(const char *zone_name)
 {
     try {
         auto& tzdb = get_tzdb();
-        tzdb.locate_zone(zone_name);
-        return true;
+        return id_by_zone(tzdb, tzdb.locate_zone(zone_name));
     } catch (std::runtime_error e) {
-        return false;
+        return TZID_INVALID;
     }
 }
 
-int offset_at_datetime(const char *zone_name, int64_t epoch_sec, int *offset)
+int offset_at_datetime(TZID zone_id, int64_t epoch_sec, int *offset)
 {
     try {
-        auto& tzdb = get_tzdb();
-        auto zone = tzdb.locate_zone(zone_name);
+        auto zone = zone_by_id(zone_id);
         local_seconds seconds((std::chrono::seconds(epoch_sec)));
         auto info = zone->get_info(seconds);
         switch (info.result) {
@@ -107,6 +135,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;