Cache parameterize() results

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "topstitch"
-version = "0.94.0"
+version = "0.95.0"
 edition = "2024"
 license = "Apache-2.0"
 description = "Stitch together Verilog modules with Rust"

src/mod_def/parameterize.rs

@@ -4,13 +4,23 @@ use indexmap::IndexMap;
 use num_bigint::{BigInt, Sign};
 use parking_lot::RwLock;
 use std::collections::{HashMap, HashSet};
-use std::sync::Arc;
+use std::sync::{Arc, LazyLock};
 
 use crate::{
-    IO, ModDef, ModDefCore, ParserConfig, Usage, mod_def::parser_param_to_param,
-    mod_def::parser_port_to_port,
+    IO, ModDef, ModDefCore, ParserConfig, Usage, mod_def::parser_cfg::ParserConfigOwnedKey,
+    mod_def::parser_param_to_param, mod_def::parser_port_to_port,
 };
 
+#[derive(Clone, Debug)]
+struct ParameterizeCacheEntry {
+    ports: IndexMap<String, IO>,
+    enum_ports: IndexMap<String, String>,
+    parameter_types: IndexMap<String, ParameterType>,
+}
+
+static PARAMETERIZE_CACHE: LazyLock<RwLock<HashMap<ParserConfigOwnedKey, ParameterizeCacheEntry>>> =
+    LazyLock::new(|| RwLock::new(HashMap::new()));
+
 // Represents the type of a parameter
 #[derive(Clone, Debug)]
 pub enum ParameterType {
@@ -137,56 +147,74 @@ impl ModDef {
             ..Default::default()
         };
 
-        let parser_result = slang_rs::run_slang(&cfg.to_slang_config()).unwrap();
-        let parser_ports = slang_rs::extract_ports_from_value(&parser_result, true);
-        let parser_parameters = slang_rs::extract_parameter_defs_from_value(&parser_result, true);
-
-        // Build new ports and enum port info based on the parameterized interface
-        let mut ports = IndexMap::new();
-        let mut enum_ports = IndexMap::new();
-        for parser_port in parser_ports[&core.name].iter() {
-            match parser_port_to_port(parser_port) {
-                Ok((name, io)) => {
-                    ports.insert(name.clone(), io.clone());
-                    if let slang_rs::Type::Enum {
-                        name: enum_name,
-                        packed_dimensions,
-                        unpacked_dimensions,
-                        ..
-                    } = &parser_port.ty
-                        && packed_dimensions.is_empty()
-                        && unpacked_dimensions.is_empty()
-                        && let IO::Input(_) = io
-                    {
-                        enum_ports.insert(name.clone(), enum_name.clone());
+        let cache_key = cfg.to_owned_key();
+        let cached_entry = PARAMETERIZE_CACHE.read().get(&cache_key).cloned();
+        let (ports, enum_ports, parameter_types) = if let Some(entry) = cached_entry {
+            (entry.ports, entry.enum_ports, entry.parameter_types)
+        } else {
+            let parser_result = slang_rs::run_slang(&cfg.to_slang_config()).unwrap();
+            let parser_ports = slang_rs::extract_ports_from_value(&parser_result, true);
+            let parser_parameters =
+                slang_rs::extract_parameter_defs_from_value(&parser_result, true);
+
+            // Build new ports and enum port info based on the parameterized interface
+            let mut ports = IndexMap::new();
+            let mut enum_ports = IndexMap::new();
+            for parser_port in parser_ports[&core.name].iter() {
+                match parser_port_to_port(parser_port) {
+                    Ok((name, io)) => {
+                        ports.insert(name.clone(), io.clone());
+                        if let slang_rs::Type::Enum {
+                            name: enum_name,
+                            packed_dimensions,
+                            unpacked_dimensions,
+                            ..
+                        } = &parser_port.ty
+                            && packed_dimensions.is_empty()
+                            && unpacked_dimensions.is_empty()
+                            && let IO::Input(_) = io
+                        {
+                            enum_ports.insert(name.clone(), enum_name.clone());
+                        }
                     }
-                }
-                Err(e) => {
-                    if !core.verilog_import.as_ref().unwrap().skip_unsupported {
-                        panic!("{e}");
-                    } else {
-                        continue;
+                    Err(e) => {
+                        if !core.verilog_import.as_ref().unwrap().skip_unsupported {
+                            panic!("{e}");
+                        } else {
+                            continue;
+                        }
                     }
                 }
             }
-        }
 
-        // Parameter types for building literals during emission
-        let mut parameter_types = IndexMap::new();
-        for parser_param in parser_parameters[&core.name].iter() {
-            match parser_param_to_param(parser_param) {
-                Ok((name, param_type)) => {
-                    parameter_types.insert(name, param_type);
-                }
-                Err(e) => {
-                    if !core.verilog_import.as_ref().unwrap().skip_unsupported {
-                        panic!("{e}");
-                    } else {
-                        continue;
+            // Parameter types for building literals during emission
+            let mut parameter_types = IndexMap::new();
+            for parser_param in parser_parameters[&core.name].iter() {
+                match parser_param_to_param(parser_param) {
+                    Ok((name, param_type)) => {
+                        parameter_types.insert(name, param_type);
+                    }
+                    Err(e) => {
+                        if !core.verilog_import.as_ref().unwrap().skip_unsupported {
+                            panic!("{e}");
+                        } else {
+                            continue;
+                        }
                     }
                 }
             }
-        }
+
+            PARAMETERIZE_CACHE.write().insert(
+                cache_key,
+                ParameterizeCacheEntry {
+                    ports: ports.clone(),
+                    enum_ports: enum_ports.clone(),
+                    parameter_types: parameter_types.clone(),
+                },
+            );
+
+            (ports, enum_ports, parameter_types)
+        };
 
         // Build final parameter specs combining values and types (types must exist)
         let mut final_parameter_specs: IndexMap<String, crate::mod_def::ParameterSpec> =

src/mod_def/parser_cfg.rs

@@ -2,6 +2,24 @@
 
 use slang_rs::SlangConfig;
 
+#[derive(Clone, Debug, Eq, Hash, PartialEq)]
+pub(crate) struct ParserConfigOwnedKey {
+    pub(crate) sources: Vec<String>,
+    pub(crate) tops: Vec<String>,
+    pub(crate) incdirs: Vec<String>,
+    pub(crate) defines: Vec<(String, String)>,
+    pub(crate) parameters: Vec<(String, String)>,
+    pub(crate) libfiles: Vec<String>,
+    pub(crate) libdirs: Vec<String>,
+    pub(crate) libexts: Vec<String>,
+    pub(crate) ignore_unknown_modules: bool,
+    pub(crate) ignore_protected: bool,
+    pub(crate) timescale: Option<String>,
+    pub(crate) skip_unsupported: bool,
+    pub(crate) include_hierarchy: bool,
+    pub(crate) extra_arguments: Vec<String>,
+}
+
 #[derive(Debug)]
 pub struct ParserConfig<'a> {
     pub sources: &'a [&'a str],
@@ -58,4 +76,35 @@ impl ParserConfig<'_> {
             extra_arguments: self.extra_arguments,
         }
     }
+
+    pub(crate) fn to_owned_key(&self) -> ParserConfigOwnedKey {
+        ParserConfigOwnedKey {
+            sources: self.sources.iter().map(|s| (*s).to_string()).collect(),
+            tops: self.tops.iter().map(|s| (*s).to_string()).collect(),
+            incdirs: self.incdirs.iter().map(|s| (*s).to_string()).collect(),
+            defines: self
+                .defines
+                .iter()
+                .map(|(k, v)| ((*k).to_string(), (*v).to_string()))
+                .collect(),
+            parameters: self
+                .parameters
+                .iter()
+                .map(|(k, v)| ((*k).to_string(), (*v).to_string()))
+                .collect(),
+            libfiles: self.libfiles.iter().map(|s| (*s).to_string()).collect(),
+            libdirs: self.libdirs.iter().map(|s| (*s).to_string()).collect(),
+            libexts: self.libexts.iter().map(|s| (*s).to_string()).collect(),
+            ignore_unknown_modules: self.ignore_unknown_modules,
+            ignore_protected: self.ignore_protected,
+            timescale: self.timescale.map(|t| t.to_string()),
+            skip_unsupported: self.skip_unsupported,
+            include_hierarchy: self.include_hierarchy,
+            extra_arguments: self
+                .extra_arguments
+                .iter()
+                .map(|s| (*s).to_string())
+                .collect(),
+        }
+    }
 }