Merge remote-tracking branch 'upstream/master' into async-profile

Author: d-ryzhykau

README.rst

@@ -64,14 +64,14 @@ this would result in::
 
 Output will follow::
 
-    Line #    Mem usage  Increment   Line Contents
-    ==============================================
-         3                           @profile
-         4      5.97 MB    0.00 MB   def my_func():
-         5     13.61 MB    7.64 MB       a = [1] * (10 ** 6)
-         6    166.20 MB  152.59 MB       b = [2] * (2 * 10 ** 7)
-         7     13.61 MB -152.59 MB       del b
-         8     13.61 MB    0.00 MB       return a
+    Line #    Mem usage    Increment  Occurences   Line Contents
+    ============================================================
+         3   38.816 MiB   38.816 MiB           1   @profile
+         4                                         def my_func():
+         5   46.492 MiB    7.676 MiB           1       a = [1] * (10 ** 6)
+         6  199.117 MiB  152.625 MiB           1       b = [2] * (2 * 10 ** 7)
+         7   46.629 MiB -152.488 MiB           1       del b
+         8   46.629 MiB    0.000 MiB           1       return a
 
 
 The first column represents the line number of the code that has been
@@ -214,6 +214,21 @@ You can also hide the function timestamps using the ``n`` flag, such as
 
     mprof plot -n
 
+Trend lines and its numeric slope can be plotted using the ``s`` flag, such as
+
+    mprof plot -s
+
+.. image:: ./images/trend_slope.png
+   :height: 350px
+
+The intended usage of the -s switch is to check the labels' numerical slope over a significant time period for : 
+
+  - ``>0`` it might mean a memory leak.
+  - ``~0`` if 0 or near 0, the memory usage may be considered stable.
+  - ``<0`` to be interpreted depending on the expected process memory usage patterns, also might mean that the sampling period is too small.
+
+The trend lines are for ilustrative purposes and are plotted as (very) small dashed lines.
+
 
 Setting debugger breakpoints
 =============================

images/trend_slope.png

@@ -230,8 +230,10 @@ def run_action():
         if not program[0].startswith("python"):
             program.insert(0, sys.executable)
         cmd_line = get_cmd_line(program)
-        program[1:1] = ("-m", "memory_profiler", "--timestamp",
-                        "-o", mprofile_output)
+        extra_args = ["-m", "memory_profiler", "--timestamp", "-o", mprofile_output]
+        if args.include_children:
+            extra_args.append("--include-children")
+        program[1:1] = extra_args
         p = subprocess.Popen(program)
     else:
         cmd_line = get_cmd_line(program)
@@ -402,13 +404,28 @@ def plot_file(filename, index=0, timestamps=True, children=True, options=None):
 
     all_colors = ("c", "y", "g", "r", "b")
     mem_line_colors = ("k", "b", "r", "g", "c", "y", "m")
+
+    show_trend_slope = options is not None and hasattr(options, 'slope') and options.slope is True
+
     mem_line_label = time.strftime("%d / %m / %Y - start at %H:%M:%S",
                                    time.localtime(global_start)) \
                      + ".{0:03d}".format(int(round(math.modf(global_start)[0] * 1000)))
 
+    mem_trend = None
+    if show_trend_slope:
+        # Compute trend line
+        mem_trend = np.polyfit(t, mem, 1)
+
+        # Append slope to label
+        mem_line_label = mem_line_label + " slope {0:.5f}".format(mem_trend[0])
+
     pl.plot(t, mem, "+-" + mem_line_colors[index % len(mem_line_colors)],
             label=mem_line_label)
 
+    if show_trend_slope:
+        # Plot the trend line
+        pl.plot(t, t*mem_trend[0] + mem_trend[1], "--", linewidth=0.5, color="#00e3d8")
+
     bottom, top = pl.ylim()
     bottom += 0.001
     top -= 0.001
@@ -422,9 +439,21 @@ def plot_file(filename, index=0, timestamps=True, children=True, options=None):
             cts  = np.asarray([item[1] for item in data]) - global_start
             cmem = np.asarray([item[0] for item in data])
 
+            cmem_trend = None
+            child_mem_trend_label = ""
+            if show_trend_slope:
+                # Compute trend line
+                cmem_trend = np.polyfit(cts, cmem, 1)
+
+                child_mem_trend_label = " slope {0:.5f}".format(cmem_trend[0])
+
             # Plot the line to the figure
-            pl.plot(cts, cmem, "+-"  + mem_line_colors[(idx+1) % len(mem_line_colors)],
-                     label="child {}".format(proc))
+            pl.plot(cts, cmem, "+-" + mem_line_colors[(idx + 1) % len(mem_line_colors)],
+                    label="child {}{}".format(proc, child_mem_trend_label))
+
+            if show_trend_slope:
+                # Plot the trend line
+                pl.plot(cts, cts*cmem_trend[0] + cmem_trend[1], "--", linewidth=0.5, color="black")
 
             # Detect the maximal child memory point
             cmax_mem = cmem.max()
@@ -710,6 +739,8 @@ def xlim_type(value):
                         help="Plot a time-subset of the data. E.g. to plot between 0 and 20.5 seconds: --window 0,20.5")
     parser.add_argument("--flame", "-f", dest="flame_mode", action="store_true",
                         help="Plot the timestamps as a flame-graph instead of the default brackets")
+    parser.add_argument("--slope", "-s", dest="slope", action="store_true",
+                        help="Plot a trend line and its numerical slope")
     parser.add_argument("--backend",
                       help="Specify the Matplotlib backend to use")
     parser.add_argument("profiles", nargs="*",

mprof.py

@@ -0,0 +1,81 @@
+import unittest
+
+from memory_profiler import LineProfiler, profile, show_results
+from io import StringIO
+
+
+class TestIncrementDisplay(unittest.TestCase):
+    """Tests memory incrementation / decrementation display"""
+
+    def test_loop_count(self):
+
+        def some_loop():
+            for i in range(12):  # line -2
+                a = 1            # line -1
+
+        profiler = LineProfiler()
+        wrapped = profiler(some_loop)
+        wrapped()
+        show_results(profiler)
+        for_line = list(list(profiler.code_map.values())[0].values())[-2]
+        looped_instruction = list(list(profiler.code_map.values())[0].values())[-1]
+
+        self.assertEqual(for_line[2], 13)
+        self.assertEqual(looped_instruction[2], 12)
+
+    def test_normal_incr(self):
+
+        def normal_incr():
+            use_some_memory = [1] * (10 ** 6)
+
+        profiler = LineProfiler()
+        wrapped = profiler(normal_incr)
+        wrapped()
+
+        show_results(profiler)
+        results = list(list(profiler.code_map.values())[0].values())[-1]
+
+        self.assertGreater(results[0], 0)
+        self.assertGreater(results[1], results[0])
+        self.assertEqual(results[2], 1)
+
+    def test_loop_incr(self):
+
+        def loop_incr():
+            a = []
+            b = [2] * (2 * 10 ** 7)      # line -4
+            for i in range(3):
+                c = [2] * (2 * 10 ** 7)  # line -2
+                a.append(c)
+
+        profiler = LineProfiler()
+        wrapped = profiler(loop_incr)
+        wrapped()
+
+        show_results(profiler)
+        b_line = list(list(profiler.code_map.values())[0].values())[-4]
+        c_line = list(list(profiler.code_map.values())[0].values())[-2]
+        self.assertAlmostEqual(b_line[2] * 3, c_line[2], delta=1)
+        self.assertEqual(c_line[2], 3)
+
+    def test_decr(self):
+
+        def del_stuff():
+            b = [2] * (2 * 10 ** 7)
+            del b
+
+        profiler = LineProfiler()
+        wrapped = profiler(del_stuff)
+        wrapped()
+
+        show_results(profiler)
+        b_line = list(list(profiler.code_map.values())[0].values())[-2]
+        del_line = list(list(profiler.code_map.values())[0].values())[-1]
+
+        self.assertGreater(0, del_line[0])
+        self.assertGreater(del_line[1], 0)
+        self.assertAlmostEqual(-del_line[0], b_line[0], delta=1)
+
+
+if __name__ == '__main__':
+    unittest.main()