Séquenceur de programme

Transcription

Haute Ecole d’Ingénierie et de Gestion
du Canton du Vaud
DSP architecture et applications
_________
Chapitre 5
SÉQUENCEUR DE PROGRAMME
Sauts
Boucles
Appel de sous programmes
Interruptions (cœur du DSP et périphériques)
Mémoire cache
DAG1
4 X 4 X 16
DAG2
4 X 4 X 16
PROGRAM
SEQUENCER
BLOCK3
CACHE
64X24-BIT
BLOCK0
BLOCK1
DATA
ADDRESS 24 BIT
DATA
ADDRESS 24 BIT
ADDRESS 16 BIT
DATA
DATA
ADDRESS 16 BIT
ADSP-219X DSP CORE
BLOCK2
INTERNAL MEMORY
FOUR INDEPENDENT BLOCKS
JTAG
TEST AND
EMULATION
6
EXTERNAL PORT
PM ADDRESSBUS
I/O ADDRESS
24
DM ADDRESSBUS
DMA CONNECT
DMA ADDRESS
PM DATA BUS
DM DATA BUS
DATA
REGISTER
FILE
I/O DATA
INPUT
REGISTERS
RESULT
REGISTERS
16 X 16-BIT
DATA BUS
MUX
24
16
16
16
I/O PROCESSOR
I/O REGISTERS
(MEMORY-MAPPED)
BARREL
SHIFTER
22
24
DMA DATA 24
PX
MULT
ADDRBUS
MUX
18
24
ALU
CONTROL
STATUS
BUFFERS
EMBEDDED
CONTROL
PERIPHERALS
AND
COMMUNICATIONS
PORTS
DMA CONTROLLER
SYSTEM INTERRUPT
CONTROLLER
CD\DDA\Cours\Chap5.doc
PROGRAMMABLE
FLAGS(16)
TIMERS
(3)
3
M. Correvon
T A B L E
D E S
M A T I E R E S
PAGE
5.
SÉQUENCEUR DE PROGRAMME...........................................................................................................................1
5.1
INTRODUCTION ...........................................................................................................................................................1
5.2
PIPELINE DES INSTRUCTIONS......................................................................................................................................5
5.3
MÉMOIRE CACHE D’INSTRUCTIONS ...........................................................................................................................6
5.3.1
Configuration de la mémoire cache....................................................................................................... 7
5.4
LES MULTI-INSTRUCTIONS .........................................................................................................................................9
5.4.1
Généralités ............................................................................................................................................ 9
5.4.2
Opération dans l’unité de calcul et double accès en mémoire............................................................... 9
5.4.3
Double accès en mémoire ..................................................................................................................... 9
5.4.4
Opération dans l’unité de calcul et lecture en mémoire ........................................................................ 9
5.4.5
Opération dans l’unité de calcul et écriture en mémoire ..................................................................... 10
5.4.6
Opération dans l’unité de calcul et transfert registre à registre ........................................................... 10
5.5
BRANCHEMENTS ......................................................................................................................................................11
5.5.1
Branchements de type saut (JUMP) et appel de sous routines (CALL) .............................................. 11
5.5.1.1 Branchements immédiats................................................................................................................. 11
5.5.1.2 Branchements retardés.................................................................................................................... 12
5.5.2
Branchements de type boucle DO/UNTIL .......................................................................................... 13
5.5.3
Branchements conditionnels ............................................................................................................... 15
5.5.4
Branchements de type interruption...................................................................................................... 15
5.6
GESTION DES PILES (STACK)....................................................................................................................................16
5.6.1
Utilisation implicite des piles .............................................................................................................. 16
5.6.1.1 Pile PC (PC Stack).......................................................................................................................... 16
5.6.1.2 Piles de boucle (LOOP BEGIN Stack, LOOP END Stack, COUNT Stack) .................................... 16
5.6.1.3 Pile d’état (Status stack) : 16 words × 32 bits ................................................................................ 16
5.6.2
Opérations explicites sur les piles ....................................................................................................... 17
5.6.2.1 Pile PC (PC Stack).......................................................................................................................... 17
5.6.2.2 Piles de boucle (LOOP BEGIN Stack, LOOP END Stack, COUNT Stack) .................................... 18
5.6.2.3 Pile d’état (Status stack) : 16 words × 32 bits ................................................................................ 18
5.6.3
Etat des piles ....................................................................................................................................... 18
5.7
RÉSUMÉ DES INSTRUCTIONS PROPRES AU SÉQUENCEUR DE PROGRAMME .............................................................20
5.8
CONTRÔLEUR D’INTERRUPTIONS .............................................................................................................................21
5.8.1
Généralités .......................................................................................................................................... 21
5.8.2
Registres dédiés à la gestion des lignes d’interruption........................................................................ 23
5.8.2.1 Flag de masquage global des interruptions .................................................................................... 23
5.8.2.2 Registre de masquage des interruptions IMASK............................................................................. 23
5.8.2.3 Registre de mémorisation des interruptions IRPTL ........................................................................ 23
5.8.2.4 Registre d’attribution des priorités des interruptions des périphériques........................................ 24
5.8.2.5 Registres de masquage individuel des interruptions des périphériques.......................................... 24
5.8.2.6 Registres d’identification des sources d’interruptions .................................................................... 24
5.8.3
Sources d’interruption pour les périphériques..................................................................................... 25
5.8.4
Table des vecteurs d’interruptions ...................................................................................................... 26
5.8.5
Exemple : Contenu de la mémoire de programme (PM, block 0) ....................................................... 27
Bibliographie
SEQUENCEUR DE PROGRAMME
Page 1
5. SÉQUENCEUR DE PROGRAMME
5.1
INTRODUCTION
Le séquenceur de programme contrôle le déroulement du programme en cours en
déterminant l’adresse de la prochaine instruction à exécuter. Le déroulement d’un
programme est principalement linéaire grâce à une exécution séquentielle des instructions.
Ce déroulement peut être modifié par l’utilisation d’une structure non séquentielle c'est-àdire que le programme ne suit pas la suite des instructions placées en mémoire de
programme (PM). Les structures non séquentielles se présentent sous la forme de cinq cas
particuliers :
LINEAR FLOW
AD DRESS:
LOOP
JUMP
N
I NSTRUCTION
D O UN TIL
N+1
I NSTRUCTION
I NSTRUCTION
I NSTRUCTION
N+2
I NSTRUCTION
I NSTRUCTION
I NSTRUCTION
N+3
I NSTRUCTION
I NSTRUCTION
N+4
I NSTRUCTION
I NSTRUCTION
I NSTRUCTION
N+5
I NSTRUCTION
I NSTRUCTION
I NSTRUCTION
SUBROUTINE
JUM P
N TI M ES
INTERRUPT
I NSTRUCTION
IDLE
IRQ
CAL L
I NSTRUCTION
ID LE
I NSTRUCTION
I NSTRUCTION
I NSTRUCTION
I NSTRUCTION
I NSTRUCTION
WAI TIN G
FOR IRQ
I NSTRUCTION
VECTOR
I NSTRUCTION
…
…
I NSTRUCTION
I NSTRUCTION
I NSTRUCTION
I NSTRUCTION
I NSTRUCTION
I NSTRUCTION
I NSTRUCTION
I NSTRUCTION
I NSTRUCTION
RTS
RTI
I NSTRUCTION
Figure 5-1 : Déroulement général d’un programme
Boucle :
(Loop). Une séquence d’instructions est exécutée plusieurs fois avec
un minimum de cycles additionnels (low overhead) dû à une gestion
optimisée de la boucle.
Sous-Routine : (Subroutine). Interruption de l’exécution séquentielle du programme
pour exécuter une partie spécifique de programme dans une zone
mémoire non contigüe suivie d’un retour à l’instruction suivant
l’interruption.
Saut :
(Jump). Interruption de l’exécution séquentielle du programme pour
une autre exécution séquentielle dont le départ se trouve à un autre
endroit de la mémoire, sans retour.
Interruption : (Interruption). Interruption du déroulement séquentielle du programme
par un événement dont l’apparition n’est pas prédictible. La suite du
déroulement du programme est propre à l’événement déclencheur. Une
Page 2
fois la routine exécutée, le déroulement initial du programme est repris
là où il a été interrompu.
Veille :
(Idle). Instruction particulière provoquant la mise en veille du
processeur notamment en limitant sa consommation. Le processeur
sort de son état de veille lorsqu’une interruption apparaît.
La Figure 5-1 illustre les cinq cas de rupture d’exécution séquentielle du programme.
Pour pouvoir réaliser les fonctions qui lui sont attribuées, c'est-à-dire déterminer l’ordre
d’exécution des instructions du programme, le séquenceur de programme doit être capable
d’exécuter les tâches listées ci-dessous.
−
−
−
−
−
−
−
Incrémenter l’adresse de recherche des instructions (fetch address).
Gérer les piles (PC, compteur, registres d’état, …).
Evaluer les conditions subordonnées aux instructions [IF COND].
Décrémenter le compteur de boucle.
Calculer les nouvelles adresses.
Gérer les instructions en cache.
Gérer les interruptions.
Pour accomplir toutes ces tâches, le séquenceur de programme a la structure donnée par la
Figure 5-2
ADSP-2199X
DSP SPECIFIC
ADSP-2199X DSP CORE
(COMMON TO ADSP-219X FAMILY)
PM DATA BUS
PROGRAMMABLE
FLAGS
COUNTER EXPIRED (CE)
ST ATUS &
CO NDITI ON
ADDRESS
FROM DAGS
ARITHMETIC STATUS
LOOP STAT US
INSTR CACHE
PC STATUS
I NSTRLATCH
LOOP & BRANCH
CONTROL
+
INTERRUPTS
INTERRUPT CONTROLLER
VECTOR
ADDR
LOOP STACK
IND
DIR PC- REL
BRAN BRAN BRAN
LOOP
ADDR
PC STACK
RT
ADDR
+1
RB INCR
ADDR ADDR
INSTRUCTION PIPELINE
LO O K AHEAD A DDRESS (LA )
PREFETC H ADDRESS ( PA )
FETCH ADDRESS (FA )
DMA REQUESTS
ADD RESS DECO DE (A D)
DM A CONTROLLER
INSTRUCT IO N DECO DE (ID )
EXECUTE (PC)
PM ADDRESS BUS
Figure 5-2 : Architecture du séquenceur de programme
STACK
ADDRESS
Page 3
Note sur les grandeurs d’entrées du multiplexeur
IND. BRAN
: Branchement indirect (JUMP (Ireg))
DIR. BRAN
: Branchement direct
(LJUMP <adresse absolue 24 bits>)
PC_REL. BRAN
: Branchement relatif (JUMP <adresse relative 16 bits>)
LOOP ADDR
: Adresse issue des piles de boucle (LOOP BEGIN, LOOP END)
RT. ADDR
: Branchement de retour de sous routine (RTS, RTI)
RB. ADDR
: Maintien de l’adresse en cours (Idle)
INCR. ADDR
: Incrémentation (déroulement séquentiel PC=PC+1)
Le séquenceur d’adresses contrôle le multiplexeur afin de fournir la valeur de l’adresse de la
prochaine instruction à aller chercher en mémoire programme (Fetch) à partir de plusieurs
sources d’adresse possible. L’adresse sélectionnée entre dans le pipeline des instructions
(Look Ahead Address) pour finir sur le multiplexeur lié au bus d’adresses de la mémoire de
programme (PMA : PM Address Bus).
Le pipeline contient l’adresse (24 bits) de l’instruction courante à aller chercher en mémoire
de programme PM puis le décodage de l’instruction en question et enfin son exécution.
Toutes les adresses générées par le séquenceur de programme sont des adresses de 24 bits
de la mémoire de programme PM contenant les instructions du programme.
La gestion des événements susceptibles de modifier la séquence du programme est réalisée
par le contrôleur d’interruption qui détermine si une source d’interruption est masquée ou
non et par conséquent génère l’adresse du vecteur d’interruption appropriée.
Grâce à un bloc de mémoire cache, le DSP peut accéder en un seul cycle d’horloge à :
− des données dans la mémoire de programme PM et rechercher une instruction sans
conflit de bus PM,
− des données et rechercher une instruction dans le même bloc mémoire sans conflit de
bloc.
La source d’adresse pour un branchement indirect peut être un des générateurs d’adresses
DAG.
Le séquenceur de programme évalue la séquence des adresses du programme faisant suite à
des instructions conditionnelles [IF COND] et la suite des adresses dans des boucles qui
peuvent être imbriquées.
Les registres du séquenceur de programme sont des registres du groupe 1 (Reg1), 2 (Reg2)
et 3 (Reg3). Ces registres sont accessibles en écriture et/ou en lecture par les registres Dreg.
Le compteur de programme PC est indirectement accessible en lecture et en écriture par
l’intermédiaire des registres STACKA et STACKP et des instructions PUSH PC et POP PC.
GROUPES DE REGISTRES
Reg0 (Dreg)
Reg1 (G1reg)
Reg2 (G2reg)
Reg3 (G3reg)
AX0
AX1
MX0
MX1
AY0
AY1
MY0
MY1
MR2
SR2
I0
I1
I2
I3
M0
M1
M2
M3
L0
L1
I4
I5
I6
I7
M4
M5
M6
M7
L4
L5
ASTAT(1) (2) (9)
MSTAT(1) (2) (7)
SSTAT(1) (2) (8)
LPSTACKP(2) (9)
CCODE(1) (2) (4)
SE
SB
PX(2)
(9)
DMPG1(2) (8)
DMPG2(2) (8)
Page 4
GROUPES DE REGISTRES
Reg0 (Dreg)
Reg1 (G1reg)
Reg2 (G2reg)
Reg3 (G3reg)
AR
SI
MR1
SR1
MR0
SR0
L2
L3
IMASK(1)
IRPTL(1)
ICNTL(1)
STACKA
L6
L7
Reservé
Reservé
CNTR
LPSTACKA
IOPG(2)
(8)
(2)
IJPG
(8)
Reservé
Reservé
Reservé
STACKP(1) (8)
Tableau 5-1 : Groupes de registres
Note 1 :
Note 2 :
registres de contrôle de l’ADSP21992
Les chiffres entre parenthèses correspondent aux nombres de bits si le registre n’a pas 16 bits
Un set de registres (ASTAT, MSTAT, CCODE, IMASK, IRPL et ICNTL) permet la
configuration du séquenceur de programme ou du contrôleur d’interruptions. L’écriture de
valeurs dans ces registres ne modifie pas immédiatement le comportement du système.
Registre
Description
Bits
Nombre de
cycles de latence
CNTR
IJPG
IOPG
DMPG1
DMPG2
Compteur de boucle
Page pour les sauts relatifs (8 bits MSB)
Page pour les I/0 (8 bits MSB)
Page associée à DAG1 (8 bits MSB)
Page associée à DAG2 (8 bits MSB)
16
8
8
8
8
11
1
1
1
1
Tableau 5-2 : Temps de latence en écriture des registres de séquenceur de programme
Note 1 :
1 cycles de latence avant une condition IF NOT CE, sans cycle de latence pour les autres instructions
Registre
Description
Bits
Nombre de
cycles de latence
ASTAT
MSTAT
SSTAT
CCODE
IRPTL
IMASK
ICNTL
CACTL
Registre d’état arithmétique
Registre de mode
Registre d’état du système
Registre de conditio
Registre de mémorisation des interruptions
Registre de masque d’interruption
Registre de contrôle d’interruption
Registre de contrôle de la mémoire cache
9
7
8
16
16
16
16
3
1
01
N/A
1
1
1
1
52
Tableau 5-3 : Temps de latence en écriture des registres de séquenceur de programme
Note 1 :
L’utilisation de l’instruction ENA MODE et DIS MODE
5.2
Page 5
PIPELINE DES INSTRUCTIONS
Lorsqu’une adresse est émise sur les bus de programme et de donnée, il faut deux cycles
d’horloge avant que les données soient exploitables dans le cœur du DSP. C’est la raison
pour laquelle l’étage LA génère l’adresse de la mémoire de programme PM permettant à
l’étage FA d’aller chercher l’instruction et l’adresse (PM ou DM) permettant à l’étage AD
de lire la donnée dans le cycle du compteur de programme PC.
Le séquenceur de programme détermine l’adresse de la prochaine instruction en examinant
le résultat de l’exécution de l’instruction courante corrélée avec l’état des divers flags du
processeur. Si aucune condition ne l’impose, le DSP exécute les instructions dans un ordre
séquentiel par incrémentation de l’adresse définie dans l’étage LA du pipeline.
Les différents étages du pipeline est les suivants :
Look-Ahead Address (LA) : le séquenceur de programme détermine la source de l’adresse
de la prochaine instruction à l’aide du multiplexeur (look-ahead address multiplexer).
Prefetch Address (PA), Fetch Address (FA) : le séquenceur de programme lit l’instruction
à exécuter dans la mémoire cache ou dans la mémoire de programme.
Address Decode (AD), Instruction Decode (ID) : Le séquenceur de programme décode
l’instruction ainsi que les conditions contrôlant l’exécution de ladite instruction.
Exécute PC : le DSP exécute l’instruction en un cycle d’horloge
Ces cycles se superposent dans le pipeline de manière à avoir, à quelques exceptions près,
un flux permettant l’exécution d’une instruction par cycle d’horloge.
Cycles
LA
PA
FA
AD
ID
PC
1
0x08 >>
2
0x09 >>
0x08 >>
3
0x0A >>
0x09 >>
0x08 >>
4
0x0B >>
0x0A >>
0x09 >>
0x08 >>
5
0x0C >>
0x0B >>
0x0A >>
0x09 >>
0x08 >>
6
0x0D >>
0x0C >>
0x0B >>
0x0A >>
0x09 >>
0x08
7
0x0E >>
0x0D >>
0x0C >>
0x0B >>
0x0A >>
0x09
8
0x0F >>
0x0E >>
0x0D >>
0x0C >>
0x0B >>
0x0A
Tableau 5-4 : Cycles d’exécution du pipeline
5.3
Page 6
MÉMOIRE CACHE D’INSTRUCTIONS
Dans des conditions normales, le séquenceur de programme va chercher une instruction en
mémoire à chaque cycle d’horloge. Il arrive cependant que des contraintes liées à
l’occupation du bus provoquent un conflit entre la recherche d’une instruction et d’une
donnée, conflit qui peut généralement être réglé en utilisant de la mémoire cache.
Des conflits se produisent dans les situations suivantes :
− Le DSP doit exécuter une instruction qui demande un accès à une donnée dans la
mémoire de programme (utilisation du bus PM). Dans ce cas il y a un conflit de bus
car le séquenceur de programme utilise le bus PM pour aller chercher une instruction
(fetch).
− Le DSP doit exécuter une instruction qui demande un accès à une donnée dans la
mémoire de donnée (utilisation du bus DM), mais dans le même bloc de mémoire que
l’instruction recherchée par le séquenceur de programme. Dans ce cas il y a un conflit
de bloc car les deux bus ne peuvent pas atteindre le même bloc simultanément.
Pour éviter les conflits de bus et de bloc, le DSP met en cache les instructions qui créent un
conflit de manière à réduire les délais. La gestion de la mémoire cache ne demande aucune
intervention, excepté les commandes de son activation / désactivation.
La première fois que le DSP rencontre un conflit, il doit attendre un cycle avant d’aller
chercher l’instruction suivante. Dans ce cas le DSP écrit automatiquement l’instruction qui
a crée le conflit dans la mémoire cache de manière à éviter que le même conflit se
reproduise.
Le séquenceur de programme inspecte la mémoire cache à chaque conflit de bus ou de bloc.
Si l’instruction recherchée est en cache le DSP va aller la chercher à cet endroit, libérant du
même coup l’accès du bus PM ou du bloc mémoire dans lequel se trouve la donnée. Dans
ce cas il n’y a pas de cycle d’horloge additionnel. Si l’instruction recherchée n’est pas en
cache le DSP va l’écrire pour la prochaine fois.
La Figure 5-3 montre l’architecture de la mémoire cache d’instructions. La mémoire cache
supporte 64 paires « instruction – adresse » placées dans 32 groupes (set 0 à 31). Les
adresses de chaque groupe ont en commun leurs 5 derniers bits (4 – 0). Chaque paire
« instruction – adresse » est associée à un bit (Valid Bit) indiquant si la paire en question est
valide ou non. Enfin un dernier bit (LRU : Least Recently Used) indique laquelle des paires
« instruction – adresse » du groupe n’a pas été utilisée lors du dernier accès au groupe en
question. En d’autres mots le bit LRU indique la paire « instruction – adresse » qui pourrait
être remplacée par une nouvelle paire lors d’un conflit non résolu.
La paire « instruction – adresse » est placée dans la mémoire cache en fonction des 5
derniers bits de l’adresse. Lorsque le séquenceur de programme inspecte la mémoire cache
suite à un conflit, il utilise ces 5 derniers bits d’adresse comme un index pour pointer le bon
groupe. Dans le groupe, le séquenceur de programme vérifie l’adresse et l’état du bit
« Valid Bit ». Si le groupe contient la bonne instruction, le séquenceur de programme utilise
l’instruction de la paire « instruction – adresse » et met à jour le bit « LRU » pour indiquer
la paire « instruction – adresse » qui ne satisfait pas la demande.
Lorsque la mémoire cache ne contient pas l’instruction recherchée, le DSP charge une
nouvelle paire « instruction – adresse » dans la position correspondant à la paire
« instruction – adresse » qui n’a pas été utilisée précédemment et inverse le bit « LRU ».
Page 7
LRU
BIT
SET 0
VALID
BIT
INSTRUCTIONS
ADDRESSES
BITS (23-5)
ENTRY 0
ADDR ESSES
BITS (4-0)
00000
ENTRY 1
SET 1
ENTRY 0
00001
ENTRY 1
SET 2
ENTRY 0
00010
ENTRY 1
SET 29
ENTRY 0
11101
ENTRY 1
SET 30
ENTRY 0
11110
ENTRY 1
SET 31
ENTRY 0
11111
ENTRY 1
Figure 5-3 : Architecture de la mémoire cache
5.3.1
Configuration de la mémoire cache
Après un Reset, la mémoire cache est activée et ne contient aucune paire « instruction –
adresse ». Dès cet instant le registre CACTL contrôle le mode opératoire de la mémoire
cache. Comme pour les autres registres de contrôle, le registre CACTL est accessible via les
instructions reg(CACTL)=dreg et dreg=reg(CACTL).
7 6 5 4 3 2 1 0
1 0 1 0 0 0 0 0
Reset = b#101n nnnn
Reserved
CDE (Cache fetches with memory block
accesses conflicting DMDAs enable)
0 = Disable
1 = Enable
CFZ (Cache freeze)
0 = Thaw (allows cache to update)
1 = Freeze
CPE (Cache fetches with memory block
accesses conflicting with PMDAs enable)
0 = Thaw (allows cache to update)
1 = Freeze
Figure 5-4 : Registre de contrôle de la mémoire cache
Les bits du registre de contrôle CACTL de la mémoire cache ont les rôles suivants :
Cache pour accès au bus de données DM, CACTL[5]. Si le bit CACTL[5] (CDE) vaut
« 1 » la mémoire cache est utilisée pour gérer les conflits sur le bus de données DM. Si le
bit CACTL[5] (CDE) vaut « 0 » les conflits sur le bus de données DM ne sont pas gérés.
Gèle de la mémoire cache, CACTL[6]. Si le bit CACTL[6] (CFZ) vaut « 1 » le contenu de
la mémoire cache est gelé, c'est-à-dire que le contenu ne peut plus être modifié mais les
conflits de bus et de blocs sont gérés en accord avec le contenu de la mémoire cache. Si le
Page 8
bit CACTL[5] (CFZ) vaut « 0 » non seulement les conflits de bus et de blocs sont gérés
mais la mémoire cache est mis à jour.
Cache pour accès au bus de programme PM, CACTL[7]. Si le bit CACTL[7] (CPE) vaut
« 1 » la mémoire cache est utilisée pour gérer les conflits sur le bus de programme PM. Si le
bit CACTL[5] (CPE) vaut « 0 » les conflits sur le bus de programme PM ne sont pas gérés.
Après un Reset, les bits CDE et CPE sont mis à « 1 » alors que le bit CFZ est mis à « 0 »
5.4
Page 9
LES MULTI-INSTRUCTIONS
5.4.1
Généralités
5.4.2
Opération dans l’unité de calcul et double accès en mémoire
Le groupe d’instruction (3) exprimé par 5.1 combine une opération arithmétique réalisée
par l’ALU ou le MAC, avec une lecture de la mémoire de donnée (DM) vers un registre
d’entrée (X) et une lecture de la mémoire de programme (PM) vers un registre d’entrée (Y).
⎛ I0
⎜
ALU
⎜ I1
,
= DM ⎜ + =
I2
MAC MX 0
⎜
⎜
MX 1
⎝ I3
AX 0
AX 1
M0 ⎞
⎟
M1 ⎟
,
M2⎟
⎟
M 3 ⎟⎠
⎛ I4
⎜
⎜ I5
= PM ⎜ + =
MY 0
I6
⎜
⎜
MY1
⎝ I7
AY 0
AY 1
M4⎞
⎟
M5 ⎟
;
M6 ⎟
⎟
M 7 ⎟⎠
5.1
L’opération arithmétique est réalisée en début de cycle, les lectures des mémoires ayant lieu
simultanément en fin de cycle. Si aucun conflit n’est détecté les trois instructions sont
exécutées en un cycle d’horloge. Dans le cas contraire le nombre de cycles peut être de
deux, voir trois.
5.4.3
Double accès en mémoire
Le groupe d’instruction (2) exprimé par 5.2 combine deux opérations de lecture, une dans le
mémoire de donnée (DM), l’autre dans la mémoire de programme (PM). Les registres de
lecture de la mémoire de donnée correspondent à l’entrée (X) de l’ALU ou du MAC alors
que les registres de lecture de la mémoire de programme correspondent à l’entrée (Y) de
l’ALU ou du MAC.
⎛ I0
⎜
⎜ I1
= DM ⎜ + =
MX 0
I2
⎜
⎜
MX 1
⎝ I3
AX 0
AX 1
M0 ⎞
⎟
M1 ⎟
,
M2⎟
⎟
M 3 ⎟⎠
⎛ I4
⎜
⎜ I5
= PM ⎜ + =
MY 0
I6
⎜
⎜
MY1
⎝ I7
AY 0
AY 1
M4⎞
⎟
M5 ⎟
;
M6 ⎟
⎟
M 7 ⎟⎠
5.2
Les lectures des mémoires ayant lieu simultanément en fin de cycle. Si aucun conflit n’est
détecté les trois instructions sont exécutées en un cycle d’horloge. Dans le cas contraire le
nombre de cycles peut être de deux, voir trois.
5.4.4
Opération dans l’unité de calcul et lecture en mémoire
par l’ALU, le MAC ou le BS avec une opération de lecture dans le mémoire de donnée
(DM). Le registre de lecture de la mémoire de donnée appartient au groupe des registres de
données DREG.
Page 10
⎛ I0
⎜
⎜ I1
⎜ I2
⎜
ALU
⎜ I3
MAC , DREG = DM ⎜ + =
⎜ I4
SHIFT
⎜ I5
⎜
⎜ I6
⎜ I7
⎝
M0 ⎞
⎟
M1 ⎟
M2⎟
⎟
M3 ⎟
⎟;
M4⎟
M5 ⎟
⎟
M6 ⎟
M 7 ⎟⎠
5.3
L’opération arithmétique est réalisée en début de cycle, la lecture des mémoires ayant lieu
en fin de cycle. Si aucun conflit n’est détecté les deux instructions sont exécutées en un
cycle d’horloge. Dans le cas contraire le nombre de cycles est de deux.
5.4.5
Opération dans l’unité de calcul et écriture en mémoire
Le groupe d’instruction (2) exprimé par 5.4 combine une opération d’écriture en mémoire
de donnée (DM) et une opération arithmétique réalisée par l’ALU, le MAC ou le BS. Le
registre d’écriture de la mémoire de donnée appartient au groupe des registres de données
DREG.
⎛ I0
⎜
⎜ I1
⎜ I2
⎜
⎜ I3
DM ⎜ + =
⎜ I4
⎜ I5
⎜
⎜ I6
⎜ I7
⎝
M0 ⎞
⎟
M1 ⎟
M2⎟
⎟
ALU
M3 ⎟
⎟ = DREG, MAC ;
M4⎟
SHIFT
M5 ⎟
⎟
M6 ⎟
M 7 ⎟⎠
5.4
Les deux opérations sont réalisées en début de cycle. Si aucun conflit n’est détecté les deux
instructions sont exécutées en un cycle d’horloge. Dans le cas contraire le nombre de cycles
est de deux.
5.4.6
Opération dans l’unité de calcul et transfert registre à registre
par l’ALU, le MAC ou le BS et un transfert de donnée de registre à registre. Les registres
utilisés pour le transfert de donnée appartiennent au groupe des registres de données DREG.
ALU
MAC
SHIFT
, DREG1 = DREG 2 ;
5.5
5.5
5.5.1
Page 11
BRANCHEMENTS
Branchements de type saut (JUMP) et appel de sous routines (CALL)
Une instruction de saut JUMP ou d’appelle de sous routine CALL/RTS permet de transférer
l’exécution séquentielle du programme dans une autre partie de la mémoire. La différence
entre les instructions JUMP et CALL réside dans le fait que, pour une instruction CALL, le
pointeur de programme (PC), après incrémentation est automatiquement sauvé dans la pile
PC Stack (PUSH PC). Lors de l’instruction RTS, le pointeur de programme prend la
dernière valeur sauvée dans la pile (POP PC), qui n’est rien d’autre que l’adresse de retour
au programme suivant l’instruction CALL. L’instruction de retour (RTS) permet au
séquenceur de programme de déterminer l’endroit où il doit aller chercher la prochaine
instruction à exécuter.
Le programme peut spécifier un certain nombre de paramètres lors d’un saut de type JUMP
ou CALL.
− Les instructions JUMP et CALL/RTS peuvent être immédiates ou retardées. En effet
les instructions contenues dans le pipeline imposent un retard de 4 cycles d’horloge.
Dans le cas d’un branchement retardé seuls deux cycles d’horloge sont effectifs.
− Les instructions JUMP et CALL/RTS peuvent se trouver à l’intérieur d’une boucle
D0/UNTIL finie (CE) or infinie (FOREVER) mais jamais en dernière position de la
boucle (là où se trouve l’étiquette (label) de fin de boucle).
− Les instructions JUMP et CALL/RTS peuvent être conditionnelles ([IF COND]). Le
séquenceur de programme peut évaluer si la condition est remplie à l’aide des flags
d’état contenus dans les registres ASTAT et MSTAT, ICNTL, CCODE. Si aucune
condition n’est spécifiée, le branchement est toujours pris en compte.
5.5.1.1 Branchements immédiats
Les branchements peuvent être directs ou indirects. Dans le premier cas, c’est le séquenceur
de programme qui génère l’adresse (voir Figure 5-2 multiplexeur DIR BRAN), dans le
second cas c’est le générateur d’adresse DAG2 (voir Figure 5-2 multiplexeur IND BRAN)
qui fournit l’adresse de la prochaine instruction.
Les branchements directs dont l’adresse est fixée par une valeur absolue ou une étiquette
(label) font usage soit d’une adresse relative sur 16 bits (le saut s’effectue à l’intérieur d’une
page de 64Kx24bits) ou d’une adresse absolue de 24 bits
− Branchement direct
JUMP fft1024 ;
CALL 23 ;
LJUMP 0x234567 ;
// saut à l’adresse absolue fft1024 (16bits)
// saut à l’adresse 23 décimal
// saut à l’adresse absolue 0x234567 (24 bits)
− Branchement indirect
JUMP (I6) ;
CALL (I7) ;
// saut indirect à l’adresse définie dans I6 (DAG2) et IJPG
// saut indirect à l’adresse définie dans I7 (DAG2) et IJPG
Dans le cas d’un branchement indirect, les 16 bits de poids faibles de l’adresse sont pris
dans le registre d’index Ix du générateur d’adresse DAG2 alors que les 8 bits de poids fort
sont déterminés par le contenu du registre de page IJPG.
Il est possible de réaliser des branchements conditionnels dont la forme des instructions est
la suivante :
Page 12
IF [COND] JUMP (I6) ; // saut indirect conditionnel
IF [COND] CALL (I7) ; // saut indirect conditionnel
Le pipeline des instructions influence la manière avec laquelle les branchements sont
supportés. Pour le branchement immédiat les instructions JUMP et CALL/RTS ne
spécifient rien quant au délai d’exécution, il y a 4 cycles d’horloge de perdus. Ces quatre
cycles correspondent au contenu du pipeline (phase de recherche (PA : Prefetch Address et
FA : Fetch Address) et de décodage (AD : Address Decode et ID : Instruction Decode). Ces
quatre phases sont remplacées par des instructions NOP (No OPeration). Ces quatre cycles
permettent au pipeline d’aller chercher et de décoder la première instruction suivant le
branchement.
Cycles
1
2
3
4
5
6
LA
j
j+1
j+2
j+3
j+4
j+5
PA
n+4→NOP
j
j+1
j+2
j+3
j+4
FA
n+3→NOP
n+4→NOP
j
j+1
j+2
j+3
AD
n+2→NOP
n+3→NOP
n+4→NOP
j
j+1
j+2
ID
n+1→NOP
n+2→NOP
n+3→NOP
n+4→NOP
j
j+1
PC
n
NOP
NOP
NOP
NOP
j
Tableau 5-5 : Séquence dans le pipeline lors d’une instruction JUMP ou CALL
Cycles
1
2
3
4
5
6
LA
r
r+1
r+2
r+3
r+4
r+5
PA
n+4→NOP
r
r+1
r+2
r+3
r+4
FA
n+3→NOP
n+4→NOP
r
r+1
r+2
r+3
AD
n+2→NOP
n+3→NOP
n+4→NOP
r
r+1
r+2
ID
n+1→NOP
n+2→NOP
n+3→NOP
n+4→NOP
r
r+1
PC
n
NOP
NOP
NOP
NOP
r
Tableau 5-6 : Séquence dans le pipeline lors d’une instruction RTS
5.5.1.2 Branchements retardés
Il est possible d’éviter un retard de 4 cycles d’horloge en effectuant un branchement retardé.
Dans ce cas les deux instructions suivants directement le branchement sont effectuées avant
le branchement proprement dit
JUMP fft1024 (DB) ;
AR=AX0+AY0 ;
DM(I0)=AR ;
…
Fft1024 : …
MX0=DM(I4+=M4) ;
RTS ;
MY0=DM(I4+=M4) ;
MR=MR+MX0*MY0 (SS) ;
// saut à l’adresse absolue fft1024 (16bits)
// première instruction exécutée avant le branchement
// deuxième instruction exécutée avant le branchement
// première instruction après le branchement
// instruction de branchement (retour)
// première instruction exécutée avant le branchement
// deuxième instruction exécutée avant le branchement
On gagne ainsi en efficacité, au détriment de la lisibilité du programme.
Cycles
1
2
3
4
5
6
LA
j
j+1
j+2
j+3
j+4
j+5
Page 13
PA
n+4→NOP
j
j+1
j+2
j+3
j+4
FA
n+3→NOP
n+4→NOP
j
j+1
j+2
j+3
AD
n+2
n+3→NOP
n+4→NOP
j
j+1
j+2
ID
n+1
n+2
n+3→NOP
n+4→NOP
j
j+1
PC
n
n+1
n+2
NOP
NOP
j
Tableau 5-7 : Séquence dans le pipeline lors d’une instruction JUMP ou CALL retardée
Cycles
1
2
3
4
5
6
LA
r
r+1
r+2
r+3
r+4
r+5
PA
n+4→NOP
r
r+1
r+2
r+3
r+4
FA
n+3→NOP
n+4→NOP
r
r+1
r+2
r+3
AD
n+2
n+3→NOP
n+4→NOP
r
r+1
r+2
ID
n+1
n+2
n+3→NOP
n+4→NOP
r
r+1
PC
n
n+1
n+2
NOP
NOP
r
Tableau 5-8 : Séquence dans le pipeline lors d’une instruction RTS retardée
Il y a un certain nombre de restrictions quant à l’utilisation des branchements retardés. En
effet les instructions suivant directement l’instruction de branchement :
− ne doivent pas être d’autres instructions de branchement (JUMP, CALL, RTS, …),
− ne doivent pas être des instructions manipulant les piles (PUSH, POP ou écriture
dans la pile du PC),
− ne doivent pas être des opérations initiant des boucles (D0/UNTIL) ou d’arrêt (IDLE),
− ne doivent être des instructions demandant deux cycles d’horloge à moins que ces
instructions apparaissent directement après l’instruction de branchement.
5.5.2
Branchements de type boucle DO/UNTIL
Les boucles DO/UNTIL représentent un type de déroulement du programme de manière
non séquentielle. La boucle peut avoir un nombre d’itérations fini grâce à la condition CE
(Counter Empty) du compteur de boucle ou infini (FOREVER).
L’instruction DO/UNTIL utilise les propriétés du séquenceur de boucle et la condition CE.
Les boucles sont efficaces du point de vue software. Il n’y a pas d’instructions
additionnelles de décrémentation de compteur ou de branchement et de condition.
L’exemple de code ci-dessous donne une idée de la simplicité de l’élaboration de boucle.
CNTR=30 ;
DO Fin_de_boucle UNTIL CE ;
AX0=DM(I0+=M0), AY0=PM(I4+=M4) ;
AR=AX0+AY0 ;
Fin_de_boucle : DM(I1+=M0)=AR ;
// compteur de boucle à 30
// condition de réalisation de la boucle
// multi instructions
// opération dans l’ALU
// dernière ligne de la boucle
Lors de l’exécution de l’instruction DO/UNITL, le séquenceur de programme envoie
l’adresse de début de boucle et l’adresse de fin de boucle dans respectivement les piles de
boucle LOOP BEGIN STACK et LOOP END STACK.
Les instructions étant contenues dans le pipeline, dans le cas d’une boucle, le séquenceur de
programme doit tester la condition de fin de boucle et décrémente le compteur à la fin de
Page 14
chaque boucle. Si la condition du test est fausse, le séquenceur provoque la répétition de la
boucle. Si la condition est vraie, le séquenceur sort de la boucle et met à jour les piles de
boucle LOOP BEGIN STACK et LOOP END STACK.
Contenu du pipeline lors d’une itération (pas de sortie de boucle)
Cycles
1
2
3
4
5
6
7
LA
e1
b2
b+1
b+2
b+3
b+43
b+5
PA
e-1
e
b
b+1
b+2
b+33
b+4
FA
e-2
e-1
e
b
b+1
b+23
b+3
AD
e-3
e-2
e-1
e
b
b+13
b+2
ID
e-4
e-3
e-2
e-1
e
b3
b+1
PC
e-5
e-4
e-3
e-2
e-1
e3
b
Tableau 5-9 : Séquence dans le pipeline lors d’une itération de boucle
1 : Test de condition de fin de boucle faux (retour en début de boucle pour le passage suivant)
2 : Adresse de début de boucle
3 : Pour des boucles de moins de 6 instructions (inférieur à la taille du pipeline), le pipeline retient les instructions de la
boucle (e à b+4). Lors de la première itération d’une telle boucle, il y a introduction de 4 NOP avant que le pipeline
soit dans la bonne configuration
Contenu du pipeline lors d’une sortie de boucle
Cycles
1
2
3
4
5
6
7
LA
e1
e+1
e+2
e+3
e+4
e+5
e+6
PA
e-1
e
e+1
e+2
e+3
e+4
e+5
FA
e-2
e-1
e
e+1
e+2
e+3
e+4
AD
e-3
e-2
e-1
e
e+1
e+2
e+3
ID
e-4
e-3
e-2
e-1
e
e+1
e+2
PC
e-5
e-4
e-3
e-2
e-1
e
e+12
Tableau 5-10 : Séquence dans le pipeline lors d’une sortie de boucle
1 : Test de condition de fin de boucle vrai (sortie de la boucle)
2 : Fin de boucle et mise à jour des piles LOOP BEGIN STACK et LOOP END STACK
Pour avoir une efficacité maximum, c'est-à-dire avoir un nombre de cycles d’horloges aussi
petit que possible (low overhead), le DSP contient trois piles distinctes pour les boucles, soit
les piles LOOP BEGIN STACK et LOOP END STACK et COUNTER. Le séquenceur de
programme contrôle ces piles lors de l’entrée dans la boucle (DO/UNTIL CE) et lorsqu’elle
se termine, c'est-à-dire lorsque le compteur arrive à « 0 », Par contre lorsque la sortie de
boucle est le résultat d’un saut conditionnel (IF COND JUMP), les piles ne sont pas mises à
jour.
Il existe encore une restriction sur la fin de boucle. En effet la dernière instruction de boucle
ne peut pas être un appel de sous routine CALL/RTS ou un saut retardé JUMP (DB).
Pour les boucles imbriquées, les adresses de fin de boucles doivent être séparées les unes
des autres.
5.5.3
Page 15
Branchements conditionnels
Le tableau ci-dessous donne un aperçu des possibilités de branchement conditionnel.
Syntaxe
Condition
Vrai si
EQ
NE
LT
GE
LE
GT
AC
NOT AC
AV
NOT AV
MV
NOT MV
=0
≠0
<0
≥0
≤0
>0
Carry = 1
Carry = 0
Dépassement ALU
Pas de dépassement ALU
Dépassement MAC
Pas de dépassement MAC
Compare valeur dans le
registre CCODE avec
PF0 … PF13 = 1, AS, SV
Compare valeur dans le
registre CCODE avec
PF0 … PF13 = 0,
NOT AS, NOT SV
Compteur de boucle = 0
Compteur de boucle ≠ 0
Toujours vrai (DO/UNTIL)
Toujours vrai (IF)
SWCOND
NOT SWCOND
CE
NOT CE
FOREVER
TRUE
DO/UNTIL
IF COND
AZ = 1
AZ = 0
AN XOR AV = 1
AN XOR AV = 0
(AN XOR AV) OR AZ = 1
(AN XOR AV) OR AZ = 0
AC = 1
AC = 0
AV = 1
AV = 0
MV = 1
MV = 0
-
V
V
V
V
V
V
V
V
V
V
V
V
CCODE = SWCOND
-
V
CCODE = NOT SWCOND
-
V
LOOP COUNTER = 0
LOOP COUNTER = NOT 0
V
V
-
V
V
Tableau 5-11 : Condition IF et boucle DO/UNTIL
V
-
5.5.4
: autorisée pour l’instruction en question
: non autorisée pour l’instruction en question
Branchements de type interruption
Le déroulement séquentiel du programme peut être interrompu par une interruption dont la
source provient du cœur du DSP ou des périphériques. Le DSP assigne un vecteur unique
pour chaque interruption. Les interruptions du cœur du DSP sont au nombre de 5 (Emulator,
Reset, Powerdown, Loop and PC Stack et Emulation Kernel). Les interruptions « Reset » et
« Emulator » sont non masquables. L’interruption Powerdown est uniquement masquable
par le flag GIE du registre ICNTL (contrôle globale des interruptions ICNTL[5]). Les
sources interruptions des périphériques sont au nombre de 12.
Pour plus de détails sur les interruptions, voir section 5.8
5.6
Page 16
GESTION DES PILES (STACK)
Le séquenceur de programme contient 5 piles (PC Stack, LOOP BEGIN Stack, LOOP END
Stack, COUNTER Stack et STATUS Stack). Ces piles préservent les informations sur le
déroulement du programme lors de branchement. La Figure 5-5 montre les relations
existantes entre eux et entre les registres à sauver et à restituer à l’aide des piles qui leur sont
dédiées.
Les différentes piles présentent les caractéristiques suivantes :
−
−
−
−
−
5.6.1
pile PC (PC Stack) : 33 mots × 24 bits
pile de début de boucle (LOOP BEGIN Stack) : 8 mots × 24 bits
pile de fin de boucle (LOOP END Stack) : 8 mots × 24 bits
pile du compteur de boucle (COUNTER stack) : 8 mots × 16 bits
pile d’état (Status stack) : 16 mots × 32 bits
Utilisation implicite des piles
Les opérations sur les piles peuvent être implicites, c'est-à-dire automatique selon les
branchements du programme.
5.6.1.1 Pile PC (PC Stack)
Sauvegarde et restaure le contenu du compteur de programme PC. Seules les instructions
CALL, RTI et RTS utilisent la pile PC
<interrupt> ;
RTI ;
CALL subroutine ;
RTS
// PC → la pile PC Stack
// PC Stack → PC
// PC+1→ la pile PC Stack
// PC Stack → PC
5.6.1.2 Piles de boucle (LOOP BEGIN Stack, LOOP END Stack, COUNT Stack)
Sauvegarde l’adresse de la première et de la dernière instruction d’une boucle ainsi que le
contenu du compteur de boucle. Seule l’instruction DO/UNTIL utilise les piles de boucle.
CNTR=Nb_iteration ;
DO end_loop UNTIL CE ;
…
…
end_loop :
// PC+1 → LOOP BEGIN Stack
// end_loop → LOOP END Stack
// CNTR → COUNT stack
// LOOP BEGIN Stack →
// LOOP END Stack →
// CNTR →
5.6.1.3 Pile d’état (Status stack) : 16 words × 32 bits
Sauvegarde la valeur courante des registres ASTAT et MSTAT. Seule l’instruction RTI
utilise la pile d’état. Lorsqu’une interruption est activée, le séquenceur de programme
sauvegarde automatiquement les registres ASTAT et MSTAT dans la pile d’état.
<interrupt> ;
RTI ;
// ASTAT : MSTAT → STATUS Stack
// STATUS Stack → ASTAT : MSTAT
Page 17
24 BITS
24 BITS
DO/ UNTIL
PC
LOOP-END-ADDRESS
(IMPLICIT PUSH)
DO/ UNTIL,
CALL,
8 BI TS
LOOP
ITERATE
OR
16 BI TS
:
STACKP
STACKA
8 BITS
LPSTACKP :
16 BI TS
16 BI TS
LPSTACKA
CNTR
OR
INTERRUPT
RETURN
(IMPLICIT PUSH)
(IMPLICIT POP)
PUSH PC
POP PC
OR
OR
LOOP
LOOP
(EXPLICIT
PUSH)
(EXPLICIT
POP)
PUSH
LOOP
POP
LOOP
POP
LOOP
(EXPLICIT
POP)
(EXPLICIT
POP)
DO
UNTIL
(EXPLICIT
PUSH)
(IMPLICIT
PUSH)
OR
PUSH LOOP
(EXPLICIT
PUSH)
PC STACK
LOOP BEGIN STACK
(33 ENTRIES)
(8 ENTRIES)
9 BITS
7 BITS
ASTAT
MSTAT
LOOP END STACK
COUNTER STACK
(8 ENTRIES)
(8 ENTRIES)
THE DSP USES THESE STACKS FOR:
INTERRUPT
RETURN
(IMPLICIT PUSH)
(IMPLICIT POP)
OR
• DO/ UNTIL LOOPS
• CALL/ RETURN INSTRUCTIONS
OR
PUSH STS
POP STS
(EXPLICIT PUSH)
(EXPLICIT POP)
• INTERRUPT SERVICE ROUNTINES
STATUS STACK
(16 ENTRIES)
Figure 5-5 : Piles contrôlées par le séquenceur de programme
5.6.2
Opérations explicites sur les piles
Il est possible de faire des opérations explicites sur les piles
5.6.2.1 Pile PC (PC Stack)
PUSH PC sauvegarde le contenu des registres STACKA (16 bits) et STACKP (8 bits)
STACKA=0x3521 ;
STACKP=0x20 ;
PUSH PC ;
// 16 bits des poids faibles d’adresse
// 8 bits des poids forts d’adresse
// sauvegarde dans la pile PC Stack
POP PC restaure le contenu des registres STACKA (16 bits) et STACKP (8 bits)
POP PC ;
AX0=STACKA ;
AY0=STACKP ;
// restaure les registre STACKA et STACKP
// 16 bits des poids faibles
// 8 bits des poids forts
Page 18
5.6.2.2 Piles de boucle (LOOP BEGIN Stack, LOOP END Stack, COUNT Stack)
PUSH LOOP sauvegarde le contenu des registres STACKA (16 bits) et STACKP (8 bits)
dans la pile LOOP BEGIN Stack, et le contenu du registre CNTR dans la pile COUNT
Stack. Les 16 bits de LPSTACKA sont sauvegardés dans les 16 bits de poids faibles de la
pile LOOP END Stack. Les 8 bits de poids faibles de LPSTACKP sont sauvegardés dans
les 8 bits de poids forts de la pile LOOP END Stack. Les bits 8 à 14 de LPSTACKP doivent
être forcés à « 0 ». Le 15ème bit (MSB) s’il est « 0 » défini la condition CE (boucle finie) ou
s’il est « 1 » la condition FOREVER (boucle infinie)
CNTR=27 ;
STACKA=0x3521 ;
STACKP=0x02 ;
LPSTACKA=0x3521 ;
LPSTACKP=0x0002 ;
PUSH LOOP ;
// nombre d’itérations de la boucle
// 16 bits des poids faibles d’adresse de début
// 8 bits des poids forts d’adresse de début
// 16 bits des poids faibles d’adresse de fin
// 8 bits des poids forts d’adresse de fin
// sauvegarde dans les piles LOOP BEGIN Stack,
// LOOP END Stack COUNT Stack
POP LOOP restaure le contenu des registres STACKA (16 bits), STACKP (8 bits)
LPSTACKA (16 bits), LPSTACKP (16 bits) et CNTR
POP LOOP ;
AX0=STACKA ;
AY0=STACKP ;
AX1=LPSTACKA ;
AY1=LPSTACKP ;
// restaure le contenu des piles LOOP BEGIN Stack,
// LOOP END Stack COUNT Stack
// 16 bits des poids faibles d’adresse de début
// 8 bits des poids forts d’adresse de début
// 16 bits des poids faibles d’adresse de fin
// 8 bits des poids forts d’adresse de fin
// AY1[15] contient la condition de boucle (0=CE, 1=FOREVER)
5.6.2.3 Pile d’état (Status stack) : 16 words × 32 bits
PUSH STS sauvegarde le contenu des registres ASTAT (9 bits) et MSTAT (7 bits) dans la
pile STATUS Stack
PUSH STS ;
// sauvegarde dans la pile STATUS Stack de ASTAT : MSTAT
POP STS restaure le contenu des registres ASTAT (9 bits) et MSTAT (7 bits)
POP STS ;
5.6.3
// restaure le contenu de la pile STATUS Stack
// dans les registres ASTAT et MSTAT
Etat des piles
Le registre d’état SSTAT permet de connaître l’état d’occupation de l’ensemble des piles.
− Pile PC vide. Le flag PCSTKEMPTY (SSTAT[0]) indique que la pile PC contient
au moins une adresse sauvée
− Pile PC pleine. Le Flag PCSTKFULL (SSTAT[1]) indique que la pile PC contient
au moins une position non occupée
− Niveau de la pile PC. Le flag PCSTKLVL (SSTAT[2]) indique que la pile PC
contient entre 3 et 28 positions occupées
− Pile de boucle vide. Le Flag LPSTKEMPTY (SSTAT[4]) indique que la pile de
boucle contient au moins une position occupée
− Pile de boucle pleine. Le Flag LPSTKFULL (SSTAT[5]) indique que la pile de
boucle contient au moins une position non occupée
Page 19
− Pile d’état vide. Le Flag STSSTKEMPTY (SSTAT[6]) indique que la pile d’état
contient au moins une position occupée
− Dépassement dans une ou plusieurs piles. Le Flag STKOVERFLOW (SSTAT[7])
indique qu’une pile au moins voit son contenu dépasser le nombre de positions
allouées
7 6 5 4 3 2 1 0
0 0 0 0 0 0 0 0
Reset = b#0000 0000
PCE(PC stack empty)
0 = PC stack has a pushed address
1 = PC stack is empty
PCF (PC stack full)
0 = PC stack has an empty location
1 = PC stack is full
PCL (PC stack level)
0 = PC stack has 3–28 pushed address
1 = PC stack has hit high/low watermark
Reserved
LSE(Loop stack empty)
0 = Loop stack has a pushed address
1 = Loop stack is empty LSF (Loop stack full)
LSF (Loop stack full)
0 = Loop stack has an empty location
1 = Loop stack is full SSE (Status stack empty)
SSE(Status stack empty)
0 = Status stack has a pushed status
1 = Status stack is empty SOV (Stack overflowed)
SOV (Stack overflowed)
0 = No stack overflow or underflow
1 = Stack overflow (PC, loop, counter, or status
or stack underflow (PC or status))
Figure 5-6 : Registre d’état des piles SSTAT
5.7
Page 20
RÉSUMÉ DES INSTRUCTIONS PROPRES AU SÉQUENCEUR DE PROGRAMME
Le tableau ci-dessous est un résumé des instructions propres au séquenceur de programme
Instruction
DO <Reladdr12> UNTIL [CE, FOREVER];
[IF COND] JUMP <Reladdr13> [(DB)];
CALL <Reladdr16> [(DB)];
JUMP <Reladdr16> [(DB)];
[IF COND] LCALL <Addr24>;
[IF COND] LJUMP <Addr24>;
[IF COND] CALL <Ireg> [(DB)];
[IF COND] JUMP <Ireg> [(DB)];
[IF COND] RTI [(DB)];
[IF COND] RTS [(DB)];
PUSH |PC, LOOP, STS|;
POP |PC, LOOP, STS|;
FLUSH CACHE;
SETINT <Imm4>;
CLRINT <Imm4>;
NOP;
IDLE;
ENA | MM, AS, OL, BR, SR, SD, INT |;
DIS | MM, AS, OL, BR, SR, SD, INT |;
Abréviations pour les flags de SSTAT :
Flag du registre d’état SSTAT
LE
LF
PE
PF
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
LE = LPSTKEMPTY
LF = LPSTKFULL
PE = PCSTKEMPTY
PF = PCSTKFULL
PL = PCSTKLVL
SE = STSSTKEMPTY
SO = STKOVERFLOW
Tableau 5-12 : Instructions propres au séquenceur
PL
*
*
*
*
*
*
*
*
-
SE
*
*
*
-
SO
*
*
*
*
*
*
*
*
-
5.8
5.8.1
Page 21
CONTRÔLEUR D’INTERRUPTIONS
Généralités
Le cœur de l’ADSP21992 gère 16 lignes d’interruption. Il y a 4 lignes dédiées aux
interruptions internes et 12 lignes liées aux interruptions des périphériques. Les sources
d’interruptions pouvant être générées par les périphériques sont au nombre de 32 dont plus
de la moitié sont réservées. Le contrôleur d’interruptions des périphériques est l’élément qui
fait le lien entre les 12 lignes d’interruption mises à disposition par le cœur de l’ADSP21992
et les 32 sources issues des périphériques.
Une interruption interne peut être déclenchée, par exemple, par une pile pleine (stack
overflow) ou lorsque le programme écrit (force un bit à 1) dans le registre de mémorisation
des interruptions IRPTL (interruption software).
Plusieurs facteurs contrôlent la réponse du DSP à une interruption. Le DSP répond à une
demande d’interruption si les conditions suivantes sont remplies :
−
−
−
−
le DSP est en train d’exécuter une instruction ou se trouve en état de veille (Idle),
l’interruption n’est pas masquée,
les interruptions sont globalement activées (GIE : ICNTL[5]),
une demande d’interruption avec une priorité plus élevée n’est pas pendante.
Lorsque le DSP répond à une interruption, le séquenceur de programme provoque un
branchement avec un call à l’adresse correspondante de la table des vecteurs d’interruption
selon le déroulement suivant :
− détermine l’adresse appropriée du vecteur d’interruption,
− sauve la prochaine valeur (adresse de retour) du compteur de programme (PC) dans
la pile PC (PC stack),
− sauve les valeurs courantes des registres ASTAT et MSTAT dans la pile d’état
(Status stack),
− force à « 0 » le bit correspondant à l’interruption activée dans le registre de
mémorisation des interruptions (IRPTL).
A la fin de la routine d’interruption, lors de l’exécution de l’instruction RTI, le séquenceur
de programme effectue les tâches suivantes :
− restaure la valeur (adresse de retour) du compteur de programme dans la dernière
position de la pile PC (PC stack),
− restaure les valeurs des registres ASTAT et MSTAT contenues dans les deux
dernières positions de la pile d’état (Status stack).
Les interruptions masquées, si elles se produisent, sont sauvegardées dans le registre de
mémorisation des interruptions IRPTL et dans un des registres d’identification des sources
d’interruptions (INTRDxL et INTDxH). Si ces interruptions ne sont pas masquées, elles
seront traitées dans l’ordre de priorité. Les sources d’interruption peuvent être masquées
globalement ou séparément à l’aide des registres ICNTL et IMASK.
− Activation / masquage global des interruptions à l’aide du flag GIE (ICNTL[5]).
« 0 » provoque le masquage des interruptions, « 1 » provoque l’activation des
interruptions. Les interruptions ayant pour source l’Emulateur et le Reset ne sont pas
masquables.
ENA INT ;
DIS INT
// activation globale des interruptions : mise à 1 du bit INCTL[5] (bit GIE)
// masquage globale des interruptions : mise à 0 du bit INCTL[5] (bit GIE)
Page 22
− Activation / masquage sélectif des interruptions à l’aide du registre IMASK[0…15].
Lors d’un Reset, par défaut toutes les interruptions masquables sont masquées.
Comme indiqué plus haut, lorsqu’une source d’interruption est activée, le registre de
mémorisation des interruptions (IRPTL) enregistre cette interruption en forçant à 1 le
bit correspondant. Les bits de ce registre indiquent donc toutes les interruptions en
cours de traitement ou pendantes. Ce registre étant accessible autant en lecture qu’en
écriture, il est possible d’annuler ou de forcer une interruption de manière software.
SETINT n ;
CLRINT n ;
// mise à 1 du bit IRPTL[n] : interruption software de priorité n
// mise à 0 du bit IRPTL[n] : annulation de l’interruption de priorité n
Dès qu’une interruption est prise en compte et exécutée, le séquenceur de
programme force le bit correspondant à « 0 » dans le registre IRPTL de manière à
permettre la détection d’une nouvelle interruption aussi vite que possible. Les
priorités données aux interruptions permettent de définir l’ordre de traitement des
interruptions lorsque plusieurs d’entre elles sont actives en même temps. Dans le cas
d’interruptions imbriquées, une interruption en cours d’exécution peut être stoppée
afin de traiter une interruption dans la priorité est plus élevée. Le séquenceur de
programme utilise trois registres (ICNTL, IMASK, IRPTL) pour gérer les
interruptions imbriquées.
ENA INT ;
DIS INT
−
Activation des interruptions imbriquées en forçant à « 1 » le flag INE (ICNTL[4]).
AR=ICNTL
AR=SETBIT 4 of AR ; // interruptions imbriquées : mise à 1 du bit INCTL[4] (bit INE)
ICNTL=AR ;
−
Le registre de masquage des interruptions IMASK est directement lié à la table
d’interruption. Chacun des 16 bits de ce registre correspond aux 16 positions de la
table d’interruption. La priorité la plus haute correspond à IMASK[0] et la plus basse
à IMASK[15].
IMASK=0x1A8 ;
−
// (b#000110101000) activation des interruptions de priorité 3, 5, 7, 8
Le registre de mémorisation des interruptions IRPTL a la même configuration que
le registre IMASK. IRPTL sert à mémoriser les interruptions activées afin d’en
assurer le traitement lorsque le séquenceur de programme en donne l’ordre.
ENA INT ;
DIS INT
Lorsqu’une interruption de même priorité que celle en cours de traitement à lieu, la
seconde interruption ne sera traitée qu’à la fin de l’exécution de la première.
Lorsque les interruptions imbriquées ne sont pas autorisées, une interruption de
priorité plus élevée que celle en cours d’exécution ne peut interrompre l’exécution de
cette dernière. Dans ce cas, l’interruption la plus prioritaire n’est prise en
considération que lorsque l’interruption en cours à été complètement traitée.
L’activation des interruptions imbriquées doit se faire hors interruption
5.8.2
Page 23
Registres dédiés à la gestion des lignes d’interruption
La gestion des lignes d’interruption se fait au travers d’un certain nombre de registres dont
la description est faite dans les paragraphes ci-dessous.
5.8.2.1 Flag de masquage global des interruptions
Le registre INCTL contient un bit permettant le contrôle global des interruptions du cœur
du DSP et de ses périphériques.
ICNTL
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
Reset = 0x0000
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
INE (Interrupt nesting mode enable)
0=
1=
Disabled
Enabled
GIE (Global interrupt enable)
0=
Disabled
1=
Enabled
PCSTKE (PCstack interrupt enable)
0=
Disabled
1=
Enabled
Figure 5-7 : Registre de masquage général des interruptions
5.8.2.2 Registre de masquage des interruptions IMASK
Les lignes d’interruptions USR0 à USR11 sont activées ou non dans le registre de
masquage des interruptions du cœur du DSP, soit le registre IMASK.
IMASK
USR0
USR1
USR2
USR4
USR3
USR5
USR6
USR7
USR8
USR10
USR9
USR11
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Reset = 0x0000
EMU (Emulator–NMI) Highest priority
PWDN(Powerdown–GIEmaskable)
KERNEL (emulator kernel)
STACK (Stack interrupt) From PC stack
push/pop, PC stack watermark, PC or
status stacks underflow, or any stack
overflows
UDI (User Defined Interrupts) one interrupt per bit; bit 15 has lowest priority
Figure 5-8 : Registre de masquage des interruptions
5.8.2.3 Registre de mémorisation des interruptions IRPTL
Lorsqu’une source d’interruption est activée, le registre IRPTL mémorise cette demande.
L’assignation des bits du registre IRPTL est identique à celle de IMASK
USR0
USR1
USR2
USR4
USR3
USR5
USR6
USR7
USR8
USR10
USR9
USR11
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
IRPTL
Reset = 0x0000
EMU
PWDN
KERNEL
STACK
UDI
Figure 5-9 : Registre de mémorisation des interruptions
Page 24
5.8.2.4 Registre d’attribution des priorités des interruptions des périphériques
Le contrôleur d’interruptions des périphériques est conçu pour gérer les 32 sources
d’interruptions possibles issues des périphériques. Pour chaque source d’interruption, un
code de 4 bits permet d’allouer une des 12 lignes d’interruption du cœur de l’ADSP21992 à
la source d’interruption considérée. Pour réaliser cette opération il faut donc 8 registres de
16 bits (Interrupt Priority Registers :IRP0, …, IRP7). Chaque registre contient donc 4 codes
de 4 bits fixant la position de la source d’interruption dans la table d’interruption.
15 14 13 12 11 10 9
1
1
1
1
1
1
1
8
7
6
5
4
3
2
1
0
IPR0 IO[0x01:0x0200]
IPR7 IO[0x01:0x0207]
1
1
1
1
1
1
1
1
1
Reset = 0x1111
Priority
Priority
Priority
Priority
Figure 5-10 : Registres des priorités des interruptions pour les périphériques
Le code 0x0 correspond donc à la position USR0 de la table d’interruption et par
conséquent à la priorité la plus élevée pour les périphériques alors que le code 0xB
correspond à la position USR11 soit la priorité la plus basse. Les codes 0xC à 0xF
correspondent à un masquage de la source d’interruption.
5.8.2.5 Registres de masquage individuel des interruptions des périphériques
Le contrôleur d’interruptions des périphériques propose deux registres PIMASKH et
PIMASKL (Peripheral Interrupt MASK High or Low) permettant le masquage individuel
des 32 sources d’interruptions des périphériques.
PIMASKL IO[0x01:0x0208]
15 14 13 12 11 10 9
8
7
6
5
4
3
2
1
0
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
PIMASKM IO[0x01:0x0209]
Reset = 0x1111
1 = unmasked
0 = masked
Figure 5-11 : Registres de masquage des interruptions des périphériques
Il y a donc 3 manières de masquer les interruptions en provenance des périphériques.
1. Dans le registre de masquage IMASK (IMASK[4] à IMASK[15]).
2. Dans les registres IRP0 à IRP7 en écrivant entre 0xC et 0xF pour les 4 bit de code.
3. Dans les registres PIMASKH et PIMASKL.
5.8.2.6 Registres d’identification des sources d’interruptions
Douze doubles registres de 16 bits chacun (INTRDxH : INTRDxL, x=[0…11]) sont
dédicacés au contrôleur d’interruptions des périphériques. Ces registres permettent de
définir la source d’une interruption lorsque plusieurs d’entre-elles ont la même priorité. Par
exemple si les interruptions PWMSYNC_IRQ et TMR1_IRQ ont le même niveau de
priorité USR0, il va être possible de déterminer laquelle de ces deux sources d’interruptions
est active en observait le bit INTRD0H[5] pour le Timer 1 et le bit INTRD0L[8] pour le
PWM. Les registres INTRDxH et INTRDxL sont en lecture seulement.
Page 25
15 14 13 12 11 10 9
8
7
6
5
4
3
2
1
0
INTRD0L IO[0x01:0x0210]
INTRD11H IO[0x01:0x0227
0
0
0
0
0
0
0
0
0
0
Reset = 0x0000
0
0
0
0
0
0
Read only
Figure 5-12 : Registre des sources interruptions propres aux périphériques
5.8.3
Sources d’interruption pour les périphériques
Le tableau ci-dessous illustre l’ensemble des sources d’interruption dédiées à l’ADSP21992.
IPMASK
IPMASKL[0]
IPMASKL[1]
IPMASKL[2]
IPMASKL[3]
IPMASKL[4]
IPMASKL[5]
IPMASKL[6]
IPMASKL[7]
IPMASKL[8]
IPMASKL[9]
IPMASKL[10]
IPMASKL[11]
IPMASKL[12]
IPMASKL[13]
IPMASKL[14]
IPMASKL[15]
IPMASKH[0]
IPMASKH[1]
IPMASKH[2]
IPMASKH[3]
IPMASKH[4]
IPMASKH[5]
IPMASKH[6]
IPMASKH[7]
IPMASKH[8]
IPMASKH[9]
IPMASKH[10]
IPMASKH[11]
IPMASKH[12]
IPMASKH[13]
IPMASKH[14]
IPMASKH[15]
Registre IPR
IPR0[3 :0]
IPR0[7 :4]
IPR0[11 :8]
IPR0[15 :12]
IPR1[3 :0]
IPR1[7 :4]
IPR1[11 :8]
IPR1[15 :12]
IPR2[3 :0]
IPR2[7 :4]
IPR2[11 :8]
IPR2[15 :12]
IPR3[3 :0]
IPR3[7 :4]
IPR3[11 :8]
IPR3[15 :12]
IPR4[3 :0]
IPR4[7 :4]
IPR4[11 :8]
IPR4[15 :12]
IPR5[3 :0]
IPR5[7 :4]
IPR5[11 :8]
IPR5[15 :12]
IPR6[3 :0]
IPR6[7 :4]
IPR6[11 :8]
IPR6[15 :12]
IPR7[3 :0]
IPR7[7 :4]
IPR7[11 :8]
IPR7[15 :12]
Nom de l’interruption
SPORT_RX_IRQ
SPORT_TX_IRQ
SPI_IRQ
PWMSYNC_IRQ
PWMTRIP_IRQ
EIU0TMR_IRQ
EIU0_LATCH_IRQ
EIU0ERR-IRQ
ADC0_IRQ
TMR0_IRQ
TMR1_IRQ
TMR2_IRQ
MEMDMA_IRQ
FIOA_IRQ
FIOB_IRQ
AUXSYNC_IRQ
AUXTRIP_IRQ
Source d’interruption
Réception sur SPORT
Transmission sur SPORT
Réception/transmission sur SPI
Réservé
Réservé
Réservé
Réservé
Réservé
Synchronisation du PWM
Désactiv. des sorties du PWM
Réservé
Réservé
Interface encodeur : Timer
Interface encodeur : Acq./mémo.
Interface encodeur : Erreur
Fin de conversion du conv. A/N
Réservé
Réservé
Réservé
Réservé
Timer 0
Timer 1
Timer 2
DMA
Flag des I/0 A
Flag des I/0 A
Synchronisation du PWM aux.
Désactiv. des sorties du PWM aux
Réservé
Réservé
Réservé
Réservé
Tableau 5-13 : Source des interruptions propres aux périphériques
5.8.4
Page 26
Table des vecteurs d’interruptions
La mémoire RAM de programme PM du block 0 de l’ADSP21992 se situe aux plages
d’adresses comprises entre 0x00 0000 et 0x00 7FFF. Ces positions mémoires ont une
largeur de 24 bits. Les positions inférieures (0x00 0000 sont réservées à la table
d’interruptions. Chaque plage de 32 positions mémoires est réservée à une source
d’interruption précise. Pour des routines d’interruption trés courtes, il est possible de loger
toutes les instructions dans la plage s’y rapportant. Par contre, comme c’est généralement le
cas, pour des routines d’interruption dépassant 32 lignes d’instruction, il est nécessaire de
loger ces dernières à un autre endroit de la mémoire de programme. Dans ce cas la seule
instruction à placer dans la table d’interruption est JUMP <nom du label de la routine
d’interruption>.
Certaine interruptions ne sont pas masquables (NMI)
minimum
← Priorité →
maximum
Zone d’adresse mémoire
Nom de l’interruption
Source d’interruption
PM 0x00:0000
PM 0x00:001F mem_INT_RSTI
Reset (non masquable)
PM 0x00:0020
PM 0x00:003F mem_INT_PWRDWN
Powerdown (non masquable1)
PM 0x00:0040
PM 0x00:0060
PM 0x00:0080
PM 0x00:00A0
PM 0x00:00C0
PM 0x00:00E0
PM 0x00:0100
PM 0x00:0120
PM 0x00:0140
PM 0x00:0160
PM 0x00:0180
PM 0x00:01A0
PM 0x00:005F
PM 0x00:007F
PM 0x00:009F
PM 0x00:00BF
PM 0x00:00DF
PM 0x00:00FF
PM 0x00:11F
PM 0x00:13F
PM 0x00:15F
PM 0x00:17F
PM 0x00:19F
PM 0x00:1BF
mem_INT_KERNEL
mem_INT_STKI
mem_INT_INT4
mem_INT_INT5
mem_INT_INT6
mem_INT_INT7
mem_INT_INT8
mem_INT_INT9
mem_INT_INT10
mem_INT_INT11
mem_INT_INT12
mem_INT_INT13
Emulation Kernel
Pile du PC et de boucle
Périphérique (USR0)
PM 0x00:01C0 PM 0x00:1DF
mem_INT_INT14
PM 0x00:01E0
mem_INT_INT15
PM 0x00:1FF
Tableau 5-14 : Zone de mémoire (PM block 0) contenant la table d’interruption
1 : masquable uniquement avec le flag GIE (contrôle globale des interruptions ICNTL[5]
5.8.5
Page 27
Exemple : Contenu de la mémoire de programme (PM, block 0)
Les adresses 0x00 :0000 à 0x00 :01FF de la mémoire de programme PM interne au DSP
correspondent à la table des vecteurs d’interruption. La première instruction est un saut au
début du programme commençant à l’adresse définie par le label « Start ».
/* RESET: 0x000 - 0x01F */
JUMP start;
RTI; RTI; RTI; RTI; RTI; RTI; RTI; RTI; RTI; RTI; RTI; RTI; RTI; RTI; RTI;
RTI; RTI; RTI; RTI; RTI; RTI; RTI; RTI; RTI; RTI; RTI; RTI; RTI; RTI; RTI; RTI;
/* Powerdown: 0x020 - 0x03F */
/* Loop & PC stack: 0x040 - 0x05F */
/* Emulator Kernel/single step: 0x060 - 0x07F */
/* USR0: 0x080 - 0x09F */
JUMP PWMSYNC_ISR;
// Saut à la routine d’interruption PWMSYNC_ISR
/* USR1: 0x0A0 - 0x0BF */
JUMP ADC_ISR;
// Saut à la routine d’interruption ADC_ISR
/* USR2: 0x0C0 - 0x0DF */
JUMP TIMER1_ISR
// Saut à la routine d’interruption TIMER1_ISR
/* USR3: 0x0E0 - 0x0FF */
.
.
.
.
/* USR10: 0x1C0 - 0x1DF */
/* USR11: 0x1E0 - 0x1FF */
BIBLIOGRAPHIE
[1]
ADSP-219X DSP
INSTRUCTION SET REFERENCE
Revision 1.1, August 2003
Part Number 82-000390-07
[2]
ADSP-2199X
MIXED SIGNAL DSP CONTROLLER
HARDWARE REFERENCE
Préliminary Revision 0, 2003
Part Number 82-000640-01
[3]
MIXED-SIGNAL AND DSP DESIGN TECHNIQUES
Analog Devices, Inx
Edited by Walt Kester
ISBN 0-7506-7611-6
Page 28

Séquenceur de programme

Transcription

Documents pareils

JUMELLES 10X25 RTI JUMELLES 10X25 D`OBSERVATION

RTI Grandes entreprises

Certif MASE StA 140317

Wikango XL Millenium

L`environnement actuel

Viseur Micro-Point RTI Viseur point rouge polyvalent - Sport

cti/rti 2015 québec

Section Sportive HandBall

COTE D`IVOIRE Fiche signalétique.qxp