Les bases du calcul parallèle

Éclaircir une photo, c'est ajouter le même petit nombre à des millions de pixels. Un pixel ne dépend pas d'un autre : des milliers de petits ouvriers peuvent donc en prendre chacun quelques-uns. Une carte graphique est faite exactement pour cela. Ce lab n'a pas de carte graphique, mais il te laisse voir les idées sur lesquelles elle repose.

• Parallèle : plusieurs parties d'un travail faites en même temps.
• Ouvrier (worker) : un processus ou un fil d'exécution qui fait une part du travail.
• Partie séquentielle : la part d'un travail qui ne peut pas être découpée et qui se fait dans l'ordre.
• Accélération : combien de fois le travail est plus rapide qu'avec un seul ouvrier.
• Fil d'exécution (thread) : un petit ouvrier ; un GPU en fait tourner des milliers à la fois.
• Noyau (kernel) : la petite fonction que chaque fil exécute, chacun sur son propre élément.

ls liste le dossier de travail : le notebook start.ipynb et le dossier steps. cat affiche le premier script. Il additionne deux fois les carrés de 1 à 1000 : une fois avec une boucle Python, une fois avec une seule opération NumPy, qui fait le même travail sur tout le tableau d'un coup.

Les deux méthodes donnent 333833500, et le script indique que les deux résultats sont égaux. La boucle demande 2000 opérations au niveau de Python, une multiplication et une addition pour chacun des 1000 nombres. NumPy en demande 1, car un seul appel fait tout le travail dans du code compilé rapide. Rien n'est chronométré : le script affiche donc la même chose à chaque fois. Un GPU va plus loin : une instruction, des milliers d'éléments.

Les nombres de 1 à 40 sont coupés en 4 morceaux de 10, et deux ouvriers se les partagent. Chaque morceau donne une somme partielle, 55, 155, 255 et 355, toujours listées dans l'ordre des morceaux, et leur total fait 820, comme la somme de toute la liste d'un bloc. Le découpage marche parce que chaque morceau peut être additionné sans connaître les autres.

Une partie de tout travail ne peut pas être découpée. Le tableau calcule l'accélération avec 1, 2, 4 et 8 ouvriers quand 10, 25 et 50 pour cent ne le peuvent pas. Avec 10 pour cent de séquentiel, 8 ouvriers donnent 4,71 fois, pas 8, et même une infinité d'ouvriers ne donnent que 10,0 au plus. Avec 50 pour cent de séquentiel, 8 ouvriers ne donnent que 1,78.

Un GPU exécute une fonction appelée noyau une fois par fil. Les fils sont regroupés en blocs, et chacun calcule quel élément est le sien avec bloc * taille du bloc + fil. Ce script simule un lancement de 3 blocs de 4 fils sur 10 éléments, pour additionner deux vecteurs. Il affiche l'indice global de chaque fil, de 0 à 11, et le résultat 11, 22, et ainsi de suite jusqu'à 110. Les deux derniers fils, 10 et 11, dépassent la fin et ne font rien.

Un appareil a deux limites : la vitesse à laquelle il déplace des octets et celle à laquelle il fait des calculs. Ce script est de l'arithmétique sur un appareil inventé qui déplace 500 gigaoctets par seconde et fait 10 téraflops par seconde. Une addition de vecteurs de 10 millions d'éléments déplace 120000000 octets pour 10000000 calculs : elle est limitée par la mémoire. Une multiplication de matrices 1000 par 1000 déplace 12000000 octets pour 2000000000 calculs : elle est limitée par le calcul.

Ouvre JupyterLab depuis la barre et double-clique sur start.ipynb. Chaque cellule lance un script : tu vois donc ce que faisaient les six scripts, une idée à la fois. Clique sur une cellule et appuie sur Maj et Entrée pour l'exécuter. Pour explorer, ouvre un script dans la liste des fichiers, change un nombre, par exemple le nombre de morceaux ou la part qui ne peut pas être découpée, et relance-le.