Coverage: add a trace for not_covered_lines per file

tools/parse_llvm_coverage.py

 #!/usr/bin/env python
 # Copyright (c) 2015 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.
 
 
 """Parse an LLVM coverage report to generate useable results."""
 
 
 import argparse
@@ skipping 85 matching lines @@
 
 
 def _nanobench_json(results, properties, key):
   """Return the results in JSON format like that produced by nanobench."""
   rv = {}
   # Copy over the properties first, then set the 'key' and 'results' keys,
   # in order to avoid bad formatting in case the user passes in a properties
   # dict containing those keys.
   rv.update(properties)
   rv['key'] = key
+  rv['key'].update({'source_type': 'coverage'})
   rv['results'] = {
     _testname(f): {
-      'coverage': {

[mtklein, 2015/07/22 12:20:26]

Am I remembering this format wrong or do we want it like this?

'coverage': {
  'percent': percent,
  'lines_not_covered': lines_not_covered,
  'options': {
     'fullname': f,
     'dir': os.path.dirname(f),
     'source_type': 'coverage',
  }
}

Though, 'coverage' is already splattered around there enough that I don't know
we're going to get any real value from an extra source_type: coverage.  

I'm pretty sure source_type does not belong in the key, though.  The key
determines the identity of the trace (line on perf) so it wouldn't hurt here
(adding anything wouldn't hurt as long as it was always the same anything) but
it's also not necessary unless we're trying to make a distinction.  E.g., if we
had two different ways of getting coverage on the same machine and we wanted to
plot them as two lines, we'd need to make sure the key had 'coverage_tool:
clang' or 'coverage_tool: gcov'  (or whatever).

[borenet, 2015/07/22 13:01:59]

So one of my concerns was preventing clustering with actual perf results; I was
hoping that providing source_type might cause that to happen.  From what I could
tell, putting source_type in the key section caused it to apply to all of the
results, which saves some space over including it in each result.  It's no
problem to move it though.

-        'percent': percent,
+      'covered_percent': {
+        'value': percent,
         'options': {
           'fullname': f,
           'dir': os.path.dirname(f),
         },
       },
-    } for percent, f in results
+      'lines_not_covered': {
+        'value': not_covered_lines,
+        'options': {
+          'fullname': f,
+          'dir': os.path.dirname(f),
+        },
+      },
+    } for percent, not_covered_lines, f in results
   }
   return rv
 
 
 def _parse_key_value(kv_list):
   """Return a dict whose key/value pairs are derived from the given list.
 
   For example:
 
       ['k1', 'v1', 'k2', 'v2']
@@ skipping 17 matching lines @@
   for filepath, lines in line_by_line.iteritems():
     total_lines = 0
     covered_lines = 0
     for _, cov, _ in lines:
       if cov is not None:
         total_lines += 1
         if cov > 0:
           covered_lines += 1
     if total_lines > 0:
       per_file.append((float(covered_lines)/float(total_lines)*100.0,
+                       total_lines - covered_lines,
                        filepath))
   return per_file
 
 
 def main():
   """Generate useful data from a coverage report."""
   # Parse args.
   parser = argparse.ArgumentParser()
   parser.add_argument('--report', help='input file; an llvm coverage report.',
                       required=True)
@@ skipping 29 matching lines @@
     per_file = _get_per_file_summaries(line_by_line)
 
     # Write results.
     format_results = _nanobench_json(per_file, properties, key)
     with open(args.nanobench, 'w') as f:
       json.dump(format_results, f)
 
 
 if __name__ == '__main__':
   main()