Support unpacked array Constrained Randomization (#5437) (#5489)

include/verilated_random.cpp

@@ -250,6 +250,68 @@ static Process& getSolver() {
     return s_solver;
 }
 
+std::string readUntilBalanced(std::istream& stream) {
+    std::string result;
+    std::string token;
+    int parenCount = 1;
+    while (stream >> token) {
+        for (const char c : token) {
+            if (c == '(') {
+                ++parenCount;
+            } else if (c == ')') {
+                --parenCount;
+            }
+        }
+        result += token + " ";
+        if (parenCount == 0) break;
+    }
+    return result;
+}
+
+std::string parseNestedSelect(const std::string& nested_select_expr,
+                              std::vector<std::string>& indices) {
+    std::istringstream nestedStream(nested_select_expr);
+    std::string name, idx;
+    nestedStream >> name;
+    if (name == "(select") {
+        const std::string further_nested_expr = readUntilBalanced(nestedStream);
+        name = parseNestedSelect(further_nested_expr, indices);
+    }
+    std::getline(nestedStream, idx, ')');
+    indices.push_back(idx);
+    return name;
+}
+
+std::string flattenIndices(const std::vector<std::string>& indices, const VlRandomVar* const var) {
+    int flattenedIndex = 0;
+    int multiplier = 1;
+    for (int i = indices.size() - 1; i >= 0; --i) {
+        int indexValue = 0;
+        std::string trimmedIndex = indices[i];
+
+        trimmedIndex.erase(0, trimmedIndex.find_first_not_of(" \t"));
+        trimmedIndex.erase(trimmedIndex.find_last_not_of(" \t") + 1);
+
+        if (trimmedIndex.find("#x") == 0) {
+            indexValue = std::strtoul(trimmedIndex.substr(2).c_str(), nullptr, 16);
+        } else if (trimmedIndex.find("#b") == 0) {
+            indexValue = std::strtoul(trimmedIndex.substr(2).c_str(), nullptr, 2);
+        } else {
+            indexValue = std::strtoul(trimmedIndex.c_str(), nullptr, 10);
+        }
+        const int length = var->getLength(i);
+        if (length == -1) {
+            VL_WARN_MT(__FILE__, __LINE__, "randomize",
+                       "Internal: Wrong Call: Only RandomArray can call getLength()");
+            break;
+        }
+        flattenedIndex += indexValue * multiplier;
+        multiplier *= length;
+    }
+    std::string hexString = std::to_string(flattenedIndex);
+    while (hexString.size() < 8) { hexString.insert(0, "0"); }
+    return "#x" + hexString;
+}
 //======================================================================
 // VlRandomizer:: Methods
 
@@ -356,7 +418,6 @@ bool VlRandomizer::next(VlRNG& rngr) {
         f << "(reset)\n";
         return false;
     }
-
     for (int i = 0; i < _VL_SOLVER_HASH_LEN_TOTAL && sat; i++) {
         f << "(assert ";
         randomConstraint(f, rngr, _VL_SOLVER_HASH_LEN);
@@ -403,25 +464,29 @@ bool VlRandomizer::parseSolution(std::iostream& f) {
                        "Internal: Unable to parse solver's response: invalid S-expression");
             return false;
         }
-
         std::string name, idx, value;
+        std::vector<std::string> indices;
         f >> name;
+        indices.clear();
         if (name == "(select") {
-            f >> name;
-            std::getline(f, idx, ')');
+            const std::string selectExpr = readUntilBalanced(f);
+            name = parseNestedSelect(selectExpr, indices);
+            idx = indices[0];
         }
         std::getline(f, value, ')');
-
-        auto it = m_vars.find(name);
+        const auto it = m_vars.find(name);
         if (it == m_vars.end()) continue;
         const VlRandomVar& varr = *it->second;
         if (m_randmode && !varr.randModeIdxNone()) {
             if (!(m_randmode->at(varr.randModeIdx()))) continue;
         }
-
-        varr.set(idx, value);
+        if (indices.size() > 1) {
+            const std::string flattenedIndex = flattenIndices(indices, &varr);
+            varr.set(flattenedIndex, value);
+        } else {
+            varr.set(idx, value);
+        }
     }
-
     return true;
 }
 

include/verilated_random.h

@@ -36,17 +36,20 @@ class VlRandomVar VL_NOT_FINAL {
     const char* const m_name;  // Variable name
     void* const m_datap;  // Reference to variable data
     const int m_width;  // Variable width in bits
+    const int m_dimension;  //Variable dimension, default is 0
     const std::uint32_t m_randModeIdx;  // rand_mode index
 
 public:
-    VlRandomVar(const char* name, int width, void* datap, std::uint32_t randModeIdx)
+    VlRandomVar(const char* name, int width, void* datap, int dimension, std::uint32_t randModeIdx)
         : m_name{name}
         , m_datap{datap}
         , m_width{width}
+        , m_dimension{dimension}
         , m_randModeIdx{randModeIdx} {}
     virtual ~VlRandomVar() = default;
     const char* name() const { return m_name; }
     int width() const { return m_width; }
+    int dimension() const { return m_dimension; }
     virtual void* datap(int idx) const { return m_datap; }
     std::uint32_t randModeIdx() const { return m_randModeIdx; }
     bool randModeIdxNone() const { return randModeIdx() == std::numeric_limits<unsigned>::max(); }
@@ -55,13 +58,15 @@ public:
     virtual void emitExtract(std::ostream& s, int i) const;
     virtual void emitType(std::ostream& s) const;
     virtual int totalWidth() const;
+    virtual int getLength(int dimension) const { return -1; }
 };
 
 template <typename T>
 class VlRandomQueueVar final : public VlRandomVar {
 public:
-    VlRandomQueueVar(const char* name, int width, void* datap, std::uint32_t randModeIdx)
-        : VlRandomVar{name, width, datap, randModeIdx} {}
+    VlRandomQueueVar(const char* name, int width, void* datap, int dimension,
+                     std::uint32_t randModeIdx)
+        : VlRandomVar{name, width, datap, dimension, randModeIdx} {}
     void* datap(int idx) const override {
         return &static_cast<T*>(VlRandomVar::datap(idx))->atWrite(idx);
     }
@@ -90,6 +95,95 @@ public:
     }
 };
 
+template <typename T>
+class VlRandomArrayVar final : public VlRandomVar {
+public:
+    VlRandomArrayVar(const char* name, int width, void* datap, int dimension,
+                     std::uint32_t randModeIdx)
+        : VlRandomVar{name, width, datap, dimension, randModeIdx} {}
+
+    void* datap(int idx) const override {
+        if (idx < 0) return &static_cast<T*>(VlRandomVar::datap(0))->operator[](0);
+        std::vector<size_t> indices(dimension());
+        for (int dim = dimension() - 1; dim >= 0; --dim) {
+            const int length = getLength(dim);
+            indices[dim] = idx % length;
+            idx /= length;
+        }
+        return &static_cast<T*>(VlRandomVar::datap(0))->find_element(indices);
+    }
+
+    void emitSelect(std::ostream& s, const std::vector<int>& indices) const {
+        for (size_t idx = 0; idx < indices.size(); ++idx) s << "(select ";
+        s << name();
+        for (size_t idx = 0; idx < indices.size(); ++idx) {
+            s << " #x";
+            for (int j = 28; j >= 0; j -= 4) {
+                s << "0123456789abcdef"[(indices[idx] >> j) & 0xf];
+            }
+            s << ")";
+        }
+    }
+
+    int getLength(int dimension) const override {
+        const auto var = static_cast<const T*>(datap(-1));
+        const int lenth = var->find_length(dimension);
+        return lenth;
+    }
+
+    void emitGetValue(std::ostream& s) const override {
+        const int total_dimensions = dimension();
+        std::vector<int> lengths;
+        for (int dim = 0; dim < total_dimensions; dim++) {
+            const int len = getLength(dim);
+            lengths.push_back(len);
+        }
+        std::vector<int> indices(total_dimensions, 0);
+        while (true) {
+            emitSelect(s, indices);
+            int currentDimension = total_dimensions - 1;
+            while (currentDimension >= 0
+                   && ++indices[currentDimension] >= lengths[currentDimension]) {
+                indices[currentDimension] = 0;
+                --currentDimension;
+            }
+            if (currentDimension < 0) break;
+        }
+    }
+
+    void emitType(std::ostream& s) const override {
+        if (dimension() > 0) {
+            for (int i = 0; i < dimension(); ++i) s << "(Array (_ BitVec 32) ";
+            s << "(_ BitVec " << width() << ")";
+            for (int i = 0; i < dimension(); ++i) s << ")";
+        }
+    }
+
+    int totalWidth() const override {
+        int totalLength = 1;
+        for (int dim = 0; dim < dimension(); ++dim) {
+            const int length = getLength(dim);
+            if (length == -1) return 0;
+            totalLength *= length;
+        }
+        return width() * totalLength;
+    }
+
+    void emitExtract(std::ostream& s, int i) const override {
+        const int j = i / width();
+        i = i % width();
+        std::vector<int> indices(dimension());
+        int idx = j;
+        for (int dim = dimension() - 1; dim >= 0; --dim) {
+            int length = getLength(dim);
+            indices[dim] = idx % length;
+            idx /= length;
+        }
+        s << " ((_ extract " << i << ' ' << i << ')';
+        emitSelect(s, indices);
+        s << ')';
+    }
+};
 //=============================================================================
 // VlRandomizer is the object holding constraints and variable references.
 
@@ -113,18 +207,26 @@ public:
     // Finds the next solution satisfying the constraints
     bool next(VlRNG& rngr);
     template <typename T>
-    void write_var(T& var, int width, const char* name,
+    void write_var(T& var, int width, const char* name, int dimension,
                    std::uint32_t randmodeIdx = std::numeric_limits<std::uint32_t>::max()) {
         if (m_vars.find(name) != m_vars.end()) return;
         // TODO: make_unique once VlRandomizer is per-instance not per-ref
-        m_vars[name] = std::make_shared<const VlRandomVar>(name, width, &var, randmodeIdx);
+        m_vars[name]
+            = std::make_shared<const VlRandomVar>(name, width, &var, dimension, randmodeIdx);
     }
     template <typename T>
-    void write_var(VlQueue<T>& var, int width, const char* name,
+    void write_var(VlQueue<T>& var, int width, const char* name, int dimension,
                    std::uint32_t randmodeIdx = std::numeric_limits<std::uint32_t>::max()) {
         if (m_vars.find(name) != m_vars.end()) return;
-        m_vars[name]
-            = std::make_shared<const VlRandomQueueVar<VlQueue<T>>>(name, width, &var, randmodeIdx);
+        m_vars[name] = std::make_shared<const VlRandomQueueVar<VlQueue<T>>>(
+            name, width, &var, dimension, randmodeIdx);
+    }
+    template <typename T, std::size_t N>
+    void write_var(VlUnpacked<T, N>& var, int width, const char* name, int dimension,
+                   std::uint32_t randmodeIdx = std::numeric_limits<std::uint32_t>::max()) {
+        if (m_vars.find(name) != m_vars.end()) return;
+        m_vars[name] = std::make_shared<const VlRandomArrayVar<VlUnpacked<T, N>>>(
+            name, width, &var, dimension, randmodeIdx);
     }
     void hard(std::string&& constraint);
     void clear();

include/verilated_types.h

@@ -1322,6 +1322,43 @@ public:
     WData* data() { return &m_storage[0]; }
     const WData* data() const { return &m_storage[0]; }
 
+    std::size_t size() const { return T_Depth; }
+    // To fit C++14
+    template <std::size_t CurrentDimension = 0, typename U = T_Value>
+    int find_length(int dimension, std::false_type) const {
+        return size();
+    }
+
+    template <std::size_t CurrentDimension = 0, typename U = T_Value>
+    int find_length(int dimension, std::true_type) const {
+        if (dimension == CurrentDimension) {
+            return size();
+        } else {
+            return m_storage[0].template find_length<CurrentDimension + 1>(dimension);
+        }
+    }
+
+    template <std::size_t CurrentDimension = 0>
+    int find_length(int dimension) const {
+        return find_length<CurrentDimension>(dimension, std::is_class<T_Value>{});
+    }
+
+    template <std::size_t CurrentDimension = 0, typename U = T_Value>
+    auto& find_element(const std::vector<size_t>& indices, std::false_type) {
+        return m_storage[indices[CurrentDimension]];
+    }
+
+    template <std::size_t CurrentDimension = 0, typename U = T_Value>
+    auto& find_element(const std::vector<size_t>& indices, std::true_type) {
+        return m_storage[indices[CurrentDimension]].template find_element<CurrentDimension + 1>(
+            indices);
+    }
+
+    template <std::size_t CurrentDimension = 0>
+    auto& find_element(const std::vector<size_t>& indices) {
+        return find_element<CurrentDimension>(indices, std::is_class<T_Value>{});
+    }
+
     T_Value& operator[](size_t index) { return m_storage[index]; }
     const T_Value& operator[](size_t index) const { return m_storage[index]; }
 

src/V3AstNodeExpr.h

@@ -4147,6 +4147,7 @@ public:
     }
     string emitVerilog() override { return "%k(%l%f[%r])"; }
     string emitC() override { return "%li%k[%ri]"; }
+    string emitSMT() const override { return "(select %l %r)"; }
     bool cleanOut() const override { return true; }
     bool cleanLhs() const override { return false; }
     bool cleanRhs() const override { return true; }

src/V3Randomize.cpp

@@ -428,6 +428,13 @@ class RandomizeMarkVisitor final : public VNVisitor {
                 backp->user1(true);
         }
     }
+    void visit(AstArraySel* nodep) override {
+        if (!m_constraintExprp) return;
+        for (AstNode* backp = nodep; backp != m_constraintExprp && !backp->user1();
+             backp = backp->backp())
+            backp->user1(true);
+        iterateChildrenConst(nodep);
+    }
     void visit(AstNodeModule* nodep) override {
         VL_RESTORER(m_modp);
         m_modp = nodep;
@@ -604,6 +611,13 @@ class ConstraintExprVisitor final : public VNVisitor {
                 new AstVarRef{varp->fileline(), VN_AS(m_genp->user2p(), NodeModule), m_genp,
                               VAccess::READWRITE},
                 "write_var"};
+            uint32_t dimension = 0;
+            if (VN_IS(varp->dtypep(), UnpackArrayDType)) {
+                const std::pair<uint32_t, uint32_t> dims
+                    = varp->dtypep()->dimensions(/*includeBasic=*/true);
+                const uint32_t unpackedDimensions = dims.second;
+                dimension = unpackedDimensions;
+            }
             methodp->dtypeSetVoid();
             AstClass* const classp = VN_AS(varp->user2p(), Class);
             AstVarRef* const varRefp
@@ -619,6 +633,8 @@ class ConstraintExprVisitor final : public VNVisitor {
                 = new AstCExpr{varp->fileline(), "\"" + smtName + "\"", varp->width()};
             varnamep->dtypep(varp->dtypep());
             methodp->addPinsp(varnamep);
+            methodp->addPinsp(
+                new AstConst{varp->dtypep()->fileline(), AstConst::Unsized64{}, dimension});
             if (randMode.usesMode) {
                 methodp->addPinsp(
                     new AstConst{varp->fileline(), AstConst::Unsized64{}, randMode.index});
@@ -676,6 +692,15 @@ class ConstraintExprVisitor final : public VNVisitor {
 
         editSMT(nodep, nodep->fromp(), lsbp, msbp);
     }
+    void visit(AstArraySel* nodep) override {
+        if (editFormat(nodep)) return;
+        FileLine* const fl = nodep->fileline();
+        VNRelinker handle;
+        AstNodeExpr* const indexp
+            = new AstSFormatF{fl, "#x%8x", false, nodep->bitp()->unlinkFrBack(&handle)};
+        handle.relink(indexp);
+        editSMT(nodep, nodep->fromp(), indexp);
+    }
     void visit(AstSFormatF* nodep) override {}
     void visit(AstStmtExpr* nodep) override {}
     void visit(AstConstraintIf* nodep) override {

test_regress/t/t_randomize_array_constraints.py

@@ -0,0 +1,21 @@
+#!/usr/bin/env python3
+# DESCRIPTION: Verilator: Verilog Test driver/expect definition
+#
+# Copyright 2024 by Wilson Snyder. This program is free software; you
+# can redistribute it and/or modify it under the terms of either the GNU
+# Lesser General Public License Version 3 or the Perl Artistic License
+# Version 2.0.
+# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
+
+import vltest_bootstrap
+
+test.scenarios('simulator')
+
+if not test.have_solver:
+    test.skip("No constraint solver installed")
+
+test.compile()
+
+test.execute()
+
+test.passes()

test_regress/t/t_randomize_array_constraints.v

@@ -0,0 +1,156 @@
+// DESCRIPTION: Verilator: Verilog Test module
+//
+// This file ONLY is placed under the Creative Commons Public Domain, for
+// any use, without warranty, 2024 by PlanV GmbH.
+// SPDX-License-Identifier: CC0-1.0
+
+`define check_rand(cl, field) \
+begin \
+   longint prev_result; \
+   int ok = 0; \
+   for (int i = 0; i < 10; i++) begin \
+      longint result; \
+      void'(cl.randomize()); \
+      result = longint'(field); \
+      if (i > 0 && result != prev_result) ok = 1; \
+      prev_result = result; \
+   end \
+   if (ok != 1) $stop; \
+end
+
+class con_rand_1d_array_test;
+  rand bit [7:0] data[5];
+
+  constraint c_data {
+    foreach (data[i]) {
+      data[i] inside {8'h10, 8'h20, 8'h30, 8'h40, 8'h50};
+    }
+  }
+
+  function new();
+    data = '{default: 'h0};
+  endfunction
+
+  function void check_randomization();
+    foreach (data[i]) begin
+      `check_rand(this, data[i])
+      if (data[i] inside {8'h10, 8'h20, 8'h30, 8'h40, 8'h50}) begin
+        $display("data[%0d] = %h is valid", i, data[i]);
+      end else begin
+        $display("Error: data[%0d] = %h is out of bounds", i, data[i]);
+        $stop;
+      end
+    end
+
+  endfunction
+
+endclass
+
+
+class con_rand_2d_array_test;
+  rand bit [7:0] data[3][3];
+
+  constraint c_data {
+    foreach (data[i, j]) {
+      data[i][j] >= 8'h10;
+      data[i][j] <= 8'h50;
+    }
+  }
+
+  function new();
+    data = '{default: '{default: 'h0}};
+  endfunction
+
+  function void check_randomization();
+    foreach (data[i, j]) begin
+      `check_rand(this, data[i][j])
+      if (data[i][j] >= 8'h10 && data[i][j] <= 8'h50) begin
+        $display("data[%0d][%0d] = %h is valid", i, j, data[i][j]);
+      end else begin
+        $display("Error: data[%0d][%0d] = %h is out of bounds", i, j, data[i][j]);
+        $stop;
+      end
+    end
+  endfunction
+
+endclass
+
+
+class con_rand_3d_array_test;
+  rand bit [7:0] data[2][2][2];
+
+  constraint c_data {
+    foreach (data[i, j, k]) {
+      data[i][j][k] >= 8'h10;
+      data[i][j][k] <= 8'h50;
+      if (i > 0) {
+        data[i][j][k] > data[i-1][j][k] + 8'h05;
+      }
+      if (j > 0) {
+        data[i][j][k] > data[i][j-1][k];
+      }
+    }
+  }
+
+  function new();
+    data = '{default: '{default: '{default: 'h0}}};
+  endfunction
+
+  function void check_randomization();
+    foreach (data[i, j, k]) begin
+      `check_rand(this, data[i][j][k])
+      if (data[i][j][k] >= 8'h10 && data[i][j][k] <= 8'h50) begin
+
+        if (i > 0 && data[i][j][k] <= data[i-1][j][k] + 8'h05) begin
+          $display("Error: data[%0d][%0d][%0d] = %h does not satisfy i > 0 constraint", i, j, k, data[i][j][k]);
+          $stop;
+        end
+
+        if (j > 0 && data[i][j][k] <= data[i][j-1][k]) begin
+          $display("Error: data[%0d][%0d][%0d] = %h does not satisfy j > 0 constraint", i, j, k, data[i][j][k]);
+          $stop;
+        end
+
+        $display("data[%0d][%0d][%0d] = %h is valid", i, j, k, data[i][j][k]);
+
+      end else begin
+        $display("Error: data[%0d][%0d][%0d] = %h is out of bounds", i, j, k, data[i][j][k]);
+        $stop;
+      end
+    end
+  endfunction
+
+endclass
+
+
+module t_randomize_array_constraints;
+  con_rand_1d_array_test rand_test_1;
+  con_rand_2d_array_test rand_test_2;
+  con_rand_3d_array_test rand_test_3;
+
+  initial begin
+    // Test 1: Randomization for 1D array
+    $display("Test 1: Randomization for 1D array:");
+    rand_test_1 = new();
+    repeat(2) begin
+      rand_test_1.check_randomization();
+    end
+
+    // Test 2: Randomization for 2D array
+    $display("Test 2: Randomization for 2D array:");
+    rand_test_2 = new();
+    repeat(2) begin
+      rand_test_2.check_randomization();
+    end
+
+    // Test 3: Randomization for 3D array
+    $display("Test 3: Randomization for 3D array:");
+    rand_test_3 = new();
+    repeat(2) begin
+      rand_test_3.check_randomization();
+    end
+
+    $write("*-* All Finished *-*\n");
+    $finish;
+  end
+endmodule