[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 ↗

(On Diff #132312)

Rename to getPathLength or getNumberOfPieces or just something more informative?

229–230 ↗

(On Diff #132312)

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 ↗

(On Diff #132312)

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

[NoQ]

utils/analyzer/CmpRuns.py

229–230 ↗

(On Diff #132312)

Ouch whoops never mind.

cfe/trunk/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()