async fn load_key_mapping<T: DeserializeOwned + Send + Sync + 'static>(
        &self,
        data_type: ProverServiceDataType,
    ) -> anyhow::Result<HashMap<ProverServiceDataKey, Arc<T>>> {
        let mut mapping: HashMap<ProverServiceDataKey, Arc<T>> = HashMap::new();

        // Load each file in parallel. Note that FS access is not necessarily parallel, but
        // deserialization is. For larger files, it makes a big difference.
        // Note: `collect` is important, because iterators are lazy, and otherwise we won't actually
        // spawn threads.
        let handles: Vec<_> = ProverServiceDataKey::all_boojum()
            .into_iter()
            .map(|key| {
                let filepath = self.get_file_path(key, data_type);
                tokio::task::spawn_blocking(move || {
                    let data = Self::load_bincode_from_file(filepath)?;
                    anyhow::Ok((key, Arc::new(data)))
                })
            })
            .collect();
        for handle in futures::future::join_all(handles).await {
            let (key, setup_data) = handle.context("future loading key panicked")??;
            mapping.insert(key, setup_data);
        }
        Ok(mapping)
    }
Async function that loads mapping from disk.
Whilst IO is not parallelizable, ser/de is.
prover/crates/lib/keystore/src/keystore.rs