Performances
&
comparaison CISC/RISC (68000/SPARC)



- Mesure des performances et caractéristiques des processeurs
- CISC versus RISC
- Exemple de CISC: Motorola série 68000
- Exemple de RISC: SUN SPARC


Notions de base:

Préfix devant les unitées de mesure (son nom, symbole et facteur de multiplication) :

milli
micro
nano
pico
femto
m
m (mu)
n
p
f
10-3
10-6
10-9
10-12
10-15
kilo
méga
giga
tera
k
M
G
T
103 ou 210
106 ou 220
109 ou 230
1012 ou 240

En informatique on utilise beacoup la base 2 et c'est pourquoi souvent on utilise les préfix comme étant la puissance de 2 la plus proche plutot que la puissance de 10 normalement utilisée dans les autres sciences.  Par exemple, quand on parle de 2 kB de mémoire, on parle de 211 =  2048 octets (bytes) et non 2000 bytes.

Aussi, en général on utilise les symboles suivant pour les unitées de mesure :
    b : bit
    B : byte
    s : seconde
    Hz : Hertz. Oscillations (ou cycles) par seconde

Et on utilise parfois un 'p' pour signifier 'par' plutot que d'utiliser la division '/':
    CPI : cycles par instruction
    bps : bits par seconde


Tout est dans le chapitre 3.

Développement :

Il faut tenir compte de certains points importants lors du développement de circuits intégrés, ou plus précisemment, de micro-processeurs.
- Le coût du chassis, planche de circuit imprimé, clavier, dominent le prix du micro-processeur
- Être compatible pour préserver l'investissement en logiciel :
        - Binaire :  les anciens fichiers exécutables fonctionnent sur le nouveau processeur.
        - Source :  les anciens sources peuvent être recompilés sans modifications.
        - Émulation :  un émulateur peut faire fonctionner les anciens fichiers (programmes) exécutables.
- Ce qu'on veut :  meilleure performance, coût minimal, meilleur rapport performance/coût ?
- La perfomance est fonction de l'application; il n'y a pas de mesure universelle.

Performances :

On peut mesurer en temps ou en nombre de tâches par unité de temps.

Temps :  temps d'exécution, temps de réponse, latence.
    Plus petit est meilleur.
    Moyenne sur n programmes :  moyenne arithmétique  (somme des temps divisé par n)
    A est k fois plus vite que A si  temps(B) / temps(A) = k

Nombre de tâches par unité de temps :  performance, débit, taux de tranfert (bande passante).
    Plus grand est meilleur.
    Moyenne sur n programmes :  moyenne harmonique  (n divisé par la somme des inverses taux)
    A est k fois plus vite que B si  taux(A) / taux(B) = k

Bases d'évaluation :

Puisqu'il n'y a pas de mesure universelle, il faut choisir une application ou un ensemble d'applications types sur laquelle (lesquelles) on va évaluer la performance.

- Tâches réelles :
        Spécifique à la situation, n'est pas portable, difficile à exécuter et mesurer.

- Programmes tests basés sur des applications réelles
        Portable, le plus souvent utilisé, moins spécifique.

- Noyaux d'algorithmes ("Kernel Benchmarks") synthétiques
        Faciles à exécuter, faciles pour falsifier les résultats (mettre au point un compilateur qui optimise particulièrement bien ces programmes).

- Microtests ("Microbenchmarks") synthétiques
        Combinaisons spécifiques d'instructions, boucles d'itération, etc.
        Utile lors du design pour identifier des problèmes ou pour mesurer la performance maximale atteignable.

Mesures de performance :

MIPSMillions of Instructions Per Second
    Problème :  le même travail peut prendre un nombre différent d'instructions sur différents processeurs.
MFLOPSMillions of FLoating-point Operations Per Second
    Problème :  même que MIPS.
Whetstones :  Programme de mesure (bechmark) synthétique composé pour vérifier des traits spécifiques de performace, en particulier traitement à virgule flottante.
Dhrystones :  Similaire à Whetstone, sauf que construit pour mettre emphase sur traitement de nombres entiers (compilateurs, traitement de texte etc.)
SPEC :  Collection de programmes réels du monde C et UNIX venant de différents domaines.

Donnons en exemple SPEC95 :
18 programmes tests (benchmatks) avec les données utilisées sur ceux-ci.
    - 8 en nombre entiers :  go, m88ksim, gcc compress, li, ijpeg, perl, vortex.
    - 10 en nombre à virgule flottante :  tomcatv, swim, su2cor, hydro2d, mgrid, applu, turb3d, apsi, fppp, wave5.
(Applications plutot en sciences / techniques)
Il faut les exécuter avec les contrôles de compilation standard pour éliminer les optimisations que ciblent ces programmes tests seulement.
 

On peut mesurer la performance de :

- Application :  réponses par unité de temps ou opérations utiles / seconde.
- Architecture du jeu d'instructions :  MIPS, MFLOPS
- Chemin de données, contrôle :  Mégaoctets par seconde
- Unités fonctionnelles, contrôle, logique :  Cycles d'horloge par seconde

Attention, chaque mesure peut être mal utilisée.  Par exemple les MIPS pour comparer des processeurs très différents (un CISC et un RISC).

Calcul du nombre de cycle par instruction (CPI)
 

La loi d'Amdahl :

Soit une amélioration A faite sur un processeur.
Si A accélère une fraction F du programme par un facteur S :
        Temps d'exéc.(avec A) ³ (( 1 - F ) + F / S ) * Temps d'exéc.(sans A)
ou    Accélération(due à A) £ 1 / (( 1 - F ) + F / S )
Donc, même si S est grand, l'accélération peut être petite si F est petit.


CISC vs. RISC :

CISC :  Complex Instruction Set Computer
- Beaucoup d'instructions et de modes d'adressage (instructions et modes complexes)
- Nombre de cycles / instruction très variable et peut être très grand

Ces processeurs ont étés fait pour :
- Programmes de taille réduite (chaque instruction fait plus)
- Plus facile à programmer en assembleur

Mais, pour un compilateur, il n'est pas facile de choisir les meilleures combinaisons d'instructions.  Souvent seulement un sous-ensemble des instructions est utilisé par le compilateur.  Alors, pourquoi ne pas réduire le jeu d'instruction à ce sous-ensemble et ainsi permettre une organisation du processeur plus simple, donc plus rapide?

RISC :  Reduced Instruction Set Computer
- Relativement peu d'instructions, peu de modes d'adressage (instructions et modes simples)
- Instructions de taille fixe (un mot par instruction).
- Achitecture Load-and-Store :  les opérations se font entre les registres et il y a des opérations de copie entre la mémoire et les registres.
- Beaucoup de registres, généraux.
- On veut un cycle par instruction.  Donc la mémoire doit être aussi vite que le processeur (ce qui rend nécessaire l'utilisation d'une mémoire cache)

Est-ce que RISC est plus vite que CISC?  Selon un exposé à ICCD98, la différence n'est pas très grande.  En fait les deux utilisent exactement les mêmes techniques et la partie centrale du processeur est donc "la même".  Tout ce qui change entre RISC et CISC c'est le décodeur d'instructions (ou "front-end" - voir p.e. le CISC Pentium d'Intel).  Le fait que ce décodeur soit très simple dans un RISC permet de mettre plus de choses dans le centre du processeur quand la taille du processeur est limitée, mais présentement la taille du centre du processeur n'est plus une contrainte alors...  (En fait, présentement on fait un processeur et avec l'espace qui reste, on ajoute de la mémoire cache sur la puce du processeur).

Exemple d'un CISC :  Motorola série 68000
- Introduit en 1979
- Un des premier microprocesseurs 32 bits (selon la définition utilisée dans le livre, c'est-à-dire que la plupart des opérations peuvent être faites sur des opérandes de 32 bits)
        - Les opérandes sont de 32, 16 ou 8 bits.
        - La largeur des chemins de données externes varie selon le modèle (sur le MC68000, l'adresse est sur 24 bits et les données sont tranférées par tranches de 8 ou 16 bits).
- Un CISC typique:
        - Grand jeu d'instruction; opérandes dans les registres et/ou en mémoire
        - 14 modes d'adressage, taille d'instruction varie selon le mode
        - Registres de données et d'adresses, séparés.

(À regarder en général, mais pas à apprendre par coeur)
        État du processeur :  pages 97-99
        Format d'instructions :  pages 99-107
        Jeu d'instructions :  pages 107-118
        Traitement d'exceptions :  pages 118-122

Exemple d'un RISC :  SPARC
- Introduit en 1987 par Sun Microsystems (inspiré par RISC de UC Berkeley)
- Architecture "load-and-store"
- Deux modes d'adressage :  Adress = (Reg + Reg) ou (Reg + constante de 13 bits complément à 2)
- Instructions de taille fixe (32 bits), 69 instructions de base
- Un jeux de registres à virgule flottante à part des registres généraux
- La 1ère réalisation avait un pipeline à 4 étages
- Caractéristiques particulières :
        - Fenêtre de registres :  on peut accéder à 32 registres sur un ensemble de 128 registres.
        - Registre r0 lit toujours 0

Fenêtre de registres :  pages 125-126.

(À regarder en général, mais pas à apprendre par coeur)
        État du processeur :  pages 123-124
        Format d'instructions :  pages 127-129
        Jeu d'instructions :  pages 129-136
        Pipeline :  pages 136-137  (cette notion sera vue plus loin dans le cours)


Projections en classe (.PDF)