O Python 3.14 passou a expor sys._jit, um pequeno conjunto de utilitários para observar o compilador JIT experimental do CPython. JIT significa just-in-time compilation: em vez de executar todo o código apenas pelo interpretador tradicional, trechos considerados “quentes” podem ser compilados durante a execução para uma forma mais eficiente. O recurso ainda é experimental, depende de como o CPython foi compilado e não deve ser tratado como uma API estável para lógica de negócio.
Neste guia, você vai entender o que significam is_available(), is_enabled() e is_active(), como detectar suporte sem quebrar versões antigas, por que não se deve alterar o comportamento do programa com base em is_active() e como medir desempenho de forma confiável.
O que é o JIT do CPython
O CPython tradicionalmente executa bytecode em uma máquina virtual. Com o JIT experimental, partes muito executadas podem ser transformadas em código especializado. Isso não significa que todo programa ficará automaticamente mais rápido. O ganho depende do tipo de trabalho, do tempo de aquecimento, da plataforma, da versão e das decisões internas do compilador.
O módulo sys expõe apenas informações de observação. Ele não oferece uma API para marcar funções manualmente, forçar compilação ou escolher otimizações específicas. Isso é proposital: o JIT continua sendo detalhe de implementação.
Verificando se sys._jit existe
import sys
jit = getattr(sys, "_jit", None)
if jit is None:
print("Esta versão ou implementação não expõe sys._jit")
else:
print("sys._jit está disponível")
Usar getattr é melhor do que acessar diretamente sys._jit quando seu código precisa rodar em versões anteriores, em PyPy ou em builds diferentes do CPython. Como o nome começa com sublinhado, ele já sinaliza uma API interna e sujeita a mudanças.
sys._jit.is_available()
is_available() retorna True quando o executável atual foi compilado com suporte ao JIT experimental. Isso não garante que o JIT esteja ligado naquele processo. Em outras palavras, disponibilidade é uma capacidade do binário.
import sys
jit = getattr(sys, "_jit", None)
if jit and jit.is_available():
print("Este CPython foi compilado com suporte ao JIT")
else:
print("JIT indisponível neste executável")
Esse teste é útil em ferramentas de diagnóstico, relatórios de ambiente, benchmarks e pipelines de CI que comparam builds diferentes.
sys._jit.is_enabled()
is_enabled() informa se o JIT está ativado no processo atual. Um build pode suportar o recurso e ainda executá-lo desativado. A configuração pode depender da variável de ambiente PYTHON_JIT definida antes do início do interpretador.
import sys
jit = getattr(sys, "_jit", None)
if jit is None:
status = "não suportado"
elif not jit.is_available():
status = "binário sem JIT"
elif jit.is_enabled():
status = "JIT ativado"
else:
status = "JIT suportado, porém desativado"
print(status)
Use essa informação para registrar o ambiente de teste. Evite habilitar ou desabilitar o recurso no meio do programa, pois a decisão é feita na inicialização.
sys._jit.is_active()
is_active() tenta indicar se o frame Python superior está executando código JIT naquele instante. Essa função serve principalmente para testes e depuração do próprio JIT. Ela não deve controlar caminhos de produção.
import sys
jit = getattr(sys, "_jit", None)
if jit and jit.is_enabled():
print("Ativo agora:", jit.is_active())
O resultado pode surpreender. A própria chamada de inspeção, um desvio condicional ou uma linha fria pode fazer a execução sair do trecho compilado. Assim, um if sys._jit.is_active() não é uma maneira confiável de decidir qual algoritmo usar.
Não mude a lógica com base no JIT
O programa deve produzir o mesmo resultado com o JIT ligado ou desligado. Se a lógica depende da presença do compilador, você cria comportamento difícil de testar e incompatível com outras implementações.
# Evite este padrão
if getattr(sys, "_jit", None) and sys._jit.is_active():
resultado = algoritmo_a(dados)
else:
resultado = algoritmo_b(dados)
Prefira escolher algoritmos com base no formato dos dados, requisitos de precisão e medições independentes. O JIT deve ser uma otimização transparente.
Função segura para diagnóstico
import sys
def obter_status_jit():
jit = getattr(sys, "_jit", None)
if jit is None:
return {
"exposto": False,
"disponivel": False,
"ativado": False,
}
disponivel = bool(jit.is_available())
ativado = bool(jit.is_enabled()) if disponivel else False
return {
"exposto": True,
"disponivel": disponivel,
"ativado": ativado,
}
print(obter_status_jit())
Essa função evita chamar métodos inexistentes em versões incompatíveis e retorna dados simples para logs ou relatórios.
Como comparar desempenho
Para avaliar o JIT, execute o mesmo benchmark em processos separados: um com o recurso ativado e outro desativado. Inclua uma fase de aquecimento, pois o compilador precisa observar o código antes de otimizar trechos quentes.
from time import perf_counter
def trabalho(repeticoes):
total = 0
for i in range(repeticoes):
total += (i * 3) % 97
return total
for _ in range(20):
trabalho(100_000)
inicio = perf_counter()
resultado = trabalho(5_000_000)
duracao = perf_counter() - inicio
print(resultado, duracao)
Não misture tempo de inicialização, importações e aquecimento com o trecho que deseja comparar. Repita várias vezes, registre mediana e dispersão e mantenha frequência de CPU, carga do sistema e versão do Python sob controle.
Benchmarks em processos separados
A variável de ambiente deve ser aplicada antes de iniciar o Python. Em sistemas compatíveis, você pode executar o mesmo script com valores diferentes de PYTHON_JIT. Salve também sys.version, sys.implementation e a saída de obter_status_jit().
Não conclua que o JIT “não funciona” a partir de um único teste curto. Alguns programas são limitados por entrada e saída, rede, banco de dados ou bibliotecas nativas. Nesses casos, otimizar bytecode Python pode ter pouco impacto.
Compatibilidade e fallback
sys._jit foi documentado no CPython 3.14 como detalhe experimental. Bibliotecas públicas não devem exigir sua presença sem um motivo específico. Quando precisar expor informações de diagnóstico, retorne um estado neutro em versões antigas.
def jit_ativado():
import sys
jit = getattr(sys, "_jit", None)
return bool(jit and jit.is_available() and jit.is_enabled())
Essa função é adequada para telemetria. Ela não deve decidir regras de negócio.
JIT e outras implementações Python
PyPy possui uma longa tradição de JIT, mas não é obrigado a oferecer a mesma interface de sys._jit. MicroPython, GraalPy e outras implementações também têm características próprias. Verifique sys.implementation.name somente para diagnóstico; evite espalhar condicionais de implementação por todo o projeto.
Cuidados com testes
Se seus testes falham apenas com o JIT ativado, investigue dependências de tempo, ordem, concorrência, uso incorreto de estado global e extensões nativas. O resultado funcional deve permanecer equivalente. Mantenha uma matriz de CI com o modo padrão e, quando relevante, um build experimental.
Observabilidade sem ruído
Registre o status do JIT uma vez na inicialização, não em cada requisição. Chamadas repetidas a is_active() não fornecem uma métrica útil de produção e podem alterar o perfil de execução. Para analisar gargalos, combine benchmarks com cProfile, timeit e ferramentas de sistema.
Conteúdos relacionados
Veja também os guias da Academify sobre timeit no Python, cProfile, por que Python é lento e GIL no Python. Consulte ainda a documentação oficial de sys e o repositório do CPython.
Conclusão
sys._jit permite observar três estados diferentes: se o binário suporta JIT, se o recurso está ativado e se um frame parece estar executando código compilado naquele momento. A distinção é importante. Para aplicações comuns, use is_available() e is_enabled() apenas em diagnóstico e benchmark. Evite depender de is_active() na lógica do programa. Como o recurso é experimental, proteja acessos com getattr, teste em processos separados, registre versões e trate qualquer ganho de desempenho como resultado mensurável, não como garantia.
