Parallélisation en Python – Tirer le meilleur de votre CPU

La parallélisation c’est distribuer une tâche à différent travailleurs(CPU). Ces travailleurs exécute le code ensemble et donc accélere l’algorithme.

Par exemple dans une boucle for de 1 à 5 avec 3 CPU. Chaque CPU va parcourir la boucle mais chacun à une itération différente.

Le premier CPU à l’itération 1, le deuxième à l’itération 2 et le troisième à l’itération 3.

Une fois qu’un CPU a fini son travail, il prend directement l’itération suivante.

La tâche est ainsi paralléliser et l’algorithme est donc beaucoup plus rapide !

Dans cet article on va paralléliser notre code Python grâce à la librairie multiprocessing.

Nombre de CPU disponible

Avant de pouvoir paralléliser notre exécution, il faut savoir combien de CPU on peut utiliser.

Pour cela rien de plus simple, on utilise la fonction cpu_count() :

import multiprocessing

multiprocessing.cpu_count()

Output : Le nombre de CPU que vous avez.

La Parallélisation

Une fois que l’on a notre nombre de CPU, on peut enfin paralléliser.

On va utiliser des Pool. Un Pool c’est un lieu virtuel dans lequel sera exécuté notre code.

Chaque Pool correspond à un de nos CPU.

import multiprocessing
from multiprocessing import Pool

def f(x):
  return x

with Pool(processes=multiprocessing.cpu_count()) as pool:
  for i in pool.imap(f, range(10)):
    print(i)

Sortie : 0 1 2 3 4 5 6 7 8 9

Dans le code ci-dessus on détermine le nombre de Pool. Ici on lui donne comme valeur le nombre de CPU disponible.

Ensuite on distribue, avec la fonction imap(), à chaque Pool la tâche d’appliquer la fonction f à une liste de chiffre entre 1 et 10.

En fait le travail va être distribué à chacun des Pools.

Le premier Pool appliquera la fonction f à un des chiffres et en même temps le deuxième appliquera la fonction f à un autre, et ainsi de suite.

A chaque fin de tâche, le Pool applique la fonction sur l’itération suivante !

Mais est-ce que ça marche vraiment ?

Mais alors qu’est-ce qui nous dit que la parallélisation fonctionne vraiment ?

Après tout, les chiffres en sortie de code sont rangé par ordre croissant. Peut-être que l’exécution n’est tout simplement pas paralléliser ?

Eh bien, pour s’en rendre compte on va utiliser la fonction imap_unordered().

Cette fonction va distribuer les tâches de manière désordonnée. De tel sorte qu’on pourra voir que les CPU travaillent en parallèle :

import multiprocessing
from multiprocessing import Pool

def f(x):
  return x

with Pool(processes=4) as pool:
  for i in pool.imap_unordered(f, range(10)):
    print(i)

Sortie : 0 2 3 1 6 7 8 9 5 4

Ici, on voit bien que la sortie n’est pas hiérarchisée. Cela veut dire que le code n’a pas été exécuté classiquement mais bien en parallèle !

La parallélisation est une technique a utiliser que dans des cas particuliers.

Effectivement, dans une tâche aussi simple que notre fonction f, la parallélisation n’est pas utile.

Au contraire, elle prend plus de temps qu’une exécution classique car le temps de créer les Pool est considérable.

Cependant, elle s’avère efficace dans de nombreux cas où le calcul à réaliser est complexe.

Pour déterminer si vous avez besoin de la parallélisation, n’hésitez pas à vous aider de notre article sur le temps d’exécution de vos algos !

sources :

• Photo by Ales Nesetril on Unsplash