feat: Only initialize BusinessCalendar caches when data is accessed and improve caching performance

engine/time/src/main/java/io/deephaven/time/calendar/BusinessCalendar.java

@@ -100,7 +100,7 @@ public SummaryData(
     private final int yearCacheEnd;
 
     @Override
-    public synchronized void clearCache() {
+    synchronized void clearCache() {
         super.clearCache();
         schedulesCache.clear();
         summaryCache.clear();
@@ -148,12 +148,12 @@ private SummaryData summarize(final int key, final LocalDate startDate, final Lo
                 nonBusinessDates);
     }
 
-    private SummaryData computeMonthSummary(final int yearMonth) {
-        final int year = yearMonth / 100;
-        final int month = yearMonth % 100;
+    private SummaryData computeMonthSummary(final int key) {
+        final int year = YearMonthSummaryCache.yearFromMonthKey(key);
+        final int month = YearMonthSummaryCache.monthFromMonthKey(key);
         final LocalDate startDate = LocalDate.of(year, month, 1);
         final LocalDate endDate = startDate.plusMonths(1); // exclusive
-        return summarize(yearMonth, startDate, endDate);
+        return summarize(key, startDate, endDate);
     }
 
     private SummaryData computeYearSummary(final int year) {
@@ -208,13 +208,28 @@ private SummaryData getYearSummary(final int year) {
         return summaryCache.getYearSummary(year);
     }
 
+    /**
+     * Creates a key for the schedules cache.
+     *
+     * @param date date
+     * @return key
+     */
+    static int schedulesCacheKey(final LocalDate date) {
+        return date.getYear() * 10000 + date.getMonthValue() * 100 + date.getDayOfMonth();
+    }
+
+    /**
+     * Creates a date from a schedules cache key.
+     *
+     * @param key key
+     * @return date
+     */
+    static LocalDate dateFromSchedulesCacheKey(final int key) {
+        return LocalDate.of(key / 10000, (key % 10000) / 100, key % 100);
+    }
 
-    private ImmutableConcurrentCache.Pair<CalendarDay<Instant>> computeCalendarDay(final int yearMonthDay) {
-        final int year = yearMonthDay / 10000;
-        final int monthDay = yearMonthDay % 10000;
-        final int month = monthDay / 100;
-        final int day = monthDay % 100;
-        final LocalDate date = LocalDate.of(year, month, day);
+    private ImmutableConcurrentCache.Pair<CalendarDay<Instant>> computeCalendarDay(final int key) {
+        final LocalDate date = dateFromSchedulesCacheKey(key);
         final CalendarDay<Instant> h = holidays.get(date);
         final CalendarDay<Instant> v;
 
@@ -226,7 +241,7 @@ private ImmutableConcurrentCache.Pair<CalendarDay<Instant>> computeCalendarDay(f
             v = CalendarDay.toInstant(standardBusinessDay, date, timeZone());
         }
 
-        return new ImmutableConcurrentCache.Pair<>(yearMonthDay, v);
+        return new ImmutableConcurrentCache.Pair<>(key, v);
     }
 
     // endregion
@@ -358,8 +373,8 @@ public CalendarDay<Instant> calendarDay(final LocalDate date) {
                     + " lastValidDate=" + lastValidDate);
         }
 
-        final int yearMonthDay = date.getYear() * 10000 + date.getMonthValue() * 100 + date.getDayOfMonth();
-        return schedulesCache.get(yearMonthDay).getValue();
+        final int key = schedulesCacheKey(date);
+        return schedulesCache.computeIfAbsent(key).getValue();
     }
 
     /**

engine/time/src/main/java/io/deephaven/time/calendar/Calendar.java

@@ -113,7 +113,7 @@ private SummaryData computeYearSummary(final int year) {
     /**
      * Clears the cache. This should not generally be used and is provided for benchmarking.
      */
-    public synchronized void clearCache() {
+    synchronized void clearCache() {
         summaryCache.clear();
     }
 

engine/time/src/main/java/io/deephaven/time/calendar/CalendarDay.java

@@ -31,8 +31,7 @@ public class CalendarDay<T extends Comparable<T> & Temporal> {
     public static final CalendarDay<LocalTime> HOLIDAY = new CalendarDay<>();
 
     private final TimeRange<T>[] businessTimeRanges;
-    private final List<TimeRange<T>> businessTimeRangesList;
-    private volatile long businessNanos = -1;
+    private final long businessNanos;
 
     /**
      * Creates a CalendarDay instance.
@@ -66,7 +65,7 @@ public class CalendarDay<T extends Comparable<T> & Temporal> {
         }
 
         this.businessTimeRanges = ranges;
-        this.businessTimeRangesList = List.of(ranges);
+        this.businessNanos = Arrays.stream(businessTimeRanges).map(TimeRange::nanos).reduce(0L, Long::sum);
     }
 
     /**
@@ -83,7 +82,7 @@ public class CalendarDay<T extends Comparable<T> & Temporal> {
      * @return business time ranges for the day
      */
     public List<TimeRange<T>> businessTimeRanges() {
-        return businessTimeRangesList;
+        return List.of(businessTimeRanges);
     }
 
     /**
@@ -120,15 +119,7 @@ public boolean isInclusiveEnd() {
      * @return length of the day in nanoseconds
      */
     public long businessNanos() {
-        // Only read volatile 1x
-        long bn = businessNanos;
-
-        if (bn < 0) {
-            bn = Arrays.stream(businessTimeRanges).map(TimeRange::nanos).reduce(0L, Long::sum);
-            businessNanos = bn;
-        }
-
-        return bn;
+        return businessNanos;
     }
 
     /**

engine/time/src/main/java/io/deephaven/time/calendar/ImmutableConcurrentCache.java

@@ -70,22 +70,13 @@ public T getValue() {
         }
     }
 
-    private static class KeyDef<V extends IntKeyedValue> extends KeyedIntObjectKey.Strict<V> {
+    private static class KeyDef<V extends IntKeyedValue> extends KeyedIntObjectKey.BasicStrict<V> {
 
         @Override
         public int getIntKey(V v) {
             return v.getKey();
         }
 
-        @Override
-        public int hashIntKey(int i) {
-            return i;
-        }
-
-        @Override
-        public boolean equalIntKey(int i, V v) {
-            return i == v.getKey();
-        }
     }
 
     private final IntFunction<V> valueComputer;
@@ -116,7 +107,7 @@ synchronized void clear() {
      * @return the value
      * @throws IllegalArgumentException if the value is not found
      */
-    public V get(int key) {
+    public V computeIfAbsent(int key) {
         V existing = cache.get(key);
 
         if (existing != null) {

engine/time/src/main/java/io/deephaven/time/calendar/YearMonthSummaryCache.java

@@ -14,6 +14,37 @@
  */
 class YearMonthSummaryCache<T extends ImmutableConcurrentCache.IntKeyedValue> {
 
+    /**
+     * Computes a key for a year and month.
+     *
+     * @param year the year
+     * @param month the month
+     * @return the key
+     */
+    static int monthKey(int year, int month) {
+        return year * 100 + month;
+    }
+
+    /**
+     * Gets the year from a year-month key.
+     *
+     * @param key the year month key
+     * @return the year
+     */
+    static int yearFromMonthKey(int key) {
+        return key / 100;
+    }
+
+    /**
+     * Gets the month from a year-month key.
+     *
+     * @param key the year month key
+     * @return the month
+     */
+    static int monthFromMonthKey(int key) {
+        return key % 100;
+    }
+
     private final ImmutableConcurrentCache<T> monthCache;
     private final ImmutableConcurrentCache<T> yearCache;
 
@@ -36,16 +67,6 @@ synchronized void clear() {
         yearCache.clear();
     }
 
-    /**
-     * Gets the month summary for the specified year and month.
-     *
-     * @param yearMonth the year and month
-     * @return the month summary
-     */
-    T getMonthSummary(int yearMonth) {
-        return monthCache.get(yearMonth);
-    }
-
     /**
      * Gets the month summary for the specified year and month.
      *
@@ -54,7 +75,7 @@ T getMonthSummary(int yearMonth) {
      * @return the month summary
      */
     T getMonthSummary(int year, int month) {
-        return getMonthSummary(year * 100 + month);
+        return monthCache.computeIfAbsent(monthKey(year, month));
     }
 
     /**
@@ -64,7 +85,7 @@ T getMonthSummary(int year, int month) {
      * @return the year summary
      */
     T getYearSummary(int year) {
-        return yearCache.get(year);
+        return yearCache.computeIfAbsent(year);
     }
 
     private class YearMonthSummaryIterator implements Iterator<T> {
@@ -89,7 +110,7 @@ private class YearMonthSummaryIterator implements Iterator<T> {
                 incrementCurrentByMonth();
             }
 
-            currentYearMonth = currentYear * 100 + currentMonth;
+            currentYearMonth = monthKey(currentYear, currentMonth);
 
             final LocalDate endPlus1 = end.plusDays(1);
             final int endPlus1Month = endPlus1.getMonthValue();
@@ -106,7 +127,7 @@ private class YearMonthSummaryIterator implements Iterator<T> {
                 }
             }
 
-            finalYearMonth = finalYear * 100 + finalMonth;
+            finalYearMonth = monthKey(finalYear, finalMonth);
         }
 
         private void incrementCurrentByMonth() {
@@ -117,12 +138,12 @@ private void incrementCurrentByMonth() {
                 currentMonth = currentMonth + 1;
             }
 
-            currentYearMonth = currentYear * 100 + currentMonth;
+            currentYearMonth = monthKey(currentYear, currentMonth);
         }
 
         private void incrementCurrentByYear() {
             currentYear++;
-            currentYearMonth = currentYear * 100 + currentMonth;
+            currentYearMonth = monthKey(currentYear, currentMonth);
         }
 
         @Override
@@ -138,7 +159,7 @@ public T next() {
                 val = getYearSummary(currentYear);
                 incrementCurrentByYear();
             } else {
-                val = getMonthSummary(currentYear * 100 + currentMonth);
+                val = getMonthSummary(currentYear, currentMonth);
                 incrementCurrentByMonth();
             }
 

engine/time/src/test/java/io/deephaven/time/calendar/TestBusinessCalendar.java

@@ -43,6 +43,17 @@ protected void setUp() throws Exception {
         calendar = bCalendar;
     }
 
+    public void testSchedulesCacheKeys() {
+        final int y = 2023;
+        final int m = 7;
+        final int d = 11;
+        final LocalDate ld = LocalDate.of(y, m, d);
+
+        final int key = BusinessCalendar.schedulesCacheKey(ld);
+        assertEquals(key, y * 10000 + m * 100 + d);
+        assertEquals(ld, BusinessCalendar.dateFromSchedulesCacheKey(key));
+    }
+
     public void testBusinessGetters() {
         assertEquals(schedule, bCalendar.standardBusinessDay());
         assertEquals(schedule.businessNanos(), bCalendar.standardBusinessNanos());

engine/time/src/test/java/io/deephaven/time/calendar/TestImmutableConcurrentCache.java

@@ -27,27 +27,27 @@ public void testCache() {
         final ImmutableConcurrentCache<Value> cache =
                 new ImmutableConcurrentCache<>(10, TestImmutableConcurrentCache::makeVal);
 
-        assertEquals("A", cache.get(0).getValue());
-        assertEquals("A", cache.get(0).getValue());
+        assertEquals("A", cache.computeIfAbsent(0).getValue());
+        assertEquals("A", cache.computeIfAbsent(0).getValue());
 
-        assertEquals("A", cache.get(0).getValue());
-        assertEquals("B", cache.get(1).getValue());
-        assertEquals("C", cache.get(2).getValue());
+        assertEquals("A", cache.computeIfAbsent(0).getValue());
+        assertEquals("B", cache.computeIfAbsent(1).getValue());
+        assertEquals("C", cache.computeIfAbsent(2).getValue());
 
         try {
-            cache.get(3);
+            cache.computeIfAbsent(3);
             fail("Expected exception");
         } catch (final IllegalArgumentException e) {
             // pass
         }
 
         cache.clear();
-        assertEquals("A", cache.get(0).getValue());
-        assertEquals("B", cache.get(1).getValue());
-        assertEquals("C", cache.get(2).getValue());
+        assertEquals("A", cache.computeIfAbsent(0).getValue());
+        assertEquals("B", cache.computeIfAbsent(1).getValue());
+        assertEquals("C", cache.computeIfAbsent(2).getValue());
 
         try {
-            cache.get(3);
+            cache.computeIfAbsent(3);
             fail("Expected exception");
         } catch (final IllegalArgumentException e) {
             // pass