[opt-viewer] Python 3 support in opt-stats.py

[modocache]

Summary

Minor changes that allow opt-stats.py to support both Python 2 and 3.

[anemet]

This may be way less efficient for Python 2. You may want to follow the guidance from here:

http://legacy.python.org/dev/peps/pep-0469/#migrating-to-the-common-subset-of-python-2-and-3

[modocache]

Ah, good call, thanks!

[modocache]

Use the recommended compatibility functions from PEP 469.

[anemet]

LGTM, thanks!

[modocache]

Thanks for the review!

utils/opt-viewer/opt-stats.py

if __name__ == '__main__':
     else:
         pool = Pool(processes=args.jobs)
         pmap = pool.map
 
     all_remarks, file_remarks, _ = optrecord.gather_results(pmap, args.yaml_files)
 
     bypass = defaultdict(int)
     byname = defaultdict(int)
-    for r in all_remarks.itervalues():
+    for r in optrecord.itervalues(all_remarks):
         bypass[r.Pass] += 1
         byname[r.Pass + "/" + r.Name] += 1
 
     total = len(all_remarks)
     print("{:24s} {:10d}\n".format("Total number of remarks", total))
 
     print("Top 10 remarks by pass:")
     for (passname, count) in sorted(bypass.items(), key=operator.itemgetter(1),
                                     reverse=True)[:10]:
         print("  {:30s} {:2.0f}%". format(passname, count * 100. / total))
 
     print("\nTop 10 remarks:")
     for (name, count) in sorted(byname.items(), key=operator.itemgetter(1),
                                 reverse=True)[:10]:
         print("  {:30s} {:2.0f}%". format(name, count * 100. / total))

utils/opt-viewer/optrecord.py

 import subprocess
 
 import traceback
 
 p = subprocess.Popen(['c++filt', '-n'], stdin=subprocess.PIPE, stdout=subprocess.PIPE)
 p_lock = Lock()
 
 
+try:
+    dict.iteritems
+except AttributeError:
+    # Python 3
+    def itervalues(d):
+        return iter(d.values())
+    def iteritems(d):
+        return iter(d.items())
+else:
+    # Python 2
+    def itervalues(d):
+        return d.itervalues()
+    def iteritems(d):
+        return d.iteritems()
+
+
 def demangle(name):
     with p_lock:
         p.stdin.write(name + '\n')
         return p.stdout.readline().rstrip()
 
+
 def html_file_name(filename):
     return filename.replace('/', '_') + ".html"
 
+
 def make_link(File, Line):
     return "\"{}#L{}\"".format(html_file_name(File), Line)
 
 
 class Remark(yaml.YAMLObject):
     # Work-around for http://pyyaml.org/ticket/154.
     yaml_loader = Loader
 
def RelativeHotness(self):
             return "{}%".format(int(round(self.Hotness * 100 / self.max_hotness)))
         else:
             return ''
 
     @property
     def key(self):
         k = (self.__class__, self.PassWithDiffPrefix, self.Name, self.File, self.Line, self.Column, self.Function)
         for arg in self.Args:
-            for (key, value) in arg.iteritems():
+            for (key, value) in iteritems(arg):
                 if type(value) is dict:
                     value = tuple(value.items())
                 k += (key, value)
         return k
 
     def __hash__(self):
         return hash(self.key)
 
def get_remarks(input_file):
     return max_hotness, all_remarks, file_remarks
 
 
 def gather_results(pmap, filenames):
     remarks = pmap(get_remarks, filenames)
     max_hotness = max(entry[0] for entry in remarks)
 
     def merge_file_remarks(file_remarks_job, all_remarks, merged):
-        for filename, d in file_remarks_job.iteritems():
-            for line, remarks in d.iteritems():
+        for filename, d in iteritems(file_remarks_job):
+            for line, remarks in iteritems(d):
                 for remark in remarks:
                     # Bring max_hotness into the remarks so that
                     # RelativeHotness does not depend on an external global.
                     remark.max_hotness = max_hotness
                     if remark.key not in all_remarks:
                         merged[filename][line].append(remark)
 
     all_remarks = dict()
     file_remarks = defaultdict(functools.partial(defaultdict, list))
     for _, all_remarks_job, file_remarks_job in remarks:
         merge_file_remarks(file_remarks_job, all_remarks, file_remarks)
         all_remarks.update(all_remarks_job)
 
     return all_remarks, file_remarks, max_hotness != 0