Différences entre versions de « Jacket »

m (modifié les liens vers accelereye qui a été renommé à arrayfire)
 
(22 versions intermédiaires par 2 utilisateurs non affichées)
Ligne 1 : Ligne 1 :
 
[[Catégorie:Logiciels]]
 
[[Catégorie:Logiciels]]
  
[[Image:Jacket_Logo.png|thumb|Le logo de Jacket.]]
+
[[Image:Jacket_Logo.png|thumb]]
  
 
'''Jacket''' est un ''toolbox'' propriétaire pour [[MATLAB|MATLAB]] qui permet l'exécution de code sur GPUs. Similaire à [[GPUmat|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.
 
'''Jacket''' est un ''toolbox'' propriétaire pour [[MATLAB|MATLAB]] qui permet l'exécution de code sur GPUs. Similaire à [[GPUmat|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.
 +
  
 
__TOC__
 
__TOC__
Ligne 9 : Ligne 10 :
 
== Guide ==
 
== Guide ==
  
 +
'''Attention''' : Jacket est installé sur les machines '''tigre''' et '''lionceau''' seulement.
  
'''''Attention''''' : Jacket est installé sur '''tigre''' et '''lionceau'''.  
+
Présentation donnée par Alexandre Desfossés Foucault : http://dms.umontreal.ca/wiki/images/d/d0/PresentationJacket0.pdf
  
Présentation donnée par Alexandre Desfossés Foucault : http://dms.umontreal.ca/wiki/images/1/14/Jacketdiapos.pdf
+
== Exemples ==
  
== Exemples ==
+
Dans les exemples suivants, la fonction TIMEIT de Jacket est utilisée afin de chronométrer le temps d'exécution d'un segment de code ou d'une fonction tournant sur CPU ou sur GPU.
  
===Exemple 1===
+
=== Addition matricielle ===
On utilise la fonction [http://wiki.accelereyes.com/wiki/index.php/TIMEIT TIMEIT] de Jacket. La fonction TIMEIT sert à calculer le temps de calcul par les processeurs (GPU ou CPU).
 
  
 
<pre>
 
<pre>
 
addpath(genpath('/local/jacket-2.3/jacket/engine/'))
 
addpath(genpath('/local/jacket-2.3/jacket/engine/'))
  
clear; clear gpu_hook;
+
clear; clear gpu_hook;   % La mémoire du CPU et celle du GPU sont effacées.
  
 
n=6000
 
n=6000
  
Acpu=rand(n,n,'single');
+
Acpu=rand(n,n,'single'); % Déclaration de 2 matrices aléatoires (précision simple) sur CPU.
 
 
 
Bcpu=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)
+
Agpu=gsingle(Acpu);       % Copie des matrices précédentes sur GPU.
 
 
 
Bgpu=gsingle(Bcpu);
 
Bgpu=gsingle(Bcpu);
  
tCpuPlus=timeit(@() Acpu+Bcpu);
+
tCpuPlus=timeit(@() Acpu+Bcpu); % Mesure du temps d'exécution de l'addition des 2 matrices
 
+
tGpuPlus=timeit(@() Agpu+Bgpu); % pour le CPU et pour le GPU.
tGpuPlus=timeit(@() Agpu+Bgpu);
 
 
 
 
 
fprintf('Addition: %f\n', tCpuPlus/tGpuPlus); %on compare les deux calculs
 
 
 
% Le résultat: Addition: 17.26681
 
 
 
</pre>
 
 
 
=== Exemple 2 (JacketGFOR) ===
 
<pre>
 
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
 
  
 +
fprintf('Addition: %f\n', tCpuPlus/tGpuPlus);  % Comparaison des 2 temps.
  
%% On utilise GFOR pour faire tourner toutes résolutions linéaires en même temps
+
% Résultat : « Addition: 17.26681 »
 
+
% L'opération s'est exécutée 17 fois plus rapidement sur GPU.
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
 
 
</pre>
 
</pre>
  
===Exemple 3===
+
=== Multiplication matricielle ===
  
 
<pre>
 
<pre>
 
addpath(genpath('/local/jacket-2.3/jacket/engine/'))
 
addpath(genpath('/local/jacket-2.3/jacket/engine/'))
  
format short e
+
clear; clear gpu_hook; % La mémoire du CPU et celle du GPU sont effacées.
 
 
 
 
%% 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')
 
</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;
 
minSize = 100; maxSize = 2000; it = 100;
 
 
sizes = minSize:it:maxSize;
 
sizes = minSize:it:maxSize;
 
 
nbSizes = length(sizes);
 
nbSizes = length(sizes);
 
 
timeMultGPU = zeros(nbSizes,1);
 
timeMultGPU = zeros(nbSizes,1);
 
 
timeMultCPU = zeros(nbSizes,1);
 
timeMultCPU = zeros(nbSizes,1);
  
Ligne 243 : Ligne 60 :
  
 
G1=grand(currentSize); G2=grand(currentSize);
 
G1=grand(currentSize); G2=grand(currentSize);
 
 
G3=double(G1); G4=double(G2);
 
G3=double(G1); G4=double(G2);
  
 
timeMultGPU(currentTest) = timeit(@() G1*G2);   
 
timeMultGPU(currentTest) = timeit(@() G1*G2);   
 
 
timeMultCPU(currentTest) = timeit(@() G3*G4);
 
timeMultCPU(currentTest) = timeit(@() G3*G4);
  
Ligne 254 : Ligne 69 :
 
end
 
end
  
timeMultGPU         %Le temps calculé pour le GPU
+
timeMultGPU             % Le temps calculé pour le GPU.
 
+
timeMultCPU             % Le temps calculé pour le CPU.
timeMultCPU         %Le temps calculé pour le CPU
 
 
 
timeMultCPU/timeMultGPU          %Le rapport entre les deux temps calculé.  
 
  
plot(minSize:it:maxSize,timeMultGPU,'-or')
+
timeMultCPU/timeMultGPU % Le rapport des 2 temps.
  
 +
plot(minSize:it:maxSize,timeMultGPU,'-or')  % Affichage des temps sur graphique.
 
hold on
 
hold on
 
 
plot(minSize:it:maxSize,timeMultCPU,'-xb')
 
plot(minSize:it:maxSize,timeMultCPU,'-xb')
  
 
set(gca,'FontSize',16)
 
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>
  
title('Temps de calcul GPU vs CPU pour la multiplication matricielle')
+
=== Boucle <tt>gfor</tt> ===
 +
Dans cet exemple, plusieurs itérations d'une boucle sont exécutées simultanément sur le GPU par la commande <tt>gfor</tt>. Ceci est possible ici puisque les itérations sont indépendantes les unes des autres.
  
xlabel('Taille des matrices')
+
<pre>
 +
clear; clear gpu_hook;  % La mémoire du CPU et celle du GPU sont effacées.
  
ylabel('Temps de calcul (s)')
+
addpath(genpath('/local/jacket-2.3/jacket/engine/'))
  
legend('GPU','CPU','Location','NorthWest')
+
n=5; m=20;
  
</pre>
+
A = grand(n,n,m);  % On crée un tableau sur le GPU qui contient m matrices n x n aléatoires.
 +
B = gones(n);
  
 +
gfor p = 1:m
  
 +
    A(:,:,p) = A(:,:,p) * B
  
 +
gend
 +
</pre>
  
 
== Voir aussi ==
 
== Voir aussi ==
Ligne 290 : Ligne 114 :
  
 
=== Références externes ===
 
=== Références externes ===
* [http://www.accelereyes.com/ Site officiel de Jacket]
+
* [https://arrayfire.com/ Site officiel de Jacket]
* [http://en.wikipedia.org/wiki/Jacket_%28software%29 Jacket sur Wikipédia]
+
* [https://en.wikipedia.org/wiki/ArrayFire Jacket (remplaçé par Arrayfire) sur Wikipédia]

Version actuelle datée du 12 mai 2020 à 13:41


Jacket Logo.png

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 les machines tigre et lionceau seulement.

Présentation donnée par Alexandre Desfossés Foucault : http://dms.umontreal.ca/wiki/images/d/d0/PresentationJacket0.pdf

Exemples

Dans les exemples suivants, la fonction TIMEIT de Jacket est utilisée afin de chronométrer le temps d'exécution d'un segment de code ou d'une fonction tournant sur CPU ou sur GPU.

Addition matricielle

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

clear; clear gpu_hook;    % La mémoire du CPU et celle du GPU sont effacées.

n=6000

Acpu=rand(n,n,'single');  % Déclaration de 2 matrices aléatoires (précision simple) sur CPU.
Bcpu=rand(n,n,'single');

Agpu=gsingle(Acpu);       % Copie des matrices précédentes sur GPU.
Bgpu=gsingle(Bcpu);

tCpuPlus=timeit(@() Acpu+Bcpu);  % Mesure du temps d'exécution de l'addition des 2 matrices
tGpuPlus=timeit(@() Agpu+Bgpu);  % pour le CPU et pour le GPU.

fprintf('Addition: %f\n', tCpuPlus/tGpuPlus);  % Comparaison des 2 temps.

% Résultat : « Addition: 17.26681 »
% L'opération s'est exécutée 17 fois plus rapidement sur GPU.

Multiplication matricielle

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

clear; clear gpu_hook;  % La mémoire du CPU et celle du GPU sont effacées.

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 des 2 temps. 

plot(minSize:it:maxSize,timeMultGPU,'-or')  % Affichage des temps sur graphique.
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')

Boucle gfor

Dans cet exemple, plusieurs itérations d'une boucle sont exécutées simultanément sur le GPU par la commande gfor. Ceci est possible ici puisque les itérations sont indépendantes les unes des autres.

clear; clear gpu_hook;  % La mémoire du CPU et celle du GPU sont effacées.

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

n=5; m=20;

A = grand(n,n,m);  % On crée un tableau sur le GPU qui contient m matrices n x n aléatoires.
B = gones(n);

gfor p = 1:m

    A(:,:,p) = A(:,:,p) * B

gend

Voir aussi

Articles connexes

Références externes


La dernière modification de cette page a été faite le 12 mai 2020 à 13:41.