[Py-ES] El JIT experimental de Python, KO
Jesus Cea
jcea at jcea.es
Thu Nov 12 16:54:36 CET 2026
On 5/11/26 9:19, Rastersoft via general wrote:
> Una pena lo del JIT.
En uno de mis proyectos, medí ayer, la especialización por JIT,
transparente y automática, reduce el tiempo de ejecución a la mitad en
Python 3.15, sin tener que hacer nada.
Probad cosas como esta:
Ejecutar este código varias veces y mirar la diferencia de tiempos:
"""
#!/usr/bin/env python3
import time
t=time.time()
for i in range(100_000_000):
pass
print(time.time()-t)
"""
7.06 segundos en mi portátil.
El mismo código en una función:
"""
#!/usr/bin/env python3
import time
def a():
t=time.time()
for i in range(100_000_000):
pass
print(time.time()-t)
a()
"""
3.12 segundos, en mi portátil.
Ahí se ve el JIT en acción, aunque es un caso extremo poco representativo.
Es muy interesante definir una función, ejecutarla unas cuantas veces y
luego estudiar el código especializado del JIT.
Por ejemplo, tras ejecutar la función anterior un par de veces:
Primero sin especialización, antes de llamar a la función:
"""
Python 3.15.2 (main, Nov 5 2026, 02:22:00) [GCC 10.5.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> def a():
... t=time.time()
... for i in range(100_000_000):
... pass
... print(time.time()-t)
...
>>> import time
>>> import dis
>>> dis.dis(a)
1 RESUME 0
2 LOAD_GLOBAL 0 (time)
LOAD_ATTR 1 (time + NULL|self)
CALL 0
STORE_FAST 0 (t)
3 LOAD_GLOBAL 3 (range + NULL)
LOAD_CONST 0 (100000000)
CALL 1
GET_ITER 0
L1: FOR_ITER 3 (to L2)
STORE_FAST 1 (i)
4 JUMP_BACKWARD 5 (to L1)
3 L2: END_FOR
POP_ITER
5 LOAD_GLOBAL 5 (print + NULL)
LOAD_GLOBAL 0 (time)
LOAD_ATTR 1 (time + NULL|self)
CALL 0
LOAD_FAST_BORROW 0 (t)
BINARY_OP 10 (-)
CALL 1
POP_TOP
LOAD_COMMON_CONSTANT 7 (None)
RETURN_VALUE
"""
Esto que se ve son las instrucciones internas de python, lo que
realmente ejecuta el intérprete. Se entiende bastante bien, solo teneis
que recordar que la máquina virtual python en CPython está basada en
STACK no es registros como una CPU normal. El bucle en sí está entre las
etiquetas 3 y 5.
Tras ejecutarlo un par de veces para que el JIT haga su magia, tenemos esto:
"""
>>> dis.dis(a, show_caches=True, adaptive=True)
1 RESUME_CHECK 0
CACHE 0 (counter: 416)
2 LOAD_GLOBAL_MODULE 0 (time)
CACHE 0 (counter: 416)
CACHE 0 (index: 201)
CACHE 0 (module_keys_version: 0)
CACHE 0 (builtin_keys_version: 7)
LOAD_ATTR_MODULE 1 (time + NULL|self)
CACHE 0 (counter: 416)
CACHE 0 (version: 202)
CACHE 0
CACHE 0 (keys_version: 5)
CACHE 0
CACHE 0 (descr: 0)
CACHE 0
CACHE 0
CACHE 0
CALL_NON_PY_GENERAL 0
CACHE 0 (counter: 416)
CACHE 0 (func_version: 0)
CACHE 0
STORE_FAST 0 (t)
3 LOAD_GLOBAL_BUILTIN 3 (range + NULL)
CACHE 0 (counter: 416)
CACHE 0 (index: 201)
CACHE 0 (module_keys_version: 81)
CACHE 0 (builtin_keys_version: 72)
LOAD_CONST 0 (100000000)
CALL_BUILTIN_CLASS 1
CACHE 0 (counter: 416)
CACHE 0 (func_version: 0)
CACHE 0
GET_ITER 0
CACHE 0 (counter: 26)
L1: FOR_ITER_RANGE 3 (to L2)
CACHE 0 (counter: 416)
STORE_FAST 1 (i)
4 JUMP_BACKWARD_NO_JIT 5 (to L1)
CACHE 0 (counter: 32006)
3 L2: END_FOR
POP_ITER
5 LOAD_GLOBAL_BUILTIN 5 (print + NULL)
CACHE 0 (counter: 416)
CACHE 0 (index: 201)
CACHE 0 (module_keys_version: 81)
CACHE 0 (builtin_keys_version: 43)
LOAD_GLOBAL_MODULE 0 (time)
CACHE 0 (counter: 416)
CACHE 0 (index: 201)
CACHE 0 (module_keys_version: 0)
CACHE 0 (builtin_keys_version: 7)
LOAD_ATTR_MODULE 1 (time + NULL|self)
CACHE 0 (counter: 416)
CACHE 0 (version: 202)
CACHE 0
CACHE 0 (keys_version: 5)
CACHE 0
CACHE 0 (descr: 0)
CACHE 0
CACHE 0
CACHE 0
CALL_NON_PY_GENERAL 0
CACHE 0 (counter: 416)
CACHE 0 (func_version: 0)
CACHE 0
LOAD_FAST_BORROW 0 (t)
BINARY_OP_SUBTRACT_FLOAT 10 (-)
CACHE 0 (counter: 416)
CACHE 0 (descr: 0)
CACHE 0
CACHE 0
CACHE 0
CALL_BUILTIN_FAST_WITH_KEYWORDS 1
CACHE 0 (counter: 416)
CACHE 0 (func_version: 0)
CACHE 0
POP_TOP
LOAD_COMMON_CONSTANT 7 (None)
RETURN_VALUE
"""
Nuevamente el bucle está entre las etiquetas 3 y 5. Hay un poco de ruido
con todo el "CACHE", pero da una mejor idea de cómo está funcionando el
asunto. En particular, se reconoce que el se está iterando sobre un
rango y se ejecuta código específico para ese caso, en vez de usar un
iterador general. Un cambio mínimo que más que duplica su velocidad.
El JIT es buena idea, pero coincido con el comité en que se ha integrado
demasiado pronto, que está muy mal documentado y toca muchas partes del
intérprete. Pero la gestión que se está haciendo del asunto me parece un
error.
--
Jesús Cea Avión _/_/ _/_/_/ _/_/_/
jcea at jcea.es - https://www.jcea.es/ _/_/ _/_/ _/_/ _/_/ _/_/
Twitter: @jcea _/_/ _/_/ _/_/_/_/_/
jabber / xmpp:jcea at jabber.org _/_/ _/_/ _/_/ _/_/ _/_/
"Things are not so easy" _/_/ _/_/ _/_/ _/_/ _/_/ _/_/
"My name is Dump, Core Dump" _/_/_/ _/_/_/ _/_/ _/_/
"El amor es poner tu felicidad en la felicidad de otro" - Leibniz
-------------- next part --------------
A non-text attachment was scrubbed...
Name: OpenPGP_signature
Type: application/pgp-signature
Size: 495 bytes
Desc: OpenPGP digital signature
URL: <https://lists.es.python.org/pipermail/general/attachments/20261112/7509eedc/attachment.bin>
More information about the general
mailing list