New: Cumulus Stats plugin, for trans-hierarchical statistics.

cumulus/src/plugins/stats.py

@@ -0,0 +1,160 @@
+#
+# This file is part of the Coriolis Software.
+# Copyright (c) SU 2020-2020, All Rights Reserved
+#
+# +-----------------------------------------------------------------+
+# |                   C O R I O L I S                               |
+# |      C u m u l u s  -  P y t h o n   T o o l s                  |
+# |                                                                 |
+# |  Author      :                    Jean-Paul CHAPUT              |
+# |  E-mail      :            Jean-Paul.Chaput@lip6.fr              |
+# | =============================================================== |
+# |  Python      :       "./plugins/stats.py"                       |
+# +-----------------------------------------------------------------+
+
+"""
+This script hook the Stats plugin inside GCT/Unicorn.
+
+Compute some statistics on a hierarchical block.
+"""
+
+from   __future__ import print_function
+import sys
+import traceback
+import helpers
+from   helpers.io      import ErrorMessage
+from   helpers.io      import WarningMessage
+from   helpers.overlay import UpdateSession
+from   helpers         import trace
+import plugins
+from   Hurricane import Breakpoint
+from   Hurricane import DbU
+from   Hurricane import Box
+from   Hurricane import Net
+from   Hurricane import Cell
+from   Hurricane import Instance
+from   Hurricane import Transformation
+
+
+class Stats ( object ):
+
+    LUT = {}
+
+    @staticmethod
+    def lookup ( p ):
+        if isinstance(p,Cell): cell = p
+        else:                  cell = p.getMasterCell()
+        if Stats.LUT.has_key(cell): return Stats.LUT[ cell ]
+        return None
+
+    @staticmethod
+    def isInstanceTerminal ( p ):
+        if isinstance(p,Cell): cell = p
+        else:                  cell = p.getMasterCell()
+        for instance in cell.getInstances():
+            return False
+        return True
+
+    @staticmethod
+    def consolidate ():
+        ordereds = {}
+        for item in Stats.LUT.values():
+            if not ordereds.has_key(item.depth):
+                ordereds[item.depth] = []
+            ordereds[item.depth].append( item )
+        rkeys = ordereds.keys()
+        rkeys.reverse()
+        for key in rkeys:
+            for cellStat in ordereds[key]:
+                cellStat._consolidate()
+        return
+        
+    def __init__ ( self, cell, depth ):
+        self.cell          = cell
+        self.consolidated  = False
+        self.depth         = depth
+        self.directCells   = 0
+        self.indirectCells = 0
+        self.blocks        = 0
+        Stats.LUT[ cell ] = self
+
+        for instance in self.cell.getInstances():
+            if Stats.isInstanceTerminal(instance):
+                self.directCells += 1
+            else:
+                self.blocks += 1 
+                blockStat = Stats.lookup( instance )
+                if blockStat is None:
+                    blockStat = Stats( instance.getMasterCell(), depth+1 )
+                else:
+                    blockStat.updateDepth( depth+1 )
+        if self.depth == 0:
+            Stats.consolidate()
+        return
+
+    @property
+    def allCells ( self ): return self.directCells+self.indirectCells
+
+    def updateDepth ( self, depth ):
+        if self.depth < depth: self.depth = depth
+
+    def display ( self ):
+        if self.depth == 0:
+            print( '{:>8} |{:>8} |{:>8} | {}'.format( 'Cumul.', 'Own', 'Blocks', 'MasterCell' ) )
+        print( '{:8} |{:8} |{:8} | {}+ {}'.format( self.allCells
+                                              , self.directCells
+                                              , self.blocks
+                                              , ' '*(self.depth*2)
+                                              , self.cell.getName() ))
+        for instance in self.cell.getInstances():
+            if Stats.isInstanceTerminal(instance): continue
+            blockStat = Stats.lookup( instance )
+            if blockStat is None: continue
+            blockStat.display()
+        return
+
+    def _consolidate ( self ):
+        if self.consolidated: return
+        for instance in self.cell.getInstances():
+            if Stats.isInstanceTerminal(instance): continue
+            blockStat = Stats.lookup( instance )
+            if blockStat is None:
+                continue
+            self.indirectCells += blockStat.allCells
+        self.consolidated = True
+        return
+        
+
+
+# --------------------------------------------------------------------
+# Plugin hook functions, unicornHook:menus, ScritMain:call
+
+def unicornHook ( **kw ):
+    kw['beforeAction'] = 'misc.alpha'
+
+    plugins.kwUnicornHook( 'misc.alpha.stats'
+                         , 'Statistics'
+                         , 'Compute some statistics on a hierarchy of Cells '
+                         , sys.modules[__name__].__file__
+                         , **kw
+                         )
+    return
+
+
+def scriptMain ( **kw ):
+    """The mandatory function that Coriolis CGT/Unicorn will look for."""
+    rvalue = True
+    try:
+        helpers.setTraceLevel( 550 )
+        cell, editor = plugins.kwParseMain( **kw )
+
+        stats = Stats( cell, 0 )
+        stats.display()
+    except Exception, e:
+        helpers.io.catch( e )
+        rvalue = False
+
+    sys.stdout.flush()
+    sys.stderr.flush()
+        
+    return rvalue