codon

O que é códon?

O códon é uma implementação Python de alto desempenho que compila com o código da máquina nativo sem qualquer sobrecarga de tempo de execução. As acelerações típicas do Python de baunilha estão na ordem de 10-100x ou mais, em um único thread. O desempenho do códon é normalmente a par com (e às vezes melhor que) o de C/C ++. Ao contrário do Python, o códon suporta multithreading nativo, o que pode levar a acelerações muitas vezes mais altas ainda.

Pense no códon como Python reimaginado para a compilação estática e antes do tempo, construída desde o início com o melhor desempenho possível em mente.

Metas

• Sem curva de aprendizado: esteja o mais próximo possível do CPython em termos de sintaxe, semântica e bibliotecas
• Desempenho de primeira linha: pelo menos a par de idiomas de baixo nível como C, C ++ ou Rust
• Suporte de hardware: suporte completo e sem costura para programação multicore, multithreading (sem gil!), GPU e muito mais
• ? Otimizações: estrutura abrangente de otimização que pode atingir construções de python de alto nível
• ? Interoperabilidade: interoperabilidade completa com o ecossistema de pacotes e bibliotecas da Python

Não-objetivos

• Substituição de entrega para Cpython: o códon não é um substituto para o CPYTHON. Existem alguns aspectos do Python que não são adequados para compilação estática - não os apoiamos no códon. Existem maneiras de usar o códon em bases de código Python maiores por meio de seu decorador JIT ou back -end de extensão Python. O códon também suporta chamar qualquer módulo Python por meio de sua interoperabilidade Python. Veja também "Diferenças com Python" nos documentos.

• Novas sintaxe e construções de linguagem: tentamos evitar adicionar novas sintaxe, palavras -chave ou outros recursos de idioma o máximo possível. Enquanto o códon adiciona uma nova sintaxe em alguns lugares (por exemplo, para expressar o paralelismo), tentamos torná -lo o mais familiar e intuitivo possível.

Instalar

Os binários pré-criados para Linux (x86_64) e macOS (x86_64 e arm64) estão disponíveis ao lado de cada versão. Baixe e instale com:

/bin/bash -c " $( curl -fsSL https://exaloop.io/install.sh ) "

Ou você pode construir a partir da fonte.

Exemplos

O códon é uma linguagem compatível com Python, e muitos programas Python funcionarão com poucas ou nenhuma modificação:

 def fib ( n ):
    a , b = 0 , 1
    while a < n :
        print ( a , end = ' ' )
        a , b = b , a + b
    print ()
fib ( 1000 )

O compilador codon possui várias opções e modos:

 # compile and run the program
codon run fib.py
# 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987

# compile and run the program with optimizations enabled
codon run -release fib.py
# 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987

# compile to executable with optimizations enabled
codon build -release -exe fib.py
./fib
# 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987

# compile to LLVM IR file with optimizations enabled
codon build -release -llvm fib.py
# outputs file fib.ll

Veja os documentos para obter mais opções e exemplos.

Você pode importar e usar qualquer pacote python do códon. Por exemplo:

 from python import matplotlib . pyplot as plt
data = [ x ** 2 for x in range ( 10 )]
plt . plot ( data )
plt . show ()

(Lembre -se de definir a variável de ambiente CODON_PYTHON para a biblioteca compartilhada do CPYTHON, conforme explicado nos documentos.)

Este exemplo de contagem principal mostra o suporte do OpenMP do Codon, ativado com a adição de uma linha. A anotação @par diz ao compilador para paralelizar o seguinte for -loop, neste caso usando um cronograma dinâmico, tamanho de pedaço de 100 e 16 threads.

 from sys import argv

def is_prime ( n ):
    factors = 0
    for i in range ( 2 , n ):
        if n % i == 0 :
            factors += 1
    return factors == 0

limit = int ( argv [ 1 ])
total = 0

@ par ( schedule = 'dynamic' , chunk_size = 100 , num_threads = 16 )
for i in range ( 2 , limit ):
    if is_prime ( i ):
        total += 1

print ( total )

O códon suporta escrever e executar kernels da GPU. Aqui está um exemplo que calcula o conjunto de Mandelbrot:

 import gpu

MAX    = 1000  # maximum Mandelbrot iterations
N      = 4096  # width and height of image
pixels = [ 0 for _ in range ( N * N )]

def scale ( x , a , b ):
    return a + ( x / N ) * ( b - a )

@ gpu . kernel
def mandelbrot ( pixels ):
    idx = ( gpu . block . x * gpu . block . dim . x ) + gpu . thread . x
    i , j = divmod ( idx , N )
    c = complex ( scale ( j , - 2.00 , 0.47 ), scale ( i , - 1.12 , 1.12 ))
    z = 0j
    iteration = 0

    while abs ( z ) <= 2 and iteration < MAX :
        z = z ** 2 + c
        iteration += 1

    pixels [ idx ] = int ( 255 * iteration / MAX )

mandelbrot ( pixels , grid = ( N * N ) // 1024 , block = 1024 )

A programação da GPU também pode ser feita usando a sintaxe @par com @par(gpu=True) .

Documentação

Consulte docs.exaloop.io para obter uma documentação aprofundada.