Constrained random: emit rand constraint right away

This change gets rid of most of the shared pointers and useless memory
allocations.

Signed-off-by: Arkadiusz Kozdra <akozdra@antmicro.com>

Author: kozdra

include/verilated_random.cpp

@@ -254,17 +254,6 @@ static Process& getSolver() {
 // VlRandomizer:: Methods
 
 void VlRandomVar::emit(std::ostream& s) const { s << m_name; }
-void VlRandomConst::emit(std::ostream& s) const {
-    s << "#b";
-    for (int i = 0; i < m_width; i++) s << (VL_BITISSET_Q(m_val, m_width - i - 1) ? '1' : '0');
-}
-void VlRandomBinOp::emit(std::ostream& s) const {
-    s << '(' << m_op << ' ';
-    m_lhs->emit(s);
-    s << ' ';
-    m_rhs->emit(s);
-    s << ')';
-}
 void VlRandomExtract::emit(std::ostream& s) const {
     s << "((_ extract " << m_idx << ' ' << m_idx << ") ";
     m_expr->emit(s);
@@ -307,27 +296,28 @@ bool VlRandomVar::set(std::string&& val) const {
     return true;
 }
 
-std::shared_ptr<const VlRandomExpr> VlRandomizer::randomConstraint(VlRNG& rngr, int bits) {
-    unsigned long long hash = VL_RANDOM_RNG_I(rngr) & ((1 << bits) - 1);
-    std::shared_ptr<const VlRandomExpr> concat = nullptr;
-    std::vector<std::shared_ptr<const VlRandomExpr>> varbits;
+void VlRandomizer::randomConstraint(std::ostream& os, VlRNG& rngr, int bits) {
+    IData hash = VL_RANDOM_RNG_I(rngr) & ((1 << bits) - 1);
+    std::vector<std::unique_ptr<const VlRandomExpr>> varbits;
     for (const auto& var : m_vars) {
         for (int i = 0; i < var.second->width(); i++)
-            varbits.emplace_back(std::make_shared<const VlRandomExtract>(var.second, i));
+            varbits.emplace_back(std::make_unique<const VlRandomExtract>(var.second, i));
     }
+    os << "(= #b";
+    for (int i = bits - 1; i >= 0; i--) os << (VL_BITISSET_I(hash, i) ? '1' : '0');
+    if (bits > 1) os << " (concat";
     for (int i = 0; i < bits; i++) {
-        std::shared_ptr<const VlRandomExpr> bit = nullptr;
+        os << " (bvxor";
         for (unsigned j = 0; j * 2 < varbits.size(); j++) {
             unsigned idx = j + VL_RANDOM_RNG_I(rngr) % (varbits.size() - j);
-            auto sel = varbits[idx];
             std::swap(varbits[idx], varbits[j]);
-            bit = bit == nullptr ? sel : std::make_shared<const VlRandomBinOp>("bvxor", bit, sel);
+            os << ' ';
+            varbits[j]->emit(os);
         }
-        concat = concat == nullptr ? bit
-                                   : std::make_shared<const VlRandomBinOp>("concat", concat, bit);
+        os << ')';
     }
-    return std::make_shared<const VlRandomBinOp>(
-        "=", concat, std::make_shared<const VlRandomConst>(hash, bits));
+    if (bits > 1) os << ')';
+    os << ')';
 }
 
 bool VlRandomizer::next(VlRNG& rngr) {
@@ -356,7 +346,7 @@ bool VlRandomizer::next(VlRNG& rngr) {
 
     for (int i = 0; i < _VL_SOLVER_HASH_LEN_TOTAL && sat; i++) {
         f << "(assert ";
-        randomConstraint(rngr, _VL_SOLVER_HASH_LEN)->emit(f);
+        randomConstraint(f, rngr, _VL_SOLVER_HASH_LEN);
         f << ")\n";
         f << "\n(check-sat)\n";
         sat = parseSolution(f);

include/verilated_random.h

@@ -33,6 +33,7 @@
 class VlRandomExpr VL_NOT_FINAL {
 public:
     virtual void emit(std::ostream& s) const = 0;
+    virtual ~VlRandomExpr() = default;
 };
 class VlRandomVar final : public VlRandomExpr {
     const char* const m_name;  // Variable name
@@ -55,19 +56,6 @@ class VlRandomVar final : public VlRandomExpr {
     void emit(std::ostream& s) const override;
 };
 
-class VlRandomConst final : public VlRandomExpr {
-    const QData m_val;  // Constant value
-    const int m_width;  // Constant width in bits
-
-public:
-    VlRandomConst(QData val, int width)
-        : m_val{val}
-        , m_width{width} {
-        assert(width <= sizeof(m_val) * 8);
-    }
-    void emit(std::ostream& s) const override;
-};
-
 class VlRandomExtract final : public VlRandomExpr {
     const std::shared_ptr<const VlRandomExpr> m_expr;  // Sub-expression
     const unsigned m_idx;  // Extracted index
@@ -79,19 +67,6 @@ class VlRandomExtract final : public VlRandomExpr {
     void emit(std::ostream& s) const override;
 };
 
-class VlRandomBinOp final : public VlRandomExpr {
-    const char* const m_op;  // Binary operation identifier
-    const std::shared_ptr<const VlRandomExpr> m_lhs, m_rhs;  // Sub-expressions
-
-public:
-    VlRandomBinOp(const char* op, std::shared_ptr<const VlRandomExpr> lhs,
-                  std::shared_ptr<const VlRandomExpr> rhs)
-        : m_op{op}
-        , m_lhs{lhs}
-        , m_rhs{rhs} {}
-    void emit(std::ostream& s) const override;
-};
-
 //=============================================================================
 // VlRandomizer is the object holding constraints and variable references.
 
@@ -103,7 +78,7 @@ class VlRandomizer final {
     const VlQueue<CData>* m_randmode;  // rand_mode state;
 
     // PRIVATE METHODS
-    std::shared_ptr<const VlRandomExpr> randomConstraint(VlRNG& rngr, int bits);
+    void randomConstraint(std::ostream& os, VlRNG& rngr, int bits);
     bool parseSolution(std::iostream& file);
 
 public: