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

# Create 2 delayed objects
delayed_num1 = delayed(my_square_function)(3)
delayed_num2 = delayed(my_square_function)(4)

# Add them
result = delayed_num1 + delayed_num2


# Plot the task graph
result.visualize()

Un schéma illustrant les étapes du calcul : my-square-function s'exécute deux fois, puis les deux sorties sont passées à une fonction add. Celle-ci retourne une sortie.

Graphe de tâches chevauchant

delayed_intermediate = delayed(my_square_function)(3)

# These two results both use delayed_intermediate_result
delayed_result1 = delayed_intermediate - 5
delayed_result2 = delayed_intermediate + 4

Graphe de tâches chevauchant

delayed_result1.visualize()

Un schéma illustrant le graphe de tâches pour result 1.

delayed_result2.visualize()

Un schéma illustrant le graphe de tâches pour result 2.

Graphe de tâches chevauchant

# Plot the task graph
dask.visualize(delayed_result1, delayed_result2)

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

Multithreading vs traitement parallèle

Déplacement des données

Traitement parallèle

Chaque processus a son propre espace de mémoire vive

Multithreading

Les fils d'exécution partagent le même espace de mémoire vive

Multithreading vs traitement parallèle

# Run a sum on two big arrays
sum1 = delayed(np.sum)(big_array1)
sum2 = delayed(np.sum)(big_array2)

# Compute using processes
dask.compute(sum1, sum2)

Lent avec le traitement parallèle

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

Multithreading vs traitement parallèle

# Run a sum on two big arrays
sum1 = delayed(np.sum)(big_array1)
sum2 = delayed(np.sum)(big_array2)

# Compute using threads
dask.compute(sum1, sum2)

Rapide avec le multithreading

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

Le GIL

Verrou global de l'interpréteur (GIL) : un seul fil d'exécution 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 multithreading n'aidera pas ici
Le traitement parallèle, oui

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

P. ex., 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é

Fils d'exécution

Démarrent très vite
Partagent la mémoire avec la session principale
Aucun transfert de mémoire requis
Limités par le GIL, qui laisse un seul fil lire le code à la fois

Processus

Coûteux en temps et en mémoire à initialiser
Ont des espaces mémoire distincts
Très lents pour transférer des données entre eux et vers la session Python principale
Ont chacun leur propre GIL, donc pas d'alternance pour lire le code

Passons à la pratique !

Programmation parallèle avec Dask en Python