Saltar a contenido

Puntos de Referencia

Esta página documenta cómo se compara la CLI de Rust actual con la CLI de Python de la versión 7.0.1. Ambas versiones comparten el mismo motor de análisis en Rust; la diferencia es la tubería de la CLI: el análisis de argumentos, la resolución de configuración, el recorrido de rutas y la representación de la salida ahora se ejecutan en Rust, y el intérprete de Python ya no realiza ningún trabajo de análisis. El bloque de entorno más abajo indica la versión y el commit exactos.

Metodología

  • CLI nueva: compilada desde el repositorio con uv run maturin develop --release, invocada como .venv/bin/complexipy.
  • CLI de referencia: complexipy==7.0.1 instalada desde PyPI con uv add en un proyecto aislado, invocada como bin/complexipy de su entorno virtual.
  • Paridad de invocación: ambas CLIs se ejecutan como scripts de consola directos con flags idénticas, cada carga desde su propio directorio vacío. El envoltorio uv run queda excluido de la medición para que ningún lado pague el costo del proceso de uv.
  • Corpus: repositorios reales de código abierto, clonados de forma superficial en commits fijados, más una prueba de un solo archivo que aísla el arranque del intérprete y de la CLI del análisis del árbol.
  • Métricas: tiempo de pared con hyperfine (calentamiento 3, 5 ejecuciones; la prueba de un solo archivo usa calentamiento 5, 20 ejecuciones) con la salida estándar descartada; RSS máximo con /usr/bin/time -l, 3 ejecuciones, se reporta el máximo.
  • Puerta de paridad: antes de medir, ambas CLIs exportan JSON para el repositorio requests y la prueba de un solo archivo. Los códigos de salida coinciden y cada función que reporta la CLI de referencia tiene la misma puntuación en la CLI nueva, así que ambos lados puntúan el mismo código. La CLI nueva también puntúa funciones definidas bajo un if o un try a nivel de módulo, que la 7.0.1 omite.

El punto de referencia es repetible:

bash benchmarks/benchmark-cli.sh

Environment

  • Machine: MacBookPro18,1 (arm64)
  • OS: macOS 26.5.1
  • CPU: Apple M1 Pro
  • RAM: 16 GB
  • New CLI: complexipy 8.3.0 (built from 83fbd1d, python 3.12.12)
  • Baseline CLI: 7.0.1 (PyPI, python 3.12.12)
  • uv: uv 0.10.3 (c75a0c625 2026-02-16)
  • hyperfine: hyperfine 1.20.0
  • Runs: hyperfine warmup=3 runs=5 (probe warmup=5 runs=20); RSS via /usr/bin/time -l, 3 runs, maximum
  • Modes: default, --quiet, --failed, and render (full output written to a file)
  • Scaling fixture: 285 base functions, sizes 1x/2x/4x, 5 runs each
  • Date: 2026-11-01

Corpus (shallow clones at pinned commits):

  • requests @ 5460f467b02e49471c0fd6cfc9ca0adab6351f98 (37 files)
  • flask @ d318b683471101618febed18996405ad26462110 (83 files)
  • django @ 0b40210e4808937a7c0922e8b7502bff4752faa3 (2929 files)
  • single-file probe: requests/src/requests/init.py @ 5460f467b02e49471c0fd6cfc9ca0adab6351f98

Wall time

Workload 8.3.0 Rust CLI 7.0.1 Python CLI Speedup
requests (37 files) [default] 0.031 s ± 0.001 s 0.420 s ± 0.003 s 13.40x
requests (37 files) [quiet] 0.031 s ± 0.001 s 0.302 s ± 0.003 s 9.62x
requests (37 files) [failed] 0.033 s ± 0.001 s 0.338 s ± 0.004 s 10.17x
requests (37 files) [render] 0.033 s ± 0.001 s 0.425 s ± 0.003 s 12.77x
flask (83 files) [default] 0.033 s ± 0.000 s 0.479 s ± 0.006 s 14.70x
flask (83 files) [quiet] 0.034 s ± 0.003 s 0.318 s ± 0.005 s 9.33x
flask (83 files) [failed] 0.038 s ± 0.001 s 0.365 s ± 0.002 s 9.69x
flask (83 files) [render] 0.034 s ± 0.001 s 0.480 s ± 0.003 s 13.96x
django (2929 files) [default] 0.202 s ± 0.002 s 18.374 s ± 0.087 s 90.97x
django (2929 files) [quiet] 0.186 s ± 0.002 s 12.636 s ± 0.061 s 68.11x
django (2929 files) [failed] 0.195 s ± 0.001 s 13.928 s ± 0.023 s 71.60x
django (2929 files) [render] 0.212 s ± 0.009 s 18.585 s ± 0.061 s 87.85x
single-file probe [default] 26.5 ms ± 1.5 ms 87.2 ms ± 3.2 ms 3.28x
single-file probe [quiet] 25.1 ms ± 1.2 ms 84.7 ms ± 2.2 ms 3.38x
single-file probe [failed] 27.4 ms ± 1.0 ms 87.4 ms ± 2.3 ms 3.19x
single-file probe [render] 26.3 ms ± 1.1 ms 88.6 ms ± 1.9 ms 3.37x

Scaling (synthetic fixture)

Size Mean Ratio --quiet mean Ratio Peak RSS
1x (3995 lines) 28.9 ms - 28.9 ms - 26 MB
2x (7990 lines) 29.5 ms 1.02 31.3 ms 1.08 29 MB
4x (15980 lines) 36.5 ms 1.24 35.0 ms 1.12 37 MB

The fixture is generated deterministically by benchmarks/generate_scaling_fixture.py (285 base functions, sizes 1x/2x/4x, kept outside the repo under /Users/rhafid/.cache/complexipy-benchmarks/scaling; never committed). Ratios near 2 mean linear scoring; ratios near 4 mean quadratic behavior.

Peak RSS

Workload 8.3.0 Rust CLI 7.0.1 Python CLI
requests (37 files) [default] 35 MB 39 MB
requests (37 files) [quiet] 34 MB 38 MB
requests (37 files) [failed] 35 MB 38 MB
requests (37 files) [render] 34 MB 39 MB
flask (83 files) [default] 35 MB 39 MB
flask (83 files) [quiet] 36 MB 38 MB
flask (83 files) [failed] 35 MB 38 MB
flask (83 files) [render] 36 MB 39 MB
django (2929 files) [default] 198 MB 139 MB
django (2929 files) [quiet] 198 MB 137 MB
django (2929 files) [failed] 201 MB 137 MB
django (2929 files) [render] 199 MB 139 MB
single-file probe [default] 22 MB 35 MB
single-file probe [quiet] 22 MB 34 MB
single-file probe [failed] 22 MB 35 MB
single-file probe [render] 22 MB 35 MB

Notes: stdout is discarded during timing except the [render] mode, which writes the full output to a file; both CLIs run as bare console scripts with identical flags. The django workload exits 1 on both CLIs because its own test fixture (tests/test_runner_apps/tagged/tests_syntax_error.py) is intentionally unparseable.

Qué dicen los números

  • Los árboles grandes ganan más. django (~2.900 archivos, con su suite de pruebas incluida) es aproximadamente 68-91 veces más rápido: el motor de Rust analiza el árbol en paralelo en todos los núcleos, mientras que la CLI de Python lo procesaba en uno.
  • Los árboles pequeños y medianos (requests, flask) son aproximadamente 9-15 veces más rápidos.
  • El arranque es más barato. La prueba de un solo archivo es unas 3,3 veces más rápida: es el costo del intérprete de Python y de la importación de typer/rich eliminado del camino crítico.
  • La tabla de escalado al final de los resultados mide el motor de Rust con una fixture sintética en tamaños 1x, 2x y 4x. Razones cercanas a 2 significan análisis lineal; razones cercanas a 4 significan comportamiento cuadrático. Las razones registradas rondan 1,0-1,2.
  • La representación de la salida también es más barata. Mostrar la tabla completa de resultados en django cuesta ~0,02 s en la CLI de Rust frente a ~5,7 s en la CLI de Python (la diferencia entre el modo por defecto y --quiet), así que la brecha de tiempo crece en árboles grandes cuando los resultados se imprimen de verdad - las filas [render] miden ese camino de extremo a extremo.
  • La memoria máxima es menor en árboles pequeños y mayor en los grandes. La CLI de Rust usa 3-5 MB menos en requests y flask y unos 13 MB menos en la prueba de un solo archivo, porque el intérprete de Python y sus bibliotecas de presentación ya no están en el proceso. En django alcanza unos 60 MB más: analiza los archivos en paralelo y reserva memoria con mimalloc, que cambian memoria por velocidad.

Comparación con otras herramientas de complejidad cognitiva

Gráfico de barras del tiempo de pared para puntuar la complejidad cognitiva del código de Django con complexipy, flake8-cognitive-complexity y pylint-cognitive-complexity Gráfico de barras del tiempo de pared para puntuar la complejidad cognitiva del código de Django con complexipy, flake8-cognitive-complexity y pylint-cognitive-complexity

Esta comparación mide las herramientas de Python que calculan la misma métrica, la complejidad cognitiva, sobre el árbol completo de django. Las herramientas que calculan la complejidad ciclomática, como radon o la regla C901 de Ruff, miden otra métrica y no se incluyen.

  • flake8-cognitive-complexity se ejecuta como plugin de flake8 con solo CCR001 seleccionada.
  • pylint-cognitive-complexity se ejecuta como plugin de pylint con todas las demás comprobaciones desactivadas. pylint usa un solo núcleo por defecto.
  • Cada herramienta usa un umbral de 15, se ejecuta con su paralelismo por defecto e ignora cualquier configuración del proyecto. Todas las implementaciones siguen el mismo artículo, pero no reportan la misma puntuación para cada función.
bash benchmarks/benchmark-competitors.sh
  • Machine: MacBookPro18,1, Apple M1 Pro
  • django @ 0b40210e4808937a7c0922e8b7502bff4752faa3
  • complexipy 8.3.0 built from d170454; flake8==7.5.0 flake8-cognitive-complexity==0.1.0; pylint==4.1.3 pylint-cognitive-complexity==0.1.1
  • hyperfine warmup=1 runs=5, threshold 15 for every tool, each tool with its default parallelism
  • Date: 2026-11-01
Tool Mean Relative to complexipy
complexipy 8.3.0 0.206 s ± 0.004 s 1.0x
flake8-cognitive-complexity 0.1.0 4.364 s ± 0.075 s 21.2x
pylint-cognitive-complexity 0.1.1 25.896 s ± 1.074 s 125.7x