[analyzer] [tests] Add an option to show the histogram of path differences between the analyzer runs

[NoQ]

Cool stuff!

utils/analyzer/CmpRuns.py

66–67

Rename to getPathLength or getNumberOfPieces or just something more informative?

229–230

Suggest swapping these lines because the opts check in the front would immediately inform the reader if he's interested in this block of code.

[george.karpenkov]

utils/analyzer/CmpRuns.py

229–230

@NoQ makes sense, but then it would be duplicated thrice.

[NoQ]

utils/analyzer/CmpRuns.py

229–230

Ouch whoops never mind.

utils/analyzer/CmpRuns.py

Usage:
     # Generate a relation from diagnostics in run A to diagnostics in run B
     # to obtain a list of triples (a, b, confidence).
     diff = compareResults(resultsA, resultsB)
 
 """
 
 import os
 import plistlib
+from math import log
 
 
 # Information about analysis run:
 # path - the analysis output directory
 # root - the name of the root directory, which will be disregarded when
 # determining the source file name
 class SingleRunInfo:
     def __init__(self, path, root="", verboseLog=None):
         self.path = path
         self.root = root.rstrip("/\\")
         self.verboseLog = verboseLog
 
 
 class AnalysisDiagnostic:
     def __init__(self, data, report, htmlReport):
         self._data = data
         self._loc = self._data['location']
         self._report = report
         self._htmlReport = htmlReport
+        self._reportSize = len(self._data['path'])
 
     def getFileName(self):
         root = self._report.run.root
         fileName = self._report.files[self._loc['file']]
         if fileName.startswith(root) and len(root) > 0:
             return fileName[len(root) + 1:]
         return fileName
 
     def getLine(self):
         return self._loc['line']
 
     def getColumn(self):
         return self._loc['col']
 
+    def getPathLength(self):
+        return self._reportSize
+
     def getCategory(self):
         return self._data['category']
 
     def getDescription(self):
         return self._data['description']
 
     def getIssueIdentifier(self):
         id = self.getFileName() + "+"
def loadResultsFromSingleRun(info, deleteEmpty=True):
 
     return run
 
 
 def cmpAnalysisDiagnostic(d):
     return d.getIssueIdentifier()
 
 
-def compareResults(A, B):
+def compareResults(A, B, opts):
     """
     compareResults - Generate a relation from diagnostics in run A to
     diagnostics in run B.
 
     The result is the relation as a list of triples (a, b, confidence) where
     each element {a,b} is None or an element from the respective run, and
     confidence is a measure of the match quality (where 0 indicates equality,
     and None is used if either element is None).
     """
 
     res = []
 
+    # Map size_before -> size_after
+    path_difference_data = []
+
     # Quickly eliminate equal elements.
     neqA = []
     neqB = []
     eltsA = list(A.diagnostics)
     eltsB = list(B.diagnostics)
     eltsA.sort(key=cmpAnalysisDiagnostic)
     eltsB.sort(key=cmpAnalysisDiagnostic)
     while eltsA and eltsB:
         a = eltsA.pop()
         b = eltsB.pop()
         if (a.getIssueIdentifier() == b.getIssueIdentifier()):
+            if a.getPathLength() != b.getPathLength():
+                if opts.relative_path_histogram:
+                    path_difference_data.append(
+                        float(a.getPathLength()) / b.getPathLength())
+                elif opts.relative_log_path_histogram:
+                    path_difference_data.append(
+                        log(float(a.getPathLength()) / b.getPathLength()))
+                elif opts.absolute_path_histogram:
+                    path_difference_data.append(a.getPathLength() - b.getPathLength())
+
             res.append((a, b, 0))
         elif a.getIssueIdentifier() > b.getIssueIdentifier():
             eltsB.append(b)
             neqA.append(a)
         else:
             eltsA.append(a)
             neqB.append(b)
     neqA.extend(eltsA)
     neqB.extend(eltsB)
 
     # FIXME: Add fuzzy matching. One simple and possible effective idea would
     # be to bin the diagnostics, print them in a normalized form (based solely
     # on the structure of the diagnostic), compute the diff, then use that as
     # the basis for matching. This has the nice property that we don't depend
     # in any way on the diagnostic format.
 
     for a in neqA:
         res.append((a, None, None))
     for b in neqB:
         res.append((None, b, None))
 
+    if opts.relative_log_path_histogram or opts.relative_path_histogram or \
+            opts.absolute_path_histogram:
+        from matplotlib import pyplot
+        pyplot.hist(path_difference_data, bins=100)
+        pyplot.show()
+
     return res
 
 
 def dumpScanBuildResultsDiff(dirA, dirB, opts, deleteEmpty=True):
     # Load the run results.
     resultsA = loadResults(dirA, opts, opts.rootA, deleteEmpty)
     resultsB = loadResults(dirB, opts, opts.rootB, deleteEmpty)
 
     # Open the verbose log, if given.
     if opts.verboseLog:
         auxLog = open(opts.verboseLog, "wb")
     else:
         auxLog = None
 
-    diff = compareResults(resultsA, resultsB)
+    diff = compareResults(resultsA, resultsB, opts)
     foundDiffs = 0
     totalAdded = 0
     totalRemoved = 0
     totalChanged = 0
     for res in diff:
         a, b, confidence = res
         if a is None:
             print "ADDED: %r" % b.getReadableName()
def main():
     parser.add_option("", "--rootB", dest="rootB",
                       help="Prefix to ignore on source files for directory B",
                       action="store", type=str, default="")
     parser.add_option("", "--verbose-log", dest="verboseLog",
                       help="Write additional information to LOG \
                       [default=None]",
                       action="store", type=str, default=None,
                       metavar="LOG")
+    parser.add_option("--relative-path-differences-histogram",
+                      action="store_true", dest="relative_path_histogram",
+                      default=False,
+                      help="Show histogram of relative paths differences. \
+                      Requires matplotlib")
+    parser.add_option("--relative-log-path-differences-histogram",
+                      action="store_true", dest="relative_log_path_histogram",
+                      default=False,
+                      help="Show histogram of log relative paths differences. \
+                      Requires matplotlib")
+    parser.add_option("--absolute-path-differences-histogram",
+                      action="store_true", dest="absolute_path_histogram",
+                      default=False,
+                      help="Show histogram of absolute paths differences. \
+                      Requires matplotlib")
     (opts, args) = parser.parse_args()
 
     if len(args) != 2:
         parser.error("invalid number of arguments")
 
     dirA, dirB = args
 
     dumpScanBuildResultsDiff(dirA, dirB, opts)
 
 
 if __name__ == '__main__':
     main()