Chapter 2

Architecture du TMS320C6000
Vue densemble
 Objectifs du chapitre

Dcrire l'architecture du CPU du C6000.

Introduire de quelques instructions de base.
Dcrire la mmoire du C6000.
Donner une vue d'ensemble des priphriques.
 Implantation de la somme de produits
(SdP)
Il a t montr au chapitre 1
que la SdP est l'lment cl
pour la plupart des algorithmes
DSP..
DSP
Donc, nous allons crire le
code pour cet algorithme et
en mme temps dcouvrir
l'architecture C6000
6000..
N
Y = an * xn
n = 1
= a1 * x1 + a2 * x2 +... + aN * xN
Deux oprations
de base sont ncessaires
pour cet algorithme.
(1) Multiplication
(2) Addition
Donc deux instructions
de base sont requises.
 Implantation de la somme de produits
(SdP)
Donc, nous allons mettre
en uvre l'algorithme SdP! N
Y = an * xn
Limplantation dans ce n = 1
module doit se faire en = a1 * x1 + a2 * x2 +... + aN * xN
assembleur.
Deux oprations
de base sont ncessaires
pour cet algorithme.
(1) Multiplication
(2) Addition
Donc deux instructions
de base sont requises.
multiplicateur (MPY)
N
Y = an * xn
n = 1
= a1 * x1 + a2 * x2 +... + aN * xN

La multiplication de a1 par x1 est faite en

assembleur par linstruction suivante:

MPY a1, x1, Y

Cette instruction est effectue par

lunit de multiplication appele
.M
 multiplicateur (unit .M)
40
Y = an * xn
n = 1

.M
L unit . M effectue les multiplications
en hardware

MPY .M a1, x1, Y

Note: Un multiplicateur 16-

16 -bit par 16-
16-bit fournit un
rsultat sur 32-
32-bit.
Un multiplicateur 32-
32-bit par 32-
32-bit fournit un rsultat
sur 64-
64-bit.
Addition (.?)
40
Y = an * xn
n = 1

.M

.? MPY .M a1, x1, prod

ADD .? Y, prod, Y
 Addition (Unit .L)
40
Y = an * xn
n = 1

.M

.L MPY .M a1, x1, prod

ADD .L Y, prod, Y

Les processeurs RISC (Reduced

(Reduced Instruction
Instruction--Set
Computer) comme le C6000 utilisent les registres pour
garder les oprandes, alors on change ce code.
 Pile des Registres - A
40
Register File A
Y = an * xn
A0 a1 n = 1
A1 x1
A2
A3 prod .M
A4 Y

. .L
. MPY .M a1, x1, prod
.
ADD .L Y, prod, Y

A15
32--bits
32

Laissez-nous corriger ce problme en remplaant a, x,

Laissez-
prod et Y par les registres comme indiqu ci-
ci-dessus.
Spcification de noms des registres
40
Register File A
Y = an * xn
A0 a1 n = 1
A1 x1
A2
A3 prod .M
A4 Y

. .L
. MPY .M A0, A1, A3
.
ADD .L A4, A3, A4

A15
32--bits
32

Les registres A0, A1, A3 et A4 contiennent les valeurs

qui seront utilises par les instructions.
Spcification de noms des registres
40
Register File A
Y = an * xn
A0 a1 n = 1
A1 x1
A2
A3 prod .M
A4 Y

. .L
. MPY .M A0, A1, A3
.
ADD .L A4, A3, A4

A15
32--bits
32

La pile des registres A contient 16 registres (A0 -A15)

32--bits de largeur.
32
 Chargement des donnes
Register File A Q: Comment peut
peut--on charger
A0 a1 les oprandes dans les
A1 x1 registres?
registres?
A2
A3 prod .M
A4 Y

. .L
.
.

A15
32--bits
32
 Unit Load .D
Register File A Q: Comment peut
peut--on charger
A0 a1 les oprandes dans les
A1 x1 registres?
registres?
A2
A3 prod .M
Y
A: Les oprandes sont chargs
dans les registres en les
. chargeant partir de la
. .L mmoire l'aide de lunit
.
.D .

A15
.D
32--bits
32

Mmoire Data
 Unit Load .D
Register File A
Il convient de noter ce stade
A0 a1 que la seule faon d'accder
A1 x1 la mmoire est dans lunit
A2 .D
D..
A3 prod .M
Y

. .L
.
.

A15
.D
32--bits
32

Data Memory
 Instruction de chargement
Register File A Q: Quelle instruction (s) peut
A0 a1 tre utilise pour le
A1 x1 chargement des oprandes
A2 de la mmoire aux
prod .M registres?
A3
Y

. .L
.
.

A15
.D
32--bits
32

Data Memory
Instructions Load (LDB, LDH,LDW,LDDW)
Register File A Q: Quelle instruction (s) peut
A0 a1 tre utilise pour le
A1 x1 chargement des oprandes
A2 de la mmoire aux
prod .M registres?
A3
Y
A: Les instructions Load.
. .L
.
.

A15
.D
32--bits
32

Data Memory
Utilisation des Instructions Load
Avant d'utiliser l'unit de Data address
charge, il faut savoir que ce 00000000
processeur est adressable par
octet, ce qui signifie que 00000002
chaque octet est reprsent 00000004
par une adresse unique unique.. 00000006
00000008
De plus, les adresses sont 32
32--
bits..
bits

FFFFFFFF

16--bits
16
Utilisation des Instructions Load
La syntaxe de l'instruction de Data address
chargement est
est:: 00000000
a1
LD *Rn,Rm
*Rn,Rm x1 00000002
o:
o: 00000004
Rn est un registre qui contient prod 00000006
l'adresse de l'oprande Y 00000008
charger

et
Rm est le registre de
destination..
destination
FFFFFFFF

16--bits
16
Utilisation des Instructions Load
La syntaxe de l'instruction de Data address
chargement est
est:: 00000000
a1
x1 00000002
LD *Rn,Rm
*Rn,Rm
00000004

La question est maintenant prod 00000006

combien d'octets vont tre Y 00000008
charges dans le registre de
destination?

FFFFFFFF

16--bits
16
Utilisation des Instructions Load
La syntaxe de l'instruction de Data address
chargement est
est:: 00000000
a1
x1 00000002
LD *Rn,Rm
00000004
La rponse est que, cela dpend prod 00000006
de l'instruction que vous Y 00000008
choisissez::
choisissez
LDB:: loads one byte (8-bit)
LDB
LDH
LDH:: loads half word (16
16--bit)
LDW
LDW:: loads a word (32
32--bit)
LDDW
LDDW:: loads a double word (64
64--bit) FFFFFFFF

Note: LD en elle mme

Note: 16--bits
16
n'existe pas
pas..
Utilisation des Instructions Load
Data
La syntaxe de l'instruction de 1 0
address
chargement est
est:: 0xA 0xB 00000000
0xC 0xD 00000002
LD *Rn,Rm
0x2 0x1 00000004
0x4 0x3 00000006
Exemple::
Exemple
Si on suppose que A5 = 0x4 alors
alors:: 0x6 0x5 00000008
(1) LDB *A5, A7 ; gives A7 = 0x00000001 0x8 0x7
(2) LDH *A5,A7; gives A7 = 0x00000201
(3) LDW *A5,A7; gives A7 = 0x04030201
(4) LDDW *A5,A7:A6; gives A7:A6 =
0x0807060504030201
FFFFFFFF

16--bits
16
 Utilisation des Instructions Load
La syntaxe de l'instruction de Data address
chargement est
est:: 0xA 0xB 00000000
0xC 0xD 00000002
LD *Rn,Rm
0x2 0x1 00000004
0x4 0x3 00000006
Question::
Question
0x6 0x5 00000008
Si les donnes ne sont accessibles 0x8 0x7
que par l'instruction de
chargement et l'unit .D, comment
peut--on charger le registre de
peut
pointeur de Rn en premier lieu?
FFFFFFFF

16--bits
16
 Chargement du Pointeur Rn
u Linstruction MVKL va permettre un
dplacement dune constante 16-
16 -bit dans le
registre comme montr dessous:
MVKL .? a, A5
(a est une constante ou tiquette)
u Combien de bits reprsentent une adresse
complte?
complte?
32 bits
u Alors pourquoi linstruction ne permet pas un
dplacement de 32-
32 -bit?
Toutes les instructions sont sur 32-
32-bit (voir
instruction opcode
opcode).
).
 Chargement du Pointeur Rn
u Utiliser toujours MVKL puis MVKH, les
exemples suivants:
Example 1
A5 = 0x87654321

MVKL 0x1234FABC, A5 MVKH 0x1234FABC, A5

A5 = 0xFFFFFABC (sign extension) A5 = 0x1234FABC ; OK

Example 2

MVKH 0x1234FABC, A5 MVKL 0x1234FABC, A5

A5 = 0x12344321 A5 = 0xFFFFFABC ; Wrong
 LDH, MVKL and MVKH
Register File A
A0 a MVKL pt1, A5
A1 x MVKH pt1, A5
A2 MVKL pt2, A6
A3 prod .M MVKH pt2, A6
Y
LDH .D *A5, A0
. .L LDH .D *A6, A1
.
.
MPY .M A0, A1, A3
ADD .L A4, A3, A4
A15
.D
32--bits
32

Data Memory
 Crer une boucle
Jusqu'ici, nous avons
seulement mis en MVKL pt1, A5
uvre la SdP pour MVKH pt1, A5
une seule ronde, i.e. MVKL pt2, A6
MVKH pt2, A6
Y= a1 * x1
LDH .D *A5, A0
LDH .D *A6, A1
Donc, nous allons MPY .M A0, A1, A3
crer une boucle afin ADD .L A4, A3, A4
que nous puissions
mettre en uvre la
SdP pour N Taps
Taps..
 Crer une boucle
Jusqu'ici, nous avons
seulement mis en
uvre la SdP pour
une seule ronde, i.e.
Avec les processeurs
Y= a1 * x1 C6000: absence
d'instructions spcifiques
tels que la rptition de
Donc, nous allons bloc. La boucle est cre en
utilisant l'instruction B.
crer une boucle afin
que nous puissions
mettre en uvre la
SdP pour N Taps
Taps..
What are the steps for creating a loop
1. Create a label to branch to.

2. Add a branch instruction, B.

3. Create a loop counter.

4. Add an instruction to decrement the loop counter.

5. Make the branch conditional based on the value in

the loop counter.
1. Create a label to branch
MVKL
to
pt1, A5
MVKH pt1, A5
MVKL pt2, A6
MVKH pt2, A6

loop LDH .D *A5, A0

LDH .D *A6, A1
MPY .M A0, A1, A3
ADD .L A4, A3, A4
2. Add a branch instruction,
MVKL
B.
pt1, A5
MVKH pt1, A5
MVKL pt2, A6
MVKH pt2, A6

loop LDH .D *A5, A0

LDH .D *A6, A1
MPY .M A0, A1, A3
ADD .L A4, A3, A4
B .? loop
 Which unit is used by the B
Register File A instruction?
MVKL pt1, A5
MVKH pt1, A5
A0 a .S MVKL pt2, A6
A1 x
MVKH pt2, A6
A2
prod .M
A3 .M
Y loop LDH .D *A5, A0
. LDH .D *A6, A1
. .L
. .L MPY .M A0, A1, A3
ADD .L A4, A3, A4
.D B .? loop
A15 .D
32--bits
32

Data Memory
 Which unit is used by the B
Register File A instruction?
MVKL .S pt1, A5
MVKH .S pt1, A5
A0 a .S MVKL .S pt2, A6
A1 x
MVKH .S pt2, A6
A2
prod .M
A3 .M
Y loop LDH .D *A5, A0
. LDH .D *A6, A1
. .L
. .L MPY .M A0, A1, A3
ADD .L A4, A3, A4
.D B .S loop
A15 .D
32--bits
32

Data Memory
 3. Create a loop counter.
MVKL .S pt1, A5
Register File A
MVKH .S pt1, A5
A0 a .S MVKL .S pt2, A6
A1 x
MVKH .S pt2, A6
A2 MVKL .S count, B0
prod .M
A3 .M
Y loop LDH .D *A5, A0
. LDH .D *A6, A1
. .L
. .L MPY .M A0, A1, A3
ADD .L A4, A3, A4
.D B .S loop
A15 .D
32--bits
32
B registers will be introduced later

Data Memory
 4. Decrement the loopMVKL
counter
.S pt1, A5
Register File A
MVKH .S pt1, A5
A0 a .S MVKL .S pt2, A6
A1 x
MVKH .S pt2, A6
A2 MVKL .S count, B0
prod .M
A3 .M
Y loop LDH .D *A5, A0
. LDH .D *A6, A1
. .L
. .L MPY .M A0, A1, A3
ADD .L A4, A3, A4
.D SUB .S B0, 1, B0
A15 .D
B .S loop
32--bits
32

Data Memory
 5. Make the branch conditional based
u What is the syntaxon the instruction
for making
value in the loop counter
conditional?
[condition
condition]] Instruction Label
e.g.
[B1] B loop

(1) The condition can be one of the following

registers: A1, A2, B0, B1, B2.
(2) Any instruction can be conditional.
 5. Make the branch conditional based
oninverted
u The condition can be the by adding the
value
exclamation in the
symbol loop
! as counter
follows:
[!condition] Instruction Label
e.g.
[!B0] B loop ;branch if B0 = 0
[B0] B loop ;branch if B0 != 0
 5. Make the branch conditional
MVKL .S2 pt1, A5
Register File A
MVKH .S2 pt1, A5
A0 a .S MVKL .S2 pt2, A6
A1 x
MVKH .S2 pt2, A6
A2 MVKL .S2 count, B0
prod .M
A3 .M
Y loop LDH .D *A5, A0
. LDH .D *A6, A1
. .L
. .L MPY .M A0, A1, A3
ADD .L A4, A3, A4
.D SUB .S B0, 1, B0
A15 .D
[B0] B .S loop
32--bits
32

Data Memory
More on the Branch Instruction (1)
u With this processor all the instructions are
encoded in a 32-
32-bit.
u Therefore the label must have a dynamic range
of less than 32-
32-bit as the instruction B has to be
coded.
32--bit
32

B 21--bit relative address

21

u Case 1: B .S1 label

u Relative branch.
u Label limited to +/-
+/- 220 offset.
More on the Branch Instruction (2)
u By specifying a register as an operand instead of
a label, it is possible to have an absolute branch.
u This will allow a dynamic range of 2 32.

32--bit
32
5-bit register
B code

u Case 2: B .S2
.S2 register
u Absolute branch.
u Operates on .S2 ONLY!
 Testing the code
MVKL .S2 pt1, A5
MVKH .S2 pt1, A5
MVKL .S2 pt2, A6
MVKH .S2 pt2, A6
This code performs the following MVKL .S2 count, B0
operations:
loop LDH .D *A5, A0
a0*x0 + a0*x0 + a0*x0 + + a0*x0 LDH .D *A6, A1
MPY .M A0, A1, A3
However, we would like to perform: ADD .L A4, A3, A4
a0*x0 + a1*x1 + a2*x2 + + aN*xN SUB .S B0, 1, B0
[B0] B .S loop
 Modifying the pointers
MVKL .S2 pt1, A5
MVKH .S2 pt1, A5
MVKL .S2 pt2, A6
MVKH .S2 pt2, A6
MVKL .S2 count, B0

The solution is to modify the pointers loop LDH .D *A5, A0

LDH .D *A6, A1
A5 and A6.
MPY .M A0, A1, A3
ADD .L A4, A3, A4
SUB .S B0, 1, B0
[B0] B .S loop
 Syntax
Indexing Pointers
Description
Pointer
Modified
*R Pointer No
disp]
*+R[disp
*+R[ ] + Pre-
Pre-offset No
*-R[ disp]
R[disp ] - Pre
Pre--offset No
disp]
*++R[disp
*++R[ ] Pre--increment
Pre Yes
*--
--R[ disp]
R[disp ] Pre--decrement
Pre Yes
disp]
*R++[disp
*R++[ ] Post--increment
Post Yes
*R--
*R [disp
--[ disp]
] Post--decrement
Post Yes

w [disp] specifies # elements - size in DW, W, H, or B.

w disp = R or 5-
5-bit constant.
w R can be any register.
 Modify and testing the code
MVKL .S2 pt1, A5
MVKH .S2 pt1, A5
MVKL .S2 pt2, A6
MVKH .S2 pt2, A6
MVKL .S2 count, B0

This code now performs the following loop LDH .D *A5++,, A0

*A5++
operations:
LDH .D *A6++,, A1
*A6++
a0*x0 + a1*x1 + a2*x2 + ... + aN*xN
MPY .M A0, A1, A3
ADD .L A4, A3, A4
SUB .S B0, 1, B0
[B0] B .S loop
 Store the final result
MVKL .S2 pt1, A5
MVKH .S2 pt1, A5
MVKL .S2 pt2, A6
MVKH .S2 pt2, A6
MVKL .S2 count, B0

This code now performs the following loop LDH .D *A5++, A0

operations:
LDH .D *A6++, A1
a0*x0 + a1*x1 + a2*x2 + ... + aN*xN
MPY .M A0, A1, A3
ADD .L A4, A3, A4
SUB .S B0, 1, B0
[B0] B .S loop
STH .D A4, *A7
 Store the final result
MVKL .S2 pt1, A5
MVKH .S2 pt1, A5
MVKL .S2 pt2, A6
MVKH .S2 pt2, A6
MVKL .S2 count, B0

loop LDH .D *A5++, A0

The Pointer A7 has not been initialised.
LDH .D *A6++, A1
MPY .M A0, A1, A3
ADD .L A4, A3, A4
SUB .S B0, 1, B0
[B0] B .S loop
STH .D A4, *A7
 Store the final result
MVKL .S2 pt1, A5
MVKH .S2 pt1, A5
MVKL .S2 pt2, A6
MVKH .S2 pt2, A6
MVKL .S2 pt3, A7
MVKH .S2 pt3, A7
MVKL .S2 count, B0
The Pointer A7 is now initialised.
loop LDH .D *A5++, A0
LDH .D *A6++, A1
MPY .M A0, A1, A3
ADD .L A4, A3, A4
SUB .S B0, 1, B0
[B0] B .S loop
STH .D A4, *A7
What is the initial value of A4?
MVKL .S2 pt1, A5
MVKH .S2 pt1, A5
MVKL .S2 pt2, A6
MVKH .S2 pt2, A6
MVKL .S2 pt3, A7
MVKH .S2 pt3, A7
A4 is used as an accumulator, MVKL .S2 count, B0
so it needs to be reset to zero. ZERO .L A4
loop LDH .D *A5++, A0
LDH .D *A6++, A1
MPY .M A0, A1, A3
ADD .L A4, A3, A4
SUB .S B0, 1, B0
[B0] B .S loop
STH .D A4, *A7