codon

Qu'est-ce que le codon?

Le codon est une implémentation Python haute performance qui compile vers le code machine natif sans aucune surcharge d'exécution. Les accélérations typiques sur la vanille python sont de l'ordre de 10-100x ou plus, sur un seul fil. Les performances du codon sont généralement à égalité avec (et parfois meilleure que celle de C / C ++. Contrairement à Python, le codon prend en charge le multithreading natif, ce qui peut entraîner des accélération plusieurs fois plus élevés.

Considérez le codon comme Python repensé pour une compilation statique à l'avance, construit à partir de zéro avec de meilleures performances possibles à l'esprit.

Objectifs

• Pas de courbe d'apprentissage: Soyez aussi proche que possible de Cpython en termes de syntaxe, de sémantique et de bibliothèques
• Performances de haut niveau: au moins à égalité avec des langues de bas niveau comme C, C ++ ou Rust
• Prise en charge du matériel: prise en charge complète et transparente pour la programmation multiset
• ? Optimisations: cadre d'optimisation complet qui peut cibler les constructions et bibliothèques Python de haut niveau
• ? Interopérabilité: Interopérabilité complète avec l'écosystème de packages et de bibliothèques de Python

Non-Goals

• Remplacement d'allumage pour CPYTHON: le codon n'est pas un remplacement sans rendez-vous pour CPYthon. Il existe certains aspects de Python qui ne conviennent pas à la compilation statique - nous ne les soutenons pas dans le codon. Il existe des moyens d'utiliser le codon dans des bases de code Python plus grandes via son décorateur JIT ou son backend d'extension Python. Codon prend également en charge l'appel de tout module Python via son interopérabilité Python. Voir aussi "Différences avec Python" dans les documents.

• Nouvelles constructions de syntaxe et de langage: nous essayons d'éviter d'ajouter autant que possible de nouvelles syntaxes, de mots clés ou d'autres fonctionnalités linguistiques. Bien que le codon ajoute une nouvelle syntaxe à quelques endroits (par exemple pour exprimer le parallélisme), nous essayons de le rendre aussi familier et intuitif que possible.

Installer

Les binaires prédéfinis pour Linux (x86_64) et macOS (x86_64 et arm64) sont disponibles à côté de chaque version. Télécharger et installer avec:

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

Ou vous pouvez construire à partir de la source.

Exemples

Codon est une langue compatible Python, et de nombreux programmes Python fonctionneront avec peu ou pas de modifications:

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

Le compilateur codon a un certain nombre d'options et de modes:

 # 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

Voir les documents pour plus d'options et d'exemples.

Vous pouvez importer et utiliser n'importe quel package Python à partir de codon. Par exemple:

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

(N'oubliez pas de définir la variable d'environnement CODON_PYTHON dans la bibliothèque partagée CPYthon, comme expliqué dans les documents.)

Cet exemple de comptage principal présente la prise en charge OpenMP de Codon, activé avec l'ajout d'une ligne. L'annotation @par indique au compilateur de paralléliser les éléments suivants for -loop, dans ce cas en utilisant un calendrier dynamique, une taille de morceau de 100 et 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 )

CODON prend en charge l'écriture et l'exécution des noyaux GPU. Voici un exemple qui calcule l'ensemble 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 )

La programmation GPU peut également être effectuée en utilisant la syntaxe @par avec @par(gpu=True) .

Documentation

Veuillez consulter docs.exaloop.io pour une documentation approfondie.