memray
v1.15.0
Memray es un generador de perfiles de memoria para Python. Puede realizar un seguimiento de las asignaciones de memoria en el código Python, en los módulos de extensión nativos y en el propio intérprete de Python. Puede generar varios tipos diferentes de informes para ayudarlo a analizar los datos de uso de memoria capturados. Si bien se usa comúnmente como herramienta CLI, también se puede usar como biblioteca para realizar tareas de creación de perfiles más detalladas.
Características notables:
Memray puede ayudar con los siguientes problemas:
Nota Memray solo funciona en Linux y MacOS y no se puede instalar en otras plataformas.
Buscamos constantemente comentarios de nuestra increíble comunidad ❤️. Si ha utilizado Memray para resolver un problema, perfilar una aplicación, encontrar una pérdida de memoria o cualquier otra cosa, ¡háganoslo saber! Nos encantaría conocer su experiencia y cómo le ayudó Memray.
Por favor, considere escribir su historia en la página de discusión de Historias de éxito.
¡Realmente hace la diferencia!
Memray requiere Python 3.7+ y se puede instalar fácilmente utilizando las herramientas de empaquetado de Python más comunes. Recomendamos instalar la última versión estable de PyPI con pip:
python3 -m pip install memrayTenga en cuenta que Memray contiene una extensión C, por lo que las versiones se distribuyen como ruedas binarias, además del código fuente. Si una rueda binaria no está disponible para su sistema (Linux x86/x64 o macOS), deberá asegurarse de que se cumplan todas las dependencias en el sistema donde está realizando la instalación.
Si desea compilar Memray desde el código fuente, necesita las siguientes dependencias binarias en su sistema:
Consulte su administrador de paquetes sobre cómo instalar estas dependencias (por ejemplo apt-get install build-essential python3-dev libdebuginfod-dev libunwind-dev liblz4-dev en sistemas basados en Debian o brew install lz4 en MacOS). Tenga en cuenta que es posible que deba enseñarle al compilador dónde encontrar los archivos de encabezado y biblioteca de las dependencias. Por ejemplo, en MacOS con brew es posible que necesites ejecutar:
export CFLAGS= " -I $( brew --prefix lz4 ) /include " LDFLAGS= " -L $( brew --prefix lz4 ) /lib -Wl,-rpath, $( brew --prefix lz4 ) /lib " antes de instalar memray . Consulte la documentación de su administrador de paquetes para conocer la ubicación de los archivos de encabezado y biblioteca para obtener información más detallada.
Si está compilando en MacOS, también deberá establecer el objetivo de implementación.
export MACOSX_DEPLOYMENT_TARGET=10.14Una vez que tengas instaladas las dependencias binarias, puedes clonar el repositorio y seguir con el proceso de construcción normal:
git clone [email protected]:bloomberg/memray.git memray
cd memray
python3 -m venv ../memray-env/ # just an example, put this wherever you want
source ../memray-env/bin/activate
python3 -m pip install --upgrade pip
python3 -m pip install -e . -r requirements-test.txt -r requirements-extra.txt Esto instalará Memray en el entorno virtual en modo de desarrollo (el -e del último comando pip install ).
Si planeas contribuir, debes instalar los ganchos de confirmación previa:
pre-commit installEsto asegurará que su contribución pase nuestros controles de linting.
Puede encontrar la documentación más reciente disponible aquí.
Hay muchas formas de utilizar Memray. La forma más sencilla es utilizarlo como herramienta de línea de comandos para ejecutar su script, aplicación o biblioteca.
usage: memray [-h] [-v] {run,flamegraph,table,live,tree,parse,summary,stats} ...
Memory profiler for Python applications
Run `memray run` to generate a memory profile report, then use a reporter command
such as `memray flamegraph` or `memray table` to convert the results into HTML.
Example:
$ python3 -m memray run -o output.bin my_script.py
$ python3 -m memray flamegraph output.bin
positional arguments:
{run,flamegraph,table,live,tree,parse,summary,stats}
Mode of operation
run Run the specified application and track memory usage
flamegraph Generate an HTML flame graph for peak memory usage
table Generate an HTML table with all records in the peak memory usage
live Remotely monitor allocations in a text-based interface
tree Generate a tree view in the terminal for peak memory usage
parse Debug a results file by parsing and printing each record in it
summary Generate a terminal-based summary report of the functions that allocate most memory
stats Generate high level stats of the memory usage in the terminal
optional arguments:
-h, --help Show this help message and exit
-v, --verbose Increase verbosity. Option is additive and can be specified up to 3 times
-V, --version Displays the current version of Memray
Please submit feedback, ideas, and bug reports by filing a new issue at https://github.com/bloomberg/memray/issues
Para usar Memray sobre un script o un único archivo Python, puedes usar:
python3 -m memray run my_script.py Si normalmente ejecuta su aplicación con python3 -m my_module , puede usar el indicador -m con memray run :
python3 -m memray run -m my_module También puedes invocar Memray como herramienta de línea de comandos sin tener que usar -m para invocarlo como módulo:
memray run my_script.py
memray run -m my_module El resultado será un archivo binario (como memray-my_script.2369.bin ) que puedes analizar de diferentes maneras. Una forma es utilizar el comando memray flamegraph para generar un gráfico de llama:
memray flamegraph my_script.2369.binEsto producirá un archivo HTML con un gráfico de llama del uso de memoria que puede inspeccionar con su navegador favorito. Hay muchos otros reporteros que puede utilizar para generar otros tipos de informes, algunos de ellos generan resultados basados en terminales y otros generan archivos HTML. A continuación se muestra un ejemplo de un flamegraph de Memray:
Si desea una manera fácil y conveniente de usar memray en su conjunto de pruebas, puede considerar usar pytest-memray. Una vez instalado, este complemento de pytest le permite simplemente agregar --memray a la invocación de la línea de comando:
pytest --memray tests/Y automáticamente obtendrá un informe como este:
python3 -m pytest tests --memray
=============================================================================================================================== test session starts ================================================================================================================================
platform linux -- Python 3.8.10, pytest-6.2.4, py-1.10.0, pluggy-0.13.1
rootdir: /mypackage, configfile: pytest.ini
plugins: cov-2.12.0, memray-0.1.0
collected 21 items
tests/test_package.py ..................... [100%]
================================================================================================================================= MEMRAY REPORT ==================================================================================================================================
Allocations results for tests/test_package.py::some_test_that_allocates
? Total memory allocated: 24.4MiB
? Total allocations: 33929
Histogram of allocation sizes: |▂ █ |
? Biggest allocating functions:
- parse:/opt/bb/lib/python3.8/ast.py:47 -> 3.0MiB
- parse:/opt/bb/lib/python3.8/ast.py:47 -> 2.3MiB
- _visit:/opt/bb/lib/python3.8/site-packages/astroid/transforms.py:62 -> 576.0KiB
- parse:/opt/bb/lib/python3.8/ast.py:47 -> 517.6KiB
- __init__:/opt/bb/lib/python3.8/site-packages/astroid/node_classes.py:1353 -> 512.0KiB
También puedes utilizar algunos de los marcadores incluidos para hacer que las pruebas fallen si la ejecución de dicha prueba asigna más memoria de la permitida:
@ pytest . mark . limit_memory ( "24 MB" )
def test_foobar ():
# do some stuff that allocates memoryPara obtener más información sobre cómo se puede utilizar y configurar el complemento, consulte la documentación del complemento.
Memray admite el seguimiento de funciones nativas de C/C++, así como de funciones de Python. Esto puede ser especialmente útil al crear perfiles de aplicaciones que tienen extensiones C (como numpy o pandas ), ya que brinda una visión holística de cuánta memoria asigna la extensión y cuánta memoria asigna el propio Python.
Para activar el seguimiento nativo, debe proporcionar el argumento --native cuando utilice el subcomando run :
memray run --native my_script.pyEsto agregará automáticamente información nativa al archivo de resultados y será utilizada automáticamente por cualquier reportero (como los reporteros de flamegraph o de tabla). Esto significa que en lugar de ver esto en los flamegraphs:
Ahora podrás ver lo que sucede dentro de las llamadas de Python:
Los reporteros muestran fotogramas nativos en un color diferente al de los fotogramas de Python. También se pueden distinguir observando la ubicación del archivo en un marco (los marcos de Python generalmente se generarán a partir de archivos con una extensión .py, mientras que los marcos nativos se generarán a partir de archivos con extensiones como .c, .cpp o .h).
El modo en vivo de Memray ejecuta un script o un módulo en una interfaz basada en terminal que le permite inspeccionar interactivamente su uso de memoria mientras se ejecuta. Esto es útil para depurar scripts o módulos que tardan mucho en ejecutarse o que exhiben múltiples patrones de memoria complejos. Puede usar la opción --live para ejecutar el script o módulo en modo en vivo:
memray run --live my_script.pyo si quieres ejecutar un módulo:
memray run --live -m my_moduleEsto mostrará la siguiente interfaz TUI en su terminal:
Los resultados se muestran en orden descendente de la memoria total asignada por una función y las subfunciones llamadas por ella. Puede cambiar el orden con los siguientes atajos de teclado:
t (predeterminado): ordenar por memoria total
o: Ordenar por memoria propia
a: Ordenar por recuento de asignación
En la mayoría de las terminales, también puede hacer clic en los botones "Ordenar por total", "Ordenar por propiedad" y "Ordenar por asignaciones" en el pie de página.
El encabezado de la columna ordenada está subrayado.
De forma predeterminada, el comando en vivo presentará el hilo principal del programa. Puede ver diferentes subprocesos del programa presionando las teclas mayor y menor que, < y > . En la mayoría de las terminales, también puede hacer clic en los botones "Hilo anterior" y "Hilo siguiente" en el pie de página.
Además de rastrear los procesos de Python desde una CLI usando memray run , también es posible habilitar el seguimiento mediante programación dentro de un programa Python en ejecución.
import memray
with memray . Tracker ( "output_file.bin" ):
print ( "Allocations will be tracked until the with block ends" )Para obtener más información, consulte la documentación de la API.
Memray tiene licencia Apache-2.0, como se encuentra en el archivo LICENCIA.
Este proyecto ha adoptado un Código de Conducta. Si tiene alguna inquietud sobre el Código o el comportamiento que haya experimentado en el proyecto, contáctenos en [email protected].
Si cree que ha identificado una vulnerabilidad de seguridad en este proyecto, envíe un correo electrónico al equipo del proyecto a [email protected], detallando el problema sospechoso y cualquier método que haya encontrado para reproducirlo.
NO abra un problema en el repositorio de GitHub, ya que preferiríamos mantener privados los informes de vulnerabilidad hasta que hayamos tenido la oportunidad de revisarlos y abordarlos.
¡Agradecemos sus contribuciones para ayudarnos a mejorar y ampliar este proyecto!
A continuación encontrará algunos pasos básicos necesarios para poder contribuir al proyecto. Si tiene alguna pregunta sobre este proceso o cualquier otro aspecto de la contribución a un proyecto de código abierto de Bloomberg, no dude en enviar un correo electrónico a [email protected] y responderemos sus preguntas lo más rápido posible.
Dado que este proyecto se distribuye bajo los términos de una licencia de código abierto, las contribuciones que usted realice tienen licencia bajo los mismos términos. Para que podamos aceptar sus contribuciones, necesitaremos su confirmación explícita de que puede y desea proporcionarlas según estos términos, y el mecanismo que utilizamos para hacerlo se llama Certificado de origen del desarrollador (DCO). . Esto es muy similar al proceso utilizado por el kernel de Linux, Samba y muchos otros proyectos importantes de código abierto.
Para participar bajo estos términos, todo lo que debe hacer es incluir una línea como la siguiente como última línea del mensaje de confirmación para cada confirmación en su contribución:
Signed-Off-By: Random J. Developer <[email protected]>
La forma más sencilla de lograr esto es agregar -s o --signoff a su comando git commit .
Debes utilizar tu nombre real (lo siento, no se permiten seudónimos ni contribuciones anónimas).
