optimize era storage

robertbastian · robertbastian · commit ea3835868d54 · 2025-12-18T17:07:38.000+01:00
diff --git a/components/calendar/src/cal/japanese.rs b/components/calendar/src/cal/japanese.rs
@@ -11,7 +11,7 @@ use crate::error::{DateError, UnknownEraError};
 use crate::provider::{CalendarJapaneseModernV1, EraStartDate};
 use crate::{types, AsCalendar, Date};
 use icu_provider::prelude::*;
-use tinystr::tinystr;
+use tinystr::{tinystr, TinyAsciiStr};
 
 /// The [Japanese Calendar] (with modern eras only)
 ///
@@ -37,9 +37,49 @@ use tinystr::tinystr;
 ///
 /// These eras are loaded from data, requiring a data provider capable of providing [`CalendarJapaneseModernV1`]
 /// data.
-#[derive(Clone, Debug, Default)]
+#[derive(Clone, Debug, Copy)]
 pub struct Japanese {
-    eras: DataPayload<CalendarJapaneseModernV1>,
+    last_era: PackedEra,
+}
+
+impl Default for Japanese {
+    fn default() -> Self {
+        Self {
+            last_era: PackedEra::new(REIWA),
+        }
+    }
+}
+
+#[derive(Clone, Debug, Copy)]
+struct PackedEra {
+    // The year is stored as an offset from `REIWA`,
+    // which works until 2274
+    year: u8,
+    month: u8,
+    day: u8,
+    name: TinyAsciiStr<8>,
+}
+
+impl PackedEra {
+    const fn new(v: (EraStartDate, TinyAsciiStr<16>)) -> Self {
+        Self {
+            year: (v.0.year - REIWA.0.year) as u8,
+            month: v.0.month,
+            day: v.0.day,
+            name: v.1.resize(),
+        }
+    }
+
+    const fn expand(self) -> (EraStartDate, TinyAsciiStr<16>) {
+        (
+            EraStartDate {
+                year: self.year as i32 + REIWA.0.year,
+                month: self.month,
+                day: self.day,
+            },
+            self.name.resize(),
+        )
+    }
 }
 
 impl Japanese {
@@ -50,11 +90,27 @@ impl Japanese {
     /// [📚 Help choosing a constructor](icu_provider::constructors)
     #[cfg(feature = "compiled_data")]
     pub const fn new() -> Self {
-        Self {
-            eras: DataPayload::from_static_ref(
-                crate::provider::Baked::SINGLETON_CALENDAR_JAPANESE_MODERN_V1,
-            ),
-        }
+        let last_era = const {
+            if let Some(&zerovec::ule::tuple::Tuple2ULE(start, name)) =
+                crate::provider::Baked::SINGLETON_CALENDAR_JAPANESE_MODERN_V1
+                    .dates_to_eras
+                    .as_slice()
+                    .as_ule_slice()
+                    .last()
+            {
+                PackedEra::new((
+                    EraStartDate {
+                        year: i32::from_le_bytes(start.year.0),
+                        month: start.month,
+                        day: start.day,
+                    },
+                    name,
+                ))
+            } else {
+                panic!("Invalid era data")
+            }
+        };
+        Self { last_era }
     }
 
     icu_provider::gen_buffer_data_constructors!(() -> error: DataError,
@@ -70,36 +126,59 @@ impl Japanese {
         provider: &D,
     ) -> Result<Self, DataError> {
         Ok(Self {
-            eras: provider.load(Default::default())?.payload,
+            last_era: PackedEra::new(
+                provider
+                    .load(Default::default())?
+                    .payload
+                    .get()
+                    .dates_to_eras
+                    .last()
+                    .ok_or_else(|| DataError::custom("Invalid era data"))?,
+            ),
         })
     }
 }
 
-const MEIJI_START: EraStartDate = EraStartDate {
-    year: 1868,
-    month: 10,
-    day: 23,
-};
-const TAISHO_START: EraStartDate = EraStartDate {
-    year: 1912,
-    month: 7,
-    day: 30,
-};
-const SHOWA_START: EraStartDate = EraStartDate {
-    year: 1926,
-    month: 12,
-    day: 25,
-};
-const HEISEI_START: EraStartDate = EraStartDate {
-    year: 1989,
-    month: 1,
-    day: 8,
-};
-const REIWA_START: EraStartDate = EraStartDate {
-    year: 2019,
-    month: 5,
-    day: 1,
-};
+const MEIJI: (EraStartDate, TinyAsciiStr<16>) = (
+    EraStartDate {
+        year: 1868,
+        month: 10,
+        day: 23,
+    },
+    tinystr!(16, "meiji"),
+);
+const TAISHO: (EraStartDate, TinyAsciiStr<16>) = (
+    EraStartDate {
+        year: 1912,
+        month: 7,
+        day: 30,
+    },
+    tinystr!(16, "taisho"),
+);
+const SHOWA: (EraStartDate, TinyAsciiStr<16>) = (
+    EraStartDate {
+        year: 1926,
+        month: 12,
+        day: 25,
+    },
+    tinystr!(16, "showa"),
+);
+const HEISEI: (EraStartDate, TinyAsciiStr<16>) = (
+    EraStartDate {
+        year: 1989,
+        month: 1,
+        day: 8,
+    },
+    tinystr!(16, "heisei"),
+);
+const REIWA: (EraStartDate, TinyAsciiStr<16>) = (
+    EraStartDate {
+        year: 2019,
+        month: 5,
+        day: 1,
+    },
+    tinystr!(16, "reiwa"),
+);
 
 impl GregorianYears for &'_ Japanese {
     fn extended_from_era_year(
@@ -110,82 +189,36 @@ impl GregorianYears for &'_ Japanese {
         if let Ok(g) = CeBce.extended_from_era_year(era, year) {
             return Ok(g);
         }
-        let Some(era) = era else {
-            // unreachable, handled by CeBce
-            return Err(UnknownEraError);
-        };
-
-        // Avoid linear search by trying well known eras
-        if era == b"reiwa" {
-            return Ok(year - 1 + REIWA_START.year);
-        } else if era == b"heisei" {
-            return Ok(year - 1 + HEISEI_START.year);
-        } else if era == b"showa" {
-            return Ok(year - 1 + SHOWA_START.year);
-        } else if era == b"taisho" {
-            return Ok(year - 1 + TAISHO_START.year);
-        } else if era == b"meiji" {
-            return Ok(year - 1 + MEIJI_START.year);
-        }
 
-        let era_start = self
-            .eras
-            .get()
-            .dates_to_eras
-            .iter()
-            .rev()
-            .find_map(|(s, e)| (e.as_bytes() == era).then_some(s))
+        let (start, _) = [self.last_era.expand(), REIWA, HEISEI, SHOWA, TAISHO, MEIJI]
+            .into_iter()
+            .find(|(_, name)| era == Some(name.as_bytes()))
             .ok_or(UnknownEraError)?;
-        Ok(era_start.year + year - 1)
+
+        Ok(year - 1 + start.year)
     }
 
     fn era_year_from_extended(&self, year: i32, month: u8, day: u8) -> types::EraYear {
         let date: EraStartDate = EraStartDate { year, month, day };
 
-        let (start, era) = if date >= MEIJI_START
-            && self
-                .eras
-                .get()
-                .dates_to_eras
-                .last()
-                .is_some_and(|(_, e)| e == tinystr!(16, "reiwa"))
+        if let Some((start, era)) = [self.last_era.expand(), REIWA, HEISEI, SHOWA, TAISHO, MEIJI]
+            .into_iter()
+            .find(|&(start, _)| date >= start)
         {
-            // We optimize for the five "modern" post-Meiji eras, which are stored in a smaller
-            // array and also hardcoded. The hardcoded version is not used if data indicates the
-            // presence of newer eras.
-            if date >= REIWA_START {
-                (REIWA_START, tinystr!(16, "reiwa"))
-            } else if date >= HEISEI_START {
-                (HEISEI_START, tinystr!(16, "heisei"))
-            } else if date >= SHOWA_START {
-                (SHOWA_START, tinystr!(16, "showa"))
-            } else if date >= TAISHO_START {
-                (TAISHO_START, tinystr!(16, "taisho"))
-            } else {
-                (MEIJI_START, tinystr!(16, "meiji"))
+            types::EraYear {
+                era,
+                // TODO: return era indices?
+                era_index: None,
+                year: year - start.year + 1,
+                extended_year: year,
+                ambiguity: types::YearAmbiguity::CenturyRequired,
             }
         } else {
-            let data = &self.eras.get().dates_to_eras;
-            #[allow(clippy::unwrap_used)] // binary search
-            match data.binary_search_by(|(d, _)| d.cmp(&date)) {
-                Err(0) => {
-                    return types::EraYear {
-                        // TODO: return era indices?
-                        era_index: None,
-                        ..CeBce.era_year_from_extended(year, month, day)
-                    };
-                }
-                Ok(index) => data.get(index).unwrap(),
-                Err(index) => data.get(index - 1).unwrap(),
+            types::EraYear {
+                // TODO: return era indices?
+                era_index: None,
+                ..CeBce.era_year_from_extended(year, month, day)
             }
-        };
-
-        types::EraYear {
-            era,
-            era_index: None,
-            year: year - start.year + 1,
-            extended_year: year,
-            ambiguity: types::YearAmbiguity::CenturyRequired,
         }
     }
 
diff --git a/components/datetime/src/neo.rs b/components/datetime/src/neo.rs
@@ -391,7 +391,7 @@ where
 size_test!(
     DateTimeFormatter<crate::fieldsets::YMD>,
     neo_year_month_day_formatter_size,
-    368
+    344
 );
 
 /// [`DateTimeFormatter`] is a formatter capable of formatting dates and/or times from
diff --git a/ffi/capi/src/calendar.rs b/ffi/capi/src/calendar.rs
@@ -6,7 +6,6 @@
 #[diplomat::abi_rename = "icu4x_{0}_mv1"]
 pub mod ffi {
     use alloc::boxed::Box;
-    use alloc::sync::Arc;
 
     #[cfg(feature = "buffer_provider")]
     use crate::unstable::errors::ffi::DataError;
@@ -72,17 +71,15 @@ pub mod ffi {
     #[diplomat::opaque]
     #[diplomat::transparent_convert]
     #[diplomat::rust_link(icu::calendar::AnyCalendar, Enum)]
-    pub struct Calendar(pub Arc<icu_calendar::AnyCalendar>);
+    pub struct Calendar(pub icu_calendar::AnyCalendar);
 
     impl Calendar {
         /// Creates a new [`Calendar`] for the specified kind, using compiled data.
         #[diplomat::rust_link(icu::calendar::AnyCalendar::new, FnInEnum)]
         #[diplomat::attr(auto, constructor)]
         #[cfg(feature = "compiled_data")]
         pub fn create(kind: CalendarKind) -> Box<Calendar> {
-            Box::new(Calendar(Arc::new(icu_calendar::AnyCalendar::new(
-                kind.into(),
-            ))))
+            Box::new(Calendar(icu_calendar::AnyCalendar::new(kind.into())))
         }
 
         /// Creates a new [`Calendar`] for the specified kind, using a particular data source.
@@ -93,12 +90,12 @@ pub mod ffi {
             provider: &DataProvider,
             kind: CalendarKind,
         ) -> Result<Box<Calendar>, DataError> {
-            Ok(Box::new(Calendar(Arc::new(
+            Ok(Box::new(Calendar(
                 icu_calendar::AnyCalendar::try_new_with_buffer_provider(
                     provider.get()?,
                     kind.into(),
                 )?,
-            ))))
+            )))
         }
 
         /// Returns the kind of this calendar
diff --git a/ffi/capi/src/date.rs b/ffi/capi/src/date.rs
@@ -8,7 +8,6 @@ use ffi::IsoWeekOfYear;
 #[diplomat::abi_rename = "icu4x_{0}_mv1"]
 pub mod ffi {
     use alloc::boxed::Box;
-    use alloc::sync::Arc;
     use core::fmt::Write;
     #[cfg(feature = "unstable")]
     use diplomat_runtime::DiplomatOption;
@@ -81,7 +80,7 @@ pub mod ffi {
         #[diplomat::rust_link(icu::calendar::Date::to_any, FnInStruct)]
         #[diplomat::attr(demo_gen, disable)] // covered by Date
         pub fn to_any(&self) -> Box<Date> {
-            Box::new(Date(self.0.to_any().into_atomic_ref_counted()))
+            Box::new(Date(self.0.to_any()))
         }
 
         /// Returns this date's Rata Die
@@ -234,7 +233,7 @@ pub mod ffi {
     #[diplomat::transparent_convert]
     /// An ICU4X Date object capable of containing a date for any calendar.
     #[diplomat::rust_link(icu::calendar::Date, Struct)]
-    pub struct Date(pub icu_calendar::Date<Arc<icu_calendar::AnyCalendar>>);
+    pub struct Date(pub icu_calendar::Date<icu_calendar::AnyCalendar>);
 
     impl Date {
         /// Creates a new [`Date`] representing the ISO date
