Table des matières Python

Problème FPU : module python

1. Introduction

Le module python présenté dans ce document comporte un intégrateur symplectique (méthode de Stormer-Verlet) pour une chaîne d'oscillateurs non linéaires (problème Fermi-Pasta-Ulam). L'énergie de la chaîne et l'énergie des modes propres sont aussi calculées. La chaîne peut avoir des bords fixes (ondes stationnaires) ou des conditions aux bords périodiques (ondes progressives).

Le module contient une implémentation CUDA pour processeur graphique (GPU) NVIDIA et une implémentation pour processeur central (CPU).

Les prototypes de l'implémentation CUDA sont présentés dans Problème FPU : implémentation CUDA et Problème FPU périodique: implémentation CUDA.

Les calculs se font en flottant simple précision (32 bits).

2. Téléchargement

Code source : fpuchain-0.1.tar.gz

3. Installation

Le module nécessite Python 2.5, 2.6 ou 2.7 et Numpy.

Il faut disposer d'une carte graphique NVIDIA compatible CUDA, de capacité de calcul supérieure ou égale à 1.0.

Pour la compilation, il faut disposer d'un toolkit CUDA. Une fois celui-ci installé, modifier ci nécessaire le chemin d'accès au répertoire CUDA dans le fichier setup.py

Pour compiler et installer :

4. Fonctions

Le module contient les 4 classes suivantes :

Les quatre classes ont les mêmes méthodes.

Fpu(nvar) ou FpuPer(nvar) ou FpuCuda(nvar) ou FpuPerCuda(nvar)

Constructeur.

  • nvar (integer)  :  nombre de masses dans la chaîne (nombre de variables).

La liste des périphériques CUDA (devices) disponibles est affichée à l'exécution du constructeur. Par défaut, le périphérique 0 est sélectionné. Pour en sélectionner un autre, il suffit d'ajouter l'argument optionnel dev=n, où n est le numéro du périphérique.

close()

Fermeture du solveur, à exécuter après le calcul pour libérer la mémoire réservée, en particulier la mémoire de la carte graphique.

init(m)

Condition initiale de la chaîne dans un mode propre.

  • m (integer)  :  indice du mode propre.

run(h,n1,n2,b,n,nm)

Exécution d'une simulation.

  • h (float)  :  pas de temps de l'intégrateur.
  • n1 (integer)  :  nombre de pas élémentaires dans chaque blocs de calcul. À la fin d'un bloc, l'état de la chaîne est mémorisé.
  • n2 (integer)  :  nombre de blocs de calculs. Le temps à la du calcul est t=hn1n2.
  • b (float)  :  amplitude du terme non linéaire.
  • n (float)  :  puissance du temre non linéaire (2 ou 3).
  • nm (integer)  :  nombre de modes à calculer (au maximum nvar).

Les données sont obtenues après l'exécution de la fonction run dans les tableaux (numpy) suivants (attributs d'instance). Dans tous les tableaux, chaque ligne correspond à un instant, obtenu à la fin de chaque bloc de calcul.

  • t (float array) : temps.
  • qmat (float array) : déplacements des points de la chaîne.
  • pmat (float array) : vitesses des points de la chaîne.
  • emat (float array) : énergie de la chaîne.
  • emodemat (float array) : énergies des modes propres du problème linéaire.
  • qstat (float array) : pour la chaîne avec conditions limites périodiques, déplacements des points dans le repère se déplaçant à la vitesse de l'onde correspondant au mode initial.
  • pstat (float array) : pour la chaîne avec conditions limites périodiques, vitesses des points, leur position étant rapportée au repère mobile.

5. Exemple

L'exemple suivant calcule le mouvement d'une chaîne à conditions limites périodiques, avec l'implémentation CUDA. La chaîne a 128 points.

import fpuchain.main
import numpy
from pylab import *
nvar=128
f=fpuchain.main.FpuPerCuda(128)
f.init(1) # condition initiale : mode 1
b=0.1
n=2 # terme non lineaire quadratique
nm=10 # nombre de modes
h=0.1
n1=2000
n2=500
f.run(h,n1,n2,b,n,nm)
f.close()

Tracé de l'énergie des modes : 

figure(0)
for m in range(nm):
    plot(f.emodemat[:,m])
xlabel("t/(n1h)")
ylabel("Em")
plotAplotA.pdf

Tracé des déplacements et des vitesses dans le repère mobile :

matshow(numpy.transpose(f.qstat))
xlabel("t/(n1h)")
ylabel("k")
title("q")
colorbar()
plotBplotB.pdf 
matshow(numpy.transpose(f.pstat))
xlabel("t/(n1h)")
ylabel("k")
title("p")
colorbar()
plotCplotC.pdf

Ecart type relatif des variations d'énergie : 

print(f.deltaE)
--> 1.995566500545455e-05

Durée du calcul (en secondes) : 

print(f.T)
--> 10.414947986602783

6. Performances

Les tests ont été effectués avec les deux configurations matérielles suivantes :

Dans le cas (1) le GPU est de type Tesla avec une capacité de calcul 1.2. Le nombre maximal de threads par bloc est maxThreads=512.

Dans le cas (2), le GPU est de type Fermi avec une capacité de calcul 2.1. Le nombre maximal de threads par bloc est maxThreads=1024.

La technique de calcul est différente suivant que nvar est supérieur ou inférieur à maxThreads. Si nvar<maxThreads, le bloc de calcul à n1 pas utilise la mémoire locale du GPU, plus rapide que la mémoire de la carte graphique. Lorsque nvar>maxThreads, la mémoire de la carte graphique est utilisée.

La figure suivante représente les temps de calcul pour les deux configurations avec n1=1000 et n2=1000, pour la chaîne avec bords fixes.

nvar1_cpu=[64,128,256,512,1024]
t1_cpu = [14.7,29.2,57.6,115,227]
nvar1_cuda=[64,128,256,512,513,1024,2048]
t1_cuda=[15.15,15.46,18.31,28.75,143,190,277]
nvar2_cpu=[64,128,256,512,1024,4096]
t2_cpu=[16.2,32.1,64.1,128.4,258,1044]
nvar2_cuda=[64,128,256,512,1024,1025,2048,4096,8192]
t2_cuda=[10.6,10.6,10.7,11.7,17.5,75.5,83,121,232]
figure(3)
loglog(nvar1_cpu,t1_cpu)
loglog(nvar1_cuda,t1_cuda)
loglog(nvar2_cpu,t2_cpu)
loglog(nvar2_cuda,t2_cuda)
xlabel("nvar")
ylabel("t (s)")
legend(("(1) cpu","(1) cuda","(2) cpu","(2) cuda"),loc='upper right')
plotDplotD.pdf

La version CPU (processeur central) est un peu plus rapide sur le Core i5 que sur le Core 2 duo. Dans les deux cas, un seul thread est utilisé.

L'utilisation de la version CUDA est intéressante dès que nvar dépasse 64. Par exemple, dans la configuration (2), pour nvar=256, la version CUDA est 6 fois plus rapide que la version CPU.

Pour la version CPU, le temps de calcul est proportionnel à nvar. Pour la version CUDA, le temps de calcul reste à peu près constant tant que tous les processeurs du GPU ne sont pas utilisés à plein. Lorsque nvar franchit maxThreads, on remarque le saut de temps de calcul dû au passage de la mémoire locale à la mémoire globale. À nvar=4096 pour la configuration (2), la version CUDA est 8.6 fois plus rapide que la version CPU.

Remarque 1: pour des chaînes de plus de 1000 points, le nombre de pas nécessaire pour observer des phénomènes intéressants est considérablement plus grand que celui utilisé pour le test (1 million). Par exemple, pour nvar=2048, un calcul de 100 millions de pas (d'une durée de 2.5 heures) permet d'observer la décroissance du mode fondamental mais pas sa première récurrence.

Remarque 2 : lorsque n1 dépasse 10000, l'utilisation du GPU ne lui permet plus d'assurer l'affichage en temps réel.

Remarque 3 : dans la version CUDA, un cœur du processeur central est utilisé à plein.

Creative Commons LicenseTextes et figures sont mis à disposition sous contrat Creative Commons.