Graphes de tâches et méthodes d'ordonnancement

Programmation parallèle avec Dask en Python

James Fulton

Climate Informatics Researcher

Visualiser un graphe de tâches

# Créer 2 objets delayed
delayed_num1 = delayed(my_square_function)(3)
delayed_num2 = delayed(my_square_function)(4)

# Les additionner
result = delayed_num1 + delayed_num2


# Tracer le graphe de tâches
result.visualize()

Un schéma montrant les étapes pour calculer le résultat. my-square-function est exécutée deux fois, et les deux sorties sont passées à une fonction add, qui renvoie une sortie.

Graphe de tâches avec chevauchement

delayed_intermediate = delayed(my_square_function)(3)

# Ces deux résultats utilisent delayed_intermediate_result
delayed_result1 = delayed_intermediate - 5
delayed_result2 = delayed_intermediate + 4

Graphe de tâches avec chevauchement

delayed_result1.visualize()

Un schéma montrant le graphe de tâches pour le résultat 1.

delayed_result2.visualize()

Un schéma montrant le graphe de tâches pour le résultat 2.

Graphe de tâches avec chevauchement

# Tracer le graphe de tâches
dask.visualize(delayed_result1, delayed_result2)

Un graphe de tâches montrant que le résultat 1 et le résultat 2 partagent un résultat intermédiaire.

Multi‑threading vs traitement parallèle

Déplacement des données

Traitement parallèle

Chaque processus a son propre espace RAM

Multi‑threading

Les threads partagent le même espace RAM

Multi‑threading vs traitement parallèle

# Calculer une somme sur deux grands tableaux
sum1 = delayed(np.sum)(big_array1)
sum2 = delayed(np.sum)(big_array2)

# Calculer avec des processus
dask.compute(sum1, sum2)

Lent avec le traitement parallèle

Le schéma montre que les deux tableaux issus d'un processus Python doivent être envoyés à deux autres processus Python.

Multi‑threading vs traitement parallèle

# Calculer une somme sur deux grands tableaux
sum1 = delayed(np.sum)(big_array1)
sum2 = delayed(np.sum)(big_array2)

# Calculer avec des threads
dask.compute(sum1, sum2)

Rapide avec le multi‑threading

Le schéma montre que les deux tableaux n'ont pas besoin d'être copiés.

Le GIL

Global Interpreter Lock : un seul thread peut lire le script Python à la fois

def sum_to_n(n):
    """Sums numbers from 0 to n"""
    total = 0
    for i in range(n+1):
        total += i
    return total

Le multi‑threading n'aide pas ici
Le traitement parallèle, si

sum1 = delayed(sum_to_n)(1000)
sum2 = delayed(sum_to_n)(1000)

Exemples de temps – GIL

Trois diagrammes de Gantt montrant les temps d'exécution d'une simple fonction Python 16 fois. Parmi trois méthodes d'ordonnancement, les processus sont les plus rapides.

Fonctions qui libèrent le GIL

Par exemple, la fonction pd.read_csv() libère le GIL

df1 = delayed(pd.read_csv)('file1.csv')
df2 = delayed(pd.read_csv)('file2.csv')

Exemples de temps – Chargement des données

Résumé

Threads

Démarrent très vite
Partagent la mémoire avec la session principale
Pas de transfert mémoire nécessaire
Limités par le GIL, qui n'autorise qu'un thread à lire le code à la fois

Processus

Nécessitent du temps et de la mémoire pour l'initialisation
Ont des espaces mémoire séparés
Très lents pour transférer des données entre eux et vers la session Python principale
Ont chacun leur propre GIL et n'ont pas à se relayer pour lire le code

Passons à la pratique !

Programmation parallèle avec Dask en Python