Add supports for nested breakdown in 'dmprof cat'.

tools/deep_memory_profiler/lib/sorter.py

 # Copyright 2013 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import cStringIO
 import json
 import logging
 import os
 import re
 
 
 LOGGER = logging.getLogger('dmprof')
 
 BASE_PATH = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 
 DEFAULT_SORTERS = [
     os.path.join(BASE_PATH, 'sorter.malloc-component.json'),
     os.path.join(BASE_PATH, 'sorter.malloc-type.json'),
     os.path.join(BASE_PATH, 'sorter.vm-map.json'),
     os.path.join(BASE_PATH, 'sorter.vm-sharing.json'),
     ]
 
+DEFAULT_TEMPLATES = os.path.join(BASE_PATH, 'templates.json')
+
 
 class Unit(object):
   """Represents a minimum unit of memory usage categorization.
 
   It is supposed to be inherited for some different spaces like the entire
   virtual memory and malloc arena. Such different spaces are called "worlds"
   in dmprof. (For example, the "vm" world and the "malloc" world.)
   """
   def __init__(self, unit_id, size):
     self._unit_id = unit_id
@@ skipping 112 matching lines @@
     if not overwrite and unit.unit_id in self._units:
       LOGGER.error('The unit id=%s already exists.' % str(unit.unit_id))
     self._units[unit.unit_id] = unit
 
 
 class AbstractRule(object):
   """An abstract class for rules to be matched with units."""
   def __init__(self, dct):
     self._name = dct['name']
     self._hidden = dct.get('hidden', False)
-    self._subworlds = dct.get('subworlds', [])
+    self._subs = dct.get('subs', [])
 
   def match(self, unit):
     raise NotImplementedError()
 
   @property
   def name(self):
     return self._name
 
   @property
   def hidden(self):
     return self._hidden
 
-  def iter_subworld(self):
-    for subworld in self._subworlds:
-      yield subworld
+  def iter_subs(self):
+    for sub in self._subs:
+      yield sub
 
 
 class VMRule(AbstractRule):
   """Represents a Rule to match with virtual memory regions."""
   def __init__(self, dct):
     super(VMRule, self).__init__(dct)
     self._backtrace_function = dct.get('backtrace_function', None)
     if self._backtrace_function:
       self._backtrace_function = re.compile(self._backtrace_function)
     self._backtrace_sourcefile = dct.get('backtrace_sourcefile', None)
@@ skipping 140 matching lines @@
     return self._no_bucket
 
 
 class AbstractSorter(object):
   """An abstract class for classifying Units with a set of Rules."""
   def __init__(self, dct):
     self._type = 'sorter'
     self._version = dct['version']
     self._world = dct['world']
     self._name = dct['name']
+    self._root = dct.get('root', False)
     self._order = dct['order']
 
     self._rules = []
     for rule in dct['rules']:
       if dct['world'] == 'vm':
         self._rules.append(VMRule(rule))
       elif dct['world'] == 'malloc':
         self._rules.append(MallocRule(rule))
       else:
         LOGGER.error('Unknown sorter world type')
@@ skipping 20 matching lines @@
       return None
 
   @property
   def world(self):
     return self._world
 
   @property
   def name(self):
     return self._name
 
+  @property
+  def root(self):
+    return self._root
+
   def find(self, unit):
     raise NotImplementedError()
 
   def find_rule(self, name):
     """Finds a rule whose name is |name|. """
     for rule in self._rules:
       if rule.name == name:
         return rule
     return None
 
@@ skipping 26 matching lines @@
     if unit.bucket.component_cache:
       return unit.bucket.component_cache
 
     for rule in self._rules:
       if rule.match(unit):
         unit.bucket.component_cache = rule
         return rule
     assert False
 
 
+class SorterTemplates(object):
+  """Represents a template for sorters."""
+  def __init__(self, dct):
+    self._dict = dct
+
+  def as_dict(self):
+    return self._dict
+
+  @staticmethod
+  def load(filename):
+    with open(filename) as templates_f:
+      templates_dict = json.load(templates_f)
+    return SorterTemplates(templates_dict)
+
+
 class SorterSet(object):
   """Represents an iterable set of Sorters."""
   def __init__(self, additional=None, default=None):
     if not additional:
       additional = []
     if not default:
       default = DEFAULT_SORTERS
     self._sorters = {}
     for filename in default + additional:
       sorter = AbstractSorter.load(filename)
       if sorter.world not in self._sorters:
         self._sorters[sorter.world] = []
       self._sorters[sorter.world].append(sorter)
+    self._templates = SorterTemplates.load(DEFAULT_TEMPLATES)
 
   def __repr__(self):
     result = cStringIO.StringIO()
     result.write(self._sorters)
     return result.getvalue()
 
   def __iter__(self):
     for sorters in self._sorters.itervalues():
       for sorter in sorters:
         yield sorter
 
   def iter_world(self, world):
     for sorter in self._sorters.get(world, []):
       yield sorter
+
+  @property
+  def templates(self):
+    return self._templates