Upload
kaia
View
55
Download
0
Embed Size (px)
DESCRIPTION
Conception logicielle et matérielle d’un décodeur MP3 sur la plate-forme NIOS-Stratix. Steven Derrien Équipe R2D2. Contexte. Module CSE en DIIC 2 (TP) Conception de circuits en VHDL Approche mixte logiciel-matériel Utilisation d’une plate-forme reconfigurable TP « décodeur MP3 » - PowerPoint PPT Presentation
Citation preview
1
Conception logicielle et matérielle d’un décodeur
MP3 sur la plate-forme NIOS-Stratix
Steven Derrien
Équipe R2D2
2
Contexte
Module CSE en DIIC 2 (TP) Conception de circuits en VHDL Approche mixte logiciel-matériel Utilisation d’une plate-forme reconfigurable
TP « décodeur MP3 » Exploiter les possibilités de la plate-forme NIOS Utiliser des méthodologies de conception Travailler sur une « véritable » application
Objectif du mini-projet Obtenir une implémentation « temps-réel » de
référence, qui sera utilisé pour les TP.
3
Chaîne de décodage MP3
Stereo Decoding
Stereo Decoding
AliasReconstruction
AliasReconstruction
SynthesisPolyphaseFilter Bank
SynthesisPolyphaseFilter Bank
FrequencyInversion
FrequencyInversionIMDCTIMDCT
ReorderingReorderingRequantizeRequantizeHuffmanDecoding
HuffmanDecoding
Synchronization
CRC Check
Huffman tables
Scalefactors
Synchronization
CRC Check
Huffman tables
Scalefactors
Bitstream
Right PCM Channel
Left PCM Channel
AliasReconstruction
AliasReconstruction
SynthesisPolyphaseFilter Bank
SynthesisPolyphaseFilter Bank
FrequencyInversion
FrequencyInversionIMDCTIMDCT
ReorderingReorderingRequantizeRequantizeHuffmanDecoding
HuffmanDecoding
Scale factors
Huffman table
4
Travail déjà effectué
Portage du code « C » référence Passage des calculs flottants en entiers Restructuration du code Portage sur le NIOS (pas de SGF)
Mise en œuvre sur un OS temps-réel Utilisation de micro-OS II. Découpage de l’application en tâches Communications par files d’attente Version à 4 tâches fonctionnelle
5
Chaîne de décodage MP3
Stereo Decoding
Stereo Decoding
AliasReconstruction
AliasReconstruction
SynthesisPolyphaseFilter Bank
SynthesisPolyphaseFilter Bank
FrequencyInversion
FrequencyInversionIMDCTIMDCT
ReorderingReorderingRequantizeRequantizeHuffmanDecoding
HuffmanDecoding
Synchronization
CRC Check
Huffman tables
Scalefactors
Synchronization
CRC Check
Huffman tables
Scalefactors
Bitstream
Right PCM Channel
Left PCM Channel
AliasReconstruction
AliasReconstruction
SynthesisPolyphaseFilter Bank
SynthesisPolyphaseFilter Bank
FrequencyInversion
FrequencyInversionIMDCTIMDCT
ReorderingReorderingRequantizeRequantizeHuffmanDecoding
HuffmanDecoding
Scale factors
Huffman table
Tâch
e 1
Tâch
e 2
Tâch
e 3
Tâch
e 4
6
Résultats
Implémentation 5x trop lente pour du temps-réel. Deux tâches utilisent 80% des ressources CPU Accélération matérielle de IMDCT et SubBand
Etape durée %CPU
Huffman 15%Dequantize ?Reorder ?Stereo ?IMDCT 28%SubBand 33%
7
Architecture visée
Tâche 1
Nios CPU + OS temps-réel
Tâche 3
Tâche 2IMDCT
Co-processeur (VHDL)
FIFO
FIFO
Tâche 4SubBand
Co-processeur (VHDL)
FIFO
FIFO
FIFO
CNA
Bus Avalon
8
Travail à réaliser
Filtre IMDCT à finaliser Mise au point de bancs de tests Intégration du composant dans l’appli Validation du fonctionnement
Filtre SubBand à réaliser Conception VHDL de l’accélérateur Définition de l’interface soft-hard Intégration du composant dans l’appli Validation du fonctionnement
9
Méthodologie de conception en VHDL
Décomposition UT/UC Définition d’un squelette d’UT
Mémoires, registres Opérateurs (*,+) Interconnexions
Dérivation du contrôleur Associer à chaque calcul un instant d’exécution et une ressource
de traitement. Plusieurs opération en parallèle Respects des dépendances de données Vérifier l’absence de conflits
En déduire l’automate de contrôle.
10
1 adx = 0 2 while(1) {3 X[adx]=read_fifo(); 4 y=0;i=0;5 adx=(adx++) % 8;6 while(i<8) {7 y=y+X[adx]*C[i]; 8 adx=(adx++) % 8; 9 i++;10 }11 write_fifo(y);11 };
Définition de l’interface
On utilisera une interface à base de FIFOs matérielles, qui seront directement connectées au bus Avalon. Le contrôle de flux étant géré par le processeur NIOS
outputFIFO
inputFIFO
11
1 adx = 0 2 while(1) {3 X[adx]=read_fifo(); 4 y=0;i=0;5 adx=(adx++) % 8;6 while(i<8) {7 y=y+X[adx]*C[i]; 8 adx=(adx++) % 8; 9 i++;10 }11 write_fifo(y);11 };
Choix des ressources de mémorisation
y
outputFIFO
C[16]X[16]
ROM
adx i
inputFIFO
On alloue un registre pour chaque variable, et on utilise des mémoire (RAM ou ROM) pour stocker les tableaux.
12
y
outputFIFO
C[16]X[16]
ROM
adx
+X
+1
i
+1
inputFIFO
1 adx = 0 2 while(1) {3 X[adx]=read_fifo(); 4 y=0;i=0;5 adx=(adx++) % 8;6 while(i<8) {7 y=y+X[adx]*C[i]; 8 adx=(adx++) % 8; 9 i++;10 }11 write_fifo(y);11 };
Choix des ressources de traitementOn alloue ensuite des unités fonctionnelles à notre chemin de données en fonction des opérations présentes dans le bloc de traitement à accélérer. La duplication de certaines unités de traitement permet parfois de tirer parti d’un parallélisme au niveau instruction.
13
1 adx = 0 2 while(1) {3 X[adx]=read_fifo(); 4 y=0;i=0;5 adx=(adx++) % 8;6 while(i<8) {7 y=y+X[adx]*C[i]; 8 adx=(adx++) % 8; 9 i++;10 }11 write_fifo(y);11 };
Signaux de contrôles de l’UT
On dispose alors d’une représentation presque complète de l’unité de traitement à laquelle il faut ajouter les signaux de contrôles.
ey
foutputFIFO
wr_fifo
C[16]X[16]
ROM
adx
+X
+1
i
+1
di_en
y_en
cadx_en
a rd_fifoinputFIFO
b wr_en
y_rst
i_rstadx_rst
14
ey
foutputFIFO
wr_fifo
C[16]X[16]
ROM
adx
+X
+1
i
+1
di_en
y_en
cadx_en
a rd_fifoinputFIFO
b wr_en
y_rst
i_rstadx_rst
Allocation et ordonnancement
On effectue ensuite l’allocation et l’ordonnancement des calculs :À chaque opération, on associe un opérateur matériel, et un instant d’exécution.
T 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20rd_fifo 3 X Xwr_en 3 X Xadx_rst 1 X X X X X X X X Xadx_en 5 8 8 8 8 8 8 8 8 X X X X X X X X Xi_rst 4 X X X X X X X X X X Xi_en 9 9 9 9 9 9 9 9 X X X X X X X X X X Xy_rst 4 X X X X X X X X X X Xy_En 7 7 7 7 7 7 7 7 X X X X X X X X X X Xwr_fifo 11 X
1 adx = 0 2 while(1) {3 X[adx]=read_fifo(); 4 y=0;i=0;5 adx=(adx++) % 8;6 while(i<8) {7 y=y+X[adx]*C[i]; 8 adx=(adx++) % 8; 9 i++;10 }11 write_fifo(y);11 };
15
Dérivation du contrôleur
5y
7outputFIFO
wr_fifo
C[16]X[16]
ROM
adx
+X
+1
i
+1
7i_en
y_en
7adx_en
7 rd_fifoinputFIFO
7 wr_en
Une fois l’allocation et l’ordonnancement effectués, on peut dériver l’automate de contrôle qui commandera l’unité de traitement.
S3
S2
S0
S1
i<16
i=16
wr_fifo=’1'adx_en=’1'
i_en=’1’y_en=’1’adx_en=’1’
rd_fifo=’1'wr_en=’1'
i_rst=’1’adx_rst=’1’y_rst=’1’
1
1
16
Exercices
Ordonnancement pour des opérateurs pipelinés Latence Add =1 cycle, Mul=2 cycles
Reprendre l’exercice pour un filtre symétrique:
1 adx = 0 2 while(1) {3 X[adx]=read_fifo(); 4 y=0;i=0;5 adx=(adx++) % 4;6 while(i<4) {7 y=y+(X[adx]+X[7-adx])*C[i]; 8 adx=(adx++) % 4; 9 i++;10 }11 write_fifo(y);11 };
17
Méthodologie
1. Traces d’exécution pour un fichier MP3
2. Testbench C fonctionnant sur traces Architecture VHDL TestBench pour chaque bloc important
3. Testbench VHDL Simulation des E/S bus, et utilisation des traces
4. TestBench C « in situ » intégrant le co-processeur Mise en œuvre de l’interface logicielle Mesure de performances (speed-up)
5. Intégration à l’application
18
Exercice 1
1. Reprendre l’exemple SlavePeriph_fifo.vhd
2. L’intégrer à un système NIOS.
3. Écrire un programme C de test pour le NIOS.
4. Valider le fonctionnement de l’ensemble.
19
Exercice 2
1. Se baser sur le code de IMDCT pour proposer un squelette d’unité de traitement avec les caractéristiques suivantes :
a) Double multiplieur-accumulateur pipeliné
b) ROM à double port pour iCOS[] et iWin[]
c) ROM et RAM synchrones
2. Réfléchir à un ordonnancement.a) Exploiter la présence de 2 MAC
b) Attention aux délais :• Mémoire synchrone• MAC pipeliné
20
Code IMDCT
while(1) {block_type=get_fifo();
for(i= 0;i<36;i++) iin[i]=get_fifo(); for(p= 0;p<9;p++){
isum = 0; isum2= 0;addr_a = 19+(p<<1);addr_b = 55+(p<<1);step_a = ((p<<2)+38);step_b = ((p<<2)+110);if (step_b>=144) step_b -= 144;
for(m=0;m<18;m++) {isum += iin[m]*iCOS[addr_a];isum2 += iin[m]*iCOS[addr_b];addr_a = addr_a + step_a;if (addr_a>=144) addr_a -= 144;addr_b = addr_b + step_b;if (addr_b>=144) addr_b -= 144;}iout[p] = isum*iwin[block_type][p]; iout[17-p] = -isum*iwin[block_type][17-p];iout[18+p] = isum2*iwin[block_type][18+p];iout[35-p] = isum2*iwin[block_type][35-p];
}for(i= 0;i<36;i++) put_fifo(iout[i]);
}
21
iWin[256]
+
X
+
X
iCos[144]iIn[36] iOut[36]
hrd_fifoinput
FIFO
moutputFIFO
wr_fifo
ly_eny_rstisum2ky_en
y_rst isum
step_aaddr_a
(a+b)%144
step_baddr_b
(a+b)%144
p
<<2
+1
+110+38
block_type
-
+17 +35 +18
<<2
+
f sel_mux
g bt_enbt_rst
e stpb_enstpb_rst
cadb_rstadb_en
a p_enp_rst
bada_rstada_en
d stpa_enstpa_rst
iiin_we
jiout_we
m
+1
n m_enm_rst
addriout
+1
o adio_rstadio_en
RAM ROM ROM RAM
Unité de traitement pour l’IMDCT
22
Exercice 3
1. Se baser sur le code de SUBBAND pour compléter l’unité de traitement :
2. Réfléchir à un ordonnancement.
3. Dériver le contrôleur
23
Code SubBand
while(1) {bufOffset[channel] = (bufOffset[channel] - 64) & 0x3ff;ibufferPtr = &(ibuf[channel][0]); // @ du début de bufferfor (k=0; k<32; k++) bandPtr[k] = get_fifo();for (i=0; i<64; i++) {
isum = 0;for (k=0; k<32; k++) {
isum += bandPtr[k]*filterInt[i][k];}addr_ibuf = i+bufOffset[channel];ibuffferPtr[addr_ibuf] = isum;
}for (k=0; k<32; j++) {
isum = 0;for (i=0; i<16; i++) {
addr_iwin = k + (i<<5);addr_ibuf = k + ((i<<5) + (((i+1)>>1)<<6)) +
bufOffset[channel]) & 0x3FF;isum += iwindow[addr_iwin]*ibuffferPtr[addr_ibuf];
}put_fifo(isum);
}channel= 1-channel;
}
24
Unité de traitement pour SubBand
iBuf[1024]
cibuf_we
filter[2048]
ard_fifoinput
FIFO
????
???? ????iwin[4096]
f sel_mux
+
X
b isum
moutputFIFO
wr_fifo
fsel_mux