0.4.4

- (#92) Corrected an issue where soft constraints were dropped while
  combining solve sets
- (#91) Corrected the field-access overloading to properly handle
  re-assignment to VSC fields
- (#88) Correct how the width of unary expressions is propagated
- (#87) Correct handling of enum-type fields by increasing common
  implementation with scalar/int-type fields
- (#86) Properly handle part-select on array-element references
- (#85) Correct an issue with complex-reference resolution and
  dist constraints
- (#84) Correct an issue with expanding complex references inside
  foreach constraints

Signed-off-by: Matthew Ballance <matt.ballance@gmail.com>

Author: mballance

doc/Changelog.md

@@ -1,4 +1,18 @@
 
+## 0.4.4
+- (#92) Corrected an issue where soft constraints were dropped while
+  combining solve sets
+- (#91) Corrected the field-access overloading to properly handle
+  re-assignment to VSC fields
+- (#88) Correct how the width of unary expressions is propagated 
+- (#87) Correct handling of enum-type fields by increasing common
+  implementation with scalar/int-type fields
+- (#86) Properly handle part-select on array-element references
+- (#85) Correct an issue with complex-reference resolution and
+  dist constraints
+- (#84) Correct an issue with expanding complex references inside
+  foreach constraints
+
 ## 0.4.3
 - (#81,#82) Correctly propagate context-dependent expression widths 
   down the evaluation tree

etc/ivpm.info

@@ -1,4 +1,4 @@
 
 name=pyvsc
-version=0.4.3
+version=0.4.4
 

src/vsc/coverage.py

@@ -127,18 +127,18 @@ def sample(self, *args, **kwargs):
                 if isinstance(ex_f, FieldCompositeModel):
                     # TODO: probably need to do something a bit more than this?
                     model.set_field(i, args[i].get_model())
-                elif isinstance(ex_f, FieldScalarModel):
-                    if isinstance(args[i], type_base):
-                        ex_f.set_val(args[i].get_val())
-                    else:
-                        ex_f.set_val(int(args[i]))
                 elif isinstance(ex_f, EnumFieldModel):
                     ei = us_f.enum_i
                     if isinstance(args[i], type_enum):
                         ex_f.set_val(args[i].get_val())
                     else:
                         # Use the enum map to convert to an int
                         ex_f.set_val(ei.e2v(args[i]))
+                elif isinstance(ex_f, FieldScalarModel):
+                    if isinstance(args[i], type_base):
+                        ex_f.set_val(args[i].get_val())
+                    else:
+                        ex_f.set_val(int(args[i]))
                 else:
                     raise Exception("unhandled sample case")
 

src/vsc/impl/enum_info.py

@@ -36,7 +36,7 @@ def e2v(self, ev)->int:
         return self.e2v_m[ev]
 
     def v2e(self, v):
-        return self.v2e_m[v]
+        return self.v2e_m[int(v)]
 
     def e2e(self, ev):
         v = self.e2v_m[ev]

src/vsc/model/enum_field_model.py

@@ -8,41 +8,32 @@
 
 from vsc.model.field_model import FieldModel
 from vsc.model.rand_gen_data import RandGenData
+from vsc.model.value_enum import ValueEnum
+from vsc.model.field_scalar_model import FieldScalarModel
 
 
-class EnumFieldModel(FieldModel):
+class EnumFieldModel(FieldScalarModel):
 
     def __init__(self,
                  name : str,
                  enums : List[int],
                  is_rand : bool):
-        super().__init__(name)
+        super().__init__(
+            name,
+            32,
+            True,
+            is_rand,
+            None)
         self.enums = enums
-        self.is_declared_rand = is_rand
-        self.is_used_rand = is_rand
-        self.var = None
-        self.val = enums[0]
-        self.rand_if = None
-        
-        # TODO: a bit simplistic
-        self.width = 32
-        self.is_signed = True
-        
-        
-    def set_used_rand(self, is_rand, level=0):
-        self.is_used_rand = (is_rand and (self.is_declared_rand or level==0))
-
-    def dispose(self):
-        self.var = None
+        self.val = ValueEnum(enums[0])
 
     def accept(self, v):
         v.visit_enum_field(self)
 
     def build(self, btor):
+        super().build(btor)
+        
         if self.is_used_rand:
-            sort = btor.BitVecSort(self.width)
-            self.var = btor.Var(sort)
-
             c = None
             for e in self.enums:
                 if c is None:
@@ -56,32 +47,8 @@ def build(self, btor):
                             self.var,
                             btor.Const(e, self.width)))
             btor.Assert(c)
-        else:
-            self.var = btor.Const(self.val, self.width)
+            
         return self.var
 
-    def get_constraints(self, constraint_l):
-        pass
-
-    def pre_randomize(self):
-        if self.rand_if is not None:
-            self.rand_if.do_pre_randomize()
-    
-    def set_val(self, val):
-        self.val = val
-        
-    def get_val(self):
-        return self.val
-    
-    def post_randomize(self):
-        if self.var is not None:
-            val = 0
-            for b in self.var.assignment:
-                val <<= 1
-                if b == '1':
-                    val |= 1
-            self.set_val(val)
-            
-        if self.rand_if is not None:
-            self.rand_if.do_post_randomize()
-    
+#    def set_val(self, val):
+#        self.val.v = val

src/vsc/model/expr_partselect_model.py

@@ -1,5 +1,3 @@
-from vsc.model.expr_literal_model import ExprLiteralModel
-
 # Licensed to the Apache Software Foundation (ASF) under one
 # or more contributor license agreements.  See the NOTICE file
 # distributed with this work for additional information
@@ -23,6 +21,7 @@
 #
 # @author: ballance
 
+from vsc.model.expr_literal_model import ExprLiteralModel
 from vsc.model.expr_model import ExprModel
 
 class ExprPartselectModel(ExprModel):
@@ -37,8 +36,8 @@ def build(self, btor, ctx_width=-1):
         lower = self.lower if self.lower is not None else self.upper 
         return btor.Slice(
             self.lhs.build(btor),
-            lower.val(), 
-            upper.val())
+            upper.val(),
+            lower.val()) 
 
     def width(self):
         upper = self.upper

src/vsc/model/expr_unary_model.py

@@ -26,6 +26,11 @@ def build(self, btor : Boolector, ctx_width=-1):
             ret = btor.Not(self.expr.build(btor, ctx_width))
 
         return ret
+    
+    def width(self):
+        # Currently-supported unary expressions have the 
+        # same width as the base expression
+        return self.expr.width()
 
     def accept(self, v):
         v.visit_expr_unary(self)

src/vsc/model/rand_info_builder.py

@@ -44,10 +44,13 @@
 from vsc.model.rand_set import RandSet
 from vsc.model.constraint_dist_scope_model import ConstraintDistScopeModel
 from vsc.visitors.expand_solve_order_visitor import ExpandSolveOrderVisitor
+from vsc.visitors.expr2field_visitor import Expr2FieldVisitor
 
 
 class RandInfoBuilder(ModelVisitor,RandIF):
 
+    EN_DEBUG = 0
+    
     def __init__(self, rng):
         # TODO: need access to the random state
         super().__init__()
@@ -69,9 +72,9 @@ def __init__(self, rng):
         self.active_cp = None
         self._rng = rng
         self._order_l = []
-        self._order_s = set()
 
         self._order_m = {}
+        self._expr2fm = Expr2FieldVisitor()
 
     @staticmethod
     def build(
@@ -167,30 +170,6 @@ def visit_constraint_solve_order(self, c : ConstraintSolveOrderModel):
             for b in c.before_l:
                 for a in c.after_l:
                     ExpandSolveOrderVisitor(self._order_m).expand(a, b)
-
-#                     b_i = -1
-#                     a_i = -1
-#                     if b in self._order_s:
-#                         b_i = self._order_l.index(b)
-#                     if a in self._order_s:
-#                         a_i = self._order_l.index(a)
-#                     
-#                     if b_i == -1 and a_i == -1:
-#                         # Just add the elements to the list
-#                         self._order_l.append(b)
-#                         self._order_l.append(a)
-#                         self._order_s.add(a)
-#                         self._order_s.add(b)
-#                     elif b_i != -1:
-#                         self._order_l.insert(b_i+1, a)
-#                         self._order_s.add(a)
-#                     elif a_i != -1:
-#                         self._order_l.insert(a_i, b)
-#                         self._order_s.add(b)
-#                     else:
-#                         # Found both in the list already.
-#                         # They might be in the list for good reasons or bad
-#                         pass
 
     def visit_constraint_stmt_enter(self, c):
         if self._pass == 1 and len(self._constraint_s) == 1:
@@ -219,27 +198,39 @@ def visit_constraint_dynref(self, c):
             c_stmt.accept(self)
 
     def visit_constraint_expr(self, c):
+        if RandInfoBuilder.EN_DEBUG:
+            print("--> RandInfoBuilder::visit_constraint_expr")
+            
         super().visit_constraint_expr(c)
 
+        if RandInfoBuilder.EN_DEBUG:
+            print("<-- RandInfoBuilder::visit_constraint_expr")
+        
     def visit_constraint_dist_scope(self, s : ConstraintDistScopeModel):
         super().visit_constraint_dist_scope(s)
 
         # Save information on dist constraints to the 
         # appropriate randset
         if self._active_randset is not None:
-            f = s.dist_c.lhs.fm
+            f = self._expr2fm.field(s.dist_c.lhs)
             if f in self._active_randset.dist_field_m.keys():
                 self._active_randset.dist_field_m[f].append(s)
             else:
                 self._active_randset.dist_field_m[f] = [s]
 
     def visit_constraint_soft(self, c:ConstraintSoftModel):
+        if RandInfoBuilder.EN_DEBUG:
+            print("--> RandInfoBuilder::visit_constraint_soft")
+            
         # Update the priority of this constraint
         c.priority += self._soft_priority
         self._soft_priority += 1
 
         super().visit_constraint_soft(c)
 
+        if RandInfoBuilder.EN_DEBUG:
+            print("<-- RandInfoBuilder::visit_constraint_soft")
+        
     def visit_expr_array_subscript(self, s : ExprArraySubscriptModel):
         fm = s.getFieldModel()
         if self._pass == 1:
@@ -281,53 +272,64 @@ def visit_expr_array_subscript(self, s : ExprArraySubscriptModel):
                 self._field_s.remove(fm)
 
     def visit_expr_fieldref(self, e):
-        if self._pass == 1:
+        # If the field is already referenced by an existing randset
+        # that is not this one, we need to merge the sets
+        fm = self._expr2fm.field(e)
+        
+        if self._pass == 0:
+            fm.accept(self)
+        elif self._pass == 1:
             # During pass 1, build out randsets based on constraint
             # relationships
 
-            # If the field is already referenced by an existing randset
-            # that is not this one, we need to merge the sets
-            if isinstance(e.fm, FieldArrayModel):
+            
+            if isinstance(fm, FieldArrayModel):
+                # Note: this is important for unique constraints on an
+                # entire (possibly variable-size) scalar array
                 for f in e.fm.field_l:
                     self.process_fieldref(f)
             else:
-                self.process_fieldref(e.fm)
+                self.process_fieldref(fm)
 
-
-        super().visit_expr_fieldref(e)
+#        super().visit_expr_fieldref(e)
 
     def visit_expr_indexed_fieldref(self, e):
         self.process_fieldref(e.get_target())
 
     def process_fieldref(self, fm):
+        if RandInfoBuilder.EN_DEBUG > 0:
+            print("--> RandInfoBuilder::process_fieldref %s" % fm.fullname)
         if fm in self._randset_field_m.keys():
             # There's an existing randset that holds this field
             ex_randset = self._randset_field_m[fm]
             if self._active_randset is None:
                 self._active_randset = ex_randset
             elif ex_randset is not self._active_randset:
-                if fm in self._order_s:
-                    # This field is part of the ordering constraint set. 
-                    if self._active_randset.order != -1 and self._active_randset.order < ex_randset.order:
-                        # If the active randset is also ordered, and comes before
-                        # the one containing this field as primary, then we must
-                        # save the constraints
-                        self._active_order_randset_s.add(ex_randset)
-                        self._active_randset.add_nontarget(fm)
-                else:
-                    # This field isn't being ordered, so go ahead and
-                    for f in self._active_randset.fields():
-                        # Relink to the new consolidated randset
-                        self._randset_field_m[f] = ex_randset
-                        ex_randset.add_field(f)
+                if RandInfoBuilder.EN_DEBUG > 0:
+                    print("RandInfoBuilder: combine two randsets")
+                    
+                # This field isn't being ordered, so go ahead and
+                for f in self._active_randset.fields():
+                    # Relink to the new consolidated randset
+                    self._randset_field_m[f] = ex_randset
+                    ex_randset.add_field(f)
 
-                    for c in self._active_randset.constraints():
-                        ex_randset.add_constraint(c)
+                for c in self._active_randset.constraints():
+                    ex_randset.add_constraint(c)
+                    
+                for c in self._active_randset.soft_constraints():
+                    ex_randset.add_constraint(c)
 
-                    # Remove the previous randset
-                    self._randset_s.remove(self._active_randset)                    
-                    self._active_randset = ex_randset
+                # Remove the previous randset
+                self._randset_s.remove(self._active_randset)                    
+                self._active_randset = ex_randset
+            else:
+                # Field is handled by a randset that is the active one
+                pass
         else:
+            if RandInfoBuilder.EN_DEBUG > 0:
+                print("RandInfoBuilder: create new randset")
+                
             # No existing randset holds this field
             if self._active_randset is None:
                 self._active_randset = RandSet()
@@ -339,6 +341,9 @@ def process_fieldref(self, fm):
 
         if fm in self._field_s:
             self._field_s.remove(fm)        
+            
+        if RandInfoBuilder.EN_DEBUG > 0:
+            print("<-- RandInfoBuilder::process_fieldref %s" % fm.fullname)
 
 
     def visit_composite_field(self, f):

src/vsc/model/rand_set_node_builder.py

@@ -51,4 +51,5 @@ def visit_expr_fieldref(self, e):
         if self.phase == 0:
             e.fm.accept(self)
         super().visit_expr_fieldref(e)
+