chore fully init the smaller fields' cache of lagrange basis

Author: titouantanguy

core/service/src/bin/kms-server.rs

@@ -368,11 +368,14 @@ async fn main_exec() -> anyhow::Result<()> {
 
     tracing::info!("Starting KMS Server with core config: {:?}", &core_config);
 
-    if let Some(threshold_config) = core_config.threshold.as_ref()
-        && let Some(peers) = threshold_config.peers.as_ref()
-    {
-        init_all_lagrange_stores(peers.len(), threshold_config.threshold as usize)?;
-    }
+    // NOTE: Cache for GF16 (which we use here -- for now) is fully
+    // hence why the block below is commented out.
+
+    //if let Some(threshold_config) = core_config.threshold.as_ref()
+    //    && let Some(peers) = threshold_config.peers.as_ref()
+    //{
+    //    init_all_lagrange_stores(peers.len(), threshold_config.threshold as usize)?;
+    //}
 
     tracing::info!(
         "Multi-threading values: tokio::num_workers: {}, rayon_num_threads: {}, total_num_cpus: {}",

core/threshold-algebra/src/galois_fields/common.rs

@@ -7,7 +7,7 @@ use itertools::Itertools;
 
 /// Builds a LagrangeMap containing pre-computed Lagrange polynomials for all sorted subsets
 /// of `{embed(1), ..., embed(num_parties)}` with size ≥ `threshold + 1`.
-fn build_lagrange_map<F: Field>(
+pub(crate) fn build_lagrange_map<F: Field>(
     num_parties: usize,
     threshold: usize,
 ) -> anyhow::Result<LagrangeMap<F>> {
@@ -25,17 +25,13 @@ fn build_lagrange_map<F: Field>(
     Ok(map)
 }
 
+#[allow(unused_variables)]
 /// Pre-computes Lagrange polynomial stores for all enabled Galois field types.
 /// Must be called at startup with the known number of parties and threshold.
+///
+/// __NOTE__: GF8 and GF16 are small enough that we can pre-compute all possible lagrange basis.
+/// so they are skipped here.
 pub fn init_all_lagrange_stores(num_parties: usize, threshold: usize) -> anyhow::Result<()> {
-    #[cfg(feature = "extension_degree_3")]
-    super::gf8::LAGRANGE_STORE
-        .set(build_lagrange_map(num_parties, threshold)?)
-        .ok();
-    #[cfg(feature = "extension_degree_4")]
-    super::gf16::LAGRANGE_STORE
-        .set(build_lagrange_map(num_parties, threshold)?)
-        .ok();
     #[cfg(feature = "extension_degree_5")]
     super::gf32::LAGRANGE_STORE
         .set(build_lagrange_map(num_parties, threshold)?)

core/threshold-algebra/src/galois_fields/gf16.rs

@@ -1,11 +1,11 @@
 use crate::{
-    galois_fields::LagrangeMap,
+    galois_fields::{LagrangeMap, common::build_lagrange_map},
     poly::Poly,
     structure_traits::{Field, FromU128, One, Ring, RingWithExceptionalSequence, Sample, Zero},
 };
 use g2p::{GaloisField, g2p};
 use serde::{Deserialize, Serialize};
-use std::sync::{LazyLock, OnceLock};
+use std::sync::LazyLock;
 
 g2p!(
     GF16,
@@ -84,11 +84,15 @@ impl RingWithExceptionalSequence for GF16 {
     }
 }
 
-pub(crate) static LAGRANGE_STORE: OnceLock<LagrangeMap<GF16>> = OnceLock::new();
+pub(crate) static LAGRANGE_STORE: LazyLock<LagrangeMap<GF16>> = LazyLock::new(|| {
+    build_lagrange_map::<GF16>(0, 15).expect(
+        " Initializaiton of the GF16 Lagrange basis can't fail with 15 parties and threshold 0",
+    )
+});
 
 impl Field for GF16 {
     fn cached_lagrange_polys(points: &[Self]) -> Option<&'static [Poly<Self>]> {
-        LAGRANGE_STORE.get()?.get(points).map(|v| v.as_slice())
+        LAGRANGE_STORE.get(points).map(|v| v.as_slice())
     }
 }
 

core/threshold-algebra/src/galois_fields/gf8.rs

@@ -1,11 +1,11 @@
 use crate::{
-    galois_fields::LagrangeMap,
+    galois_fields::{LagrangeMap, common::build_lagrange_map},
     poly::Poly,
     structure_traits::{Field, FromU128, One, Ring, RingWithExceptionalSequence, Sample, Zero},
 };
 use g2p::{GaloisField, g2p};
 use serde::{Deserialize, Serialize};
-use std::sync::{LazyLock, OnceLock};
+use std::sync::LazyLock;
 
 g2p!(
     GF8,
@@ -84,11 +84,15 @@ impl RingWithExceptionalSequence for GF8 {
     }
 }
 
-pub(crate) static LAGRANGE_STORE: OnceLock<LagrangeMap<GF8>> = OnceLock::new();
+pub(crate) static LAGRANGE_STORE: LazyLock<LagrangeMap<GF8>> = LazyLock::new(|| {
+    build_lagrange_map::<GF8>(0, 7).expect(
+        " Initializaiton of the GF8 Lagrange basis can't fail with 7 parties and threshold 0",
+    )
+});
 
 impl Field for GF8 {
     fn cached_lagrange_polys(points: &[Self]) -> Option<&'static [Poly<Self>]> {
-        LAGRANGE_STORE.get()?.get(points).map(|v| v.as_slice())
+        LAGRANGE_STORE.get(points).map(|v| v.as_slice())
     }
 }