Discussion :

[Brisingle]

Bonjour,
J'ai pas mal cherch� sur le net mais je ne trouve rien (ou ne comprend pas) comment l'appliquer � mon cas.
Je ne sais pas trop comment l'expliquer alors je vais plut�t essayer de vous illustrer ma question.
Prenons ce code :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
Points = [[0, i] for i in range(4)]
while True:
    for i in range(4):
        Points[i][0] += Points[i][1]
    print ([Points[i][0] for i in range(4)])

J'aimerais le modifier de fa�on � ce que chaque it�ration de la boucle for s'ex�cute en parall�le plut�t que les unes apr�s les autres.
Sur un programme plus complexe, ca devrait am�liorer la rapidit� d'ex�cution non ?
Merci et bonne journ�e.

[wiztricks]

Salut,

Sur un programme plus complexe, ca devrait am�liorer la rapidit� d'ex�cution

Ce n'est pas si simple.
Ex�cuter en parall�le, c'est d�marrer le programme, cr�er un certain nombre de workers, leur distribuer le boulot et collecter/assembler les r�sultats.

Vous voyez (ou pas) qu'il y a des portions "s�quentielles", et des portions "parall�lis�es" (lorsque les workers bossent).

La portion s�quentielle "borne" le temps qu'on va gagner � parall�liser.

Pour les d�tails, voir l'article Wikipedia sur la loi de Amdhal.

Apr�s pour faire une op�ration comme Points[i][0] += Points[i][1], c'est l'ajout de deux vecteurs... et plut�t que parall�liser, il sera plus int�ressant de "vectoriser" (en utilisant la carte graphique par exemple).

- W

[Brisingle]

Ce n'est pas si simple.
Ex�cuter en parall�le, c'est d�marrer le programme, cr�er un certain nombre de workers, leur distribuer le boulot et collecter/assembler les r�sultats.

Vous voyez (ou pas) qu'il y a des portions "s�quentielles", et des portions "parall�lis�es" (lorsque les workers bossent).

La portion s�quentielle "borne" le temps qu'on va gagner � parall�liser.

J'avoue ne pas avoir tout compris... ^^'

Apr�s pour faire une op�ration comme Points[i][0] += Points[i][1], c'est l'ajout de deux vecteurs... et plut�t que parall�liser, il sera plus int�ressant de "vectoriser" (en utilisant la carte graphique par exemple).

Qu'entendez vous par "vectoriser" ? Parce que la c'est un exemple vraiment bidon, dans le code que j'utilise, il y a bien d'autres op�rations dans la boucle for.

Merci de votre r�ponse

[wiztricks]

J'avoue ne pas avoir tout compris... ^^'

Je vous ai mentionn� un article de Wikipedia pour vous permettre d'approfondir.

Qu'entendez vous par "vectoriser" ? Parce que la c'est un exemple vraiment bidon, dans le code que j'utilise, il y a bien d'autres op�rations dans la boucle for.

Si vous avez 2 vecteurs � N �l�ments comme par exemple (1, 1, 1, 1, 1) et (2, 2, 2, 2, 2) on peut les ajouter �l�ment par �l�ment (dans une boucle par exemple) ou avoir une "machine" vectorielle qui effectue ces additions en une seule op�ration/instruction.

Si vous ne connaissez pas le concept vous pouvez regarder ce que raconte Wikepedia sur le sujet.

dans le code que j'utilise, il y a bien d'autres op�rations dans la boucle for.

Avant de vectoriser ou de parall�liser, on essaie d'optimiser son code... Si on est au bout du bout, on fait une estimation de combien de temps on esp�re gagner en parall�lisant ou en vectorisant pour savoir si �� vaut le co�t (car il va falloir r�organiser tout ou partie du code pour que �� puisse fonctionner).

- W

[tyrtamos]

Bonjour,

Faire que plusieurs op�rations puissent se d�rouler "en m�me temps" peut se faire en Python de plusieurs fa�ons:

- par thread. Mais on ne gagne pas de temps puisque les threads vont se partager le m�me c�ur du CPU. Celui-ci va travailler alternativement pour chacun des threads, mais ce sera tellement rapide qu'� notre �chelle, on aura l'impression que ce sera "en m�me temps". Exemple d'utilisation: faire un calcul tr�s long dans un programme graphique g�lerait le graphique � l'�cran si on ne le faisait pas dans un thread.

- par processus. L�, c'est plus int�ressant puisque � la cr�ation du processus, l'OS l'affectera � l'un des c�urs disponibles (s'il y en a un!) du CPU. On utilise le module Python "multiprocessing". On peut avec lui cr�er plusieurs processus, chacun pouvant faire un traitement identique ou non sur les donn�es. On peut m�me imaginer que certains processus en attendent d'autres selon les donn�es, et m�me qu'ils s�ex�cutent en permanence et vont chercher eux-m�mes du travail s'il y en a en attente. Bref, on fait ce qu'on veut, et �a marche tr�s bien, mais je n'ai pas dit que c'�tait facile � programmer...

- cas particulier du traitement par processus: le module "concurrent.futures". L�, il s'agit de r�aliser la m�me op�ration sur une liste d'arguments en utilisant les c�urs du CPU au maximum. Et c'est facile � programmer! Et bien s�r, pour faire �a, chaque traitement doit �tre ind�pendant des autres! Pour prendre un exemple concret, dans le cadre d'un programme de recherche de photos, il a fallu que je calcule des centaines de vignettes en attente d'affichage. Comme ces calculs de vignettes sont ind�pendants des autres, le calcul en parall�le fait gagner du temps.

Enfin, soyons clairs sur un point: on ne peut gagner du temps que si le travail � faire est suffisamment important. S'il ne l'est pas assez, le temps pour mettre en place les processus et assurer les �changes de donn�es seront trop importants par rapport au temps de traitement. Cela fera que, par exemple avec un CPU � 4 c�urs, le temps ne sera divis�e que par 1.5 ou 2 au lieu de 4.

Voil� un petit exemple pour illustrer mon propos: un test pour savoir si un nombre est premier ou non:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
# -*- coding: utf-8 -*-
 
from math import sqrt, floor
import concurrent.futures
from random import randint
from time import perf_counter
 
##############################################################################
def estpremier(n):
    """dit si un nombre est premier (renvoie True ou False) par la méthode des 
       divisions
    """
    if n<2:
        return False
    if n % 2==0:
        return n == 2 # pour les nombres pairs, seul 2 est premier
    d, rac = 3, int(floor(sqrt(n)))
    while d <= rac:
        if n % d == 0:
            return False # diviseur trouvé => n n'est pas premier
        d += 2 # nombre impair suivant
    return True # aucun diviseur trouvé: n est premier
 
##############################################################################
if __name__ == '__main__':
 
    #=========================================================================
    # génère des nombres aléatoires
    nombres = [randint(100, 10**15-1) for i in range(0, 1000)]
    print(nombres)
    print()
 
    #=========================================================================
    # calcul utilisant les coeurs du CPU multicores
    tps1 = perf_counter()
    resultat1 = []
    with concurrent.futures.ProcessPoolExecutor() as executor:
        for nombre, resultat in zip(nombres, executor.map(estpremier, nombres)):
            resultat1.append([nombre, resultat])
    tps1 = perf_counter()-tps1
    print(resultat1)
    print(tps1)
    print()
 
    #=========================================================================
    # calcul normal dans une boucle
    tps2 = perf_counter()
    resultat2 = []
    for nombre in nombres:
        resultat2.append([nombre, estpremier(nombre)])
    tps2 = perf_counter()-tps2
    print(resultat2)
    print(tps2)

Avec mon CPU � 4 c�urs, et sur une ex�cution quelconque, j'ai obtenu sur les m�mes donn�es 35 secondes pour la m�thode normale (boucle s�quentielle), et 10 secondes pour la m�thode avec concurrent-futures, soit un temps divis� par 3.5...

Bien s�r, mon propos tr�s simplifi� ne remplace pas la nombreuse litt�rature sur le sujet, y compris les liens d�j� donn�s!

[Sve@r]

Bonjour

Voil� un petit exemple pour illustrer mon propos: un test pour savoir si un nombre est premier ou non:

Excellent cet exemple. Je ne connaissais pas "concurrent.futures" (et chaque fois que je vois tes posts ou ceux de wiztricks je r�alise que je connais que dalle en r�alit�) mais j'ai ador�

Je me suis ensuite amus� � y calquer un test utilisant multiprocessing. Mais j'ai aussi enlev� le "append" pouvant fausser les tests

Code python :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
from multiprocessing import Pool
... (le début pris dans le code de tyrtamos...)
 
if __name__ == '__main__':
	# génère des nombres aléatoires
	nombres=tuple(randint(100, 10**15-1) for i in range(0, 1000))
	print(nombres)
	print()
 
	# calcul normal dans une boucle
	tps = perf_counter()
	resultat=tuple((n, isPremier(n)) for n in nombres)
	tps = perf_counter()-tps
	#print(tuple((n, r) for (n, r) in resultat if r))
	print("base: ", tps)
	print()
 
	# calcul utilisant concurrent.futures
	tps = perf_counter()
	resultat = []
	with concurrent.futures.ProcessPoolExecutor() as executor:
		resultat=tuple((n, r) for (n, r) in zip(nombres, executor.map(isPremier, nombres)))
	tps = perf_counter()-tps
	#print(tuple((n, r) for (n, r) in resultat if r))
	print("concurrent:", tps)
	print()
 
	# calcul utilisant multiprocessing
	tps = perf_counter()
	resultat = []
	with Pool(4) as p:
		resultat=tuple((n, r) for (n, r) in zip(nombres, p.map(isPremier, nombres)))
	tps = perf_counter()-tps
	#print(tuple((n, r) for (n, r) in resultat if r))
	print("pool:", tps)

Et au r�sultat
base: 30.387541256000986
concurrent: 8.219779146995279
pool: 7.944510806992184

Mais cela ne veut pas dire grand chose car en le lan�ant une seconde fois...
base: 26.867525838999427
concurrent: 7.170248055990669
pool: 8.165446345999953



PS: accessoirement j'ai eu un mal fou � faire marcher ce code car � chaque fois, il me sortait en erreur avec en derni�re ligne AttributeError: module 'signal' has no attribute 'SIGTERM'. Et quand je prenais le code source d'exemple de la doc de multiprocessing, �a fonctionnait. Sauf que l'exemple de la doc je l'ex�cutais dans "/tmp" tandis que ce code je l'ex�cutais l� o� je mets mon "fourre-tout" des exemples Python.
J'ai finalement fini par trouver. C'�tait � cause d'un autre source Python nomm� "signal.py" qui �tait plac� dans le m�me dossier

[wiztricks]

Salut,

Excellent cet exemple.

C'est l'exemple donn� dans la documentation du module concurrent.futures.

Je ne l'aime pas parce qu'il montre juste qu'il est facile gr�ce au fonctionnalit�s du module de parall�liser l'appel � une fonction "pure" (ce qui va de soi).

H�las, parall�liser un code qui n'a pas �t� pens� pour est une autre paire de manche...

- W