[Coverage] Add coverage-data-split feature.

tools/sanitizers/sancov_formatter.py

 #!/usr/bin/env python
 # Copyright 2016 the V8 project authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Script to transform and merge sancov files into human readable json-format.
 
-The script supports two actions:
+The script supports three actions:
 all: Writes a json file with all instrumented lines of all executables.
 merge: Merges sancov files with coverage output into an existing json file.
+split: Split json file into separate files per covered source file.
 
 The json data is structured as follows:
 {
   "version": 1,
   "tests": ["executable1", "executable2", ...],
   "files": {
     "file1": [[<instr line 1>, <bit_mask>], [<instr line 2>, <bit_mask>], ...],
     "file2": [...],
     ...
   }
 }
 
 The executables are sorted and determine the test bit mask. Their index+1 is
 the bit, e.g. executable1 = 1, executable3 = 4, etc. Hence, a line covered by
 executable1 and executable3 will have bit_mask == 5 == 0b101. The number of
 tests is restricted to 52 in version 1, to allow javascript JSON parsing of
 the bitsets encoded as numbers. JS max safe int is (1 << 53) - 1.
 
 The line-number-bit_mask pairs are sorted by line number and don't contain
 duplicates.
 
+Split json data preserves the same format, but only contains one file per
+json file.
+
 The sancov tool is expected to be in the llvm compiler-rt third-party
 directory. It's not checked out by default and must be added as a custom deps:
 'v8/third_party/llvm/projects/compiler-rt':
     'https://chromium.googlesource.com/external/llvm.org/compiler-rt.git'
 """
 
 import argparse
 import json
 import logging
 import os
@@ skipping 164 matching lines @@
   return {
     'version': 1,
     'tests': sorted(map(os.path.basename, exe_list)),
     'files': {f: map(lambda l: [l, 0], sorted(result[f])) for f in result},
   }
 
 
 def write_instrumented(options):
   """Implements the 'all' action of this tool."""
   exe_list = list(executables())
-  logging.info('Reading instrumented lines from %d executables.' %
+  logging.info('Reading instrumented lines from %d executables.',
                len(exe_list))
   pool = Pool(CPUS)
   try:
     results = pool.imap_unordered(get_instrumented_lines, exe_list)
   finally:
     pool.close()
 
   # Merge multiprocessing results and prepare output data.
   data = merge_instrumented_line_results(exe_list, results)
 
-  logging.info('Read data from %d executables, which covers %d files.' %
-               (len(data['tests']), len(data['files'])))
-  logging.info('Writing results to %s' % options.json_output)
+  logging.info('Read data from %d executables, which covers %d files.',
+               len(data['tests']), len(data['files']))
+  logging.info('Writing results to %s', options.json_output)
 
   # Write json output.
   with open(options.json_output, 'w') as f:
     json.dump(data, f, sort_keys=True)
 
 
 def get_covered_lines(args):
   """Return the covered lines of an executable.
 
   Called trough multiprocessing pool. The args are expected to unpack to:
@@ skipping 95 matching lines @@
           os.path.isdir(options.coverage_dir))
 
   # Inputs for multiprocessing. List of tuples of:
   # Coverage dir, executable name, sancov file name.
   inputs = []
   for f in os.listdir(options.coverage_dir):
     match = SANCOV_FILE_RE.match(f)
     if match:
       inputs.append((options.coverage_dir, match.group(1), f))
 
-  logging.info('Merging %d sancov files into %s' %
-               (len(inputs), options.json_input))
+  logging.info('Merging %d sancov files into %s',
+               len(inputs), options.json_input)
 
   # Post-process covered lines in parallel.
   pool = Pool(CPUS)
   try:
     results = pool.imap_unordered(get_covered_lines, inputs)
   finally:
     pool.close()
 
   # Load existing json data file for merging the results.
   with open(options.json_input, 'r') as f:
     data = json.load(f)
 
   # Merge muliprocessing results. Mutates data.
   merge_covered_line_results(data, results)
 
-  logging.info('Merged data from %d executables, which covers %d files.' %
-               (len(data['tests']), len(data['files'])))
-  logging.info('Writing results to %s' % options.json_output)
+  logging.info('Merged data from %d executables, which covers %d files.',
+               len(data['tests']), len(data['files']))
+  logging.info('Writing results to %s', options.json_output)
 
   # Write merged results to file.
   with open(options.json_output, 'w') as f:
     json.dump(data, f, sort_keys=True)
 
 
+def split(options):
+  """Implements the 'split' action of this tool."""
+  # Load existing json data file for splitting.
+  with open(options.json_input, 'r') as f:
+    data = json.load(f)
+
+  logging.info('Splitting off %d coverage files from %s',
+               len(data['files']), options.json_input)
+
+  for file_name, coverage in data['files'].iteritems():
+    # Preserve relative directories that are part of the file name.
+    file_path = os.path.join(options.output_dir, file_name + '.json')

[tandrii(chromium), 2016/03/16 16:31:31]

my only concern here, which I was not able to completely clear myself, is what
if file_name contains something like "../../some_dir". The code below actually
creates such, which seems not good. What did I miss?

[Michael Achenbach, 2016/03/16 17:34:00]

Only normalized relative paths in the project dir are included. We skip the rest
in line 131. So all files have the form:
'src/foo/bar.cc' or 'include/baz.h'

[tandrii(chromium), 2016/03/16 17:49:46]

Acknowledged.

+    try:
+      os.makedirs(os.path.dirname(file_path))
+    except OSError:
+      # Ignore existing directories.
+      pass
+
+    with open(file_path, 'w') as f:
+      # Flat-copy the old dict.
+      new_data = dict(data)

[Michael Hablich, 2016/03/16 13:39:12]

I thought you only want the data of the individual file. I am confused. 

[Michael Achenbach, 2016/03/16 14:13:32]

This assignment copies the key/values of data flat (as such is fast). Below I
reassign the 'files' key with data of just one file.

The other option would have been to explicitly specify the dict again with all
keys, which is more code, more error-prone and possibly incomplete (as soon as I
add other keys to the format).

[Michael Hablich, 2016/03/17 08:16:47]

Acknowledged.

+
+      # Update current file.
+      new_data['files'] = {file_name: coverage}

[Michael Hablich, 2016/03/16 13:39:12]

'file_name: coverage' does not make sense to me in this context. I assume you
mean coverage data, why is it saved in a property called file_name?

[Michael Achenbach, 2016/03/16 14:13:32]

These are not strings. These are the variables from line 384 containing the
original key/value pair for one file.

[Michael Hablich, 2016/03/17 08:16:47]

Huh, I never indicated that I think these are simple strings. It is simply that
the naming does not make sense to me at all. Why is the coverage_data saved in a
property named file_name?

Essentially it is about readability of the code not about its functional side.

[Michael Achenbach, 2016/03/17 08:34:54]

How would you map it? The code coverage data contains the covered lines of
specific files. The line coverage of each file is collected in a list and mapped
to that file's name. I've felt having file names as keys is the most intuitive
to get to the coverage data of that specific file. Also in the code review tool
that's the data flow. Somebody opens a particular file for review. The file name
is the key by which the corresponding coverage data is fetched.

In regards to naming code_coverage_data just coverage my opinion is: If the
longer name is useful to distinguish code_coverage_data from
code_coverage_meta_data or test_coverage_data, etc, I'd go for the long name.
But in short methods, where no other concepts exist, I prefer short names.

+
+      # Write json data.
+      json.dump(new_data, f, sort_keys=True)
+
+
 def main():
   parser = argparse.ArgumentParser()
   parser.add_argument('--coverage-dir',
                       help='Path to the sancov output files.')
   parser.add_argument('--json-input',
                       help='Path to an existing json file with coverage data.')
-  parser.add_argument('--json-output', required=True,
+  parser.add_argument('--json-output',
                       help='Path to a file to write json output to.')
-  parser.add_argument('action', choices=['all', 'merge'],
+  parser.add_argument('--output-dir',
+                      help='Directory where to put split output files to.')
+  parser.add_argument('action', choices=['all', 'merge', 'split'],
                       help='Action to perform.')
 
   options = parser.parse_args()
   if options.action.lower() == 'all':
+    if not options.json_output:
+      print '--json-output is required'
+      return 1
     write_instrumented(options)
   elif options.action.lower() == 'merge':
     if not options.coverage_dir:
       print '--coverage-dir is required'
       return 1
     if not options.json_input:
       print '--json-input is required'
       return 1
+    if not options.json_output:
+      print '--json-output is required'
+      return 1
     merge(options)
+  elif options.action.lower() == 'split':
+    if not options.json_input:
+      print '--json-input is required'
+      return 1
+    if not options.output_dir:
+      print '--output-dir is required'
+      return 1
+    split(options)
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main())