Performance tweaks

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

Author: mballance

doc/source/reference/formats/ncdb-format.rst

@@ -11,23 +11,17 @@ class MemCoverIndexIterator(object):
 
     def __init__(self, coveritems : List[MemCoverIndex], mask : CoverTypeT):
         self.coveritems = coveritems
-        self.mask = mask
+        self.mask = int(mask)
         self.idx = 0
-        
+
     def __iter__(self):
         return self
-    
+
     def __next__(self):
-        next = None
-        
-        while self.idx < len(self.coveritems) and next is None:
+        mask = self.mask
+        while self.idx < len(self.coveritems):
             n = self.coveritems[self.idx]
-
-            if (n.data.type & self.mask) != 0:
-                next = n
             self.idx += 1
-
-        if next is None:
-            raise StopIteration
-        
-        return next
+            if (int(n.data.type) & mask) != 0:
+                return n
+        raise StopIteration

src/ucis/mem/mem_cover_index_iterator.py

@@ -50,15 +50,16 @@ def createScope(self,
         source : SourceT, 
         type : ScopeTypeT, 
         flags : FlagsT) -> 'Scope':
-        if (type & ScopeTypeT.COVERGROUP) != 0:
+        itype = int(type)
+        if (itype & int(ScopeTypeT.COVERGROUP)) != 0:
             ret = MemCovergroup(self, name, srcinfo, weight, source)
-        elif (type & ScopeTypeT.BLOCK) != 0:
+        elif (itype & int(ScopeTypeT.BLOCK)) != 0:
             ret = MemBlockScope(self, name, srcinfo, weight, source, flags)
-        elif (type & ScopeTypeT.BRANCH) != 0:
+        elif (itype & int(ScopeTypeT.BRANCH)) != 0:
             ret = MemBranchScope(self, name, srcinfo, weight, source, flags)
-        elif (type & ScopeTypeT.TOGGLE) != 0:
+        elif (itype & int(ScopeTypeT.TOGGLE)) != 0:
             ret = MemToggleScope(self, name, srcinfo, weight, source, flags)
-        elif (type & ScopeTypeT.FSM) != 0:
+        elif (itype & int(ScopeTypeT.FSM)) != 0:
             from ucis.mem.mem_fsm_scope import MemFSMScope
             ret = MemFSMScope(self, name, srcinfo, weight, source, flags)
         else:
@@ -96,4 +97,4 @@ def createToggle(self,
     def getIthCoverItem(self, i)->CoverItem:
         return self.m_cover_item_l[i]
 
-    
+    

src/ucis/mem/mem_instance_scope.py

@@ -11,25 +11,19 @@ class MemScopeIterator(object):
     def __init__(self, nodes : List['MemScope'], mask):
         self.nodes = nodes
         self.idx = 0
-        self.mask = mask
-        
+        self.mask = int(mask)
+
     def __iter__(self):
         return self
-    
+
     def __next__(self):
         next = None
+        mask = self.mask
 
-        while next is None and self.idx < len(self.nodes):
+        while self.idx < len(self.nodes):
             n = self.nodes[self.idx]
-            # TODO: qualify mask
-            if (n.getScopeType() & self.mask) != 0:
-                next = n
-
             self.idx += 1
-            
-            if next is not None:
-                break
+            if (int(n.getScopeType()) & mask) != 0:
+                return n
 
-        if next is None:        
-            raise StopIteration
-        return next
+        raise StopIteration

src/ucis/mem/mem_scope_iterator.py

@@ -32,6 +32,10 @@ def dfs_scope_list(db) -> list:
     Toggle-pair BRANCH scopes are included (they appear in scope_tree.bin
     as TOGGLE_PAIR records but still occupy one DFS slot each).
     """
+    cached = getattr(db, '_dfs_scope_cache', None)
+    if cached is not None:
+        return cached
+
     result = []
 
     def _visit(scope):
@@ -43,4 +47,5 @@ def _visit(scope):
     for top_scope in db.scopes(ScopeTypeT.ALL):
         _visit(top_scope)
 
+    db._dfs_scope_cache = result
     return result

src/ucis/ncdb/dfs_util.py

@@ -44,24 +44,26 @@ def _fixup_instance_du_links(db: MemUCIS) -> None:
     """
     from ucis.mem.mem_instance_scope import MemInstanceScope
 
+    _DU_MASK = 0x000000001F000000
+    _INSTANCE_VAL = int(ScopeTypeT.INSTANCE)
+
     def _fix_parent(parent):
-        # Build name → DU map from real (attached) children
+        children = parent.m_children if hasattr(parent, 'm_children') else list(parent.scopes(ScopeTypeT.ALL))
         du_map = {}
-        for child in parent.scopes(ScopeTypeT.ALL):
-            if ScopeTypeT.DU_ANY(child.getScopeType()):
+        instances = []
+        for child in children:
+            st = int(child.getScopeType())
+            if st & _DU_MASK:
                 du_map[child.getScopeName()] = child
-
-        # Replace placeholder DU refs on INSTANCE scopes
-        for child in parent.scopes(ScopeTypeT.ALL):
-            if isinstance(child, MemInstanceScope):
-                du = child.m_du_scope
-                if du is not None and du.m_parent is None:
-                    # Detached placeholder — replace with real DU if available
-                    real_du = du_map.get(child.getScopeName())
-                    if real_du is not None:
-                        child.m_du_scope = real_du
-            # Recurse
+            if st == _INSTANCE_VAL:
+                instances.append(child)
             _fix_parent(child)
+        for child in instances:
+            du = child.m_du_scope
+            if du is not None and du.m_parent is None:
+                real_du = du_map.get(child.getScopeName())
+                if real_du is not None:
+                    child.m_du_scope = real_du
 
     _fix_parent(db)
 

src/ucis/ncdb/ncdb_reader.py

@@ -308,21 +308,26 @@ def _read_regular_scope(self, data: bytes, offset: int, parent, counts_iter):
         num_coveritems, offset = decode_varint(data, offset)
 
         child_cover_type = None
+        at_least = 0
         if num_coveritems > 0:
             ctv, offset = decode_varint(data, offset)
             child_cover_type = CoverTypeT(ctv)
             defaults = COVER_TYPE_DEFAULTS.get(child_cover_type, (0, 0, 1))
             at_least = at_least_override if at_least_override is not None else defaults[1]
 
         if scope_type == ScopeTypeT.INSTANCE:
-            # createInstance() requires a DU reference; find the matching DU
-            # that was already serialized (DU scopes precede INSTANCE in DFS).
             du_scope = None
-            for sibling in parent.scopes(ScopeTypeT.ALL):
-                if (ScopeTypeT.DU_ANY(sibling.getScopeType())
-                        and sibling.getScopeName() == name):
-                    du_scope = sibling
-                    break
+            _du_mask = 0x000000001F000000
+            if hasattr(parent, 'm_children'):
+                for sibling in parent.m_children:
+                    if (int(sibling.getScopeType()) & _du_mask) and sibling.getScopeName() == name:
+                        du_scope = sibling
+                        break
+            else:
+                for sibling in parent.scopes(ScopeTypeT.ALL):
+                    if ScopeTypeT.DU_ANY(sibling.getScopeType()) and sibling.getScopeName() == name:
+                        du_scope = sibling
+                        break
             if du_scope is None:
                 # DU not yet in parent (INSTANCE precedes DU in source ordering).
                 # Create a detached placeholder so createInstance() can succeed
@@ -350,7 +355,7 @@ def _read_regular_scope(self, data: bytes, offset: int, parent, counts_iter):
             cd.data = count
             if at_least_override is not None or (child_cover_type and
                     COVER_TYPE_DEFAULTS.get(child_cover_type, (0,0,1))[1] != 0):
-                cd.at_least = at_least if 'at_least' in dir() else 0
+                cd.at_least = at_least
             scope.createNextCover(ci_name, cd, None)
 
         # Child scopes

src/ucis/ncdb/scope_tree.py

@@ -31,32 +31,36 @@ def build(db : 'UCIS') ->'CoverageReport':
 
 
     def _build(self)->'CoverageReport':
-        
+
+        all_coverage = 0.0
+        all_div = 0
         for iscope in self.db.scopes(ScopeTypeT.INSTANCE):
-            self.build_covergroups(iscope)
-            
+            cov, div = self.build_covergroups(iscope)
+            all_coverage += cov
+            all_div += div
+
+        if all_div > 0:
+            self.report.coverage = all_coverage / all_div
+        else:
+            self.report.coverage = 0.0
+
         return self.report
-            
 
     def build_covergroups(self, iscope):
-        
+
         coverage = 0.0
         div = 0
-        
+
         for cg_t in iscope.scopes(ScopeTypeT.COVERGROUP):
             cg = self.build_covergroup(cg_t)
             if cg.weight > 0:
                 coverage += cg.coverage * cg.weight
             div += cg.weight
             self.report.covergroups.append(cg)
             self.report.covergroup_m[cg.instname] = cg
-        
-        # Handle case when there are no covergroups
-        if div > 0:
-            self.report.coverage = coverage/div
-        else:
-            self.report.coverage = 0.0
-            
+
+        return coverage, div
+
     def build_covergroup(self, cg_n)->CoverageReport.Covergroup:
         cg_r = CoverageReport.Covergroup(
             cg_n.getScopeName(),
@@ -85,7 +89,12 @@ def build_covergroup(self, cg_n)->CoverageReport.Covergroup:
         for cr in cg_r.crosses:
             coverage += cr.coverage * cr.weight
             div += cr.weight
-            
+
+        for sub in cg_r.covergroups:
+            if sub.weight > 0:
+                coverage += sub.coverage * sub.weight
+            div += sub.weight
+
         if div > 0: coverage /= div
 
         cg_r.coverage = coverage
@@ -96,37 +105,44 @@ def build_coverpoint(self, cp_n : Coverpoint):
         cp_r = CoverageReport.Coverpoint(cp_n.getScopeName())
         cp_r.weight = cp_n.getWeight()
 
-        # Read in bins
+        # Read in bins — check both direct cover items and typed bin
+        # sub-scopes (CVGBINSCOPE, IGNOREBINSCOPE, ILLEGALBINSCOPE).
         num_hit = 0
         total = 0
-        for ci_n in cp_n.coverItems(CoverTypeT.CVGBIN):
-            cvg_data = ci_n.getCoverData()
-            
-            if cvg_data.data >= cvg_data.at_least:
-                num_hit += 1
-                
-            cp_r.bins.append(CoverageReport.CoverBin(
-                    ci_n.getName(),
-                    cvg_data.at_least,
-                    cvg_data.data))
 
-            total += 1
-            
-        for ci_n in cp_n.coverItems(CoverTypeT.IGNOREBIN):
-            cvg_data = ci_n.getCoverData()
-            
-            cp_r.ignore_bins.append(CoverageReport.CoverBin(
-                    ci_n.getName(),
-                    cvg_data.at_least,
-                    cvg_data.data))
-            
-        for ci_n in cp_n.coverItems(CoverTypeT.ILLEGALBIN):
-            cvg_data = ci_n.getCoverData()
-            
-            cp_r.illegal_bins.append(CoverageReport.CoverBin(
-                    ci_n.getName(),
-                    cvg_data.at_least,
-                    cvg_data.data))
+        def _collect_items(scope):
+            """Yield (cover_item, effective_type) from a scope."""
+            for ci in scope.coverItems(CoverTypeT.CVGBIN):
+                yield ci, CoverTypeT.CVGBIN
+            for ci in scope.coverItems(CoverTypeT.IGNOREBIN):
+                yield ci, CoverTypeT.IGNOREBIN
+            for ci in scope.coverItems(CoverTypeT.ILLEGALBIN):
+                yield ci, CoverTypeT.ILLEGALBIN
+
+        # Collect from direct items on the coverpoint
+        sources = [cp_n]
+        # Also collect from typed bin sub-scopes
+        for sub in cp_n.scopes(ScopeTypeT.CVGBINSCOPE):
+            sources.append(sub)
+        for sub in cp_n.scopes(ScopeTypeT.IGNOREBINSCOPE):
+            sources.append(sub)
+        for sub in cp_n.scopes(ScopeTypeT.ILLEGALBINSCOPE):
+            sources.append(sub)
+
+        for src in sources:
+            for ci_n, ct in _collect_items(src):
+                cvg_data = ci_n.getCoverData()
+                bin_obj = CoverageReport.CoverBin(
+                    ci_n.getName(), cvg_data.at_least, cvg_data.data)
+                if ct == CoverTypeT.CVGBIN:
+                    cp_r.bins.append(bin_obj)
+                    total += 1
+                    if cvg_data.data >= cvg_data.at_least:
+                        num_hit += 1
+                elif ct == CoverTypeT.IGNOREBIN:
+                    cp_r.ignore_bins.append(bin_obj)
+                elif ct == CoverTypeT.ILLEGALBIN:
+                    cp_r.illegal_bins.append(bin_obj)
 
         if total > 0:
             cp_r.coverage = (100*num_hit)/total
@@ -161,4 +177,4 @@ def build_cross(self, cr_n : Cross):
 
 
 
-    
+    

src/ucis/report/coverage_report_builder.py

@@ -190,6 +190,6 @@ def DU_ANY(t):
             >>> if ScopeTypeT.DU_ANY(scope.getType()):
             ...     print("This is a design unit")
         """
-        return (t & (ScopeTypeT.DU_MODULE|ScopeTypeT.DU_ARCH|ScopeTypeT.DU_PACKAGE|ScopeTypeT.DU_PROGRAM|ScopeTypeT.DU_INTERFACE)) != 0
+        return (int(t) & 0x000000001F000000) != 0
 
-    
+