Use json to describe dmprof policies.

tools/deep_memory_profiler/dmprof

 #!/usr/bin/env python
 # Copyright (c) 2012 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.
 
 """The deep heap profiler script for Chrome."""
 
 from datetime import datetime
 import json
 import optparse
@@ skipping 60 matching lines @@
 # Heap Profile Policy versions
 
 # POLICY_DEEP_1 DOES NOT include allocation_type columns.
 # mmap regions are distincted w/ mmap frames in the pattern column.
 POLICY_DEEP_1 = 'POLICY_DEEP_1'
 
 # POLICY_DEEP_2 DOES include allocation_type columns.
 # mmap regions are distincted w/ the allocation_type column.
 POLICY_DEEP_2 = 'POLICY_DEEP_2'
 
+# POLICY_DEEP_3 is in JSON format.
+POLICY_DEEP_3 = 'POLICY_DEEP_3'
+
 
 class EmptyDumpException(Exception):
   def __init__(self, value):
     self.value = value
   def __str__(self):
     return repr(self.value)
 
 
 class ParsingException(Exception):
   def __init__(self, value):
@@ skipping 35 matching lines @@
         self.loaded_static_symbols = StaticSymbols.load(self.prepared_data_dir)
       finally:
         if not self.keep:
           shutil.rmtree(self.prepared_data_dir)
     return self.loaded_static_symbols
 
 
 class Rule(object):
   """Represents one matching rule in a policy file."""
 
-  def __init__(self, name, mmap, pattern):
+  def __init__(self, name, mmap, stacktrace_pattern):
     self.name = name
     self.mmap = mmap
-    self.condition = re.compile(pattern + r'\Z')
+    self.stacktrace_pattern = re.compile(stacktrace_pattern + r'\Z')
 
 
 class Policy(object):
   """Represents a policy, a content of a policy file."""
 
   def __init__(self, rules, version, components):
     self.rules = rules
     self.version = version
     self.components = components
 
@@ skipping 13 matching lines @@
       A string representing a component name.
   """
   if not bucket:
     return 'no-bucket'
   if bucket.component_cache:
     return bucket.component_cache
 
   stacktrace = ''.join(symbols[a] + ' ' for a in bucket.stacktrace).strip()
 
   for rule in rule_list:
-    if bucket.mmap == rule.mmap and rule.condition.match(stacktrace):
+    if bucket.mmap == rule.mmap and rule.stacktrace_pattern.match(stacktrace):
       bucket.component_cache = rule.name
       return rule.name
 
   assert False
 
 
 class Bucket(object):
   """Represents a bucket, which is a unit of memory classification."""
 
   def __init__(self, stacktrace, mmap):
@@ skipping 462 matching lines @@
       for address, symbol in zip(unresolved_addresses, symbol_list):
         if not symbol:
           symbol = '??'
         stripped_symbol = symbol.strip()
         symbols[address] = stripped_symbol
         symbol_f.write('%x %s\n' % (address, stripped_symbol))
 
     sys.stderr.write('  All symbols resolved.\n')
 
 
-def parse_policy(policy_path):
-  """Parses policy file.
+def parse_policy_text(policy_path):
+  """Parses policy file in text format.
 
   A policy file contains component's names and their
   stacktrace pattern written in regular expression.
   Those patterns are matched against each symbols of
   each stacktraces in the order written in the policy file
 
+  TODO(dmikurube): Deprecate this function after a while.
+
   Args:
        policy_path: A path for a policy file.
   Returns:
-       A list containing component's name and its regex object
+       A loaded policy object.
   """
   with open(policy_path, mode='r') as policy_f:
     policy_lines = policy_f.readlines()
 
   policy_version = POLICY_DEEP_1
   if policy_lines[0].startswith('heap profile policy: '):
     policy_version = policy_lines[0][21:].strip()
     policy_lines.pop(0)
   rule_list = []
   components = []
@@ skipping 15 matching lines @@
 
       if pattern != 'default':
         rule_list.append(Rule(name, mmap, pattern))
       if components.count(name) == 0:
         components.append(name)
 
   else:
     sys.stderr.write('  invalid heap profile policy version: %s\n' % (
         policy_version))
 
-  return rule_list, policy_version, components
+  return Policy(rule_list, policy_version, components)
+
+
+def parse_policy_json(policy_path):
+  """Parses policy file in json format.
+
+  A policy file contains component's names and their
+  stacktrace pattern written in regular expression.
+  Those patterns are matched against each symbols of
+  each stacktraces in the order written in the policy file
+
+  Args:
+       policy_path: A path for a policy file.
+  Returns:
+       A loaded policy object.
+  """
+  with open(policy_path, mode='r') as f:
+    policy = json.load(f)
+
+  rules = []
+  for rule in policy['rules']:
+    rules.append(Rule(
+        rule['name'], rule['allocator'] == 'mmap', rule['stacktrace']))
+  return Policy(rules, policy['version'], policy['components'])
 
 
 def find_prefix(path):
   return re.sub('\.[0-9][0-9][0-9][0-9]\.heap', '', path)
 
 
 def load_buckets(prefix):
   # Reading buckets
   sys.stderr.write('Loading bucket files.\n')
   buckets = {}
@@ skipping 79 matching lines @@
 
 
 def load_default_policies():
   with open(POLICIES_JSON_PATH, mode='r') as policies_f:
     default_policies = json.load(policies_f)
   return default_policies
 
 
 def load_policy(policies_dict, policy_label):
   policy_file = policies_dict[policy_label]['file']
+  policy_format = policies_dict[policy_label]['format']
   policy_path = os.path.join(os.path.dirname(__file__), policy_file)
-  rule_list, policy_version, components = parse_policy(policy_path)
+  policy = None
+  if policy_format == 'json':
+    policy = parse_policy_json(policy_path)
+  elif policy_format == 'text':
+    policy = parse_policy_text(policy_path)
+  else:
+    return None
   sys.stderr.write('  %s: %s (version: %s)\n' %
-                   (policy_label, policy_path, policy_version))
-  return Policy(rule_list, policy_version, components)
+                   (policy_label, policy_path, policy.version))
+  return policy
 
 
 def load_policies_dict(policies_dict):
   sys.stderr.write('Loading policy files.\n')
   policies = {}
   for policy_label in policies_dict:
-    policies[policy_label] = load_policy(policies_dict, policy_label)
+    loaded_policy = load_policy(policies_dict, policy_label)
+    if loaded_policy:
+      policies[policy_label] = loaded_policy
   return policies
 
 
 def load_policies(options_policy):
   default_policies = load_default_policies()
   if options_policy:
     policy_labels = options_policy.split(',')
     specified_policies = {}
     for specified_policy in policy_labels:
       if specified_policy in default_policies:
@@ skipping 276 matching lines @@
    dmprof stacktrace [--keep] <dump>
 """ % (sys.argv[0]))
     sys.exit(1)
   action = sys.argv.pop(1)
 
   return COMMANDS[action](sys.argv)
 
 
 if __name__ == '__main__':
   sys.exit(main())