Chapitre II Principe du pipeline et traitement vectoriel

Chapitre II

Principe du pipeline et traitement vectoriel

• Pipeline

• Principe

• Unidimensionnel

• Bidimensionnel

• Ordinateurs vectoriels

• Cray-1

• Vectorisation

Pipeline unidimensionnel

Hypothèses :

E_i : étage i (1≤ i ≤ k), T : tampon et H : horloge

Temps(E_i) =

t

,

t

t

t

t

n tâches, T₁ et T_k : temps sans et avec pipeline de k étages T_k =

t

t

t

t + t

Supposons que T₁ = nk

t

 Rendement = T /T = nk

t

t + t

Objectif : amélioration des performances

E₁ E₂ E_k

tâches _{T T T T T}

H

…

H H H H

Additionneur des virgules flottante

Entrée : deux nombres en virgules flottante normalisée.

A = a x 2^p et B = b x 2^q

a et b : matisses et p et q : exposants.

On veut calculer :

A + B = c x 2^r = d x 2^s où r = max(p.q) et 0,1  d < 1.

Exemple : A = 0,101 x 2⁸ et B = 0,1101 x 2⁹ A + B = 0,101 x 2⁸ + 0,1101 x 2⁹

= 0,0101 x 2⁹ + 0,1101 x 2^{9 --}réduction au même exposant

= 1,0010 x 2^{9 --}addition des matisses

= 0,1001 x 2^{10 --}normalisation

Algorithme de calcul

1. Déterminer r = max(p,q) et t = | p – q |

2. Décaler à droite la mantisse associée au plus petit exposant par t bits 3. Additionner les mantisses pour obtenir c

4. Normaliser le résultat : si c < 1 alors u = 0 si c > 1 alors u = 1 5. Le résultat final est :

d = c << u et s = r + u

Pipeline de l’addition flottante

A=a x 2^p p a

Soustracteur d’exposants

Décaleur droite Sélecteur

de fraction

Compteur de zéros

Additionneur d’

exposants Additionneur

de

fraction Décaleur

gauche B=b x 2^q

q

b

S₁ S₁ S₁ S₁

r=max(p,q)

t=| p – q |

Fraction avec min(p,q) Autre fraction

s

d C=A+B=d x 2^s c

c c

u

d

Réduction des délais

Hypothèses :

t₀ = 10 ns, t₁ = 90 ns, t₂ = 70 ns, t₃ = 60 ns et t₃ = 40 ns la période du pipeline P ≥ 90 + 10 = 100 ns = 10^-7s

la fréquence f = 1/P = 10⁷ Hz = 10 Mhz

 après initialisation, exécution d'une opération toutes les 100 ns T₁ = (90 + 70 + 60 + 40) * n = 260 * n

T_k = 285 + 100 * (n - 1) = 185 + 100 * n

 Rendement

≈

Exercice : Pouvez-vous réduire le temps en fusionnant S3 et S4 ?

Exemples de UAL pipeline

Ordinateur Nombre d’étages

Star-100 4

TI-ASC 8

Cray-1 14

Cyber 20 26

Pipeline à 2 dimensions

Produit matriciel

C= A * B où A et B sont 2 matrices d’ordre n soit t : temps d’éxécution d’une multiplication Algorithme classique (SISD)

nombre de multiplications = n³

si n = 10³ et t = 1 ms  temps d'exécution = 10³ s ≈ 16 mn Réseau systolique (MISD)

nombre de cellules de base = 3n²-3n+1

multiplication est complétée après 3n-1 périodes si n = 10⁴ et une période en 1 ms

≈ 3 M processeurs et temps d'exécution ≈ 3 ms

Compilation

Ordinateurs pipeline

Chevauchement du traitement de données dans : - UAL

- UC

- Processeur d'E/S

- Hiérarchie de la mémoire

La performance peut se dégrader de façon significative à cause de la dépendance des données ---> conflit des ressources.

Ordinateurs vectoriels

Un superordinateur est caractérisé par : - haute vitesse de calcul

- MP et MS grandes et rapides - logiciels //

généralement conçu pour effectuer le calcul - vectoriel

- ou matriciel

utilisé dans les applications scientifiques : prévision météorologique, recherche nucléaire, intelligence artificielle

Générations des ordinateurs vectoriels

génération Année Machine MFLOPS installations

première

1960 Star-100 50 7 en 1978

TI-ASC 30 4

Illiac-IV 1

deuxième

1975 Cray-1 160 60 en 1982

Cyber 200 800

Fujitsu VP-200 500 Troisième et

quatrième

VP-200 400

Cray-2 2000

Cyber-205 3000

Nec 5000

Coprocesseurs scientifiques (Scientific Attaches Processors)

Caractéristiques

Reliés à un ordinateur hôte une structure pipeline

traitement des vecteurs et nombres en virgule flottante

Génération du micro-code pour les applications vectorielle spécifiques (traitement du signal,...)

Interface rapide Exemple :

AP-120B + VAX11/780 ---> 12 MFLOPS

80386 (33 Mhz) + 80387 ---> 80486 (50 Mhz).

Remarque :

la vitesse maximale n'est jamais atteinte.

la vitesse moyenne Cray-1 est de 24 MFLOPS au lieu de 160 car les logiciels n'exploitent pas efficacement (proprement) le matériel (langage, compilation,

Ordinateur vectoriel : Cray-1 (1/2)

Premier ordinateur vectoriel moderne

période de l'horloge = 12.5 ms  fréquence = 80 Mhz.

cycle de la mémoire = 50 ms, bipolaire (SECDED)

transfert de (4 mots) /période de l'horloge) de ou vers la mémoire.= 320 M mots/s les canaux ont un taux de transfert = 80 M mots/s

4 canaux opèrent simultanément pour achever le taux maximum de transfert.

266 tampons d'instruction 800 registres

12 unités fonctionnelles pipeline (1 à 14 étages).

Registres

adresses (A) 8 x 24 bits scalaires (S) 8 x 64 bits

vectors (V) 8 x 64 x 64 bits vectors (V) 8 x 64 x 64 bits Tampons-adresse (B) 64 x 24 bits Tampons-scalaire (T) 64 x 64 bits

Ordinateur vectoriel : Cray-1 (2/2)

VL : vector lenght

format d'instructions = 16 ou 32 bits

Algorithme LRU de remplacement des tampons d'instruction

*P = Program counter 22 bits

NIP = Next Instruction Parcel 16 bits CIP = Current Instruction Parcel 16 bits LIP = Lower Instruction Parcel 16 bits

*Recip Ap : Inverse approximatif d'un opérande de 64 bits en virgule flottante.

Pop/17 : compter le nombre de "1" dans l'opérande/

compter le nombre de '0' précédant un "1"

*Nombres en virgule flottante (64 bits) et en double précision (128 bits) Dans Cray-1, une opération sur 1 vecteur ayant

3 éléments s'exécutent plus rapidement en mode scalaire

4 3 3 3 3 10

g h i j k m

Compilation

Exemples de programmes Cray-1

Instructions indépendantes V0 <--- V1 + V2 V3 <--- V4 + V5

Réservation de l'unité fonctionnelle V3 <--- V1 + V2

V6 <--- V4 + V5 Réservation de l'opérande

V3 <--- V1 + V2 V6 <--- V1 * V5

Réservation de l'opérande et de l'unité V0 <--- V1 + V2

V3 <--- V1 + V5

Exemple d’une boucle

Soient A et B deux vecteurs de longueur N.

D0 I = 1, N

A(I) = 5 * B(I) + C 10 CONTINUE

Q N div 64 R  N mod 64

pour i = 1 à Q faire Calculer (A,64) Calculer (A,R)

Fonction Calculer(A,longueur)

S0 5 initialiser le registre scalaire par une constante S1 C charger C dans le registre scalaire

VL  N initialiser la longueur du vecteur

V0 B multiplier chaque élément du vecteur par une constante V1 S0 * V0 multiplier une constante

V2 S1 + V1 additionner une constante A V2 sauvegarder le résultat dans A

Vectorisation (1/3)

Vectorisation : ensemble de transformations apportées à un programme scalaire conduisant à de bonnes performances lorsqu'il est exécuté sur un ordinateur vectoriel.

Rôle : Compilateur ou manuellement (règles ou critères) Exemple:

D0 10 I = 1, 10 V(1) = A(1) + B(1) V(I) = A(I) + B(I) V(2) = A(2) + B(2)

10 CONTINUE V(3) = A(3) + B(3)

- - - -

V(1) = A(1) + B(1)

Vectorisation (2/3)

Indépendance des données

DO 10 I = 1, 20 X(1) = X(1) + 5 X(I) = X(I) + 5 X(2) = X(2) + 5

10 CONTINUE X(3) = X(3) + 5

……

Dépendance des données

DO 10 I = 2, 20 X(2) = X(1) + 5 X(I) = X(I-1) + 5 X(3) = X(2) + 5

10 CONTINUE X(4) = X(3) + 5

……

Restructuration du programme

DO 20 I = 1, 1000 DO 20 J = 1,100 DO 20 J = 1, 100 DO 20 I = 1,1000

A(I,J+1) = A(I,J) + B(I,J) A(I,J+1) = A(I,J) + B(I,J)

20 CONTINUE 20 CONTINUE

Vectorisation (3/3)

Eclatement de la boucle

DO 30 I = 1,100 DO 20 I=1,100 A(I) = A(I) + 2 A(I) = A(I)+2 B(I+1) = B(I) + 1 20 CONTIONUE

30 CONTINUE DO 30 I =1,100

B(I+1)=B(I)+1 30 CONTINUE

Instruction conditionnelle et de branchement

DO 30 I = 1,100 DO 30 I=1,100 10 if (A(I) > 0) Goto 30 10 S(I) = A(I) > 0

20 B(I) = C(I) * 5 20 if S(I) then B(I) = C(I)*5 30 CONTINUE 30 CONTINUE

Exemples : ACTUS (1979) et VECTRAN (1975)

Vectorisation assistée

Vectorisation automatique (compilateur) n'est pas encore une solution

satisfaisante pour optimiser la performance d'un ordinateur vectoriel car :

• réalisation d'un compilateur vectoriel est complexe

• algorithmes sophistiqués Vectorisation assistée :

• compilateur détecte les zones du programmes requérant le plus de temps d'exécution.

• utilisateur peut intervenir pour restructurer le code du module.

Outils :

• bibliothèque de sous-programmes vectorisés (écrits par l'utilisateur ou par le constructeur). Par exemple : opérations matricielles, équations d'algèbre

linéaire, détermination des valeurs propres, traitement du signal (TFR), …

• Expérience de l'utilisateur (architecture, compilateur, bibliothèque).