Différences entre versions de « Jacket »

Ligne 46 : Ligne 46 :
 
</pre>
 
</pre>
  
=== Exemple 2 (JacketGFOR) ===
+
===Exemple 2===
 +
 
 +
<pre>
 +
 
 +
addpath(genpath('/local/jacket-2.3/jacket/engine/'))
 +
 
 +
clear; clear gpu_hook;
 +
 
 +
% Chronométrons pour comparer le temps de calcul du CPU au temps de calcul du GPU (en utilisant cette fois-ci la fonction TIMEIT).
 +
 
 +
minSize = 100; maxSize = 2000; it = 100;
 +
 
 +
sizes = minSize:it:maxSize;
 +
 
 +
nbSizes = length(sizes);
 +
 
 +
timeMultGPU = zeros(nbSizes,1);
 +
 
 +
timeMultCPU = zeros(nbSizes,1);
 +
 
 +
currentTest = 1;
 +
 
 +
for currentSize = minSize:it:maxSize
 +
 
 +
G1=grand(currentSize); G2=grand(currentSize);
 +
 
 +
G3=double(G1); G4=double(G2);
 +
 
 +
timeMultGPU(currentTest) = timeit(@() G1*G2); 
 +
 
 +
timeMultCPU(currentTest) = timeit(@() G3*G4);
 +
 
 +
currentTest = currentTest + 1;
 +
 
 +
end
 +
 
 +
timeMultGPU          %Le temps calculé pour le GPU
 +
 
 +
timeMultCPU          %Le temps calculé pour le CPU
 +
 
 +
timeMultCPU/timeMultGPU          %Le rapport entre les deux temps calculé.
 +
 
 +
plot(minSize:it:maxSize,timeMultGPU,'-or')
 +
 
 +
hold on
 +
 
 +
plot(minSize:it:maxSize,timeMultCPU,'-xb')
 +
 
 +
set(gca,'FontSize',16)
 +
 
 +
title('Temps de calcul GPU vs CPU pour la multiplication matricielle')
 +
 
 +
xlabel('Taille des matrices')
 +
 
 +
ylabel('Temps de calcul (s)')
 +
 
 +
legend('GPU','CPU','Location','NorthWest')
 +
 
 +
</pre>
 +
 
 +
=== Exemple 3 (JacketGFOR) ===
 
<pre>
 
<pre>
 
clear
 
clear
Ligne 121 : Ligne 181 :
 
</pre>
 
</pre>
  
===Exemple 3===
+
===Exemple 4===
  
 
<pre>
 
<pre>
Ligne 218 : Ligne 278 :
 
</pre>
 
</pre>
  
===Exemple 4===
 
 
 
<pre>
 
 
addpath(genpath('/local/jacket-2.3/jacket/engine/'))
 
 
clear; clear gpu_hook;
 
 
% Chronométrons pour comparer le temps de calcul du CPU au temps de calcul du GPU (en utilisant cette fois-ci la fonction TIMEIT).
 
 
minSize = 100; maxSize = 2000; it = 100;
 
 
sizes = minSize:it:maxSize;
 
 
nbSizes = length(sizes);
 
 
timeMultGPU = zeros(nbSizes,1);
 
 
timeMultCPU = zeros(nbSizes,1);
 
 
currentTest = 1;
 
  
for currentSize = minSize:it:maxSize
 
 
G1=grand(currentSize); G2=grand(currentSize);
 
 
G3=double(G1); G4=double(G2);
 
 
timeMultGPU(currentTest) = timeit(@() G1*G2); 
 
 
timeMultCPU(currentTest) = timeit(@() G3*G4);
 
 
currentTest = currentTest + 1;
 
 
end
 
 
timeMultGPU          %Le temps calculé pour le GPU
 
 
timeMultCPU          %Le temps calculé pour le CPU
 
 
timeMultCPU/timeMultGPU          %Le rapport entre les deux temps calculé.
 
 
plot(minSize:it:maxSize,timeMultGPU,'-or')
 
 
hold on
 
 
plot(minSize:it:maxSize,timeMultCPU,'-xb')
 
 
set(gca,'FontSize',16)
 
 
title('Temps de calcul GPU vs CPU pour la multiplication matricielle')
 
 
xlabel('Taille des matrices')
 
 
ylabel('Temps de calcul (s)')
 
 
legend('GPU','CPU','Location','NorthWest')
 
 
</pre>
 
  
  

Version du 25 avril 2013 à 10:28


Le logo de Jacket.

Jacket est un toolbox propriétaire pour MATLAB qui permet l'exécution de code sur GPUs. Similaire à GPUmat, son cousin gratuit, pour sa syntaxe, Jacket comprend cependant davantage de fonctions implémentées et accélère également l'affichage des graphismes 2d ou 3d, en faisant usage du GPU.

Guide

Attention : Jacket est installé sur tigre et lionceau.

Présentation donnée par Alexandre Desfossés Foucault : http://dms.umontreal.ca/wiki/images/1/14/Jacketdiapos.pdf

Exemples

Exemple 1

On utilise la fonction TIMEIT de Jacket. La fonction TIMEIT sert à calculer le temps de calcul par les processeurs (GPU ou CPU).

addpath(genpath('/local/jacket-2.3/jacket/engine/'))

clear; clear gpu_hook;

n=6000

Acpu=rand(n,n,'single');

Bcpu=rand(n,n,'single');

Agpu=gsingle(Acpu); %on déclare la même matrice, mais cette fois-ci pour le GPU (c.-à-d., gsingle)

Bgpu=gsingle(Bcpu);

tCpuPlus=timeit(@() Acpu+Bcpu);

tGpuPlus=timeit(@() Agpu+Bgpu);


fprintf('Addition: %f\n', tCpuPlus/tGpuPlus); %on compare les deux calculs 

% Le résultat: «Addition: 17.26681»
% Le verdict: l'addition matricielle en utilisant le GPU est 17 fois plus rapide.  

Exemple 2


addpath(genpath('/local/jacket-2.3/jacket/engine/'))

clear; clear gpu_hook;

% Chronométrons pour comparer le temps de calcul du CPU au temps de calcul du GPU (en utilisant cette fois-ci la fonction TIMEIT).

minSize = 100; maxSize = 2000; it = 100;

sizes = minSize:it:maxSize;

nbSizes = length(sizes);

timeMultGPU = zeros(nbSizes,1);

timeMultCPU = zeros(nbSizes,1);

currentTest = 1;

for currentSize = minSize:it:maxSize

	G1=grand(currentSize); G2=grand(currentSize);

	G3=double(G1); G4=double(G2);

	timeMultGPU(currentTest) = timeit(@() G1*G2);  

	timeMultCPU(currentTest) = timeit(@() G3*G4);

	currentTest = currentTest + 1;

end

timeMultGPU          %Le temps calculé pour le GPU

timeMultCPU          %Le temps calculé pour le CPU

timeMultCPU/timeMultGPU          %Le rapport entre les deux temps calculé. 

plot(minSize:it:maxSize,timeMultGPU,'-or')

hold on

plot(minSize:it:maxSize,timeMultCPU,'-xb')

set(gca,'FontSize',16)

title('Temps de calcul GPU vs CPU pour la multiplication matricielle')

xlabel('Taille des matrices')

ylabel('Temps de calcul (s)')

legend('GPU','CPU','Location','NorthWest')

Exemple 3 (JacketGFOR)

clear

addpath(genpath('/local/jacket-2.3/jacket/engine/'))

%% Exécution de plusieurs opérations indépendantes sur le CPU

%Création des matrices sur le CPU

matrixSize = 2000;

A = rand(matrixSize);

b = ones(matrixSize,1);

tic

%pour plusieurs valeurs de p différentes, on résout le système linéaire

for p = 1:50
    
x = linsolve(A,p*b); 
   
end

allCpuTime = toc


%% On refait la même chose, en mettant les variables sur le GPU

A = gdouble(A);
b = gdouble(b);

tic

%pour plusieurs valeurs de p différentes, on résout le système linéaire

for p = 1:50
    
x = linsolve(A,p*b); 
   
end

gsync

gpuVariablesForLoopTime = toc


%% On utilise GFOR pour faire tourner toutes résolutions linéaires en même temps

tic

gfor p = 1:50
    
x = linsolve(A,p*b); 
   
gend

gsync

GFORTime = toc

%% Résultats

%Variables sur cpu  :  1.4222e+01 

% Variables sur GPU et boucle for : 4.4444e+00

% Variables sur GPU et boucle GFOR : 2.5247e+00


%Attention, chiffres valides pour une matrice 2000x2000

Exemple 4

addpath(genpath('/local/jacket-2.3/jacket/engine/'))

format short e


%% multiplication matricielle, calcul sur le GPU

G1 = gones(100);

G2 = 2 * gones(100);


result = G1 * G2;

% seule différence : gones au lieu de ones



%% Chronométrons pour comparer le temps de calcul du CPU au temps de calcul du GPU

% Multiplication sur le GPU :

maxSize = 1510;

sizes = 10:100:maxSize;

nbSizes = length(sizes);

timeMultJacket = zeros(nbSizes,1);

currentTest = 1;

for currentSize = 10:100:maxSize

tic

G1=grand(currentSize);

G2=2*grand(currentSize);

result = G1*G2;

gsync

timeMultJacket(currentTest) = toc;

currentTest = currentTest + 1;

end

%% Multiplication matricielle, calcul sur le CPU

timeMultJacket

timeMultCPU = zeros(nbSizes,1);


currentTest = 0;

for currentSize = 10:100:maxSize

currentTest = currentTest + 1;

tic

G3 = rand(currentSize);

G4 = 2*rand(currentSize);

result = G3*G4;

timeMultCPU(currentTest) = toc;
    
end

timeMultCPU

plot(10:100:1510,timeMultJacket,'-or')

hold on

plot(10:100:1510,timeMultCPU,'-xb')

set(gca,'FontSize',16)

title('Temps de calcul JACKET vs CPU pour la multiplication matricielle')

xlabel('Taille des matrices')

ylabel('Temps de calcul')

legend('Jacket','CPU')




Voir aussi

Articles connexes

Références externes


La dernière modification de cette page a été faite le 25 avril 2013 à 10:28.