SMT8 Program Generator

.gitignore

@@ -16,6 +16,8 @@ log/
 /test_apps/**/.session
 rls/
 .pytest_cache
+.cline_storage/
+
 
 # pyenv
 .python-version

python/origen/origen/producer.py

@@ -159,6 +159,9 @@ def Flow(self, **kwargs):
             flow_refs = _origen_metal.prog_gen.start_new_flow(flow.name, **options)
             origen.interface.top_level_options = kwargs
 
+        if "namespace" in kwargs:
+            _origen_metal.prog_gen.set_namespace(kwargs["namespace"])
+
         #origen.tester.reset()
         #origen.target.reload()
         #origen.tester.clear_dut_dependencies(ast_name=flow.name)

rust/origen/src/core/tester.rs

@@ -23,6 +23,7 @@ use std::collections::HashSet;
 use std::env;
 use std::io::Write;
 use std::path::{Path, PathBuf};
+use std::process::Command;
 
 #[macro_export]
 macro_rules! push_pin_actions {
@@ -31,6 +32,40 @@ macro_rules! push_pin_actions {
     }};
 }
 
+/// When running on GitHub Actions, this function runs a diff command
+/// to show the differences in the CI log. Does nothing otherwise.
+fn display_diff_on_ci(old_path: &Path, new_path: &Path) {
+    if env::var("GITHUB_ACTIONS").map(|v| v == "true").unwrap_or(false) {
+        println!("Running diff for GitHub Actions CI:");
+        match Command::new("diff")
+            .arg("-u")
+            .arg(old_path)
+            .arg(new_path)
+            .output()
+        {
+            Ok(output) => {
+                if !output.stdout.is_empty() {
+                    println!("--- Diff Output ---");
+                    if let Ok(stdout) = String::from_utf8(output.stdout) {
+                        for line in stdout.lines() {
+                            println!("{}", line);
+                        }
+                    }
+                    println!("--- End Diff ---");
+                }
+                if !output.stderr.is_empty() {
+                    if let Ok(stderr) = String::from_utf8(output.stderr) {
+                        eprintln!("Diff stderr: {}", stderr);
+                    }
+                }
+            }
+            Err(e) => {
+                eprintln!("Failed to run diff command: {}", e);
+            }
+        }
+    }
+}
+
 #[macro_export]
 macro_rules! text {
     ($txt:expr) => {{
@@ -523,6 +558,7 @@ impl Tester {
                                                     }
                                                     self.stats.changed_pattern_files += 1;
                                                     display_redln!("Diffs found");
+                                                    display_diff_on_ci(&ref_pat, &path);
                                                     let old = to_relative_path(&ref_pat, None)
                                                         .unwrap_or(ref_pat);
                                                     let new = to_relative_path(&path, None)
@@ -620,6 +656,7 @@ impl Tester {
                                                     }
                                                     self.stats.changed_program_files += 1;
                                                     display_redln!("Diffs found");
+                                                    display_diff_on_ci(&ref_pat, &path);
                                                     let old = to_relative_path(&ref_pat, None)
                                                         .unwrap_or(ref_pat);
                                                     let new = to_relative_path(&path, None)
@@ -689,46 +726,52 @@ impl Tester {
                         display!("Created: {}", list.display());
                     }
                     if let Some(ref_dir) = crate::STATUS.reference_dir() {
-                        let ref_list = ref_dir.join("referenced.list");
-                        display!(" - ");
-                        if ref_list.exists() {
-                            let mut differ = ASCIIDiffer::new(&ref_list, &list);
-                            differ.ignore_comments("#")?;
-                            if differ.has_diffs()? {
-                                if let Err(e) = reference_files::create_changed_ref(
-                                    Path::new("referenced.list"),
-                                    &list,
-                                    &ref_list,
-                                ) {
-                                    log_error!("{}", e);
+                        match list.strip_prefix(crate::STATUS.output_dir()) {
+                            Err(e) => log_error!("{}", e),
+                            Ok(stem) => {
+                                let ref_list = ref_dir.join(&stem);
+                                display!(" - ");
+                                if ref_list.exists() {
+                                    let mut differ = ASCIIDiffer::new(&ref_list, &list);
+                                    differ.ignore_comments("#")?;
+                                    if differ.has_diffs()? {
+                                        if let Err(e) = reference_files::create_changed_ref(
+                                            Path::new("referenced.list"),
+                                            &list,
+                                            &ref_list,
+                                        ) {
+                                            log_error!("{}", e);
+                                        }
+                                        self.stats.changed_program_files += 1;
+                                        display_redln!("Diffs found");
+                                        display_diff_on_ci(&ref_list, &list);
+                                        let old = to_relative_path(&ref_list, None).unwrap_or(ref_list);
+                                        let new = to_relative_path(&list, None).unwrap_or(list.to_owned());
+                                        let diff_tool = std::env::var("ORIGEN_DIFF_TOOL")
+                                            .unwrap_or("tkdiff".to_string());
+                                        displayln!(
+                                            "  {} {} {} &",
+                                            &diff_tool,
+                                            old.display(),
+                                            new.display()
+                                        );
+                                        display!("  origen save_ref referenced.list");
+                                    } else {
+                                        display_green!("No diffs");
+                                    }
+                                } else {
+                                    self.stats.new_program_files += 1;
+                                    if let Err(e) = reference_files::create_new_ref(
+                                        Path::new("referenced.list"),
+                                        &list,
+                                        &ref_list,
+                                    ) {
+                                        log_error!("{}", e);
+                                    }
+                                    display_cyanln!("New file");
+                                    display!("  origen save_ref referenced.list");
                                 }
-                                self.stats.changed_program_files += 1;
-                                display_redln!("Diffs found");
-                                let old = to_relative_path(&ref_list, None).unwrap_or(ref_list);
-                                let new = to_relative_path(&list, None).unwrap_or(list.to_owned());
-                                let diff_tool = std::env::var("ORIGEN_DIFF_TOOL")
-                                    .unwrap_or("tkdiff".to_string());
-                                displayln!(
-                                    "  {} {} {} &",
-                                    &diff_tool,
-                                    old.display(),
-                                    new.display()
-                                );
-                                display!("  origen save_ref referenced.list");
-                            } else {
-                                display_green!("No diffs");
-                            }
-                        } else {
-                            self.stats.new_program_files += 1;
-                            if let Err(e) = reference_files::create_new_ref(
-                                Path::new("referenced.list"),
-                                &list,
-                                &ref_list,
-                            ) {
-                                log_error!("{}", e);
                             }
-                            display_cyanln!("New file");
-                            display!("  origen save_ref referenced.list");
                         }
                     }
                     displayln!("");

rust/origen/src/testers/mod.rs

@@ -20,6 +20,7 @@ pub fn instantiate_tester(g: &SupportedTester) -> Result<Box<dyn TesterAPI + std
             Ok(Box::new(DummyRendererWithInterceptors::default()))
         }
         SupportedTester::V93KSMT7 => Ok(Box::new(smt::V93K_SMT7::default())),
+        SupportedTester::V93KSMT8 => Ok(Box::new(smt::V93K_SMT8::default())),
         SupportedTester::SIMULATOR => Ok(Box::new(simulator::Renderer::default())),
         SupportedTester::ULTRAFLEX => Ok(Box::new(igxl::UltraFlex::default())),
         SupportedTester::J750 => Ok(Box::new(igxl::j750::J750::default())),

rust/origen/src/testers/smt/mod.rs

@@ -1,3 +1,4 @@
 pub mod v93k;
 
 pub use v93k::smt7::SMT7 as V93K_SMT7;
+pub use v93k::smt8::SMT8 as V93K_SMT8;

rust/origen/src/testers/smt/v93k/smt8/mod.rs

@@ -1 +1,106 @@
+use crate::core::tester::{Interceptor, TesterID};
+use crate::generator::PAT;
+use crate::testers::vector_based::pattern_renderer::Renderer;
+use crate::testers::vector_based::VectorBased;
+use crate::testers::SupportedTester;
+use origen_metal::prog_gen::SupportedTester as ProgGenSupportedTester;
+use crate::{Result, DUT};
+use origen_metal::ast::{Node, Return};
+
+#[derive(Debug, Clone)]
+pub struct SMT8 {}
+
+impl Default for SMT8 {
+    fn default() -> Self {
+        Self {}
+    }
+}
+
+impl TesterID for SMT8 {
+    fn id(&self) -> SupportedTester {
+        SupportedTester::V93KSMT8
+    }
+
+    fn id_prog_gen(&self) -> ProgGenSupportedTester {
+        ProgGenSupportedTester::V93KSMT8
+    }
+}
+
+// TODO: This has just been copied from the SMT7 impl to get program generation underway, it needs to be
+// properly implemented for SMT8 pattern generation
+impl VectorBased for SMT8 {
+    fn comment_str(&self) -> &str {
+        "#"
+    }
+
+    fn file_ext(&self) -> &str {
+        "avc"
+    }
+
+    fn print_vector(
+        &self,
+        renderer: &mut Renderer,
+        repeat: u32,
+        _compressable: bool,
+    ) -> Option<Result<String>> {
+        Some(Ok(format!(
+            "R{} {} {} # <EoL Comment>;",
+            repeat,
+            {
+                match renderer.timeset_name() {
+                    Ok(s) => s,
+                    Err(e) => return Some(Err(e)),
+                }
+            },
+            // The pin states should have been previously updated from the PinAction node, or just has default values
+            {
+                match renderer.render_states() {
+                    Ok(s) => s,
+                    Err(e) => return Some(Err(e)),
+                }
+            }
+        )))
+    }
+
+    fn print_pinlist(&self, renderer: &mut Renderer) -> Option<Result<String>> {
+        let dut = DUT.lock().unwrap();
+        let pins = renderer.states(&dut).names().join(" ");
+        Some(Ok(format!("FORMAT {};", pins)))
+    }
+
+    fn print_pattern_end(&self, _renderer: &mut Renderer) -> Option<Result<String>> {
+        Some(Ok("SQPG STOP;".to_string()))
+    }
+
+    fn override_node(
+        &self,
+        renderer: &mut Renderer,
+        node: &Node<PAT>,
+    ) -> Option<Result<Return<PAT>>> {
+        match &node.attrs {
+            PAT::Capture(capture, _metadata) => {
+                if let Ok(ids) = capture.enabled_capture_pins() {
+                    for pin in ids.iter() {
+                        if let Some(_) = capture.symbol.as_ref() {
+                            renderer
+                                .capturing
+                                .insert(Some(*pin), capture.symbol.clone());
+                        } else {
+                            renderer.capturing.insert(
+                                Some(*pin),
+                                Some(crate::standards::actions::CAPTURE.to_string()),
+                            );
+                        }
+                    }
+                    Some(Ok(Return::Unmodified))
+                } else {
+                    None
+                }
+            }
+            _ => None,
+        }
+    }
+}
+
+impl Interceptor for SMT8 {}