[opt-viewer] Reduce memory consumption

[anemet]

Summary

The observation is that we have a lot of similar remarks with lots of
identical strings (e.g. file paths, text from the remark). Storing a copy of
each of those strings in memory is wasteful. This makes all the strings in
the remark interned which maintains a single immutable instance that is
referenced everywhere.

I get an average 20% heap size reduction with this but it's possible that this
varies with the typical length of the file paths used. (I used heapy to
report the heap size.) Runtime is same or a tiny bit better.

| # of files            |   60 |  114 |  308 |  605 | 1370 |
| # of remarks          |  20K |  37K | 146K | 180K | 640K |
| total file size (MB)  |   22 |   51 |  219 |  202 | 1034 |
|-----------------------+------+------+------+------+------|
| Heap size before (MB) |  106 |  226 |  894 |  934 | 3573 |
| Heap size after       |   86 |  179 |  694 |  739 | 2798 |
| Rate                  | 0.81 | 0.79 | 0.78 | 0.79 | 0.78 |
|-----------------------+------+------+------+------+------|
| Average remark size   | 4.30 | 4.84 | 4.75 | 4.11 | 4.37 |
| Mem2disk ratio        | 3.91 | 3.51 | 3.17 | 3.66 | 2.71 |

[anemet]

Forgot David Li from the original list.

[modocache]

Excellent, thanks for all of the improvements!

I noticed a typo you could fix before landing.

tools/opt-viewer/optrecord.py

69 ↗

(On Diff #107028)

Typo: s/handels/handles/g.

[davide]

LGTM.

[anemet]

Also with https://reviews.llvm.org/rL308537, opt-stats now prints a metric for memory consumption if you have guppy (a.k.a. heapy) installed. The metric is the total memory allocated divided by the number of remarks -- average in-memory remark size (~3KB currently). This is printed once all the remarks are loaded.

llvm/trunk/tools/opt-viewer/optrecord.py

 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 initmissing(self):
+    def _intern_strings(self):
+        self.Pass = intern(self.Pass)
+        self.Name = intern(self.Name)
+        self.Function = intern(self.Function)
+
+        # Intern key and value if string and recurse if value is a dictionary.
+        # This handles [{'Caller': ..., 'DebugLoc': { 'File': ... }}]
+        def _intern_dict(old_dict):
+            new_dict = dict()
+            for (k, v) in old_dict.iteritems():
+                if type(k) is str:
+                    k = intern(k)
+
+                if type(v) is str:
+                    v = intern(v)
+                elif type(v) is dict:
+                    v = _intern_dict(v)
+                new_dict[k] = v
+            return new_dict
+
+        self.Args = [_intern_dict(arg_dict) for arg_dict in self.Args]
+
+    def canonicalize(self):
         if not hasattr(self, 'Hotness'):
             self.Hotness = 0
         if not hasattr(self, 'Args'):
             self.Args = []
+        self._intern_strings()
 
     @property
     def File(self):
         return self.DebugLoc['File']
 
     @property
     def Line(self):
         return int(self.DebugLoc['Line'])

 def get_remarks(input_file):
     max_hotness = 0
     all_remarks = dict()
     file_remarks = defaultdict(functools.partial(defaultdict, list))
 
     with open(input_file) as f:
         docs = yaml.load_all(f, Loader=Loader)
         for remark in docs:
-            remark.initmissing()
+            remark.canonicalize()
             # Avoid remarks withoug debug location or if they are duplicated
             if not hasattr(remark, 'DebugLoc') or remark.key in all_remarks:
                 continue
             all_remarks[remark.key] = remark
 
             file_remarks[remark.File][remark.Line].append(remark)
 
             # If we're reading a back a diff yaml file, max_hotness is already