Merge pull request #2535 from veryl-lang/sim_fix12_port

Improve simulator performance

Author: dalance

crates/analyzer/src/conv/declaration.rs

@@ -319,6 +319,7 @@ impl Conv<&GenerateForDeclaration> for ir::DeclarationBlock {
 
             let block = context.block(|c| {
                 let id = c.insert_var_path(path.clone(), comptime.clone());
+                let array_limit = c.config.evaluate_array_limit;
                 let variable = Variable::new(
                     id,
                     path,
@@ -327,6 +328,7 @@ impl Conv<&GenerateForDeclaration> for ir::DeclarationBlock {
                     vec![comptime.get_value().unwrap().clone()],
                     c.get_affiliation(),
                     &token,
+                    array_limit,
                 );
                 c.insert_variable(id, variable);
 
@@ -561,6 +563,7 @@ impl Conv<&PortDeclarationItem> for () {
 
                 // TODO for array
                 let id = context.insert_var_path(path.clone(), comptime);
+                let array_limit = context.config.evaluate_array_limit;
                 let variable = Variable::new(
                     id,
                     path,
@@ -569,6 +572,7 @@ impl Conv<&PortDeclarationItem> for () {
                     vec![value.clone()],
                     context.get_affiliation(),
                     &variable_token,
+                    array_limit,
                 );
                 context.insert_variable(id, variable);
             } else {
@@ -981,17 +985,17 @@ impl Conv<(&FunctionDeclaration, Option<&FuncPath>)> for () {
                     let kind = VarKind::Variable;
                     let r#type = ret_type.r#type.clone();
 
-                    if let Some(total_array) = r#type.total_array()
+                    if let Some(_total_array) = r#type.total_array()
                         && let Some(total_width) = r#type.total_width()
                     {
                         // type.expand is not necessary
                         // because member access is not allowed for return value
-                        let mut values = vec![];
-                        for _ in 0..total_array {
-                            values.push(Value::new_x(total_width, false));
-                        }
+                        // All elements are initialized to the same x-state
+                        // value, so a single template suffices.
+                        let values = vec![Value::new_x(total_width, false)];
 
                         let ret_id = c.insert_var_path(path.clone(), ret_type.clone());
+                        let array_limit = c.config.evaluate_array_limit;
                         let variable = Variable::new(
                             ret_id,
                             path,
@@ -1000,6 +1004,7 @@ impl Conv<(&FunctionDeclaration, Option<&FuncPath>)> for () {
                             values,
                             c.get_affiliation(),
                             &token,
+                            array_limit,
                         );
                         c.insert_variable(ret_id, variable);
                         Some(ret_id)

crates/analyzer/src/conv/statement.rs

@@ -704,6 +704,7 @@ fn unroll_for(
             }
 
             let id = c.insert_var_path(path.clone(), comptime.clone());
+            let array_limit = c.config.evaluate_array_limit;
             let variable = ir::Variable::new(
                 id,
                 path,
@@ -712,6 +713,7 @@ fn unroll_for(
                 vec![comptime.get_value().unwrap().clone()],
                 c.get_affiliation(),
                 &token,
+                array_limit,
             );
             c.insert_variable(id, variable);
 

crates/analyzer/src/conv/utils.rs

@@ -630,6 +630,7 @@ pub fn eval_const_assign(
             if let Some(exprs) = exprs {
                 let values = eval_array_literal_expressions(context, r#type, exprs, token)?;
                 let id = context.insert_var_path(path.clone(), comptime);
+                let array_limit = context.config.evaluate_array_limit;
                 let variable = Variable::new(
                     id,
                     path.clone(),
@@ -638,6 +639,7 @@ pub fn eval_const_assign(
                     values,
                     context.get_affiliation(),
                     &dst.token,
+                    array_limit,
                 );
                 context.insert_variable(id, variable);
             } else {
@@ -667,6 +669,7 @@ pub fn eval_const_assign(
                         value.trunc(total_width);
                     }
 
+                    let array_limit = context.config.evaluate_array_limit;
                     let variable = Variable::new(
                         id,
                         path.clone(),
@@ -675,6 +678,7 @@ pub fn eval_const_assign(
                         vec![value],
                         context.get_affiliation(),
                         &dst.token,
+                        array_limit,
                     );
                     context.insert_variable(id, variable);
                 }
@@ -709,14 +713,12 @@ pub fn eval_variable(
     let signed = comptime.r#type.signed;
     let id = context.insert_var_path(path.clone(), comptime);
 
-    let values = if let Some(total_array) = r#type.total_array()
-        && let Some(total_width) = r#type.total_width()
-    {
-        let mut values = vec![];
-        for _ in 0..total_array {
-            values.push(Value::new_x(total_width, signed));
-        }
-        values
+    // Every element starts as the same x-state template, so store it once;
+    // the simulator replicates it across the full `r#type.total_array()` at
+    // fill time. Const/param arrays with per-element literals go through
+    // `eval_array_literal` instead and keep their Vec<Value> intact.
+    let values = if let Some(total_width) = r#type.total_width() {
+        vec![Value::new_x(total_width, signed)]
     } else {
         vec![]
     };
@@ -729,6 +731,7 @@ pub fn eval_variable(
         context.insert_var_path_with_id(path, id, comptime);
     }
 
+    let array_limit = context.config.evaluate_array_limit;
     let variable = Variable::new(
         id,
         path.clone(),
@@ -737,6 +740,7 @@ pub fn eval_variable(
         values,
         context.get_affiliation(),
         &token,
+        array_limit,
     );
     context.insert_variable(id, variable);
 }
@@ -1438,6 +1442,7 @@ pub fn build_for_statement(
     } else {
         vec![]
     };
+    let array_limit = context.config.evaluate_array_limit;
     let variable = Variable::new(
         loop_var_id,
         path,
@@ -1446,6 +1451,7 @@ pub fn build_for_statement(
         values,
         context.get_affiliation(),
         &token,
+        array_limit,
     );
     context.insert_variable(loop_var_id, variable);
 

crates/analyzer/src/ir/assign_table.rs

@@ -444,6 +444,7 @@ mod tests {
             vec![],
             Affiliation::Module,
             &TokenRange::default(),
+            context.config.evaluate_array_limit,
         );
         let variable = VariableInfo::new(&variable);
 

crates/analyzer/src/ir/expression.rs

@@ -733,6 +733,17 @@ impl Factor {
     ) {
         match self {
             Factor::Variable(id, index, select, _) => {
+                // `insert_reference` bails out on arrays over `array_limit`;
+                // short-circuit to avoid cloning the full Variable (value
+                // vec scales with array size).
+                let total_array = context
+                    .variables
+                    .get(id)
+                    .map(|v| v.r#type.total_array().unwrap_or(0))
+                    .unwrap_or(0);
+                if total_array > assign_table.array_limit {
+                    return;
+                }
                 if let Some(index) = index.eval_value(context)
                     && let Some(variable) = context.variables.get(id).cloned()
                     && let Some((beg, end)) = select.eval_value(context, &variable.r#type, false)

crates/analyzer/src/ir/statement.rs

@@ -465,28 +465,38 @@ impl AssignDestination {
 
             let mut errors = vec![];
             if let Some((beg, end)) = range {
-                for i in beg..=end {
-                    let index = VarIndex::from_index(i, &variable.r#type.array);
-                    if let Some(index) = index.eval_value(context) {
-                        if assign_context.is_comb()
-                            && assign_table.check_refered(&variable.id, &index, &mask)
-                        {
-                            let mut text = variable.path.to_string();
-                            for i in &index {
-                                text.push_str(&format!("[{i}]"));
+                // `insert_assign` / `check_refered` both bail out on arrays
+                // over `array_limit`; iterating beg..=end just to hit that
+                // guard is pure waste when the index is non-const.
+                let array_size = end.saturating_sub(beg).saturating_add(1);
+                let skip_large_array = !is_index_const
+                    && variable.r#type.total_array().unwrap_or(0) > assign_table.array_limit
+                    && array_size > assign_table.array_limit;
+
+                if !skip_large_array {
+                    for i in beg..=end {
+                        let index = VarIndex::from_index(i, &variable.r#type.array);
+                        if let Some(index) = index.eval_value(context) {
+                            if assign_context.is_comb()
+                                && assign_table.check_refered(&variable.id, &index, &mask)
+                            {
+                                let mut text = variable.path.to_string();
+                                for i in &index {
+                                    text.push_str(&format!("[{i}]"));
+                                }
+                                // ignore `#[allow(unassign_variable)]` attribute
+                                errors.push(AnalyzerError::unassign_variable(&text, &self.token));
                             }
-                            // ignore `#[allow(unassign_variable)]` attribute
-                            errors.push(AnalyzerError::unassign_variable(&text, &self.token));
-                        }
 
-                        let maybe = !is_const | assign_context.is_system_verilog();
-                        let _ = assign_table.insert_assign(
-                            &variable,
-                            index,
-                            mask.clone(),
-                            maybe,
-                            self.token,
-                        );
+                            let maybe = !is_const | assign_context.is_system_verilog();
+                            let _ = assign_table.insert_assign(
+                                &variable,
+                                index,
+                                mask.clone(),
+                                maybe,
+                                self.token,
+                            );
+                        }
                     }
                 }
             }

crates/analyzer/src/ir/variable.rs

@@ -741,6 +741,7 @@ pub struct Variable {
 }
 
 impl Variable {
+    #[allow(clippy::too_many_arguments)]
     pub fn new(
         id: VarId,
         path: VarPath,
@@ -749,11 +750,19 @@ impl Variable {
         value: Vec<Value>,
         affiliation: Affiliation,
         token: &TokenRange,
+        array_limit: usize,
     ) -> Self {
-        let mut assigned = vec![];
-        for _ in 0..value.len() {
-            assigned.push(0u32.into());
-        }
+        // `assigned` tracks per-element coverage and must match the full
+        // array length (not `value.len()`, since `value` may hold a single
+        // template entry for all-same init). `set_assigned` / `unassigned()`
+        // callers gate on `> array_limit` before touching `assigned`, so
+        // arrays past the limit can leave the vec empty.
+        let total_array = r#type.total_array().unwrap_or(value.len()).max(value.len());
+        let assigned: Vec<BigUint> = if total_array > array_limit {
+            Vec::new()
+        } else {
+            vec![0u32.into(); total_array]
+        };
 
         Self {
             id,
@@ -866,8 +875,23 @@ impl fmt::Display for Variable {
         }
         r#type.array.clear();
 
-        let is_array = self.value.len() != 1;
-        for (i, value) in self.value.iter().enumerate() {
+        // Template form (`value.len() == 1 && total_array > 1`) means every
+        // element shares value[0]; otherwise treat value.len() as the
+        // effective element count.
+        let type_len = self.r#type.total_array();
+        let is_template = self.value.len() == 1 && matches!(type_len, Some(n) if n > 1);
+        let display_len = if is_template {
+            type_len.unwrap()
+        } else {
+            self.value.len()
+        };
+        let is_array = display_len != 1;
+        for i in 0..display_len {
+            let value = if is_template {
+                &self.value[0]
+            } else {
+                &self.value[i]
+            };
             if is_array {
                 ret.push_str(&format!(
                     "{} {}[{}]({}): ",

crates/simulator/src/cranelift.rs

@@ -172,6 +172,14 @@ fn build_binary_inner(
     if !config.dump_cranelift {
         settings_builder.set("enable_verifier", "false").unwrap();
     }
+    // Disable alias analysis for unified comb (no_cache path) to avoid
+    // incorrect cross-block load CSE that conflicts with the simulator's
+    // own comb evaluation semantics.
+    if disable_load_cache {
+        settings_builder
+            .set("enable_alias_analysis", "false")
+            .unwrap();
+    }
     let flags = settings::Flags::new(settings_builder);
 
     let isa = match isa::lookup(Triple::host()) {

crates/simulator/src/ir/expression.rs

@@ -1393,12 +1393,20 @@ impl ProtoExpression {
                 let cache_key = *var_offset;
                 let wide = read_width > 64;
 
-                // Load CSE: reuse previously loaded values for the same address
+                // Load CSE: reuse previously loaded values for the same address.
+                // For nb==4 variables, mask cached values to 32 bits to match
+                // the I32 load + uextend behavior of fresh loads.
                 let (mut payload, mut mask_xz) = if !context.disable_load_cache
                     && let Some(&(cached_payload, cached_mask_xz)) =
                         context.load_cache.get(&cache_key)
                 {
-                    (cached_payload, cached_mask_xz)
+                    if nb == 4 {
+                        let p = builder.ins().band_imm(cached_payload, 0xFFFFFFFF_i64);
+                        let m = cached_mask_xz.map(|v| builder.ins().band_imm(v, 0xFFFFFFFF_i64));
+                        (p, m)
+                    } else {
+                        (cached_payload, cached_mask_xz)
+                    }
                 } else {
                     let load_mem_flag = MemFlags::trusted();
 

crates/simulator/src/ir/module.rs

@@ -84,7 +84,18 @@ fn fill_buffers_recursive(
     sorted.sort_by_key(|(k, _)| **k);
 
     for (_, meta) in &sorted {
-        for (element, initial) in meta.elements.iter().zip(meta.initial_values.iter()) {
+        // Single-entry initial_values on a multi-element variable is the
+        // compact template form used for large arrays.
+        let template_mode = meta.initial_values.len() == 1 && meta.elements.len() > 1;
+        for (i, element) in meta.elements.iter().enumerate() {
+            let initial = if template_mode {
+                &meta.initial_values[0]
+            } else {
+                match meta.initial_values.get(i) {
+                    Some(v) => v,
+                    None => continue,
+                }
+            };
             let nb = element.native_bytes;
             let _vs = value_size(nb, use_4state);
             if element.is_ff() {