matplotlib · tacaswell · Nov 5, 2015 · Oct 30, 2015 · Nov 2, 2015 · Nov 2, 2015
diff --git a/lib/matplotlib/cbook.py b/lib/matplotlib/cbook.py
@@ -1438,51 +1438,6 @@ def restrict_dict(d, keys):
     return dict([(k, v) for (k, v) in six.iteritems(d) if k in keys])
 
 
-def report_memory(i=0):  # argument may go away
-    'return the memory consumed by process'
-    from matplotlib.compat.subprocess import Popen, PIPE
-    pid = os.getpid()
-    if sys.platform == 'sunos5':
-        try:
-            a2 = Popen('ps -p %d -o osz' % pid, shell=True,
-                       stdout=PIPE).stdout.readlines()
-        except OSError:
-            raise NotImplementedError(
-                "report_memory works on Sun OS only if "
-                "the 'ps' program is found")
-        mem = int(a2[-1].strip())
-    elif sys.platform.startswith('linux'):
-        try:
-            a2 = Popen('ps -p %d -o rss,sz' % pid, shell=True,
-                       stdout=PIPE).stdout.readlines()
-        except OSError:
-            raise NotImplementedError(
-                "report_memory works on Linux only if "
-                "the 'ps' program is found")
-        mem = int(a2[1].split()[1])
-    elif sys.platform.startswith('darwin'):
-        try:
-            a2 = Popen('ps -p %d -o rss,vsz' % pid, shell=True,
-                       stdout=PIPE).stdout.readlines()
-        except OSError:
-            raise NotImplementedError(
-                "report_memory works on Mac OS only if "
-                "the 'ps' program is found")
-        mem = int(a2[1].split()[0])
-    elif sys.platform.startswith('win'):
-        try:
-            a2 = Popen(["tasklist", "/nh", "/fi", "pid eq %d" % pid],
-                       stdout=PIPE).stdout.read()
-        except OSError:
-            raise NotImplementedError(
-                "report_memory works on Windows only if "
-                "the 'tasklist' program is found")
-        mem = int(a2.strip().split()[-2].replace(',', ''))
-    else:
-        raise NotImplementedError(
-            "We don't have a memory monitor for %s" % sys.platform)
-    return mem
-
 _safezip_msg = 'In safezip, len(args[0])=%d but len(args[%d])=%d'
 
 
@@ -1514,58 +1469,6 @@ def safe_masked_invalid(x):
     return xm
 
 
-class MemoryMonitor(object):
-    def __init__(self, nmax=20000):
-        self._nmax = nmax
-        self._mem = np.zeros((self._nmax,), np.int32)
-        self.clear()
-
-    def clear(self):
-        self._n = 0
-        self._overflow = False
-
-    def __call__(self):
-        mem = report_memory()
-        if self._n < self._nmax:
-            self._mem[self._n] = mem
-            self._n += 1
-        else:
-            self._overflow = True
-        return mem
-
-    def report(self, segments=4):
-        n = self._n
-        segments = min(n, segments)
-        dn = int(n / segments)
-        ii = list(xrange(0, n, dn))
-        ii[-1] = n - 1
-        print()
-        print('memory report: i, mem, dmem, dmem/nloops')
-        print(0, self._mem[0])
-        for i in range(1, len(ii)):
-            di = ii[i] - ii[i - 1]
-            if di == 0:
-                continue
-            dm = self._mem[ii[i]] - self._mem[ii[i - 1]]
-            print('%5d %5d %3d %8.3f' % (ii[i], self._mem[ii[i]],
-                                         dm, dm / float(di)))
-        if self._overflow:
-            print("Warning: array size was too small for the number of calls.")
-
-    def xy(self, i0=0, isub=1):
-        x = np.arange(i0, self._n, isub)
-        return x, self._mem[i0:self._n:isub]
-
-    def plot(self, i0=0, isub=1, fig=None):
-        if fig is None:
-            from .pylab import figure
-            fig = figure()
-
-        ax = fig.add_subplot(111)
-        ax.plot(*self.xy(i0, isub))
-        fig.canvas.draw()
-
-
 def print_cycles(objects, outstream=sys.stdout, show_progress=False):
     """
     *objects*

diff --git a/unit/agg_memleak.py b/unit/agg_memleak.py
diff --git a/unit/memleak.py b/unit/memleak.py
@@ -0,0 +1,143 @@
+#!/usr/bin/env python
+
+from __future__ import print_function
+
+import gc
+
+try:
+    import tracemalloc
+except ImportError:
+    raise ImportError("This script requires Python 3.4 or later")
+
+try:
+    import psutil
+except ImportError:
+    raise ImportError("This script requires psutil")
+
+import numpy as np
+
+
+def run_memleak_test(bench, iterations, report):
+    tracemalloc.start()
+
+    starti = min(50, iterations / 2)
+    endi = iterations
+
+    malloc_arr = np.empty((endi,), dtype=np.int64)
+    rss_arr = np.empty((endi,), dtype=np.int64)
+    rss_peaks = np.empty((endi,), dtype=np.int64)
+    nobjs_arr = np.empty((endi,), dtype=np.int64)
+    garbage_arr = np.empty((endi,), dtype=np.int64)
+    open_files_arr = np.empty((endi,), dtype=np.int64)
+    rss_peak = 0
+
+    p = psutil.Process()
+
+    for i in range(endi):
+        bench()
+
+        gc.collect()
+
+        rss = p.memory_info().rss
+        malloc, peak = tracemalloc.get_traced_memory()
+        nobjs = len(gc.get_objects())
+        garbage = len(gc.garbage)
+        open_files = len(p.open_files())
+        print("{0: 4d}: pymalloc {1: 10d}, rss {2: 10d}, nobjs {3: 10d}, garbage {4: 4d}, files: {5: 4d}".format(
+            i, malloc, rss, nobjs, garbage, open_files))
+
+        malloc_arr[i] = malloc
+        rss_arr[i] = rss
+        if rss > rss_peak:
+            rss_peak = rss
+        rss_peaks[i] = rss_peak
+        nobjs_arr[i] = nobjs
+        garbage_arr[i] = garbage
+        open_files_arr[i] = open_files
+
+    print('Average memory consumed per loop: %1.4f bytes\n' %
+          (np.sum(rss_peaks[starti+1:] - rss_peaks[starti:-1]) / float(endi - starti)))
+
+    from matplotlib import pyplot as plt
+    fig, (ax1, ax2, ax3) = plt.subplots(3)
+    ax1b = ax1.twinx()
+    ax1.plot(malloc_arr, 'r')
+    ax1b.plot(rss_arr, 'b')
+    ax1.set_ylabel('pymalloc', color='r')
+    ax1b.set_ylabel('rss', color='b')
+
+    ax2b = ax2.twinx()
+    ax2.plot(nobjs_arr, 'r')
+    ax2b.plot(garbage_arr, 'b')
+    ax2.set_ylabel('total objects', color='r')
+    ax2b.set_ylabel('garbage objects', color='b')
+
+    ax3.plot(open_files_arr)
+    ax3.set_ylabel('open file handles')
+
+    if not report.endswith('.pdf'):
+        report = report + '.pdf'
+    fig.savefig(report, format='pdf')
+
+
+class MemleakTest(object):
+    def __init__(self, empty):
+        self.empty = empty
+
+    def __call__(self):
+        import matplotlib.pyplot as plt
+
+        fig = plt.figure(1)
+
+        if not self.empty:
+            t1 = np.arange(0.0, 2.0, 0.01)
+            y1 = np.sin(2 * np.pi * t1)
+            y2 = np.random.rand(len(t1))
+            X = np.random.rand(50, 50)
+
+            ax = fig.add_subplot(221)
+            ax.plot(t1, y1, '-')
+            ax.plot(t1, y2, 's')
+
+            ax = fig.add_subplot(222)
+            ax.imshow(X)
+
+            ax = fig.add_subplot(223)
+            ax.scatter(np.random.rand(50), np.random.rand(50),
+                       s=100 * np.random.rand(50), c=np.random.rand(50))
+
+            ax = fig.add_subplot(224)
+            ax.pcolor(10 * np.random.rand(50, 50))
+
+        fig.savefig('tmp', dpi=75)
+        plt.close(1)
+
+
+if __name__ == '__main__':
+    import argparse
+
+    parser = argparse.ArgumentParser('Run memory leak tests')
+    parser.add_argument('backend', type=str, nargs=1,
+                        help='backend to test')
+    parser.add_argument('iterations', type=int, nargs=1,
+                        help='number of iterations')
+    parser.add_argument('report', type=str, nargs=1,
+                        help='filename to save report')
+    parser.add_argument('--empty', action='store_true',
+                        help="Don't plot any content, just test creating "
+                        "and destroying figures")
+    parser.add_argument('--interactive', action='store_true',
+                        help="Turn on interactive mode to actually open "
+                        "windows.  Only works with some GUI backends.")
+
+
+    args = parser.parse_args()
+
+    import matplotlib
+    matplotlib.use(args.backend[0])
+
+    if args.interactive:
+        from matplotlib import pyplot as plt
+        plt.ion()
+
+    run_memleak_test(MemleakTest(args.empty), args.iterations[0], args.report[0])