Python Profiling – Memory Profiling (Part 3, Final)

Table of Contents

1. memory_profiler
2. PySpy
3. DISassembling
4. Final Recommendations

memory_profiler

Similar to line_profiler, memory_profiler provides detailed memory usage measurements, with the aim of efficiently reducing memory consumption and optimizing memory usage to improve application performance..

Before starting using this tool, it is important to mention the impact on the execution speed of the code while it is in use, since the execution time increases dozens of times, it is convenient to profiling time and CPU beforehand, and use line_profiler only on sections identified to be optimized.

As with line_profiler, the @profile decorator indicates the method to be evaluated.

However, analyzing the memory usage in Python is complicated, even if we consider that the garbage collector is freeing memory, we do not know for sure when a section of memory is freed and when an object is going to be released, or how long it will remain in the pool until it is finally disposed. Many times, it is convenient to handle methods that consume more memory, and not repeatedly allocate memory because it is an expensive process, and it is more efficient than analyzing the memory usage of the code line by line.

Using the sorting algorithm as an experiment, we perform the following exercise:

In the following instruction, I use gtime -p along with memory_profiler to measure the execution time, but it is not required.

There are two important things to note here: first, the output of memory_profiler is very detailed line by line, which is what we are looking for when using this tool; and, second, the elapsed time is approximately 30 minutes, which is a considerable time compared to the original time (~10 seconds). These metrics should give us an indication of how and when to use this tool.

memory_profiler includes the mprof command (requires matplotlib to be installed), which allows you to visualize changes in memory usage, for example:

PySpy

PySpy is a great tool that helps us to evaluate processes that are already running, without the need to stop and configure them beforehand. For this reason, it requires additional privileges to evaluate other processes. It is especially useful for running experiments in environments such as Production or UAT.

The py-spy package must be installed with PIP or Conda, depending on the local Python installation, and the command it includes is py-spy. To evaluate a running process it is important to obtain the Process Identifier (PID), for example:

PySpy has 4 subcommands:

USAGE:
    py-spy <SUBCOMMAND>

OPTIONS:
    -h, --help       Prints help information
    -V, --version    Prints version information

SUBCOMMANDS:
    record    Records stack trace information to a flamegraph, speedscope or raw file
    top       Displays a top like view of functions consuming CPU
    dump      Dumps stack traces for a target program to stdout
    help      Prints this message or the help of the given subcommand(s)

Example of subcommand dump:

Example of subcommand top, it refreshes the information once per second:

Example of subcommand record, it generates an image file with extension .svg summarizing the experiment:

DISassembling

Understanding how the executing bytecode behaves, beyond the Python code that we have analyzed, can gives us an idea of how things work internally and why some pieces of code work better than others, and the dis module is the tool that includes the default distribution of Python that we have for this purpose.

Clearly, this output is the disassembly of the code being executed. When interpreting it we can observe the following details:

• The first column corresponds to the equivalent line number in the Python code that you are referring to.
• In the second column, only some lines contain >>, which corresponds to the redirects and moves in the Python code.
• The remaining columns correspond to the equivalent lines of the disassembled code.

Final Recommendations

The tools for profiling an application are now available, but there are several thoughts that we must take into account. Here are some recommendations:

• CPU Overclocking and BIOS-based Accelerators, as Eco Modes and Battery Optimizing, can affect the real performance of the code under testing. It is recommended to disable them.
• Telemetry Tools, Anti-Viruses, or Cloud-based File Sharing Systems should be disabled during the experiments.
• Perform several measurements to obtain valid statistics could help us to confirm the expected behavior of the changes, and confirm the hypothesis.
• Run experiments in a separated branches from the main repository, and keep the branches that reported code performance improvements
• Consider using PySpy and Pyinstrument for Web-based applications in environments where it is not possible to make changes to code.

---

If you think this content was helpful, consider buy me a cup of coffee.

Tags: profilingpython