Bonjour.

Je découvre les bases du calcul sur GPU avec Python et Pyopencl.
Pour débuter avec les aditions de vecteur et Tableau 2D.

Pour fignoler l'apprentissage , je teste l'addition de colonnes d'un Tableau 2d dans un vecteur.
Dans le test addition des 2 colonnes (1 et 5) dans le vecteur.

Cela fonctionne, mais le code est encore un peu brouillon et quelques details sont à régler .

1) En #3 pour le Kernel, je ne comprends pas pourquoi il faut garder __global int *cc
Le tableau est déclarée, le vecteur aussi.

2) En #4 = dest_dev = cl.Buffer(ctx, mf.WRITE_ONLY, vec_host.nbytes)
normalement la aussi pas besoin de cette declaration

3) En #5 idem = dest_dev , supprimable normalement

Normalement il faut déclarer seulement le tableau 2D et le vecteur de résultats ?

Merci de toute infos .

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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
 
 
import pyopencl as cl
import time
import numpy as np
 
# 0 - Choix de la dimension du Tabeau 2D et Vecteur
 
widtha = 11
 
# 1 - CPU / Tableau 2D et Vecteur Résultat
 
a_host = np.array([[1*j for j in range(widtha)] for i in range(widtha)])
vec_host = np.zeros((widtha), dtype='i')
 
print
print "==========================="
print" VECTEUR VEC Origine VIDE "
print
print vec_host[0:10]
print "==========================="
 
# 2 - Création du contexte d'execution OpenCL
 
ctx = cl.create_some_context()
queue = cl.CommandQueue(ctx)
 
# 3 - Déclaration du Kernel 
 
prg = cl.Program(ctx, """
    __kernel void sum(__global const int *a_host,__global int *cc, __global int *vec_host)
    { 
      int width = get_global_size(0);
      int gidx = get_global_id(0);
      int gidy = get_global_id(1);
      int pos = (gidx * width) + gidy;
      int pos1 = (gidx * width) + 1;
      int pos2 = (gidx * width) + 5;    
      vec_host[gidx]  = a_host[pos1] + a_host[pos2];       
 
    }     
    """).build()
 
# 4 - Copie CPU vers GPU
 
startTime = time.clock()
 
mf = cl.mem_flags
 
a_dev = cl.Buffer(ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf = a_host)
 
vec_dev = cl.Buffer(ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf = vec_host)
 
dest_dev = cl.Buffer(ctx, mf.WRITE_ONLY, vec_host.nbytes)
 
 
# 5 - Execution Kernel
prg.sum(queue,(a_host.shape), None, a_dev,dest_dev,vec_dev)
 
# 6 - QUEUE - Copie GPU vers CPU - sortie
cl.enqueue_copy(queue, vec_host, vec_dev).wait()
 
# 7 - Compteur et TEMP valcul
endTime = time.clock()
duration = (endTime - startTime)
 
# 8 - Affichage Resultat
print
print "==========================="
print 
print " Taille Tableau = " + str(widtha)
print
print "TEMPS CALCUL GPU  = " + str(duration)
print "==========================="
print
print "===== A B ==============="
print " TBL A - - - Colonne 1 "
print a_host[1:,1] 
print " TBL A - - - Colonne 2 "
print a_host[1:,5] 
print
print a_host
print
print "==========================="
print
print " VECTEUR Resultat Apres Calcul "
print
print vec_host[0:10]
print