Optimize CoverageByXPathLevels data model and trie queries

provider/source/Cargo.toml

@@ -73,7 +73,7 @@ num-traits = { workspace = true, optional = true }
 [dev-dependencies]
 postcard = { workspace = true, features = ["alloc"] }
 icu_provider_adapters = { workspace = true }
-icu_provider_export = { workspace = true, features = ["fs_exporter", "baked_exporter", "rayon"] }
+icu_provider_export = { workspace = true, features = ["fs_exporter", "baked_exporter", "rayon", "blob_exporter"] }
 icu_provider = { workspace = true, features = ["deserialize_postcard_1"] }
 icu_segmenter = { path = "../../components/segmenter", features = ["lstm"] }
 simple_logger = { workspace = true }
@@ -105,5 +105,15 @@ icu_experimental = []
 skip_feature_sets = [["use_icu4c"], ["use_wasm"]]
 max_combination_size = 3
 
+[lib]
+bench = false  # This option is required for Benchmark CI
+
+# Standalone benchmark binary for display names data export performance.
+# We set `harness = false` so that it runs as a standalone binary with main() when
+# executing `cargo bench`, but is NOT executed during `cargo test` / `cargo make ci-job-test`.
+[[bench]]
+name = "displaynames"
+harness = false
+
 [lints]
 workspace = true

provider/source/benches/displaynames.rs

@@ -0,0 +1,49 @@
+// This file is part of ICU4X. For terms of use, please see the file
+// called LICENSE at the top level of the ICU4X source tree
+// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
+
+//! Standalone benchmark measuring performance of exporting display names data
+//! across modern coverage locales.
+//!
+//! Run using:
+//! ```text
+//! cargo bench -p icu_provider_source --bench displaynames
+//! ```
+
+use icu_provider_export::blob_exporter::BlobExporter;
+use icu_provider_export::prelude::*;
+use icu_provider_source::SourceDataProvider;
+
+fn main() {
+    let t0 = std::time::Instant::now();
+    let provider = SourceDataProvider::new();
+    let mut blob_bytes = Vec::new();
+    let exporter = BlobExporter::new_with_sink(Box::new(&mut blob_bytes));
+
+    let modern_locales = provider
+        .locales_for_coverage_levels([icu_provider_source::CoverageLevel::Modern])
+        .unwrap();
+
+    ExportDriver::new(
+        modern_locales
+            .into_iter()
+            .map(DataLocaleFamily::without_descendants),
+        DeduplicationStrategy::None.into(),
+        LocaleFallbacker::try_new_unstable(&provider).unwrap(),
+    )
+    .with_markers(
+        icu::experimental::provider::MARKERS
+            .iter()
+            .copied()
+            .filter(|info| info.id.name().starts_with("LocaleNames")),
+    )
+    .export(&provider, exporter)
+    .unwrap();
+
+    let elapsed = t0.elapsed();
+    println!(
+        "displaynames bench: {:.3?} s, blob size: {} bytes",
+        elapsed.as_secs_f64(),
+        blob_bytes.len()
+    );
+}

provider/source/src/cldr_serde/displaynames/mod.rs

@@ -32,6 +32,24 @@ pub(crate) enum Alt {
     Menu,
 }
 
+impl Alt {
+    /// Returns the string representation of the `Alt` variant, or `None` if `Unknown`.
+    pub fn as_str(self) -> Option<&'static str> {
+        match self {
+            Alt::Short => Some("short"),
+            Alt::Long => Some("long"),
+            Alt::Variant => Some("variant"),
+            Alt::StandAlone => Some("stand-alone"),
+            Alt::Official => Some("official"),
+            Alt::Secondary => Some("secondary"),
+            Alt::Biot => Some("biot"),
+            Alt::Chagos => Some("chagos"),
+            Alt::Menu => Some("menu"),
+            Alt::Unknown => None,
+        }
+    }
+}
+
 impl FromStr for Alt {
     type Err = ();
     fn from_str(s: &str) -> Result<Self, Self::Err> {
@@ -57,6 +75,17 @@ pub(crate) enum Menu {
     Extension,
 }
 
+impl Menu {
+    /// Returns the string representation of the `Menu` variant, or `None` if `Unknown`.
+    pub fn as_str(self) -> Option<&'static str> {
+        match self {
+            Menu::Core => Some("core"),
+            Menu::Extension => Some("extension"),
+            Menu::Unknown => None,
+        }
+    }
+}
+
 impl FromStr for Menu {
     type Err = ();
     fn from_str(s: &str) -> Result<Self, Self::Err> {