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

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

@@ -57,7 +57,7 @@ public InvalidDateException(final String message, final Throwable cause) {
 
     // region Cache
 
-    private static class SummaryData extends ImmutableConcurrentCache.IntKeyedValue {
+    private static class SummaryData extends ReadOptimizedConcurrentCache.IntKeyedValue {
         private final Instant startInstant;
         private final LocalDate startDate;
         private final Instant endInstant;
@@ -92,8 +92,8 @@ public SummaryData(
         }
     }
 
-    private final ImmutableConcurrentCache<ImmutableConcurrentCache.Pair<CalendarDay<Instant>>> schedulesCache =
-            new ImmutableConcurrentCache<>(10000, this::computeCalendarDay);
+    private final ReadOptimizedConcurrentCache<ReadOptimizedConcurrentCache.Pair<CalendarDay<Instant>>> schedulesCache =
+            new ReadOptimizedConcurrentCache<>(10000, this::computeCalendarDay);
     private final YearMonthSummaryCache<SummaryData> summaryCache =
             new YearMonthSummaryCache<>(this::computeMonthSummary, this::computeYearSummary);
     private final int yearCacheStart;
@@ -112,26 +112,23 @@ private SummaryData summarize(final int key, final LocalDate startDate, final Lo
 
         LocalDate date = startDate;
         long businessTimeNanos = 0;
-        int days = 0;
         int businessDays = 0;
         int nonBusinessDays = 0;
         final ArrayList<LocalDate> businessDates = new ArrayList<>();
         final ArrayList<LocalDate> nonBusinessDates = new ArrayList<>();
 
         while (date.isBefore(endDate)) {
             final CalendarDay<Instant> bs = calendarDay(date);
-            final boolean ibd = bs.isBusinessDay();
-            days += 1;
-            businessDays += ibd ? 1 : 0;
-            nonBusinessDays += ibd ? 0 : 1;
-            businessTimeNanos += bs.businessNanos();
 
-            if (ibd) {
+            if (bs.isBusinessDay()) {
+                ++businessDays;
                 businessDates.add(date);
             } else {
+                ++nonBusinessDays;
                 nonBusinessDates.add(date);
             }
 
+            businessTimeNanos += bs.businessNanos();
             date = date.plusDays(1);
         }
 
@@ -228,7 +225,7 @@ static LocalDate schedulesCacheDateFromKey(final int key) {
         return LocalDate.of(key / 10000, (key % 10000) / 100, key % 100);
     }
 
-    private ImmutableConcurrentCache.Pair<CalendarDay<Instant>> computeCalendarDay(final int key) {
+    private ReadOptimizedConcurrentCache.Pair<CalendarDay<Instant>> computeCalendarDay(final int key) {
         final LocalDate date = schedulesCacheDateFromKey(key);
         final CalendarDay<Instant> h = holidays.get(date);
         final CalendarDay<Instant> v;
@@ -241,7 +238,7 @@ private ImmutableConcurrentCache.Pair<CalendarDay<Instant>> computeCalendarDay(f
             v = CalendarDay.toInstant(standardBusinessDay, date, timeZone());
         }
 
-        return new ImmutableConcurrentCache.Pair<>(key, v);
+        return new ReadOptimizedConcurrentCache.Pair<>(key, v);
     }
 
     // endregion

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

@@ -30,7 +30,7 @@ public class Calendar {
 
     // region Cache
 
-    private static class SummaryData extends ImmutableConcurrentCache.IntKeyedValue {
+    private static class SummaryData extends ReadOptimizedConcurrentCache.IntKeyedValue {
         final LocalDate startDate;
         final LocalDate endDate; // exclusive
         final List<LocalDate> dates;

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

@@ -9,12 +9,12 @@
 import java.util.function.IntFunction;
 
 /**
- * An immutable cache that is designed to be fast when accessed concurrently with read-heavy workloads. Values are
- * populated from a function when they are not found in the cache. All values must be non-null.
+ * A cache that is designed to be fast when accessed concurrently with read-heavy workloads. Values are populated from a
+ * function when they are not found in the cache. All values must be non-null.
  *
  * @param <V> the value type
  */
-class ImmutableConcurrentCache<V extends ImmutableConcurrentCache.IntKeyedValue> {
+class ReadOptimizedConcurrentCache<V extends ReadOptimizedConcurrentCache.IntKeyedValue> {
 
     /**
      * A value that has an included integer key.
@@ -88,7 +88,7 @@ public int getIntKey(V v) {
      * @param initialCapacity the initial capacity
      * @param valueComputer computes the value for a key.
      */
-    public ImmutableConcurrentCache(final int initialCapacity, final IntFunction<V> valueComputer) {
+    public ReadOptimizedConcurrentCache(final int initialCapacity, final IntFunction<V> valueComputer) {
         this.valueComputer = valueComputer;
         this.cache = new KeyedIntObjectHash<>(initialCapacity, new KeyDef<>());
     }
@@ -105,7 +105,7 @@ synchronized void clear() {
      *
      * @param key the key
      * @return the value
-     * @throws IllegalArgumentException if the value is not found
+     * @throws NullPointerException if the value is not found
      */
     public V computeIfAbsent(int key) {
         V existing = cache.get(key);
@@ -117,10 +117,10 @@ public V computeIfAbsent(int key) {
         final V newValue = valueComputer.apply(key);
 
         if (newValue == null) {
-            throw new IllegalArgumentException("Computed a null value: key=" + key);
+            throw new NullPointerException("Computed a null value: key=" + key);
         }
 
-        existing = cache.putIfAbsent(key, newValue);
+        existing = cache.put(key, newValue);
         return existing == null ? newValue : existing;
     }
 }

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

@@ -12,7 +12,7 @@
  *
  * @param <T> the type of the summary
  */
-class YearMonthSummaryCache<T extends ImmutableConcurrentCache.IntKeyedValue> {
+class YearMonthSummaryCache<T extends ReadOptimizedConcurrentCache.IntKeyedValue> {
 
     /**
      * Computes a year-month key for a year and month.
@@ -45,8 +45,8 @@ static int monthFromYearMonthKey(int key) {
         return key % 100;
     }
 
-    private final ImmutableConcurrentCache<T> monthCache;
-    private final ImmutableConcurrentCache<T> yearCache;
+    private final ReadOptimizedConcurrentCache<T> monthCache;
+    private final ReadOptimizedConcurrentCache<T> yearCache;
 
     /**
      * Creates a new cache.
@@ -55,8 +55,8 @@ static int monthFromYearMonthKey(int key) {
      * @param computeYearSummary the function to compute a year summary
      */
     YearMonthSummaryCache(IntFunction<T> computeMonthSummary, IntFunction<T> computeYearSummary) {
-        monthCache = new ImmutableConcurrentCache<>(12 * 50, computeMonthSummary);
-        yearCache = new ImmutableConcurrentCache<>(50, computeYearSummary);
+        monthCache = new ReadOptimizedConcurrentCache<>(12 * 50, computeMonthSummary);
+        yearCache = new ReadOptimizedConcurrentCache<>(50, computeYearSummary);
     }
 
     /**

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

@@ -5,9 +5,9 @@
 
 import io.deephaven.base.testing.BaseArrayTestCase;
 
-public class TestImmutableConcurrentCache extends BaseArrayTestCase {
+public class TestReadOptimizedConcurrentCache extends BaseArrayTestCase {
 
-    private static class Value extends ImmutableConcurrentCache.Pair<String> {
+    private static class Value extends ReadOptimizedConcurrentCache.Pair<String> {
         Value(int key, String value) {
             super(key, value);
         }
@@ -24,8 +24,8 @@ private static Value makeVal(Integer key) {
     }
 
     public void testCache() {
-        final ImmutableConcurrentCache<Value> cache =
-                new ImmutableConcurrentCache<>(10, TestImmutableConcurrentCache::makeVal);
+        final ReadOptimizedConcurrentCache<Value> cache =
+                new ReadOptimizedConcurrentCache<>(10, TestReadOptimizedConcurrentCache::makeVal);
 
         assertEquals("A", cache.computeIfAbsent(0).getValue());
         assertEquals("A", cache.computeIfAbsent(0).getValue());
@@ -37,7 +37,7 @@ public void testCache() {
         try {
             cache.computeIfAbsent(3);
             fail("Expected exception");
-        } catch (final IllegalArgumentException e) {
+        } catch (final NullPointerException e) {
             // pass
         }
 
@@ -49,7 +49,7 @@ public void testCache() {
         try {
             cache.computeIfAbsent(3);
             fail("Expected exception");
-        } catch (final IllegalArgumentException e) {
+        } catch (final NullPointerException e) {
             // pass
         }
     }

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

@@ -16,7 +16,7 @@
 @SuppressWarnings({"DataFlowIssue", "ConstantValue"})
 public class TestYearMonthSummaryCache extends BaseArrayTestCase {
 
-    private static class Value extends ImmutableConcurrentCache.Pair<String> {
+    private static class Value extends ReadOptimizedConcurrentCache.Pair<String> {
         Value(int key, String value) {
             super(key, value);
         }