ewal 0.1.0__tar.gz

ewal-0.1.0/Cargo.lock

@@ -0,0 +1,262 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
+dependencies = [
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+
+[[package]]
+name = "csv"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52cd9d68cf7efc6ddfaaee42e7288d3a99d613d4b50f76ce9827ae0c6e14f938"
+dependencies = [
+ "csv-core",
+ "itoa",
+ "ryu",
+ "serde_core",
+]
+
+[[package]]
+name = "csv-core"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "704a3c26996a80471189265814dbc2c257598b96b8a7feae2d31ace646bb9782"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "either"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+
+[[package]]
+name = "ewal-core"
+version = "0.1.0"
+dependencies = [
+ "csv",
+ "memmap2",
+ "rayon",
+]
+
+[[package]]
+name = "ewal-py"
+version = "0.1.0"
+dependencies = [
+ "ewal-core",
+ "pyo3",
+]
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "itoa"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
+
+[[package]]
+name = "libc"
+version = "0.2.183"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5b646652bf6661599e1da8901b3b9522896f01e736bad5f723fe7a3a27f899d"
+
+[[package]]
+name = "memchr"
+version = "2.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
+
+[[package]]
+name = "memmap2"
+version = "0.9.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "714098028fe011992e1c3962653c96b2d578c4b4bce9036e15ff220319b1e0e3"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+
+[[package]]
+name = "portable-atomic"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "pyo3"
+version = "0.28.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf85e27e86080aafd5a22eae58a162e133a589551542b3e5cee4beb27e54f8e1"
+dependencies = [
+ "libc",
+ "once_cell",
+ "portable-atomic",
+ "pyo3-build-config",
+ "pyo3-ffi",
+ "pyo3-macros",
+]
+
+[[package]]
+name = "pyo3-build-config"
+version = "0.28.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8bf94ee265674bf76c09fa430b0e99c26e319c945d96ca0d5a8215f31bf81cf7"
+dependencies = [
+ "target-lexicon",
+]
+
+[[package]]
+name = "pyo3-ffi"
+version = "0.28.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "491aa5fc66d8059dd44a75f4580a2962c1862a1c2945359db36f6c2818b748dc"
+dependencies = [
+ "libc",
+ "pyo3-build-config",
+]
+
+[[package]]
+name = "pyo3-macros"
+version = "0.28.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f5d671734e9d7a43449f8480f8b38115df67bef8d21f76837fa75ee7aaa5e52e"
+dependencies = [
+ "proc-macro2",
+ "pyo3-macros-backend",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pyo3-macros-backend"
+version = "0.28.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22faaa1ce6c430a1f71658760497291065e6450d7b5dc2bcf254d49f66ee700a"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "pyo3-build-config",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rayon"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "368f01d005bf8fd9b1206fb6fa653e6c4a81ceb1466406b81792d87c5677a58f"
+dependencies = [
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"
+dependencies = [
+ "crossbeam-deque",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "ryu"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f"
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.13.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"

ewal-0.1.0/Cargo.toml

@@ -0,0 +1,3 @@
+[workspace]
+members = ["crates/ewal-core", "crates/ewal-py"]
+resolver = "2"

ewal-0.1.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: ewal
+Version: 0.1.0
+Classifier: Topic :: Scientific/Engineering :: Electronic Design Automation (EDA)
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: 3
+Summary: Embedded Waveform Analysis Library
+Keywords: verilog,vhdl,vcd,fst,eda,fpga,waveform
+License: BSD-3-Clause
+Requires-Python: >=3.9

ewal-0.1.0/crates/ewal-core/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "ewal-core"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+memmap2 = "0.9"
+csv = { version = "1.3", optional = true }
+rayon = "1.10"
+
+[features]
+default = ["vcd", "csv_format"]
+vcd = []
+csv_format = ["dep:csv"]

ewal-0.1.0/crates/ewal-core/src/eval/expr.rs

@@ -0,0 +1,141 @@
+use crate::signal::bitpack::{bit_slice, sign_extend};
+use crate::signal::SignalValue;
+use crate::trace::{SignalId, Trace};
+
+/// Expression tree compiled from Python-side SignalExpr.
+#[derive(Clone)]
+pub enum Expr {
+    Signal(SignalId),
+    Const(SignalValue),
+    RelEval(Box<Expr>, i64),
+    Not(Box<Expr>),
+    And(Box<Expr>, Box<Expr>),
+    Or(Box<Expr>, Box<Expr>),
+    Eq(Box<Expr>, Box<Expr>),
+    Neq(Box<Expr>, Box<Expr>),
+    Gt(Box<Expr>, Box<Expr>),
+    Lt(Box<Expr>, Box<Expr>),
+    Gte(Box<Expr>, Box<Expr>),
+    Lte(Box<Expr>, Box<Expr>),
+    Add(Box<Expr>, Box<Expr>),
+    Sub(Box<Expr>, Box<Expr>),
+    BitAnd(Box<Expr>, Box<Expr>),
+    BitOr(Box<Expr>, Box<Expr>),
+    BitXor(Box<Expr>, Box<Expr>),
+    Slice(Box<Expr>, u32, u32),
+    Signed(Box<Expr>),
+    True,
+}
+
+/// Evaluate an expression at a given index, returning a SignalValue.
+pub fn eval(trace: &dyn Trace, expr: &Expr, index: usize) -> SignalValue {
+    match expr {
+        Expr::Signal(id) => {
+            trace.signal_value_by_id(*id, index)
+        }
+        Expr::Const(v) => v.clone(),
+        Expr::True => SignalValue::Scalar(1),
+        Expr::RelEval(e, offset) => {
+            let new_idx = index as i64 + offset;
+            if new_idx < 0 || new_idx as usize > trace.max_index() {
+                SignalValue::Unknown
+            } else {
+                eval(trace, e, new_idx as usize)
+            }
+        }
+        Expr::Not(e) => {
+            let v = eval(trace, e, index);
+            SignalValue::Scalar(if v.is_truthy() { 0 } else { 1 })
+        }
+        Expr::And(a, b) => {
+            let va = eval(trace, a, index);
+            let vb = eval(trace, b, index);
+            SignalValue::Scalar(if va.is_truthy() && vb.is_truthy() { 1 } else { 0 })
+        }
+        Expr::Or(a, b) => {
+            let va = eval(trace, a, index);
+            let vb = eval(trace, b, index);
+            SignalValue::Scalar(if va.is_truthy() || vb.is_truthy() { 1 } else { 0 })
+        }
+        Expr::Eq(a, b) => {
+            let va = eval(trace, a, index);
+            let vb = eval(trace, b, index);
+            SignalValue::Scalar(if va == vb { 1 } else {
+                // Also compare numerically
+                match (va.to_u64(), vb.to_u64()) {
+                    (Some(x), Some(y)) if x == y => 1,
+                    _ => 0,
+                }
+            })
+        }
+        Expr::Neq(a, b) => {
+            let eq = eval(trace, &Expr::Eq(Box::new(Expr::Const(eval(trace, a, index))),
+                                            Box::new(Expr::Const(eval(trace, b, index)))), index);
+            SignalValue::Scalar(if eq.is_truthy() { 0 } else { 1 })
+        }
+        Expr::Gt(a, b) => binop_cmp(trace, a, b, index, |x, y| x > y),
+        Expr::Lt(a, b) => binop_cmp(trace, a, b, index, |x, y| x < y),
+        Expr::Gte(a, b) => binop_cmp(trace, a, b, index, |x, y| x >= y),
+        Expr::Lte(a, b) => binop_cmp(trace, a, b, index, |x, y| x <= y),
+        Expr::Add(a, b) => binop_arith(trace, a, b, index, |x, y| x.wrapping_add(y)),
+        Expr::Sub(a, b) => binop_arith(trace, a, b, index, |x, y| x.wrapping_sub(y)),
+        Expr::BitAnd(a, b) => binop_arith(trace, a, b, index, |x, y| x & y),
+        Expr::BitOr(a, b) => binop_arith(trace, a, b, index, |x, y| x | y),
+        Expr::BitXor(a, b) => binop_arith(trace, a, b, index, |x, y| x ^ y),
+        Expr::Slice(e, high, low) => {
+            let v = eval(trace, e, index);
+            match v.to_u64() {
+                Some(val) => SignalValue::Scalar(bit_slice(val, *high, *low)),
+                None => SignalValue::Unknown,
+            }
+        }
+        Expr::Signed(e) => {
+            let v = eval(trace, e, index);
+            // Find width from context - use 64 as default
+            match v.to_u64() {
+                Some(val) => {
+                    // Try to determine width; default to 64
+                    let width = 64u32;
+                    let signed = sign_extend(val, width);
+                    SignalValue::Scalar(signed as u64)
+                }
+                None => SignalValue::Unknown,
+            }
+        }
+    }
+}
+
+fn binop_cmp(
+    trace: &dyn Trace,
+    a: &Expr,
+    b: &Expr,
+    index: usize,
+    f: fn(u64, u64) -> bool,
+) -> SignalValue {
+    let va = eval(trace, a, index);
+    let vb = eval(trace, b, index);
+    match (va.to_u64(), vb.to_u64()) {
+        (Some(x), Some(y)) => SignalValue::Scalar(if f(x, y) { 1 } else { 0 }),
+        _ => SignalValue::Unknown,
+    }
+}
+
+fn binop_arith(
+    trace: &dyn Trace,
+    a: &Expr,
+    b: &Expr,
+    index: usize,
+    f: fn(u64, u64) -> u64,
+) -> SignalValue {
+    let va = eval(trace, a, index);
+    let vb = eval(trace, b, index);
+    match (va.to_u64(), vb.to_u64()) {
+        (Some(x), Some(y)) => SignalValue::Scalar(f(x, y)),
+        _ => SignalValue::Unknown,
+    }
+}
+
+/// Evaluate an expression as a boolean at a given index.
+pub fn eval_bool(trace: &dyn Trace, expr: &Expr, index: usize) -> bool {
+    eval(trace, expr, index).is_truthy()
+}

ewal-0.1.0/crates/ewal-core/src/eval/find.rs

@@ -0,0 +1,33 @@
+use crate::eval::expr::{eval_bool, Expr};
+use crate::trace::Trace;
+use rayon::prelude::*;
+
+/// Find all timestep indices where the expression evaluates to true.
+/// Single-threaded — iterates sequentially.
+pub fn find(trace: &dyn Trace, expr: &Expr) -> Vec<usize> {
+    (0..=trace.max_index())
+        .filter(|&idx| eval_bool(trace, expr, idx))
+        .collect()
+}
+
+/// Find all matching indices using rayon parallel iteration.
+/// Splits the index range across CPU cores for true multi-core evaluation.
+/// The Trace must be Send+Sync (which our trait requires).
+pub fn parallel_find(trace: &dyn Trace, expr: &Expr) -> Vec<usize> {
+    let max = trace.max_index();
+    let mut results: Vec<usize> = (0..=max)
+        .into_par_iter()
+        .filter(|&idx| eval_bool(trace, expr, idx))
+        .collect();
+    results.sort_unstable();
+    results
+}
+
+/// Count matching indices in parallel.
+pub fn parallel_count(trace: &dyn Trace, expr: &Expr) -> usize {
+    let max = trace.max_index();
+    (0..=max)
+        .into_par_iter()
+        .filter(|&idx| eval_bool(trace, expr, idx))
+        .count()
+}

ewal-0.1.0/crates/ewal-core/src/eval/mod.rs

@@ -0,0 +1,3 @@
+pub mod expr;
+pub mod find;
+pub mod scope;

ewal-0.1.0/crates/ewal-core/src/eval/scope.rs

@@ -0,0 +1,76 @@
+use crate::trace::Trace;
+
+/// Resolve a short signal name within a scope prefix to a full path.
+/// For example, resolve("tb.dut", "counter", trace) -> Some("tb.dut.counter")
+pub fn resolve(trace: &dyn Trace, scope: &str, short_name: &str) -> Option<String> {
+    let candidate = if scope.is_empty() {
+        short_name.to_string()
+    } else {
+        format!("{}.{}", scope, short_name)
+    };
+    if trace.signal_id(&candidate).is_some() {
+        return Some(candidate);
+    }
+    // Try finding any signal ending with the short name
+    for name in trace.signal_names() {
+        if name.ends_with(short_name) {
+            let prefix = &name[..name.len() - short_name.len()];
+            if prefix.is_empty() || prefix.ends_with('.') {
+                if scope.is_empty() || name.starts_with(scope) {
+                    return Some(name.clone());
+                }
+            }
+        }
+    }
+    None
+}
+
+/// List signals that are direct children of the given scope.
+pub fn local_signals(trace: &dyn Trace, scope: &str) -> Vec<String> {
+    let prefix = if scope.is_empty() {
+        String::new()
+    } else {
+        format!("{}.", scope)
+    };
+
+    trace
+        .signal_names()
+        .iter()
+        .filter(|name| {
+            if prefix.is_empty() {
+                !name.contains('.')
+            } else if let Some(rest) = name.strip_prefix(&prefix) {
+                !rest.contains('.')
+            } else {
+                false
+            }
+        })
+        .cloned()
+        .collect()
+}
+
+/// List child scopes of the given scope.
+pub fn local_scopes(trace: &dyn Trace, scope: &str) -> Vec<String> {
+    let prefix = if scope.is_empty() {
+        String::new()
+    } else {
+        format!("{}.", scope)
+    };
+
+    let mut result: Vec<String> = Vec::new();
+    for s in trace.scopes() {
+        if prefix.is_empty() {
+            if !s.contains('.') && !result.contains(s) {
+                result.push(s.clone());
+            }
+        } else if let Some(rest) = s.strip_prefix(&prefix) {
+            // Direct child scope: no more dots
+            let child = rest.split('.').next().unwrap_or(rest);
+            let full = format!("{}.{}", scope, child);
+            if !result.contains(&full) {
+                result.push(full);
+            }
+        }
+    }
+    result
+}

ewal-0.1.0/crates/ewal-core/src/lib.rs

@@ -0,0 +1,4 @@
+pub mod signal;
+pub mod trace;
+pub mod eval;
+pub mod util;

ewal-0.1.0/crates/ewal-core/src/signal/bitpack.rs

@@ -0,0 +1,84 @@
+use super::{Logic, SignalValue};
+
+/// Parse a VCD binary string like "b0101" or "b01xz" into a SignalValue.
+pub fn parse_binary_str(s: &str) -> SignalValue {
+    let s = s.strip_prefix('b').or_else(|| s.strip_prefix('B')).unwrap_or(s);
+    if s.is_empty() {
+        return SignalValue::Unknown;
+    }
+
+    let has_xz = s.chars().any(|c| c == 'x' || c == 'X' || c == 'z' || c == 'Z');
+    if has_xz {
+        let bits: Vec<Logic> = s
+            .chars()
+            .map(|c| match c {
+                '0' => Logic::Zero,
+                '1' => Logic::One,
+                'x' | 'X' => Logic::X,
+                'z' | 'Z' => Logic::Z,
+                _ => Logic::X,
+            })
+            .collect();
+        SignalValue::FourState(bits)
+    } else {
+        let mut val: u64 = 0;
+        for c in s.chars() {
+            val = (val << 1) | if c == '1' { 1 } else { 0 };
+        }
+        SignalValue::Scalar(val)
+    }
+}
+
+/// Extract bits [high:low] from val.
+pub fn bit_slice(val: u64, high: u32, low: u32) -> u64 {
+    if high < low {
+        return 0;
+    }
+    let width = high - low + 1;
+    if width >= 64 {
+        return val >> low;
+    }
+    let mask = (1u64 << width) - 1;
+    (val >> low) & mask
+}
+
+/// Sign-extend a value of given bit width to i64.
+pub fn sign_extend(val: u64, width: u32) -> i64 {
+    if width == 0 || width > 64 {
+        return val as i64;
+    }
+    if width == 64 {
+        return val as i64;
+    }
+    let sign_bit = 1u64 << (width - 1);
+    if val & sign_bit != 0 {
+        let mask = !((1u64 << width) - 1);
+        (val | mask) as i64
+    } else {
+        val as i64
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_binary() {
+        assert_eq!(parse_binary_str("b0101"), SignalValue::Scalar(5));
+        assert_eq!(parse_binary_str("b0000"), SignalValue::Scalar(0));
+        assert_eq!(parse_binary_str("b1111"), SignalValue::Scalar(15));
+    }
+
+    #[test]
+    fn test_bit_slice() {
+        assert_eq!(bit_slice(0b11010, 4, 1), 0b1101);
+        assert_eq!(bit_slice(0xFF, 3, 0), 0xF);
+    }
+
+    #[test]
+    fn test_sign_extend() {
+        assert_eq!(sign_extend(0b1111, 4), -1i64);
+        assert_eq!(sign_extend(0b0111, 4), 7i64);
+    }
+}