memory.py: Compute a diff over Massif heap memory profiles

This tool will enable memory regression tests by comparing heap memory profiles
generated using valgrind's Massif tool (or any other tool that can generate
compatible output).

Author: tautschnig

scripts/memory-test/memory.py

@@ -0,0 +1,159 @@
+#!/usr/bin/env python
+
+from __future__ import print_function
+
+import argparse
+import difflib
+import msparser
+import os
+# import pprint
+import sys
+
+
+def near_eq(x, y):
+    fx = float(x)
+    fy = float(y)
+    return abs(fy - fx) <= 0.1 * abs(fx)
+
+
+class snapshot:
+    def __init__(self, s, is_peak):
+        self.value = s['mem_heap']
+        self.is_peak = is_peak
+        self.data = s
+
+    def __cmp__(self, other):
+        if self.__eq__(other):
+            return 0
+        else:
+            return -1 if(self.value < other.value) else 1
+
+    def __eq__(self, other):
+        if not near_eq(self.value, other.value):
+            return False
+
+        if self.data.get('heap_tree') and other.data.get('heap_tree'):
+            ds = self.data['heap_tree']['children'][0]
+            do = other.data['heap_tree']['children'][0]
+            if ds['details']['function'] != do['details']['function'] or (
+                    not near_eq(ds['nbytes'], do['nbytes'])):
+                return False
+
+        return True
+        # pprint.pprint(self.data['heap_tree'], depth=2)
+        # pprint.pprint(other.data['heap_tree'], depth=2)
+
+    def __radd__(self, other):
+        s = other + str(self.value)
+        if self.is_peak:
+            s += ' *peak*'
+        if self.data.get('heap_tree'):
+            d = self.data['heap_tree']['children'][0]
+            s += ' {}: {}'.format(d['details']['function'], d['nbytes'])
+        return s
+
+    def __hash__(self):
+        """
+        Make sure all values end up in the same hash bucket to enforce
+        comparision via ==/__eq__ as overridden above.
+        """
+        return 0
+
+
+# based on https://chezsoi.org/lucas/blog/colored-diff-output-with-python.html
+try:
+    from colorama import Fore, init
+    init()
+except ImportError:  # fallback so that the imported classes always exist
+    class ColorFallback():
+        # simulate a subset of Colorama's features (Colorama knows how to
+        # support Windows, we just don't support colours there)
+        if sys.stdout.isatty and os.name != 'nt':
+            GREEN = '\033[32m'
+            RED = '\033[31m'
+            RESET = '\033[0m'
+        else:
+            GREEN = RED = RESET = ''
+    Fore = ColorFallback()
+
+
+def color_diff(diff):
+    for line in diff:
+        if line.startswith('+'):
+            yield Fore.GREEN + line + Fore.RESET
+        elif line.startswith('-'):
+            yield Fore.RED + line + Fore.RESET
+        else:
+            yield line
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-r', '--reference', type=str, required=True,
+                        help='Massif reference output')
+    parser.add_argument('file', type=str,
+                        help='Massif output to validate')
+
+    args = parser.parse_args()
+
+    return args
+
+
+def main():
+    args = parse_args()
+
+    reference_data = ()
+    with open(args.reference) as r:
+        reference_data = msparser.parse(r)
+
+    data = ()
+    with open(args.file) as f:
+        data = msparser.parse(f)
+
+    r_peak_index = reference_data['peak_snapshot_index']
+    r_peak = reference_data['snapshots'][r_peak_index]
+    peak_index = data['peak_snapshot_index']
+    peak = data['snapshots'][peak_index]
+
+    print("snapshots: ref={} cur={}".format(
+        len(reference_data['snapshots']), len(data['snapshots'])))
+    print("peak idx : ref={} cur={}".format(r_peak_index, peak_index))
+    print("peak [kB]: ref={0:.2f} cur={1:.2f}".format(
+        r_peak['mem_heap'] / 1024.0, peak['mem_heap'] / 1024.0))
+
+    """
+    snaps = min(len(reference_data['snapshots']), len(data['snapshots']))
+    for i in range(0, snaps):
+        print("mem_heap [kB]: ref={0:.2f} cur={1:.2f}".format(
+            reference_data['snapshots'][i]['mem_heap'] / 1024.0,
+            data['snapshots'][i]['mem_heap'] / 1024.0))
+        print(snapshot(reference_data['snapshots'][i], False) ==
+              snapshot(data['snapshots'][i], False))
+    """
+
+    reference_seq = []
+    for rs in range(0, len(reference_data['snapshots'])):
+        reference_seq.append(
+                snapshot(
+                    reference_data['snapshots'][rs],
+                    rs == r_peak_index))
+
+    data_seq = []
+    for rd in range(0, len(data['snapshots'])):
+        data_seq.append(
+                snapshot(data['snapshots'][rd], rd == peak_index))
+
+    ret_code = 0
+    diff = color_diff(
+            difflib.unified_diff(
+                reference_seq, data_seq, 'ref', 'cur', n=1, lineterm=''))
+    for l in diff:
+        ret_code = 1
+        print(l)
+
+    return ret_code
+
+
+if __name__ == '__main__':
+    rc = main()
+    sys.exit(rc)