From c05c48aaf3cf820bdc5d34b73edc4d6bf3e7f467 Mon Sep 17 00:00:00 2001 From: Yilou Wang <140522618+YilouWang@users.noreply.github.com> Date: Wed, 2 Oct 2024 16:29:47 +0200 Subject: [PATCH] Support unpacked array Constrained Randomization (#5437) (#5489) --- include/verilated_random.cpp | 83 +++++++++- include/verilated_random.h | 118 ++++++++++++- include/verilated_types.h | 37 +++++ src/V3AstNodeExpr.h | 1 + src/V3Randomize.cpp | 25 +++ .../t/t_randomize_array_constraints.py | 21 +++ .../t/t_randomize_array_constraints.v | 156 ++++++++++++++++++ 7 files changed, 424 insertions(+), 17 deletions(-) create mode 100755 test_regress/t/t_randomize_array_constraints.py create mode 100755 test_regress/t/t_randomize_array_constraints.v diff --git a/include/verilated_random.cpp b/include/verilated_random.cpp index 10a22ed9f..324e6cdbe 100644 --- a/include/verilated_random.cpp +++ b/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& 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& 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 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; } diff --git a/include/verilated_random.h b/include/verilated_random.h index 2a0596780..2ae2dcb22 100644 --- a/include/verilated_random.h +++ b/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::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 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(VlRandomVar::datap(idx))->atWrite(idx); } @@ -90,6 +95,95 @@ public: } }; +template +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(VlRandomVar::datap(0))->operator[](0); + std::vector indices(dimension()); + for (int dim = dimension() - 1; dim >= 0; --dim) { + const int length = getLength(dim); + indices[dim] = idx % length; + idx /= length; + } + return &static_cast(VlRandomVar::datap(0))->find_element(indices); + } + + void emitSelect(std::ostream& s, const std::vector& 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(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 lengths; + for (int dim = 0; dim < total_dimensions; dim++) { + const int len = getLength(dim); + lengths.push_back(len); + } + std::vector 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 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 - 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::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(name, width, &var, randmodeIdx); + m_vars[name] + = std::make_shared(name, width, &var, dimension, randmodeIdx); } template - void write_var(VlQueue& var, int width, const char* name, + void write_var(VlQueue& var, int width, const char* name, int dimension, std::uint32_t randmodeIdx = std::numeric_limits::max()) { if (m_vars.find(name) != m_vars.end()) return; - m_vars[name] - = std::make_shared>>(name, width, &var, randmodeIdx); + m_vars[name] = std::make_shared>>( + name, width, &var, dimension, randmodeIdx); + } + template + void write_var(VlUnpacked& var, int width, const char* name, int dimension, + std::uint32_t randmodeIdx = std::numeric_limits::max()) { + if (m_vars.find(name) != m_vars.end()) return; + m_vars[name] = std::make_shared>>( + name, width, &var, dimension, randmodeIdx); } void hard(std::string&& constraint); void clear(); diff --git a/include/verilated_types.h b/include/verilated_types.h index d4f591a32..c93da6dea 100644 --- a/include/verilated_types.h +++ b/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 + int find_length(int dimension, std::false_type) const { + return size(); + } + + template + int find_length(int dimension, std::true_type) const { + if (dimension == CurrentDimension) { + return size(); + } else { + return m_storage[0].template find_length(dimension); + } + } + + template + int find_length(int dimension) const { + return find_length(dimension, std::is_class{}); + } + + template + auto& find_element(const std::vector& indices, std::false_type) { + return m_storage[indices[CurrentDimension]]; + } + + template + auto& find_element(const std::vector& indices, std::true_type) { + return m_storage[indices[CurrentDimension]].template find_element( + indices); + } + + template + auto& find_element(const std::vector& indices) { + return find_element(indices, std::is_class{}); + } + T_Value& operator[](size_t index) { return m_storage[index]; } const T_Value& operator[](size_t index) const { return m_storage[index]; } diff --git a/src/V3AstNodeExpr.h b/src/V3AstNodeExpr.h index adcfb3405..53881bd89 100644 --- a/src/V3AstNodeExpr.h +++ b/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; } diff --git a/src/V3Randomize.cpp b/src/V3Randomize.cpp index ffacdf603..14539771c 100644 --- a/src/V3Randomize.cpp +++ b/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 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 { diff --git a/test_regress/t/t_randomize_array_constraints.py b/test_regress/t/t_randomize_array_constraints.py new file mode 100755 index 000000000..a2b131082 --- /dev/null +++ b/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() diff --git a/test_regress/t/t_randomize_array_constraints.v b/test_regress/t/t_randomize_array_constraints.v new file mode 100755 index 000000000..7a56edc45 --- /dev/null +++ b/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