Discussion :

[Swaraj]

Bonjour à tous,

Je souhaiterais me lancer dans un petit projet perso. Je n'ai pas encore décidé le langage que j'allais utiliser. Ma préférence va pour le moment pour Python grâce à sa simplicité et toutes les bibliothèques scientifiques disponibles. Cependant il me reste une interrogation quand au parallélisme, qui pourrait peut-être me faire aller vers Scala...

Il se trouve que dans mon appli, il y a beaucoup (vraiment beaucoup) de boucles imbriquées à exécuter de type

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
from numpy import *
 
nA=10
nB=20
 
A=[random.rand(5,5) for i in range(nA)]
B=[random.rand(5,3) for i in range(nB)]
C=[]
 
for i in range(nA):
    for j in range(nB):
        C.append(dot(A[i],B[j]))

Je voudrais savoir si ce bout de code est facilement parallélisable d'un point de vue pratique (en coupant A en 2 par exemple). Si la réponse est oui, comment faut-il s'y prendre?

Merci pour votre aide

PS: Petite question annexe, est-ce que je peux pré-allouer la taille de la liste C pour aller plus vite?

[afranck64]

hmm...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
a = 61
b = 32
A = range(a)
B = range(b)
C = []
for i in A[:a/2]:
    for j in B:
        C.append((i,j))
 
for i in A[a/2:]:
    for j in B:
        C.append((i,j))
 
print len(C), a*b

De cette manière?

[Swaraj]

lol! Désolé, je ne m'attendais pas à ça!

Le but du jeu serait d'envoyer cette moitié

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
for i in A[:a/2]:
    for j in B:
        C.append((i,j))

sur un processeur et celle-ci

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
for i in A[a/2:]:
    for j in B:
        C.append((i,j))

sur un autre

Bref, je souhaiterais partager ma boucle sur plusieurs processeurs.

[afranck64]

Je l avais compris, je pensais vous laisser le faire a votre guise. Concernant la distribution pour un CPU donné par contre, vous pouvez faire appel a des Threads et je pense qeu l os se charge de gérer la distribution du boulot aux CPUs présent.

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
#!/usr/bin/env python
 
import threading
import time
 
a = 61
b = 32
A = range(a)
B = range(b)
C = []
 
def f1():
    for i in A[:a/2]:
        for j in B:
            C.append((i,j))
 
def f2():
    for i in A[a/2:]:
        for j in B:
            C.append((i,j))
 
threading.Thread(None,target=f1).start()
threading.Thread(None,target=f2).start()
 
time.sleep(1) # sinon l affichage se fera avant la fin des processus.
print len(C), a*b

[Swaraj]

Hum, je m'excuse, j'avais mal compris le message :/ Avec votre dernier post j'ai un petit peu étoffé le programme pour arriver à ça

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
#!/usr/bin/python
# -*-coding:Utf-8 -*
 
import threading
import time
from numpy import *
 
nA=200
nB=200
 
m=500
A=[random.rand(m,m) for i in range(nA)]
B=[random.rand(m,1) for i in range(nB)]
C1=[]
 
t1 = time.clock()
for i in A:
    for j in B:
        C1.append(dot(i,j))
print(time.clock()-t1)
 
 
 
C21=[]
C22=[]
t2=time.clock()
def f1():
    for i in A[:(nA/2)]:
        for j in B:
            C21.append(dot(i,j))
 
def f2():
    for i in A[(nA/2):]:
        for j in B:
            C22.append(dot(i,j))
 
th1=threading.Thread(None,target=f1)
th2=threading.Thread(None,target=f2)
th1.start()
th2.start()
th1.join()
th2.join()
 
print(time.clock()-t2)

Le programme me renvoie:
15.14
22.26

Pourquoi prend-il autant de temps dans le cas multithreadé ???

[tyrtamos]

Bonjour,

A ma connaissance, les threads s'exécutent sur le même CPU puisque c'est le même processus principal. L'avantage des threads, c'est de permettre des activités asynchrones à notre échelle, mais elles sont nécessairement sérialisées au niveau CPU.

Par contre, il y a plus de chance avec le multiprocessing. Mais c'est l'OS qui se débrouille avec les CPU et pas Python. Pour exploiter les CPU multicores, peut-être faut-il aussi utiliser les dernières versions de Python 3.x?

Des infos intéressantes sur ce genre de question ont déjà été données sur ce forum. Par exemple:http://www.developpez.net/forums/d10.../threads-lock/.

Mais des infos complémentaires sur ce sujet complexe sont toujours les bienvenues...