0.8.9

- (#205) - Ensure that recursive references between objects don't cause recursion

Signed-off-by: Matthew Ballance <[email protected]>

Author: mballance

doc/Changelog.md

@@ -1,4 +1,7 @@
 
+## 0.8.9
+- (#205) - Ensure that recursive references between objects don't cause recursion
+
 ## 0.8.8
 - Ensure covergroup type names are properly reflected in saved coverage data.
 - Test suite updates to adapt to newer Python versions

etc/ivpm.info

@@ -1,4 +1,4 @@
 
 name=pyvsc
-version=0.8.8
+version=0.8.9
 

src/vsc/model/field_array_model.py

@@ -80,17 +80,17 @@ def name_elems(self):
         for i,f in enumerate(self.field_l):
             f.name = self.name + "[" + str(i) + "]"
 
-    def pre_randomize(self):
+    def pre_randomize(self, visited):
         # Set the size field for arrays that don't
         # have a random size
         if self.is_rand_sz:
             self.size.set_used_rand(True)
         else:
             self._set_size(len(self.field_l))
-        FieldCompositeModel.pre_randomize(self)
+        FieldCompositeModel.pre_randomize(self, visited)
 
-    def post_randomize(self):
-        FieldCompositeModel.post_randomize(self)
+    def post_randomize(self, visited):
+        FieldCompositeModel.post_randomize(self, visited)
         self.sum_expr = None
         self.sum_expr_btor = None
 
@@ -116,13 +116,9 @@ def build(self, builder):
         self._set_size(len(self.field_l))
         super().build(builder)
 
-#    def set_used_rand(self, is_rand, level=0):
-#        if self.is_rand_sz:
-#            self.size.set_used_rand(is_rand)
-#        FieldCompositeModel.set_used_rand(self, is_rand, level=level)
-    def set_used_rand(self, is_rand, level=0):
-        super().set_used_rand(is_rand, level)
-        self.size.set_used_rand(is_rand, level+1)
+    def set_used_rand(self, is_rand, level=0, in_set=None):
+        super().set_used_rand(is_rand, level, in_set)
+        self.size.set_used_rand(is_rand, level+1, in_set)
 
     def get_sum_expr(self):
         if self.sum_expr is None:

src/vsc/model/field_composite_model.py

@@ -57,12 +57,17 @@ def is_declared_rand(self, v):
         self.__is_declared_rand = bool(v)
         self.rand_mode = bool(v)
 
-    def set_used_rand(self, is_rand, level=0):
+    def set_used_rand(self, is_rand, level=0, in_set=None):
         self.is_used_rand = (is_rand and 
                              ((self.is_declared_rand and self.rand_mode) or level==0))
+        
+        if in_set is None:
+            in_set = set()
 
         for f in self.field_l:
-            f.set_used_rand(self.is_used_rand, level+1)
+            if f not in in_set:
+                in_set.add(f)
+                f.set_used_rand(self.is_used_rand, level+1, in_set)
 
     def build(self, builder):
         # First, build the fields
@@ -128,27 +133,33 @@ def get_fields(self, field_l):
             else:
                 field_l.append(f)
 
-    def pre_randomize(self):
+    def pre_randomize(self, visited):
         """Called during the randomization process to propagate `pre_randomize` event"""
 
         # Perform a phase callback if available. Note,
         # only trigger pre_randomize callbacks on composite
         # fields that are actually being used as random
         if self.is_used_rand and self.rand_if is not None:
             self.rand_if.do_pre_randomize()
-            
+
+        visited.append(self)
         for f in self.field_l:
-            f.pre_randomize()
+            if f not in visited:
+                f.pre_randomize(visited)
+        visited.remove(self)
 
-    def post_randomize(self):
+    def post_randomize(self, visited):
         """Called during the randomization process to propagate `post_randomize` event"""
 
         # Perform a phase callback if available
         if self.is_used_rand and self.rand_if is not None:
             self.rand_if.do_post_randomize()
-            
+
+        visited.append(self)
         for f in self.field_l:
-            f.post_randomize()
+            if f not in visited:
+                f.post_randomize(visited)
+        visited.remove(self)
 
     def accept(self, v):
         v.visit_composite_field(self)

src/vsc/model/field_model.py

@@ -39,10 +39,10 @@ def __init__(self, name):
     def build(self, builder):
         raise Exception("FieldModel::build unimplemented for type " + str(type(self)))
 
-    def pre_randomize(self):
+    def pre_randomize(self, visited):
         pass
 
-    def post_randomize(self):
+    def post_randomize(self, visited):
         pass
 
     def get_val(self) -> Value:
@@ -53,10 +53,12 @@ def set_val(self, v : Value):
 
     @property
     def fullname(self):
+        visited = []
         ret = self.name
         p = self.parent
 
-        while p is not None:
+        while p is not None and p not in visited:
+            visited.append(p)
             if p.name is not None:
                 ret = p.name + "." + ret
             p = p.parent

src/vsc/model/field_scalar_model.py

@@ -45,7 +45,7 @@ def __init__(self,
         self.var = None
         self.val = ValueScalar(0)
 
-    def set_used_rand(self, is_rand, level=0):
+    def set_used_rand(self, is_rand, level=0, in_set=None):
         # Field is considered rand when
         # - It is a root field, on which 'randomize' is called
         # - It is declared as random, and 'rand_mode' is true
@@ -85,7 +85,7 @@ def __str__(self):
     def get_constraints(self, constraint_l):
         pass
 
-    def pre_randomize(self):
+    def pre_randomize(self, visited):
         if self.rand_if is not None:
             self.rand_if.do_pre_randomize()
 
@@ -95,7 +95,7 @@ def set_val(self, val : Value):
     def get_val(self):
         return self.val
 
-    def post_randomize(self):
+    def post_randomize(self, visited):
         if self.var is not None:
             # Convert to a Python base-10 integer (unsigned)
             val = int(self.var.assignment, 2)

src/vsc/model/model_visitor.py

@@ -53,15 +53,19 @@
 class ModelVisitor(object):
 
     def __init__(self):
+        self.field_visited = []
         pass
 
     def visit_rand_obj(self, r):
         self.visit_composite_field(r)
 
     def visit_composite_field(self, f : FieldCompositeModel):
         # Visit fields
+        self.field_visited.append(f)
         for fi in f.field_l:
-            fi.accept(self)
+            if fi not in self.field_visited:
+                fi.accept(self)
+        self.field_visited.remove(f)
 
         # Visit constraints
         for c in f.constraint_model_l:

src/vsc/model/randomizer.py

@@ -274,7 +274,8 @@ def randomize(self, ri : RandInfo, bound_m : Dict[FieldModel,VariableBoundModel]
             while x < rs_i:
                 rs = ri.randsets()[x]
                 for f in rs.all_fields():
-                    f.post_randomize()
+                    visited = []
+                    f.post_randomize(visited)
                     f.set_used_rand(False, 0)
                     f.dispose() # Get rid of the solver var, since we're done with it
                     f.accept(reset_v)
@@ -537,8 +538,9 @@ def do_randomize(
                 print("  " + ModelPrettyPrinter.print(fm))
 
         # First, invoke pre_randomize on all elements
+        visited = []
         for fm in field_model_l:
-            fm.pre_randomize()
+            fm.pre_randomize(visited)
 
         if constraint_l is None:
             constraint_l = []
@@ -601,9 +603,10 @@ def do_randomize(
                 randomize_done(srcinfo, solve_info)
             for fm in field_model_l:
                 ConstraintOverrideRollbackVisitor.rollback(fm)
-        
+
+        visited = [] 
         for fm in field_model_l:
-            fm.post_randomize()
+            fm.post_randomize(visited)
 
 
         # Process constraints to identify variable/constraint sets

src/vsc/visitors/clear_soft_priority_visitor.py

@@ -4,17 +4,25 @@
 @author: mballance
 '''
 from vsc.model.constraint_soft_model import ConstraintSoftModel
+from vsc.model.field_composite_model import FieldCompositeModel
 from vsc.model.model_visitor import ModelVisitor
 
 
 class ClearSoftPriorityVisitor(ModelVisitor):
 
     def __init__(self):
         super().__init__()
+        self.visited = set()
 
     def clear(self, e):
+        self.visited.clear()
         e.accept(self)
 
     def visit_constraint_soft(self, c:ConstraintSoftModel):
         c.priority = 0
+
+    def visit_composite_field(self, f: FieldCompositeModel):
+        if f not in self.visited:
+            self.visited.add(f)
+            super().visit_composite_field(f)
 

src/vsc/visitors/model_pretty_printer.py

@@ -33,6 +33,7 @@
 class ModelPrettyPrinter(ModelVisitor):
 
     def __init__(self):
+        super().__init__()
         self.out = StringIO()
         self.ind = ""
         self.print_values = False
@@ -69,6 +70,7 @@ def visit_composite_field(self, f : FieldCompositeModel):
         self.writeln(name + " {")
         self.inc_indent()
         super().visit_composite_field(f)
+
         self.dec_indent()
         self.writeln("}")