Aplicatii Ale Procesoarelor de Semnal in Comunicatii

Capitolul 1 - Introducere 1

CAPITOLUL 1

INTRODUCERE

Procesoarele numerice de semnal realizează operaţii matematice.

Calculatoarele folosite pentru afaceri şi alte aplicaţii generale nu sunt

optimizate pentru algoritmi de prelucrare numerică a semnalelor (cum ar fi

filtrarea digitală sau analiza Fourier).

Microprocesoarele DSP sunt specializate pentru prelucrarea numerică a

semnalelor.

Numărul acestor dispozitive a cunoscut o creştere deosebită în ultimii

zece ani, fiind folosite aproape în orice domeniu, de la telefoanele celulare

până la instrumentele ştiinţifice avansate.

Calculatoarele sunt extrem de utile în două direcţii principale:

- manipularea datelor (procesarea cuvintelor şi managementul bazelor

de date);

- calculele matematice (folosite în ştiinţă, inginerie şi procesarea

semnalelor digitale).

Toate microprocesoarele pot realiza ambele sarcini.

Este scump să realizezi un dispozitiv optimizat pentru amândouă.

Există diferenţe în proiectarea hardware, cum ar fi mărimea numărului de

instrucţiuni şi manipularea întreruperilor.

Importante sunt şi problemele de marketing: costul de dezvoltare şi

fabricare, durata de viaţă a produsului, etc. .

Aplicaţii ale procesoarelor de semnal în comunicaţii2

Microprocesoarele tradiţionale s-au îndreptat în principal către

manipularea datelor.

Similar, procesoarele DSP sunt concepute pentru realizarea calculelor

matematice necesare procesării semnalelor digitale.

Tabelul 1.1 arată cele mai importante diferenţe dintre aceste două

categorii.

Manipularea datelor este bazată pe mişcarea datelor şi verificarea

inegalităţilor, în timp ce calculul matematic foloseşte în special înmulţirea şi

adunarea.

TABELUL 1.1

Manipularea datelor Calcul matematic

Aplicaţii

Procesarea cuvintelor,Managementul bazelor de date;Sisteme de operare, etc.

Procesarea semnalelor digitale;Controlul mişcării;Simulări ştiinţifice şiinginereşti, etc

Operaţiiprincipale

Mişcarea datelor (A→B)Testarea valorii (if A=B then)

Adunarea (A+B=C)Înmulţirea (AxB=C)

Manipularea datelor implică stocarea şi sortarea informaţiei.

Să considerăm un program de procesare a cuvintelor.

Sarcina elementară este stocarea informaţiei (scrisă de către operator),

organizarea informaţiei (ştergere şi copiere, verificarea ortografiei, încadrarea

în pagină, etc.) şi apoi stocarea informaţiei (cum ar fi salvarea documentului

sau printarea). Aceste sarcini sunt finalizate prin mutarea datelor de la o

locaţie la alta şi prin verificarea inegalităţilor (A=B, A<B, etc.).

Se doreşte sortarea unei liste de cuvinte în ordine alfabetică. Fiecare

cuvânt este reprezentat de un număr pe 8 biţi, valoarea ASCII a primei litere

din cuvânt. Aranjarea în ordine alfabetică implică rearanjarea ordinii


cuvintelor până când valoarea ASCII creşte continuu de la început spre

sfârşitul listei. Aceasta poate fi realizată prin repetarea a doi paşi până când

aranjarea este terminată. Prima dată, se verifică dacă două cuvinte adiacente

sunt în ordine alfabetică. (IF A>B THEN…). Apoi, dacă cele două cuvinte nu

sunt în ordine alfabetică se schimbă între ele. Când acest proces de doi paşi se

repetă de câteva ori, pentru fiecare dintre perechile adiacente de cuvinte, lista

va fi eventual aranjată.

Ca un alt exemplu, se consideră printarea documentelor cu un soft de

procesarea cuvintelor. Computerul verifică continuu prin dispozitivul de

intrare (mouse sau tastatura) codul binar care indică printarea documentului.

Când acest cod este găsit, programul mută datele din memoria computerului

la imprimantă. Se observă aceleaşi două operaţii de bază: mutarea datelor şi

verificarea inegalităţilor. Operaţiile matematice sunt folosite ocazional şi nu

afectează semnificativ viteza de execuţie.

Comparativ, viteza de execuţie a celor mai mulţi algoritmi DSP este

limitată aproape complet de numărul de înmulţiri şi adunări. În Figura 1-1

este prezentată implementarea unui filtru digital FIR. Folosind notaţia

standard, semnalele de intrare sunt x[ ], în timp ce semnalele de ieşire sunt

notate y[ ].

Obiectivul este de a calcula eşantionul de la locaţia n (y[n]). Un filtru

FIR execută acest calcul prin adunarea eşantioanelor semnalului de intrare

ponderate cu coeficienţii a0, a1, a2, a3 … .

Ecuaţia y[n] este:

0 1 2 3 4[ ] [ ] [ 1] [ 2] [ 3] [ 4] ....y n a x n a x n a x n a x n a x n= + − + − + − + − +(1.1)

În funcţie de aplicaţie, pot fi puţini coeficienţi sau câteva mii. Deşi

există şi transfer de date şi evaluări ale inegalităţilor, operaţiile matematice

determină timpul de execuţie.


În afară de execuţia rapidă a calculelor matematice, procesoarele DSP

trebuie să realizeze un timp de execuţie prestabilit. Presupunem că am

programat computerul să efectueze o sarcină, de exemplu să convertească un

document realizat cu un procesor de cuvinte. Nu contează dacă execuţia

durează 10 milisecunde sau 10 secunde. Aşteptăm doar ca acţiunea să fie

terminată înainte să programăm computerul să execute o altă operaţie. Există

şi motive importante să nu fie mai rapid decât necesar. Odată cu creşterea

vitezei, va creşte costul, puterea consumată, dificultatea proiectării şi aşa mai

departe. Aceasta duce la o cunoaştere exactă a timpului de execuţie, (element

important pentru alegerea dispozitivului corespunzător) cât şi a algoritmului.

Figura 1-1 Filtrul digital FIR


1.1 STOCAREA CIRCULARĂ

Procesoarele DSP sunt concepute să implementeze rapid algoritmii de

prelucrare numerică.

Pentru a înţelege partea hardware, trebuie să înţelegem mai întâi

algoritmii. În această secţiune vom face o listă detaliată a paşilor necesari

implementării unui filtru FIR. În următoarea parte vom vedea cum

procesoarele DSP sunt concepute să urmeze aceşti paşi cât mai eficient

posibil.

Pentru început, trebuie să facem diferenţa între procesarea întârziată şi

procesarea în timp real.

Un geofizician poate să folosească un seismograf pentru a înregistra

mişcarea pământului în timpul unui cutremur. După ce mişcarea s-a terminat,

informaţia poate fi citită cu ajutorul unui computer şi analizată cumva. Alt

exemplu al procesării întârziate este constituit de vizualizarea medicală, cum

ar fi tomografia computerizată. Datele sunt obţinute în timp ce pacientul este

legat la aparat, dar reconstituirea imaginii poate fi întârziată. Ideea este că

toate informaţiile sunt disponibile programului de procesare.

În cazul procesării în timp real, semnalul de ieşire este obţinut în

acelaşi timp în care semnalul de intrare este recepţionat. De exemplu, în

telefonie, pentru aparate auditive şi radar. Aplicaţiile trebuie să obţină

informaţia necesară imediat, deşi, uneori, poate fi întârziată puţin.

De exemplu, o întârziere de 10 milisecunde într-o convorbire telefonică

nu poate fi detectată de vorbitor sau ascultător.

Aplicaţiile în timp real primesc un eşantion, parcurg algoritmul, apoi

generează un eşantion (la ieşire) şi aşa mai departe. Alternativ, pot primi mai

multe eşantioane, parcurg algoritmul şi dau (la ieşire) un grup de eşantioane.

Aceasta este lumea DSP.


Acum ne uităm înapoi la Figura 1-1 şi ne imaginăm că este

implementat un filtru FIR în timp real. Pentru a calcula eşantionul de ieşire,

trebuie să avem acces la cele mai recente eşantioane de la intrare.

Presupunem că folosim 8 coeficienţi pentru acest filtru: a0, a1, …., a7.

Trebuie să cunoaştem valorile celor mai recente 8 eşantioane ale semnalului

de intrare: x[n], x[n-1],…, x[n-7]. Aceste 8 eşantioane trebuie stocate în

memorie şi reînnoite continuu pe măsură ce noi eşantioane sunt achiziţionate.

Care este cea mai bună metodă să prelucrăm aceste eşantioane?

Răspunsul este stocarea circulară.

Tabelele 1.2a şi b ilustrează o stocare circulară cu 8 eşantioane. Am

aşezat eşantioanele în 8 locaţii de memorie consecutive, 20041 până la 20048.

Tabelul 1.2a - Stocarea circulară la un moment dat

Adresa dememorie

Valoareamemorată

Eşantion

20041 -0.225767 x[n-3]

20042 -0.269847 x[n-2]

20043 -0.228918 x[n-1]

20044 -0.113940 x[n] cel mai nou eşantion

20045 0.048679 x[n-7] cel mai vechi eşantion

20046 0.222977 x[n-6]

20047 0.371370 x[n-5]

20048 0.462791 x[n-4]

Tabelul 1.2a arată cum 8 eşantioane de la intrare pot fi stocate la un

moment dat, în timp ce Tabelul 1.2b arată schimbările după ce următorul

eşantion este achiziţionat.

Sfârşitul şirului linear este conectat la începutul lui. Locaţia de

memorie 20041 este văzuta ca fiind următoarea după 20048, la fel cum 20044


este lângă 20045. Urmărim şirul cu ajutorul unui pointer (a cărei variabilă este

o adresă) care indică unde sunt stocate cele mai recente eşantioane.

Tabelul 1.2b - Amortizarea circulară după eşantionul următor

Adresa dememorie

Valoareamemorată

20041 -0.225767 x[n-4]

20042 -0.269847 x[n-3]

20043 -0.228918 x[n-2]

20044 -0.113940 x[n-1]

20045 -0.062222 x[n] cel mai nou eşantion

20046 0.222977 x[n-7] cel mai vechi eşantion

20047 0.371370 x[n-6]

20048 0.462791 x[n-5]

De exemplu, în Tabelul a pointerul conţine adresa 20044, în timp ce în

Tabelul b conţine adresa 20045. Când este achiziţionat un nou eşantion, se

înlocuieşte cel mai vechi eşantion din şir, iar pointerul este mutat cu o adresa

înainte (este incrementat).

Stocarea circulară este eficientă deoarece, când este achiziţionat un nou

eşantion, trebuie schimbată o singură valoare.

Pentru a manevra un buffer circular avem nevoie de:

- un pointer care indică începutul bufferului circular în memorie (în

acest exemplu 20041);

- un pointer care să indice sfârşitul şirului (20048), sau o variabila

care să memoreze lungimea (8);

- trebuie să fie specificat pasul de citire al memoriei.

In Tabelul 1.2 pasul este 1, de exemplu: adresa 20043 conţine un

eşantion, adresa 20044 conţine următorul eşantion şi aşa mai departe.


Pointerul către cel mai recent eşantion trebuie modificat de fiecare dată

când noi eşantioane sunt achiziţionate. Cu alte cuvinte, trebuie să fie un

program logic care să controleze cum această valoare este reînnoita,

bazându-se pe parametrii bufferului circular.

Procesoarele DSP trebuie optimizate pentru manevrarea bufferelor

circulare pentru a obţine cea mai mare viteza de execuţie posibilă.

Stocarea circulara este folositoare şi în procesarea întârziată.

O metoda forţată este de a stoca în memorie întreaga lungime a fiecărui

semnal intermediar. Stocarea circulara oferă o altă opţiune: salvarea numai a

eşantioanelor necesare calculelor. Se reduce memoria necesara în schimbul

unui algoritm mult mai complicat.

Principalele companii producătoare de procesoare DSP sunt: Texas

Instruments, Analog Devices şi Motorola, etc.

Capitolul 2 – Aritmetica numerelor 145

CAPITOLUL 2

ARITMETICA NUMERELOR

2.1 SISTEME DE NUMERAŢIE

Un sistem de numeraţie foloseşte pentru reprezentarea numerelor un set

de b simboluri:

{0, 1, 2, 3, … , b-1}

Dacă b>10 trebuie adăugate noi simboluri în afara cifrelor (litere etc.).

Un număr întreg pozitiv se scrie, în baza b, folosind simbolurile dk:

-1 3 2 1 0 b=(d d ...d d d d )k km

ceea ce este echivalent cu

-1 3 2 1 0-1 3 2 1 0d b d b ... d b d b d b d bk k

k km = + + + + + +

Similar pot fi reprezentate numerele raţionale folosind i+1 simboluri

pentru partea întreagă şi f simboluri pentru partea fracţionară:

-1 1 0 -1-1 1 0 -1d b d b ... d b d b d b ... d bi i f

i i fr −−= + + + + + + +

Exemple de sisteme de numeraţie: zecimal, binar, octal, hexazecimal.

a) Zecimal (b=10),

- setul de simboluri este {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

- reprezentarea numărului întreg 493 în baza 10:

49310 = 4•102 + 9•101 + 3•100 = 400 + 90 + 3

Aplicaţii ale procesoarelor de semnal în comunicaţii 146

- reprezentarea numărului raţional 35,54 în baza 10:

35,6410 = 3•101 + 5•100 + 6•10-1 + 4•10-2 = 30 + 5 + 0,6 + 0,04

b) Binar (b=2),

- setul de simboluri este {0, 1};

- valoarea numărului 110012 în zecimal este:

110012 = 1•24 + 1•23 + 0•22 + 0•21 + 1•20 = 16 + 8 + 1 = 25

- valoarea numărului 110,012 în zecimal este:

110,012 = 1•22 + 1•21 + 0•20 + 0•2-1 + 1•2-2 = 4 + 2 + 0.25 = 6,25

c) Octal (b=8),

- setul de simboluri este {0, 1, 2, 3, 4, 5, 6, 7};

- valoarea numărului 20768 în zecimal este:

20768 = 2•83 + 0•82 + 7•81 + 6•80= 2•512 + 56 + 6= 108610

d) Hexazecimal (b=16),

- setul de simboluri este {0, 1, 2, …, 9, A, B, C, D, E, F};

- reprezentarea numărului B3F16 în zecimal este:

B3F16=11•162 + 3•161 + 15•160= 11•256 + 48 + 15= 287910

2.2 CONVERSIA ÎNTRE SISTEMELE DE NUMERAŢIE

Conversia unui număr reprezentat într-o bază b în zecimal se face în

mod direct aşa cum s-a arătat în exemplele de mai sus.

Conversia din binar în hexazecimal se realizează grupând cifrele binare

în grupuri de câte 4 biţi, identificând simbolul hexazecimal corespunzător:

1101101,10011012 = 0110 1101,1001 10102 = 6D,9A16


Conversia din zecimal în baza b se face separat pentru partea întreagă şi

pentru partea fracţionară:

- Pentru partea întreagă observăm că aceasta se mai poate scrie:

( )( )( )( )-1 3 2 1 0d b d b ... d b d b d b dk ki = + + + + + +

Se împarte i la b şi se obţine restul d0 şi un cât care are o

reprezentare similară cu i (pe mai puţini digiţi). Se repetă împărţirea

câtului la b până se ajunge la 0. Restul obţinut la fiecare împărţire

reprezintă simbolul dk al reprezentării în baza b a numărului întreg.

- Pentru partea fracţionară:

1 2 31 2 3d b d b d b ... d b ...k

kf − − − −− − − −= + + + + +

Se înmulţeşte f cu b şi se păstrează partea întreagă a membrului

drept, respectiv d–1.

1 2 11 2 3b d d b d b ... d b ...k

kf − − − +− − − −⋅ = + + + + +

( ) 1 21 2 3b b d =d d b ... d b ...k

kf − − +− − − −⋅ − + + + +

Se continuă înmulţind partea fracţionară a rezultatului la b până se

ajunge la 0. Reprezentarea în bază b a părţii fracţionare se face

luând în ordine inversă părţile întregi obţinute.

EXEMPLU: Reprezentarea în baza 2 a numărului 23,65:

- partea întreagă:

23 : 2 = 11 1 LSB 11 : 2 = 5 1 5 : 2 = 2 1 2 : 2 = 1 0 1 : 2 = 0 1 MSB

2310 = 101112


- partea fracţionară:

0,65 × 2 = 1,3 1 MSB 0,3 × 2 = 0,6 0 0,6 × 2 = 1,2 1 0,2 × 2 = 0,4 0 0,4 × 2 = 0,8 0 0,8 × 2 = 1,6 1 0,6 × 2 = 1,2 1 0,2 × 2 = 0,4 0 ...

Rezultă că numărul 0,65 nu poate fi reprezentat în binar cu un număr finit de

biţi.

23,6510 = 10111,10100110…2

Reprezentarea numerelor, în cazul procesoarelor, este limitată la un

număr finit de biţi. Gama de lucru este astfel limitată. Considerând

reprezentarea unui număr binar pe N biţi vom avea un domeniu de 2N valori

zecimale care pot fi reprezentate.

2.3 REPREZENTAREA BINARĂ A NUMERELOR NEGATIVE

Pentru reprezentarea numerelor negative, bitul din stânga reprezentării

binare este folosit ca bit de semn.

Astfel avem bitul de semn:

- 0 pentru numere pozitive (+);

- 1 pentru numere negative (–).

Restul de N–1 biţi sunt folosiţi pentru reprezentarea valorii.

2N–2 ... 20

s m 1 bit N–1 biţi

Figura 2-1 Reprezentarea numerelor întregi cu semn


2.3.1 Reprezentarea sub forma: bit de semn şi valoare absolută

(magnitudine)

Bitul de semn are semnificaţia arătată mai sus iar ceilalţi N-1 biţi

reprezintă valoarea absolută a numărului.

EXEMPLU:

Pentru N=6 biţi

9 = 0 01001

–9 = 1 01001

Domeniul de reprezentare:

- 2N–1 valori pozitive de la 0 la 2N–1–1.

- 2N–1 valori negative de la –(2N–1–1) la 0.

Se observă că:

a) avem două reprezentări ale lui zero, 000000 şi 100000.

b) maximul şi minimul (011111 şi 111111) au aceeaşi valoare absolută.

Principalele probleme sunt:

a) existenţa a două reprezentări ale lui zero;

b) pentru adunări avem nevoie de două sisteme de adunare şi de scădere

(în cazul numerelor negative).

2.3.2 Reprezentarea în complement faţă de 1

Pentru numerele pozitive, reprezentarea în complement faţă de 1 este

identică cu reprezentarea numerelor binare cu semn.

În cazul numerelor negative, reprezentarea este obţinută prin

complementarea (negarea) fiecărui bit. Această operaţie este echivalentă cu

adunarea cu 2N–1.


EXEMPLU:

Pentru N=6 biţi

13 = 0011012

–13 = 1100102

EXEMPLU:

Pentru N=6 biţi, deoarece 2N–1 = 63, reprezentarea lui –13 se

poate obţine şi altfel:

63 + (–13) = 50 = 1100102

Se observă că numărul negativ este reprezentat prin schimbarea lui 0 în

1 şi 1 în 0 (deci bitul din stânga are semnificaţia de bit de semn).

–21 = –0101012 = 1010102

– (–13) = –1100102 = 0011012

Din nou există două reprezentări ale lui zero: 000000 şi 111111.

Numerele maxime şi minime ce pot fi reprezentate au în modul aceeaşi

valoare.

2.3.3 Reprezentarea în complement faţă de 2

Pentru numerele pozitive, reprezentarea în complement faţă de 2 este

identică cu reprezentarea numerelor binare cu semn.

În cazul numerelor negative, reprezentarea numărului negativ este

obţinută prin adunarea lui 2N la valoarea negativă.

EXEMPLU:

Pentru N=6 (deci 2N = 64).

13 = 0011012

–13 este 64 + (–13) = 51 = 1100112


O metodă mai rapidă pentru obţinerea complementului faţă de 2 este:

a) Se complementează fiecare bit;

b) Se adună 1.

EXEMPLU:

Pentru N=6 biţi,

- pentru 13 = 0011012

se complementează biţii: 1100102

se adună 1: 1100112 = –13

- pentru –13 = 1100112

se complementează biţii: 0011002

se adună 1: 0011012 = +13

Bitul din stânga rămâne în continuare bit de semn. Există o singură

reprezentare a lui 0.

Domeniul de reprezentare a numerelor întregi în complement faţă de 2:

- 2N–1 valori pozitive de la 0 la 2N–1–1.

- 2N–1 valori negative de la –2N–1 la –1.

Avantajul reprezentării în complement faţă de 2 este că adunând un

număr cu complementul său faţă de 2 rezultatul este 0 (ignorând depăşirea)

ceea ce nu este valabil în cazul celorlalte reprezentări.

EXEMPLU:

Pentru N=6 biţi,

13+ 0011012

–13 1100112

= 0 10000002


2.4 ARITMETICA NUMERELOR BINARE ÎN VIRGULĂ FIXĂ

În cele mai multe cazuri, procesoarele de semnal folosesc reprezentarea

în virgulă fixă pentru o reducere a costului şi a complexităţii şi pentru o viteză

de prelucrare mai mare. Considerând reprezentarea unui cuvânt în memorie

pe N biţi vom avea un domeniu de 2N valori zecimale care pot fi reprezentate.

Reprezentarea numerelor cu semn se face în complement faţă de 2.

2.4.1 Aritmetica numerelor întregi în virgulă fixă

Pentru reprezentarea numerelor întregi în virgulă fixă în complement

faţă de doi cuvântul binar este interpretat ca având virgula la dreapta celui

mai puţin important bit (LSB). Cel mai important bit (MSB) este bit de semn.

2N–1 2N–2 ... 20

s i . N biţi

Figura 2-2 Reprezentarea numerelor întregi în virgulă fixă

Domeniul în care pot fi reprezentate numerele întregi în complement

faţă de doi:

1 1,2 ..., 1,0,...,2 1N N− −− − −

EXEMPLU:

Reprezentarea numerelor întregi cu semn pentru N=4 biţi:

Zecimal Binar Zecimal Binar

0 0000 -8 1000 1 0001 -7 1001 2 0010 -6 1010 3 0011 -5 1011 4 0100 -4 1100 5 0101 -3 1101 6 0110 -2 1110 7 0111 -1 1111


Adunarea numerelor întregi cu semn

EXEMPLU:

Pentru N=4 biţi,

1111 011 11 +3 0011 –5 1011 –3 1101 –2 1110 +3 0011 –4 1100

1 0001 –2 1110 –7 1001

Transportul de la bitul cel mai semnificativ se ignoră.

Pot apărea depăşiri ale formatului de reprezentare dacă rezultatul

adunării este mai mare ca 7 sau mai mic ca –8.

EXEMPLU:

Pentru N=4 biţi,

+3 0011 –3 1101 +6 0110 –6 1010

9 1001=–7 –9 0111 =7

Evident ambele rezultate sunt greşite, depăşirea fiind greu de detectat.

Se poate observa că, dacă adunând două numere cu acelaşi semn, rezultatul

are semn opus atunci a apărut depăşirea.

Procesoarele de semnal pot utiliza aritmetica cu saturaţie prin care, în

cazul unei depăşiri, rezultatul este înlocuit cu valoarea limită a intervalului de

reprezentare.

Scăderea numerelor întregi cu semn

Operaţia de scădere este echivalentă cu adunarea cu complementul faţă

de doi al descăzutului (scăderea unui număr e echivalentă cu adunarea

negativului numărului).


Extensia bitului de semn

Este operaţia necesară la creşterea numărului de biţi pentru

reprezentarea binară a unui număr întreg. Bitul de semn este copiat de la

poziţia iniţială (al N-lea bit), spre stânga, până la MSB-ul noului cuvânt binar.

EXEMPLU:

N=4 biţi N’=8 biţi +3 0011 +3 0000 0011 –3 1101 –3 1111 1101

Înmulţirea / împărţirea cu o putere a lui 2

Înmulţirea cu 2k este echivalentă cu deplasarea numărului binar cu k

biţi spre stânga şi completarea cu 0 a biţilor mai puţin semnificativi.

Împărţirea cu 2k este echivalentă cu deplasarea numărului binar cu k

biţi spre dreapta şi extensia bitului de semn.

EXEMPLU:

N=8 biţi N=8 biţi 3 0000 0011 –3 1111 1101 3.22 0000 1100 –3.22 1111 0100

24 0001 1000 –24 1110 1000 24/23 0000 0011 –24/23 1111 1101

Înmulţirea numerelor întregi

Înmulţirea numerelor întregi fără semn în virgulă fixă necesită o

dublare a preciziei reprezentării rezultatului în caz contrar apar depăşiri.

Înmulţirea în binar se face la fel ca în zecimal doar că sunt numai două cifre

(0 şi 1).


EXEMPLU:

Pentru N=4 biţi, rezultatul va fi reprezentat pe cel mult 8 biţi.

6 ×5

__ 30

0110 ×0101 0110 0000 0110 0000 + 0011110

În exemplul de mai sus au fost suficienţi 7 biţi dar dacă se înmulţesc

numere mai mari se poate avea transport şi la al 8-lea bit.

Înmulţirea poate fi privită şi ca o succesiune de deplasări la stânga şi

adunări ale înmulţitorului.

EXEMPLU:

În exemplul de mai sus numărul 5 poate fi scris:

0 25 2 2= +

Deci înmulţirea poate fi calculată ca o sumă:

( )0 2 26 5 6 2 2 6 1 6 2× = × + = × + ×

unde se face o deplasare la stânga a lui 6 cu 2 biţi.

6×1 6×22

0110 0110 + 0011110

Înmulţirea numerelor întregi cu semn trebuie să ia în considerare şi

extensia de semn. Astfel, pentru o reprezentare a rezultatului pe 2N biţi

trebuie ca cei doi operanzi cu semn reprezentaţi fiecare pe N biţi să fie extinşi

la 2N biţi înaintea înmulţirii. Pentru rezultatul înmulţirii vor fi consideraţi cei

mai puţin semnificativi 2N biţi.


EXEMPLU:

–3 × 5

__

–15

11111101 ×00000101 11111101 11111101 + 1111110001

Având în vedere că reprezentarea pe 8 biţi a lui +15 este: 00001111

rezultatul înmulţirii cu semn este corect.

O altă metodă de înmulţire a două numere cu semn este de a înmulţi

numerele în valoare absolută (înmulţire fără semn) apoi se determină semnul

rezultatului din semnele celor doi operanzi şi se reprezintă rezultatul (în

complement faţă de 2 dacă e negativ).

Împărţirea numerelor întregi

Împărţirea numerelor întregi se face prin scăderi repetate ale

împărţitorului din deîmpărţit la fel ca împărţirea în zecimal.

EXEMPLU:

15| 3 1111 11 5 –11

0011 –11 00

101


2.4.2 Aritmetica numerelor fracţionare în virgulă fixă

Un număr fracţionar f este un număr al cărui modul satisface

inegalitatea:

0.0 | | 1.0f≤ <

Exemple de numere fracţionare sunt: 0.15 şi –0.67.

Pentru reprezentarea numerelor fracţionare în virgulă fixă, pe N biţi, în

complement faţă de doi, cuvântul binar este interpretat ca având virgula la

dreapta bitului cel mai semnificativ (MSB) care este bitul de semn.

–20 2–1 ... 2–(N–1)

s . f N biţi

Figura 2-3 Reprezentarea numerelor fracţionare în virgulă fixă

Notând cu 1B N= − numărul de biţi alocaţi pentru valoarea

fracţionară, domeniul în care pot fi reprezentate numerele fracţionare în

complement faţă de doi pe N biţi este:

1,..., 2 ,0,2 ...,1 2B B B− − −− − −

EXEMPLU:

Reprezentarea numerelor fracţionare cu semn pentru N=4 biţi:

Zecimal Binar Zecimal Binar

0 0000 -1 1000 0.125 0001 -0.875 1001 0.250 0010 -0.750 1010 0.375 0011 -0.625 1011 0.500 0100 -0.500 1100 0.625 0101 -0.375 1101 0.750 0110 -0.250 1110 0.875 0111 -0.125 1111


O metodă rapidă de conversie a numerelor fracţionare binare

Pentru o conversie mai rapidă a unui număr fracţionar din reprezentarea

binară în zecimal se observă că f reprezentat în binar pe N=B+1 biţi este

multiplu întreg de 2–B.

Fie i multiplul întreg corespunzător. Avem:

2Bi f= ⋅

ceea ce este echivalent cu o deplasare la stânga cu B biţi. Se obţine în binar un

număr întreg i cu aceeaşi reprezentare ca f.

–20 2–1 ... 2–B

s . f

–2B 2B–1 ... 20

s i . N biţi

Figura 2-4 Conversia fracţionar – întreg pentru reprezentarea pe N biţi

Astfel, pentru conversia binar-zecimal a unui număr fracţionar se

consideră reprezentarea binară ca un număr întreg cu semn şi se împarte la 2B.

EXEMPLU:

Conversia din binar în zecimal,

- pentru 0,010 0110 (N=8 biţi, B=7)

se calculează numărul întreg: 0010 0110 = 3810

se împarte la 27=128: 38/128 = 0.296875

- pentru 1,110 1100 (N=8 biţi, B=7)

se calculează numărul întreg 1110 1100

în complement faţă de 2: 0001 0100 = –2010

se împarte la 27=128: –20/128 = –0.15625


Invers, pentru conversia unui număr fracţionar din reprezentarea

zecimală în binar se înmulţeşte numărul fracţionar f cu 2B şi se reprezintă în

binar partea întreagă i în complement faţă de 2 pe N=B+1 biţi.

EXEMPLU:

Conversia din zecimal în binar,

- pentru 0,875 (N=8 biţi, B=7)

se înmulţeşte cu 27=128: 0,875.128=11210

se reprezintă în binar pe 8 biţi: 11210 = 011100002

- pentru –0,625 (N=8 biţi, B=7)

se înmulţeşte cu 27=128: –0,625.128= –8010

se reprezintă pe 8 biţi: 8010 = 010100002

în complement faţă de 2: –8010 = 101100002

- pentru 0,65 (N=8 biţi, B=7)

se înmulţeşte cu 27=128: 0,65.128= 83,210

se reprezintă partea întreagă: 8310 = 010100112

În ultimul exemplu apare fenomenul de trunchiere deoarece numărul

fracţionar 0,65 nu poate fi reprezentat exact pe 8 biţi. Numărul 010100112

este în zecimal 0.6484375.

Adunarea numerelor fracţionare cu semn

Operaţia de adunare se face la fel ca pentru numerele întregi cu semn.

Reprezentarea în binar şi calculele se efectuează la fel, ceea ce este foarte util,

deoarece se pot folosi aceleaşi circuite de adunare şi pentru numerele întregi

şi pentru numerele fracţionare. Diferă reprezentarea în zecimal a rezultatelor.


EXEMPLU:

Pentru N=4 biţi,

011 111 –0,625 1011 –0,25 1110 +0,375 0011 +0,375 0011 –0,25 1110 0,125 0001

Transportul de la bitul cel mai semnificativ se ignoră.

Pot apărea depăşiri ale formatului de reprezentare dacă rezultatul

adunării este mai mare ca 1–2–B sau mai mic ca –1.

EXEMPLU:

Pentru N=4 biţi,

0,75 0110 –0,875 1001 0,5 0100 –0,25 1110 1,25 1010 = –0,75 –1,125 0111 = 0,75

Înmulţirea numerelor fracţionare cu semn

În cazul înmulţirii numerelor fracţionare apar unele dificultăţi.

Rezultatul înmulţirii în binar a două numere reprezentate cu B biţi pentru

partea fracţionară + 1 bit de semn va trebui reprezentat pe 2B biţi + 1 bit de

semn. Aceasta este echivalent cu o dublare a zecimalelor pentru numerele

fracţionare reprezentate în zecimal.

N biţi s . f ×

1bit B biţi s . f

s . f

1bit 2B biţi

Figura 2-5 Reprezentarea rezultatului înmulţirii numerelor fracţionare


Totuşi, folosind metoda de înmulţire a numerelor binare cu semn,

înmulţind două numere cu semn reprezentate pe N=B+1 biţi rezultă 2N biţi.

Rezultatul va avea cei mai puţin semnificativi 2B biţi corespunzând părţii

fracţionare iar cei mai semnificativi 2 biţi corespund părţii din stânga virgulei

(adică doi biţi de semn).

× N biţi

2N biţi s s . f

2 biţi 2B biţi

Figura 2-6 Reprezentarea rezultatului folosind înmulţirea numerelor întregi

Rezultatul binar astfel obţinut trebuie deplasat la stânga cu un bit pentru

a corespunde reprezentării unui număr fracţionar pe 2N biţi.

s . f 0 1bit 2B biţi 1bit

Figura 2-7 Reprezentarea rezultatului înmulţirii în format fracţionar

Rezultă că nu se pot folosi aceleaşi circuite de înmulţire şi pentru

numerele întregi cu semn şi pentru numerele fracţionare.

EXEMPLU:

0,5 × 0,5

____ 0,25

0100 × 0100 0000 0000 0100 + 00010000 0,0100000

În urma înmulţirii, precizia de reprezentare a rezultatului trebuie

dublată. Dacă se doreşte stocarea rezultatului în precizie simplă se poate face


trunchierea celor mai puţini semnificativi biţi apărând o eroare de trunchiere

la ultimele zecimale ale numărului fracţionar. În cazul înmulţirii a două

numere întregi rezultatul nu poate fi trunchiat în mod direct.

Extinderea preciziei de reprezentare a numerelor fracţionare

În urma operaţiilor aritmetice cu numere fracţionare pot să apară două

fenomene: rezultatul înmulţirii trebuie stocat în dublă precizie şi rezultatul

adunării poate avea depăşiri spre partea întreagă. Pentru aceasta, în

procesoarele digitale de semnal există registre (acumulator) folosite pentru

stocarea în precizie extinsă a rezultatelor intermediare ale unor operaţii

aritmetice.

20.2–1 ... 2–(N–1) s . fracţionar 2M 21 20.2–1 ... 2–(N–1) 2–N ... 2–(2N–1) s întreg . fracţionar fracţionar

M biţi N biţi N biţi

Figura 2-8 Extinderea preciziei de reprezentare a numerelor fracţionare

Extinderea preciziei părţii fracţionare se face completând cu 0 la

dreapta LSB.

Extinderea preciziei părţii întregi se face prin extensie de semn la

stânga MSB.

EXEMPLU:

Să se reprezinte în precizie dublă pentru partea fracţionară şi cu

extensie de 4 biţi pentru partea întreagă numerele fracţionare reprezentate în

precizie simplă pe 8 biţi:

0,5 01000000 -0,25 11100000

0000 01000000 00000000 1111 11100000 00000000


2.5 REPREZENTAREA NUMERELOR ÎN VIRGULĂ MOBILĂ

Formatele în virgulă mobilă pentru procesoarele de semnal din familia

Texas Instruments C3x constau în trei câmpuri:

- exponent;

- semnul;

- partea fracţionară.

Câmpul de semn şi câmpul parte fracţionară pot fi considerate ca o

singură entitate numită mantisa.

Figura 2-9 Formatul general în virgula mobilă

Ecuaţia generală pentru calculul valorii unui număr în virgulă mobilă

este:

2. 2eX ss f= ×

unde: s este bitul de semn, s este inversul valorii bitului de semn, f este

valoarea binară a câmpului reprezentând partea fracţionară şi e este

echivalentul zecimal al câmpului exponent.

Mantisa reprezintă un număr în complement faţă 2 normalizat.

Dacă s=0, atunci primii doi biţi ai mantisei sunt 01.

Dacă s=1, atunci primii doi biţi ai mantisei sunt 10.

Dacă bitul de semn este egal cu 0, mantisa devine 01.f2, unde f este

reprezentarea binară a câmpului parte fracţionară.

Dacă bitul de semn este egal cu 1, mantisa devine egala cu 10.f2, unde f

este reprezentarea binara a câmpului parte fracţionară.


EXEMPLU:

Dacă f=000000000012 şi s=0, valoarea mantisei este

01.000000000012.

Dacă s=1 pentru aceeaşi valoare a lui f, valoarea mantisei este

10.000000000012.

Câmpul exponent este un număr în complement fată de 2 care

determină factorul lui 2 prin care numărul este înmulţit.

Câmpul exponent mută punctul binar în mantisă (la dreapta - dacă

exponentul este pozitiv şi la stânga - daca exponentul este negativ).

EXEMPLU:

Dacă

mantisa = 01.000000000012 şi e=1110

atunci punctul binar este mutat 11 locaţii la dreapta, obţinându-se numărul:

01000000000012

egal cu 2049 în zecimal.

‘C3x suportă patru formate în virgulă mobilă:

1. Imediat scurt, constând într-un exponent pe 4 biţi (în complement

faţă de 2), un bit de semn şi o parte fracţionara pe 11 biţi (sau echivalent un

câmp de 12 biţi reprezentând mantisa în complement fată de 2).

Figura 2-10 Formatul imediat scurt în virgula mobilă


Operaţiile sunt realizate cu un punct binar între biţii 11 şi 10. Numărul

în format virgula mobila imediat scurt este dat de formula următoare:

e

e

01.f 2 daca 0

10.f 2 daca 1

0 daca e=-8

s

x s

⎧ × =⎪= × =⎨⎪⎩

În formatul scurt imediat în virgulă mobilă pentru a reprezenta 0

folosim următoarele valori rezervate:

e=–8, s=0, f =0

Următoarele exemple ilustrează gama de variaţie şi precizia formatului

scurt imediat în virgulă mobilă:

• Cel mai pozitiv: x = (2 – 2 –11 ) × 2 7 = 2.5594 × 102

• Cel mai puţin pozitiv: x = 1 × 2–7 = 7.8125 × 10–3

• Cel mai puţin negativ: x = (–1–2–11 ) × 2–7 = –7.8163 × 10–3

• Cel mai negativ: x = –2 × 27 = –2.5600 × 102

2. Normal scurt, pe 16 biţi, pentru date externe, în complement faţă de

2, format din un câmp de exponent de 8 biţi, un bit de semn şi o parte

fracţionară pe 7 biţi (Figura 2-11).

Figura 2-11 Formatul virgulă mobilă normal scurt pe 16 biţi, pentru date

externe

Numărul în formatul virgulă mobilă normal scurt pe 16 Biţi, pentru

date externe este dat de formula următoare:


e

e

01.f 2 daca 0

10.f 2 daca 1

0 daca e=-128

s

x s

⎧ × =⎪= × =⎨⎪⎩

Pentru a reprezenta 0 folosim următoarele valori rezervate:

e =–128, s =0, f =0

Următoarele exemple ilustrează gama de variaţie şi precizia formatului

în virgulă mobilă normal scurt pe 16 Biţi, pentru date externe:

• Cel mai pozitiv: x = (2 – 2 –8 ) × 2 127 = 3.3961775 × 1038

• Cel mai puţin pozitiv: x = 1 × 2–127 = 5.8774717541 × 10–39

• Cel mai puţin negativ: x = (–1–2–8 ) × 2–127 = –5.9004306 × 10–39

• Cel mai negativ: x = –2 × 2127 = –3.4028236 × 1038

3. Precizie simplă cu un câmp de 8 biţi pentru exponent (e), un bit de

semn şi o parte fracţionara de 23 de biţi (mantisa de 24 de biţi in complement

binar - man), deci pe 32 biţi.

Figura 2-12 Formatul virgulă mobilă în precizie simplă

Operaţiile sunt realizate cu un punct binar implicit între biţii 23 si 22.

Când bitul implicit cel mai semnificativ este explicitat, el este localizat in

imediata vecinătate a punctului binar, in stânga.

Numărul in virgula mobila x este dat de următoarele relaţii:

e

e

01.f 2 daca 0

10.f 2 daca 1

0 daca e=-128

s

x s

⎧ × =⎪= × =⎨⎪⎩


Trebuie folosite următoarele valori rezervate pentru a reprezenta 0:

e=-128, s=0, f=0

Gama de variaţie şi precizia formatului în virgulă mobilă în precizie

simplă:

Cel mai pozitiv: x = (2 – 2 –23 ) × 2 127 = 3.4028234 × 1038

Cel mai puţin pozitiv: x = 1 × 2–127 = 5.8774717 × 10–39

Cel mai puţin negativ: x = (–1–2–23 ) × 2–127 = –5.8774724 × 10–39

Cel mai negativ: x = –2 × 2127 = –3.4028236 × 1038

4. Precizie extinsă constând într-un exponent pe 8 biţi, un bit de semn

şi o parte fracţionara pe 31 de biţi (deci mantisa pe de 32 de biţi). Operaţiile

sunt realizate cu punct binar implicit între biţii 31 si 30.

Figura 2-13 Formatul virgulă mobilă în precizie extinsă

Numărul in virgula mobila x este dat de următoarele relaţii:

e

e

01.f 2 daca 0

10.f 2 daca 1

0 daca e=-128

s

x s

⎧ × =⎪= × =⎨⎪⎩

Trebuie folosite următoarele valori rezervate pentru a reprezenta 0:

e=-128, s=0, f=0

Gama de variaţie şi precizia formatului în virgulă mobilă cu precizie

extinsă:

• Cel mai pozitiv: x=(2-2-23) × 2127=3.4028234 × 1038

• Cel mai puţin pozitiv: x=1 × 2-127=5.8774717541 × 1038


• Cel mai puţin negativ: x=(-1-2-31) × 2-127=-5.8774717569 × 10-39

• Cel mai negativ: x=-2× 2127=-3.4028236691 × 1038

Determinarea echivalentului zecimal a formatului în virgulă mobilă

Pentru a converti numărul ‘C3x în virgulă mobilă la echivalentul său

zecimal, trebuie respectaţi următorii paşi:

Pas 1: Se converteşte câmpul exponent la reprezentarea zecimală.

Câmpul exponent este un număr în complementul faţă de 2.

Pas 2: Se converteşte câmpul mantisa la reprezentarea zecimala. Dacă

bitul de semn este şters (s=0), se formează mantisa scriind 01 şi adăugând biţii

în câmpul fracţie după punctul binar.

EXEMPLU:

Dacă

f=101000000002

atunci

man=01.101000000002.

Dacă bitul de semn este setat (s=1), se formează mantisa prin scrierea

lui 10 şi adăugând biţii în câmpul fracţie după punctul binar.

EXEMPLU:

Dacă

f=101000000002

atunci

man=10. 101000000002


Pas 3: Se deplasează punctul zecimal al mantisei în concordanţă cu

valoarea exponentului. Dacă exponentul este pozitiv, se deplasează punctul

binar la dreapta cu valoarea exponentului. Dacă exponentul este negativ, se

deplasează punctul binar la stângă.

EXEMPLU:

Daca e=210 şi man=01.110000000002, atunci mantisa devine

0111.0000000002, care este echivalent cu 7 în baza zece.

EXEMPLU:

Dacă e=2-10 şi man=01.100000000002, atunci mantisa deplasată devine

0.01100000000002, care este echivalentă cu 3/8 în bază zece.

EXEMPLU:

0 2 4 0 0 0 0 0 Valoarea hexazecimală

0000 0010 0100 0000 0000 0000 0000 0000 Valoarea binară

Exponentul = 0000 00102 = 2; Semn = 0; Fracţie = .100002;

Valoare = 01.12 × 22 = 01102. = 6

EXEMPLU:

0 1 C 0 0 0 0 0 Valoarea hexazecimală

0000 0001 1100 0000 0000 0000 0000 0000 Valoarea binară

Exponentul = 0000 00012 = 1; Semn = 1; Fracţie = .100002;

Valoare = 10.12 × 21 = 1012=–3

Operaţiile în virgulă mobilă presupun şi conversia (automată în

hardware) dintr-un format în altul (Figura 2-14).


Figura 2-14 Conversii în virgulă mobilă

EXEMPLU:

F B 4 0 0 0 0 0 Valoarea hexazecimală

1111 1011 0100 0000 0000 0000 0000 0000 Valoarea binară

Exponent = 1111 10112 = –5; Semn = 0; Fracţie = .100002

Valoare = 01.12 × 2–5 = .0000112 = 3/64

Formatul ‘C3x în virgulă mobilă nu este compatibil cu standardul IEEE

754. Formatul IEEE pentru virgula mobilă foloseşte notaţie semn-

magnitudine pentru mantisă. Într-un cuvânt de 32 biţi reprezentând un număr

în virgulă mobilă, primul bit este bit de semn.

Capitolul 3 – Procesoarele DSP Motorola 56300 31

CAPITOLUL 3

PROCESOARELE DSP MOTOROLA

- FAMILIA 56300 -

3.1 INTRODUCERE

Familia de procesoare Motorola DSP 56300 este prezentată în Figura

3.1-1.

Figura 3.1-1 Familia de procesoare Motorola DSP 56300

Procesoarele digitale de semnal DSP56311 şi DSP56307 sunt folosite

în special în telecomunicaţii. Ca si celelalte componente din familia


DSP56300, aceste dispozitive au evoluat din nucleul DSP56000 Motorola şi

păstrează coduri compatibile.

DSP56307 şi DSP56311, datorită memoriei mari integrate în chip şi a

coprocesorului, destinat în special operaţiilor de filtrare, sunt foarte potrivite

pentru aplicaţii DSP cum ar fi:

- eliminarea ecoului;

- procesarea benzii de baza;

- codarea si decodarea vocii.

Coprocesorul procesează algoritmi de filtrare în paralel cu funcţionarea

nucleului. Memoria RAM mare din interiorul chipurilor elimină stările de

aşteptare, permite funcţionarea pe mai multe canale, îmbunătăţeşte

performantele aplicaţiilor, şi reduce consumul de putere.

Principalele caracteristici ale procesorului DSP56307 sunt

• 170 MIPS, 100 Core MIPS

• EFCOP (coprocesor cu filtrare îmbunătăţită) 100 MIPS

• 64K cuvinte (24-bit) on-chip SRAM

• memoria de program: 16K, 24K, 32K, 40K sau 48K

• memoria de date: 48K, 40K, 32K, 24K sau 16K

• mai multe porturi: 2 porturi ESSI, portul SCI, interfaţa HI08, 6 canale

DMA

Principalele caracteristici pentru procesorul DSP56311 sunt:

• 255 MIPS, 150 Core MIPS;

• EFCOP (coprocesor de filtrare) 150 MIPS;

• memoria de program: 32K, 48K, 64K, 80K sau 96K;

• memoria de date: 96K, 80K, 64K, 48K sau 32K;

• 2 porturi ESSI, port SCI, interfaţa HI08, 6 canale DMA.


Prezentăm două priviri de ansamblu pentru blocurile funcţionale la

DSP563xx.

Pentru privirea de ansamblu 1 apar:

1. Zona perifericelor (Peripheral Expansion Area)

2. Zona memoriei (Memory Expansion Area);

3. Nucleul (DSP56300 Core).

Figura 3.1-2 Privirea de ansamblu 1

Zona perifericelor (Peripheral Expansion Area)

• Coprocesorul - Enhanced Filter Coprocessor (EFCOP);

• Portul de comunicaţie serială - Serial Communications Interface (SCI)

port;

• Timerul - Triple Timer Module;

• Interfaţa HI08 - Host Interface (HI08) port;


• Porturile de comunicaţie serială sincronă - Dual Enhanced Synchronous

Serial Interface (ESSI) ports;

• Pinii I/O - 34 user-configurable General-Purpose I/O (GPIO) pins.

Figura 3.1-3 Privirea de ansamblu 2

Zona memoriei (Memory Expansion Area)

• 128K de cuvinte RAM;

• Memoria de program P: până la 96K x 24 biţi;

• Memoria de date X: până la 48K x 24 biţi;

• Memoria de date Y: până la 48K x 24 biţi;

• Până la 12M cuvinte de memorie externă pentru memoria de program – P

şi date X, Y.


Figura 3.1-4 Nucleul

NUCLEUL (DSP56300 CORE)

• Unitatea aritmetică şi logică - Data Arithmetic Logic Unit (ALU);

• Unitatea de Generare a adreselor Address Generation Unit (AGU);

• Memoria portului A - Port A Memory Expansion;

• Memoria ROM;

• Program Control Unit – Program Control Unit (PCU);

• Controlerul DMA - Direct Memory Access (DMA) Controller;

• Oscilatorul - Phase Lock Loop (PLL) Clock Oscillator;

• Emulatorul - On-Chip Emulator.


3.2 UNITATEA ARITMETICĂ ŞI LOGICĂ (ALU)

Registrele ALU sunt (Figura 3-5):

a) de intrare: X(X1,X0) şi Y(Y1,Y0), cu lungime 48(24,24);

b) acumulatori: A(A2,A1,A0) şi B(B2,B2,B0) cu lungime 56(8,24,24).

47 0 47 0

23 0 23 0 23 0 23 0

55 0 55 0

23 7 0 23 0 23 0 23 7 0 23 0 23 0

*Citiţi ca biţi de extensie de semn.

X1 X0 Y0Y1

B1 B0A1 A0* A2 * B2

DATA ALUREGISTRE ACUMULATOR

DATA ALUREGISTRE DE INTRAREX Y

A B

Figura 3-5 Registrele ALU

În Figura 3-6 este prezentată structura ALU.

DSP56300 foloseşte reprezentarea fracţionară pentru toate operaţiile

ALU.

Virgula zecimală este aliniată la stânga (după bitul de semn).

Pentru a păstra alinierea la virgulă, datele pe 24 de biţi sunt scrise în

partea cea mai semnificativă a acumulatorului (A1 sau B1) iar A0 sau B0 vor

fi 0.

La scrierea operanzilor în acumulator se realizează extensia de semn în

registrele A2 sau B2.


X0

X1

Y0

Y1

MULTIPLICARE

REGISTRE PIPELINE

MUX

REG PIPELINEREGISTRE PIPELINE

UNITATEA PRELUCRARE

PE BIT ŞI DE SHIFTARE

UNITATEA DE

ACUMULARE

ŞI ROTUNJIRE

ŞIFTARE

ACUMULATOR

A(56)

B(56)

SHIFTARE/LIMITARE

Y DATA BUS

P DATA BUS

24 24

X DATA BUS

OPERAND IMEDIAT

24 24

56

48

56

56

56

56 56 56

24

56

24

Figura 3-6 ALU

Rezultatele adunării şi scăderii sunt echivalente atât pentru numerele

fracţionare cât şi pentru numerele întregi.


La înmulţire sau la împărţire reprezentarea numerelor fracţionare diferă

de a numerelor întregi. Pentru înmulţirea numerelor întregi, datele sunt

aliniate la dreapta şi virgula zecimală este considerată la dreapta LSB.

Deoarece rezultatul înmulţirii este aliniat la dreapta, rezultă extensia la

doi biţi de semn. Pentru înmulţirea numerelor fracţionare, datele sunt aliniate

la stânga, cu virgula după bitul de semn.

Rezultatul înmulţirii este de asemenea aliniat la stânga şi se adaugă un

zero la LSB pentru completarea celor 2N biţi.

Rezultatul corect al înmulţirii numerelor întregi se obţine prin

deplasarea (shiftarea) aritmetică la dreapta cu un bit a rezultatului înmulţirii

fracţionare.

ÎNMULŢIREA NUMERELOR CU SEMN N x N –> 2N – 1 BIŢI

S

INTREG FRACŢIONAL

S

REZULTAT 2N – 1EXTENSIE DE SEMN

2N BIŢI

ÎNMULŢIRE CU SEMN

S MSP LSPS

S S

REZULTAT 2N – 1COMPLETARE CU ZERO

2N BIŢI

ÎNMULŢIRE CU SEMN

S MSP LSP 0

Figura 3-7 Înmulţirea numerelor întregi

Unitatea de înmulţire-acumulare (MAC UNIT)

Datele de intrare în MAC pot fi numai din registrele X sau Y.

Unitatea efectuează înmulţiri pe 24 x 24 biţi în format fracţionar,

operanzi cu sau fără semn.

Rezultatul înmulţirii este adunat la acumulatorul destinaţie

(instrucţiunea MAC).


Dacă se foloseşte instrucţiunea MPY, acumulatorul este şters şi apoi se

scrie rezultatul înmulţirii.

Dacă rezultatul înmulţirii (56 biţi) este stocat ca operand pe 24 de biţi

LSP poate fi trunchiat sau rotunjit (rotunjirea cu instrucţiunile MACR,

MPYR, MACRI, MPYRI). Rotunjirea poate fi convergentă sau în

complement faţă de 2.

La stocarea în acumulator rezultatul înmulţirii poate fi saturat astfel ca

acesta să intre în 48 de biţi (fără a se mai folosi extensia acumulatorului A2

sau B2).

Înmulţirea cu acumulare

MAC (±)S1,S2,D 1 2D S S D± ⋅ →

S1, S2 - surse: registre: X0,Y0, X1,Y1

D - destinaţia: acumulator: A, B

MAC (±)S,#n,D 2 nD S D−± ⋅ →

S - sursa: registre: X0,Y0,X1,Y1

#n valoare imediată <23

D - destinaţia: acumulator: A,B

Înmulţirea

MPY (±)S1,S2,D 1 2S S D± ⋅ →

S1, S2 - surse: registre: X0,Y0,X1,Y1


MPY (±)S,#n,D 2 nS D−± ⋅ →

S - sursa: registre: X0,Y0, X1,Y1

#n valoare imediată <23



Înmulţirea cu acumulare cu operand imediat

MACI (±)#xxxx,S,D #D xxxx S D± ⋅ →

S - sursa: registre: X0,Y0, X1,Y1

#xxxx valoare imediată pe 24 biţi


Înmulţirea cu operand imediat

MPYI (±)#xxxx,S,D # xxxx S D± ⋅ →

S - sursa: registre: X0, Y0, X1, Y1

#xxxx valoare imediată pe 24 biţi


EXEMPLU:

Înmulţirea numerelor complexe se face conform formulei:

( ) ( )R I R I R IC jC A jA B jB+ = + ⋅ +

Rezultă:

R R R I I

I R I I R

C A B A BC A B A B

= ⋅ − ⋅= ⋅ + ⋅

Putem lua un exemplu numeric:

( ) ( )0.5 0.2 0.4 0.1 0.18 0.13j j j+ ⋅ + = +

Vom iniţializa registrele de date ale ALU astfel:

x1 x0 y1 y0

0.5RA = 0.4RB = 0.2IA = 0.1IB =

Rezultatul va fi obţinut în registrele acumulator astfel:

a b

0.18RC = 0.13IC =


Programul în limbaj de asamblare este următorul:

move #0.5,x1 x1 x0move #0.4,x0 0.5 0.4move #0.2,y1 y1 y0move #0.1,y0 0.2 0.1

ampy x0,x1,a 0.2mac -y0,y1,a 0.2 + (-0.02) = 0.18 bmpy y0,x1,b 0.05mac x0,y1,b 0.05 + 0.08 = 0.13

Registrele acumulator A şi B

Sunt registrele de 56 de biţi, fiecare registru acumulator constă din trei

registre concatenate A2:A1:A0 sau B2:B1:B0. Oricare din cele 6 registre

menţionate pot fi scrise/citite pe magistrala de date X sau Y.

Dacă se doreşte transferul întregului acumulator pe magistrala X sau Y,

cei 56 de biţi din acumulator sunt shiftaţi/limitaţi la 24 de biţi.

Registrele acumulator sunt folosite ca:

- destinaţie pentru înmulţire şi operaţii logice;

- sursă / destinaţie pentru adunare şi deplasări.

Adunarea

ADD S,D S D D+ →

S - sursa: registru: B/A, X, Y, X0, Y0, X1, Y1

valoare imediată: #$xx, #$xxxxxx

D - destinaţia: acumulator: A/B


Scăderea

SUB S,D D S D− →

S - sursa: registru: B/A, X, Y, X0, Y0, X1, Y1



Un tip special de instrucţiuni sunt cele de înmulţire / împărţire cu 2 a

acumulatorului şi adunarea / scăderea unui operand. Aceste instrucţiuni sunt

utile în implementarea eficientă a fluturilor pentru decimare în timp la

algoritmii FFT.

Deplasarea la stânga şi acumularea

ADDL S,D 2S D D+ ⋅ →

Deplasarea la dreapta şi acumularea

ADDR S,D / 2S D D+ →

Deplasarea la stânga şi scăderea

SUBL S,D 2 D S D⋅ − →

Deplasarea la dreapta şi scăderea

SUBR S,D / 2D S D− →

S - sursa: acumulator: B/A



EXEMPLU:

Să considerăm funcţia de transfer:

1 * 1 * 1 * 2 1 2 2

1 1 1( )

(1 )(1 ) 1 ( ) 1 2Re{ } | |H z

pz p z p p z p pz p z p z− − − − − −= = =− − − + + − +

Ieşirea ( )y n poate fi calculată astfel:

2( ) 2Re{ } ( 1) | | ( 2) ( )y n p y n p y n x n= − − − +

Pentru un exemplu numeric:

0.8 0.5p j= − .

Avem

2| | 0.64 0.25 0.89p = + =

( ) 2 0.8 ( 1) 0.89 ( 2) ( )y n y n y n x n= ⋅ − − − +

Considerăm că avem în registrele y0, y1 şi b stările filtrului:

y1 y0 b

( 2)y n − ( 1)y n − ( )x n

Deoarece termenul 2Re{ }p are valori supraunitare nu putem stoca

direct valoarea 1.6 în registrul x0.

x1 x02| | 0.89p = Re{ } 0.8p =

Programul va calcula ieşirea ( )y n folosind instrucţiunea addl astfel:

mac x0,y0,a ; 0.8 ( 1)a y n= −

mac -x1,y1,b ; ( ) 0.89 ( 2)b x n y n= − −

addl b,a ; 2 ( )a a b y n= + ⇒


3.3 UNITATEA LOGICĂ ŞI DE DEPLASARE

Conţine un registru de deplasare pe 56 de biţi, bidirecţional, multi-bit şi

unitatea de procesare logică. Operaţiile efectuate sunt:

- deplasare stânga / dreapta multi-bit aritmetică şi logică;

- rotaţie cu 1 bit stânga / dreapta;

- extragerea, inserţia, concatenarea unui câmp de biţi;

- normalizarea acumulatorului;

- operaţii logice.

Deplasare aritmetică la stânga

ASL D cu un bit

ASL S1,S2,D cu mai mulţi biţi

Deplasare aritmetică la dreapta

ASR D cu un bit

ASR S1,S2,D cu mai mulţi biţi

S1 - număr de biţi: registru: X0,Y0,X1,Y1,A1,B1 sau

valoare imediată pe 6 biţi: #n

S2 - sursa: acumulator: A,B



EXEMPLU:

asl #7,a,b

asr x0,a,b

Deplasare logică la stânga

LSL D cu un bit

LSL S,D cu mai mulţi biţi

Deplasare logică la dreapta

LSR D cu un bit

LSR S,D cu mai mulţi biţi

S - număr de biţi: registru: X0, Y0, X1, Y1, A1,B1

valoare imediată pe 6 biţi: #n



EXEMPLU:

lsl #7,a

lsr x0,b

Rotaţie la stânga cu un bit

ROL D

D: acumulator A,B

Rotaţie la dreapta cu un bit

ROR D

D: acumulator A,B


Normalizarea acumulatorului

• pasul 1: se numără câţi biţi de 0 sau de 1 consecutivi sunt în acumulator

începând de la MSB (bitul 55);

• pasul 2: se scade acest număr din 9 şi se scrie rezultatul în MSP a

acumulatorului destinaţie (A1 sau B1). Acest rezultat este în intervalul –47,

+8;

• pasul 3: se shiftează aritmetic acumulatorul, la dreapta dacă operandul e

pozitiv, sau la stânga dacă e negativ, cu numărul de biţi egal cu diferenţă

anterioară.

CLB S,D D = 9 nr. MSB de 0 sau de 1din S

S - sursa: acumulator: A/B

D - destinaţia: MSP acumulator: B/A

Normalizarea acumulatorului

NORMF S,D dacă S[23]=0 atunci ASR S,D altfel ASL –S,D

S - sursa: registru: X0,Y0,X1,Y1,A1,B1


EXEMPLU:

Înaintea execuţiei După execuţie

clb a,b A: $20:0000:0000 B: $00:0007:0000

normf b1,a A: $20:0000:0000 A: $00:4000:0000


Manipularea câmpurilor de date

EXEMPLU:

extract b1,a,a

EXEMPLU:

insert b1,x0,a

EXEMPLU:

merge x0,b


Instrucţiuni logice

Şi logic

AND S,D [47 24] [47 24]S D D• − → −

S - sursa: registru: X0,Y0, X1,Y1



Sau logic

OR S,D [47 24] [47 24]S D D+ − → −

S - sursa: registru: X0, Y0, X1, Y1



Nu logic

NOT D [47 24] [47 24]D D− → −


Sau exclusiv

EOR S,D [47 24] [47 24]S D D⊕ − → −

S - sursa: registru: X0, Y0, X1, Y1




EXEMPLU: Conversia din binar în cod Gray

Două numere consecutive scrise în codul Gray diferă printr-un singur

bit.

Binar Gray Binar Gray

0000 0000 1000 1100

0001 0001 1001 1101

0010 0011 1010 1111

0011 0010 1011 1110

0100 0110 1100 1010

0101 0111 1101 1011

0110 0101 1110 1001

0111 0100 1111 1011

Obţinerea numărului în cod Gray se face cu operaţia sau-exclusiv între

numărul scris în binar şi numărul binar deplasat (shiftat la dreapta) cu un bit.

De exemplu: codul Gray pentru numărul 0110:

0110 EOR 0011 = 0101

Pseudocodul programului este:

for (b=0,b<N,b++)

{ a = b;

x0 = a;

a = lsr a;

a = x0 eor a;

}

Valoarea binară care trebuie convertită este scrisă din acumulatorul b în

a cu instrucţiunea tfr b,a care utilizează magistrala internă ALU (56 biţi).


Registrul x0 este folosit ca registru temporar pentru a păstra valoarea

lui a1.

Instrucţiunea lsr a efectuează deplasarea logică la dreapta cu un bit a

registrului a1 (biţii 47-24).

Instrucţiunea eor x0,a efectuează operaţia sau-exclusiv între x0 şi a1 iar

rezultatul este în a1.

Valoarea binară din b este incrementată (x1=1) şi se continuă cu

următoarea valoare binară.

Etichetă Instr. OperanziMagistrala de

date XMagistralade date Y

Cicluriceas

clr b #>1,x1 1

do #N,_endtst 5

tfr b,a 1

lsr a a1,x0 2 i’lock

eor x0,a 1

add x1,b a1,x:output 2 i’lock

_endt

TOTAL 6N+6

Unitatea de Scalare şi Limitare

Datele transferate din acumulator spre magistralele de date XDB sau

YDB trec prin aceste unităţi de scalare şi limitare.

Scalarea se poate face în funcţie de biţii S1 şi S0 din Status Register

(SR) astfel:

• S1=1, S0=0 în sus – shiftează data la stânga cu un bit.

• S1=0, S0=1 în jos – shiftează data la dreapta cu un bit.

• S1=0, S0=0 nu se efectuează scalarea – datele trec nemodificate.


Scalarea se face automat asupra datelor pe 24 de biţi transferate pe

magistrală, fără a afecta rezultatul din acumulator.

Limitarea apare dacă vrem să transferăm pe magistrala XDB sau YDB

(de 24 de biţi) operanzi din acumulator reprezentaţi pe 56 de biţi (care

folosesc şi cei 8 biţi de extensie). Nu apare limitarea dacă operanzii transferaţi

sunt din A1, A0, B1, B0.

Sunt două unităţi de scalare-limitare ceea ce permite transferul pe XDB

şi YDB prin limitarea a doi operanzi simultan sau limitarea unui operand la

48 de biţi.

Valorile la care sunt limitaţi operanzii ce depăşesc numărul de biţi ai

magistralei de date sunt:

• $7FFFFF – pentru valori pozitive pe 24 de biţi

• $7FFFFF FFFFFF – pentru valori pozitive pe 48 de biţi

• $800000 – pentru valori negative pe 24 de biţi

• $800000 000000 – pentru valori negative pe 48 de biţi

Operaţia de limitare nu afectează conţinutul acumulatorului, spre

deosebire de operaţia de saturare aritmetică.

EXEMPLU:

Fără limitare Cu limitare

A2 A1 A0 A2 A1 A00000 10000…0 00000…0 = 1 0000 10000…0 00000…0 = 1

move a1,x0 move a,x0

X0 10000…0 = –1 X0 01111…1 = 0.999999Eroarea = 2 Eroarea = 0.000001


Saturarea aritmetică

Acest mod este setat de bitul SM din Status Register (SR). Rezultatul

oricărei operaţii aritmetice este limitat la 48 de biţi în acumulator.

Acest mod foloseşte algoritmilor care nu lucrează cu extensia

acumulatorului (A2 sau B2) obţinându-se un rezultat saturat la 48 de biţi.

Saturarea se efectuează în funcţie de trei biţi: EXT[7], EXT[0] din

partea extinsă a acumulatorului şi bitul cel mai semnificativ al lui A1 sau B1:

MSP[23].

EXT[7] EXT[0] MSP[23] ACUMULATOR

0 0 0 neschimbat

0 0 1 $00 7FFFFF FFFFFF



1 0 0 $FF 800000 000000

1 0 1 $FF 800000 000000

1 1 0 $FF 800000 000000

1 1 1 neschimbat

Modurile de rotunjire

Instrucţiunile care efectuează operaţii de rotunjire a rezultatului din

acumulator pe 24 de biţi sunt:

• MACR, MACRI – înmulţire cu acumulare şi rotunjire.

• MPYR, MPYRI – înmulţire cu rotunjire.

• RND – rotunjirea valorii din acumulator.

Unitatea ALU de date efectuează rotunjirea porţiunii superioare MSP a

acumulatorului în funcţie de conţinutul părţii inferioare LSP a acumulatorului.


Sunt două tipuri de rotunjiri în funcţie de bitul Rounding Mode (RM) din

porţiunea EMR a Status Register:

• rotunjire convergentă (rotunjire la numărul par).

X X X …X X X0100 011XXX…XXXX X..XX A2 A1 A0

CAZUL I: DACĂ A0< $800000 (1/2), ATUNCI ROTUNJEŞTE ÎN JOS (NU SE ADUNĂ NIMIC)

ÎNAINTEA ROTUNJIRII

55 48 47 24 23 0

0

X X X …X X X0100 000…………000X X..XX A2 A1 A0*

DUPĂ ROTUNJIRE

55 48 47 24 23 0

X X X …X X X0100 1110XX….XXXX X..XX A2 A1 A0

CAZUL II: DACĂ A0> $800000 (1/2), ATUNCI ROTUNJEŞTE ÎN SUS (ADUNĂ 1 LA A1)

ÎNANTEA ROTUNJIRII

55 48 47 24 23 0

1

X X X …X X X0101 000…………000X X..XX A2 A1 A0*

DUPĂ ROTUNJIRE

55 48 47 24 23 0

X X X …X X X0100 10000…….000X X..XX A2 A1 A0

CAZUL III: DACĂ A0= $800000 (1/2), ŞI LSB A1=0, ATUNCI ROTUNJEŞTE ÎN JOS (NU ADUNĂ NIMIC)


55 48 47 24 23 0

0

X X X …X X X0100 000…………000X X..XX A2 A1 A0*

DUPĂ ROTUNJIRE

55 48 47 24 23 0

X X X …X X X0101 10000………000X X..XX A2 A1 A0

CAZUL IV: DACĂ A0= $800000 (1/2), ŞI LSB A1=1, ATUNCI ROTUNJEŞTE ÎN SUS (ADUNĂ 1 LA A1)


55 48 47 24 23 0

1

X X X …X X X0110 000…………000X X..XX A2 A1 A0*

DUPĂ ROTUNJIRE

55 48 47 24 23 0


• rotunjire în complement faţă de 2.

X X X …XXX0100 011XXX…XXXX X..XX A2 A1 A0

CAZUL I: DACĂ A0< $800000 (1/2), ATUNCI ROTUNJEŞTE ÎN JOS (NU SE ADUNĂ NIMIC)


55 48 47 24 23 0

0

X X X …X X X0100 000…………000X X..XX A2 A1 A0*

DUPĂ ROTUNJIRE

55 48 47 24 23 0

X X X …X X X0100 1110XX….XXXX X..XX A2 A1 A0

CAZUL II: DACĂ A0> $800000 (1/2), ATUNCI ROTUNJEŞTE ÎN SUS (ADUNĂ 1 LA A1)


55 48 47 24 23 0

1

X X X …X X X0101 000…………000X X..XX A2 A1 A0*

DUPĂ ROTUNJIRE

55 48 47 24 23 0

X X X …X X X0100 10000…….000X X..XX A2 A1 A0

CAZUL III: DACĂ A0= $800000 (1/2), ŞI LSB A1=0, ATUNCI ROTUNJEŞTE ÎN SUS (ADUNĂ 1 LA A1)


55 48 47 24 23 0

1

X X X …X X X0101 000…………000X X..XX A2 A1 A0*

DUPĂ ROTUNJIRE

55 48 47 24 23 0

X X X …X X X0101 10000………000X X..XX A2 A1 A0

CAZUL IV: DACĂ A0= $800000 (1/2), ŞI LSB A1=1, ATUNCI ROTUNJEŞTE ÎN SUS (ADUNĂ 1 LA A1)


55 48 47 24 23 0

1

X X X …X X X0110 000…………000X X..XX A2 A1 A0*

DUPĂ ROTUNJIRE

55 48 47 24 23 0


3.4 UNITATEA DE GENERARE A ADRESELOR (AGU)

Unitatea de generare a adreselor este prezentată în Figura 3.3-1.

N0 M0

N1 M1N2 M2N3 M3

R0 R4

R1 R5R2 R6R3 R7

M4 N4

M5 N5M6 N6M7 N7

EI

Multiplexor Triplu

ALUAdrese

ALUAdrese

Magistrala de date globale

Magistrala de date de program

XAB YAB PAB

ALU adrese primare ALU adrese secundare

Figura 3.3-1 Unitatea de generare a adreselor DSP 56300

AGU calculează adresa efectivă pentru adresarea operanzilor în

memorie.

Sunt realizate patru tipuri de calcule aritmetice:

- liniar;

- modulo;

- modulo cu revenire la adresa de bază;

- bit-reversed.

AGU este compusă din două părţi, fiecare având o unitate aritmetico-

logică de adrese şi patru grupe de registre.


Fiecare grup conţine trei tipuri de registre:

• Rn - registru de adresă;

• Nn - registru ofset;

• Mn - registru de modificare.

Registre R, N şi M sunt tratate împreună (de exemplu numai N2 şi M2

sunt folosiţi pentru actualizarea adresei din R2). Cele două ALU pot genera

două adrese pe 24 de biţi într-un singur ciclu instrucţiune pentru adresarea pe

magistralele XAB, YAB, sau o adresă pentru PAB. Spaţiul de memorie

adresabil este de 16M cuvinte, pentru fiecare zonă de memorie (X, Y, P).

Fiecare unitate ALU de adrese conţine:

a) un sumator de ofset pe 24 de biţi care adună la registrul adresă R:

• plus unu;

• minus unu;

• conţinutul registrului ofset N corespunzător;

• minus ofsetul N.

b) un sumator modulo care adună rezultatul primului sumator la valoarea

modulo (M sau minus M) conţinută în registrul modificator M.

c) un sumator cu transport invers care adună la registrul R (cu transport de

la MSB la LSB):

• plus unu;

• minus unu;

• conţinutul registrului ofset N corespunzător;

• minus ofsetul N.

Printr-un test logic se selectează ieşirea sumatorului ce va fi folosită

drept adresă efectivă şi actualizarea registrului R.


Modelul de Programare AGU

Pentru programator, AGU reprezintă trei grupuri de 8 registre care pot

fi folosiţi atât ca registre temporare de date cât şi ca pointeri pentru adresarea

indirectă (Figura 3.3-2).

Fiecare registru de adresare R are asociat un registru ofset N şi un

registru modificator M.

Registrele R sunt utilizate la calculul adresei efective a operanzilor în

memorie.

Registre N sunt folosite pentru furnizarea unui ofset pentru actualizarea

adresei.

Registre M selectează tipul de actualizare aritmetică a adresei.

R7R6R5R4R3R2R1R0EP

N7N6N5N4N3N2N1N0

M7M6M5M4M3M2M1M0

23 0 23 0 23 0

Registre adresă Registre ofset Registre modificator

Setul secundar

Setul primar

Figura 3.3-2 Modelul de Programare AGU

La transferul paralel al datelor din memoria X şi Y registre de adresă

trebuie folosite separat:

- pentru transferul din memoria X - registrele R0 - R3;

- pentru transferul din memoria Y - registrele R4 - R7.


Moduri de Adresare

Se specifică dacă operanzii sunt în registre şi / sau în locaţii din

memorie şi oferă adresa acestora.

Familia DSP56300 oferă patru moduri principale de adresare:

- adresare directă cu registru;

- adresare indirectă cu registru;

- adresare relativă la PC;

- alte adresări speciale (adresare imediată, adresare absolută, etc.).

Adresare directă cu registru

Operandul este în unul din registre

- de date: A2, A1, A0, B2, B1, B0, X1, X0, Y1, Y0;

- de adrese: R0-R7, N0-N7, M0-M7;

- de control: OMR, SR, PC, VBA, LA, LC, SP

EXEMPLU:

Adresare cu registru de date

move x0,a1 X X X X X X 8 7 6 5 4 3

X X X X X X X X X X X XX X

X1 X0

A2 A1 A0

ÎNAINTEA EXECUŢIEI DUPĂ EXECUŢIE

X X X X X X 8 7 6 5 4 3

8 7 6 5 4 3 X X X X X XX X

X1 X0

A2 A1 A0

EXEMPLU:

Adresare cu registru de adrese

move a,n7

X X X X X X

1 2 3 4 5 6 7 8 9 a b c0 0

N7

A2 A1 A0


1 2 3 4 5 6

1 2 3 4 5 6 7 8 9 a b c0 0

N7

A2 A1 A0


Adresare indirectă cu registru

Un registru adresă Rn este folosit pentru a indica adresa operandului în

memorie. Pot fi efectuate operaţii aritmetice asupra adresei înainte sau după

execuţia instrucţiunii. Registrul ofset Nn asociat registrului adresă Rn indică

valoarea care va fi adunată la Rn. Registrul modificator Mn indică tipul

operaţiei aritmetice care urmează să fie efectuată când este actualizat Rn.

Pentru adresare liniară M=$FFFFFF.

EXEMPLU:

Fără actualizare (Rn)

move a1,x:(r0)

1 2 3 4 5 6 X X X X X XX X A2 A1 A0


1 2 3 4 5 6 X X X X X XX X A2 A1 A0

::

X X X X X X::

0 0 1 0 0 0

X X X X X X

F F F F F F

Memoria X:

23 0

$ 1000

R0

N0

M0

::

1 2 3 4 5 6::

0 0 1 0 0 0

X X X X X X

F F F F F F

Memoria X:

23 0

$ 1000

R0

N0

M0

EXEMPLU:

Postincrementare cu o unitate (Rn)+

move b0,y:(r1)+

X X X X X X 1 2 3 4 5 6X X B2 B1 B0


X X X X X X 1 2 3 4 5 6X X B2 B1 B0

::

X X X X X X:

0 0 2 0 0 0

X X X X X X

F F F F F F

Memoria Y:

23 0

$ 2000

R1

N1

M1

:X X X XX X

1 2 3 4 5 6:

0 0 2 0 0 1

X X X X X X

F F F F F F

Memoria Y:

23 0

$ 2000

R1

N1

M1

$ 2001


EXEMPLU:

Postdecrementare cu o unitate (Rn)–

move y0,y:(r2)–

X X X X X X F E D C B A Y1 Y0


X X X X X X F E D C B A Y1 Y0

:X X X X X X

::

0 0 3 0 0 0

X X X X X X

F F F F F F

Memoria Y:

23 0

$ 3000

R2

N2

M2

:F E D C B AX X X X X X

:

0 0 2 F F F

X X X X X X

F F F F F F

Memoria Y:

23 0

$ 2FFF

R2

N1

M1

$ 3000

EXEMPLU:

Postincrementare cu ofset (Rn)+Nn

move x1,x:(r4)+n4

9 8 7 6 5 4 X X X X X X X1 X0


9 8 7 6 5 4 X X X X X X X1 X0

::::

0 0 5 0 0 0

0 0 0 0 0 4

F F F F F F

Memoria X:

23 0

$ 5000

R4

N4

M4

X X X X X::

0 0 5 0 0 4

0 0 0 0 0 4

F F F F F F

Memoria X:

23 0

$ 5000

R4

N4

M4

$ 5004

X X X X X 9 8 7 6 5 4


EXEMPLU:

Postdecrementare cu ofset (Rn)–Nn

move x:(r5)–n5,a0


4 5 6 7 8 9:::

0 0 6 0 0 0

0 0 0 0 0 5

F F F F F F

Memoria X:

23 0$ 6000

R5

N5

M5

4 5 6 7 8 9::

0 0 5 F F B

0 0 0 0 0 5

F F F F F F

Memoria X:

23 0

$ 5FFB

R5

N5

M5

$ 6000

: :

X X X X X X X X X X X XX X A2 A1 A0

0 0 0 0 0 0 4 5 6 7 8 90 0 A2 A1 A0

: X X X X X

EXEMPLU:

Predecrementare cu o unitate –(Rn)

move x:–(r3),b


:X X X X X X

1 2 1 2 1 2:

0 0 4 0 0 0

X X X X X X

F F F F F F

Memoria X:

23 0

$ 4000

R3

N3

M3

:X X X X X X

1 2 1 2 1 2:

0 0 3 F F F

X X X X X X

F F F F F F

Memoria X:

23 0

$ 3FFF

R3

N3

M3

$ 4000

X X X X X X X X X X X XX X B2 B1 B0

1 2 1 2 1 2 0 0 0 0 0 00 0 B2 B1 B0


EXEMPLU:

Deplasament scurt (Rn+#nn)

move a,x:(r0+#<$07)


X X X X X X:::

0 0 2 0 0 0

X X X X X X

F F F F F F

Memoria X:

23 0$ 2000

R0

N0

M0

1 2 3 4 5 6:::

0 0 2 0 0 0

X X X X X X

F F F F F F

Memoria X:

23 0

$ 2000

R0

N0

M0

$ 2007

: :

1 2 3 4 5 6 0 0 0 0 0 00 0 A2 A1 A0

1 2 3 4 5 6 0 0 0 0 0 00 0 A2 A1 A0

X X X X X X X X X X X$ 2000

EXEMPLU:

Deplasament lung (Rn+#nnnnnn)

move y:(r1+#>$123456),x0


a b c d e f:::

0 0 0 0 0 0

X X X X X X

F F F F F F

Memoria Y:

23 0$ 123456

R1

N1

M1

a b c d e f:::

0 0 0 0 0 0

X X X X X X

F F F F F F

Memoria Y:

23 0

$ 0000000

R1

N1

M1

$ 123456

: :

X X X X X XX0

a b c d e fX0

X X X X X X X X X X X$ 000000


EXEMPLU:

Indexare cu ofset (Rn+Nn)

move y0,x:(r6+n6)


:X X X X X X

::

0 0 7 0 0 0

0 0 0 0 0 3

F F F F F F

Memoria Y:

23 0

$ 7003

R6

N6

M6

:A B C D E F

:

0 0 7 0 0 0

0 0 0 0 0 3

F F F F F F

Memoria Y:

23 0

$ 7000

R6

N6

M6

$ 7003

X X X X X X X X X X X X: :

X X X X X X A B C D E F Y1 Y0

X X X X X X A B C D E F X1 X0

$ 7000

Moduri speciale de adresare

Acestea nu folosesc un registru pentru a specifica adresa operandului.

Operandul sau adresa acestuia sunt conţinute în codul instrucţiunii.

Adresare imediată.

Acest mod de adresare indică un operand pe 24 biţi în cadrul

instrucţiunii.

EXEMPLU:

Date în acumulator pe 24 biţi

move #$123456,a0ÎNAINTEA EXECUŢIEI DUPĂ EXECUŢIE


X X X X X X 1 2 3 4 5 6X X A2 A1 A0


EXEMPLU:

Date pozitive în acumulator pe 56 biţi

move #$654321,aÎNAINTEA EXECUŢIEI DUPĂ EXECUŢIE


6 5 4 3 2 1 0 0 0 0 0 00 0 A2 A1 A0

EXEMPLU:

Date negative în acumulator pe 56 biţi

move #$876543,bÎNAINTEA EXECUŢIEI DUPĂ EXECUŢIE


8 7 6 5 4 3 0 0 0 0 0 0F F B2 B1 B0

Adresare imediată cu date scurte.

Operandul este pe 8 sau 12 biţi.

EXEMPLU:

Date scurte în registru pe 24 biţi

move #$FE,y1ÎNAINTEA EXECUŢIEI DUPĂ EXECUŢIE

X X X X X X X X X X X X Y1 Y0

F E 0 0 0 0 X X X X X X Y1 Y0

EXEMPLU:

Date scurte în acumulator 24 biţi

move #$FE,a1ÎNAINTEA EXECUŢIEI DUPĂ EXECUŢIE


0 0 0 0 F E X X X X X XX X A2 A1 A0

EXEMPLU:

Date scurte pozitive în acumulator 56 biţi

move #$34,aÎNAINTEA EXECUŢIEI DUPĂ EXECUŢIE


3 4 0 0 0 0 0 0 0 0 0 00 0 A2 A1 A0


EXEMPLU:

Date scurte negative în acumulator 56 biţi

move #$87,bÎNAINTEA EXECUŢIEI DUPĂ EXECUŢIE


8 7 0 0 0 0 0 0 0 0 0 0F F B2 B1 B0

Dacă destinaţia este A2, A1, A0, B2, B1, B0, R0-R7, N0-N7 atunci

operandul imediat pe 8 biţi este tratat ca un întreg fără semn.

Dacă destinaţia este X1, X0, Y1, Y0, A, B atunci operandul imediat pe

8 biţi este tratat ca un număr fracţionar cu semn.

Adresare absolută.

Adresa operandului este conţinută în codul instrucţiunii.

EXEMPLU:

Adresare absolută lungă (adresa pe 24 biţi)

move y:$1000,b0



X X X X X X 7 6 5 4 3 2X X B2 B1 B0

:7 6 5 4 3 2

:

Memoria Y:

23 0

$ 1000:

7 6 5 4 3 2:

Memoria Y:

23 0

$ 1000

EXEMPLU:

Adresare absolută scurtă (adresa pe 6 biţi)

move a1,x:$21

7 6 5 4 3 2 X X X X X XX X A2 A1 A0


7 6 5 4 3 2 X X X X X XX X A2 A1 A0

::

X X X X X X::

Memoria X:

23 0

$ 000021

::

7 6 5 4 3 2::

Memoria X:

23 0$ 00003F

$ 000000

Domeniupentru

adresareabsolutăscurtă

$ 000021

$ 00003F

$ 000000


Adresarea absolută scurtă foloseşte o adresă de 6 biţi în codul

instrucţiunii completată cu zerouri.

Este posibilă adresarea primelor 64 cuvinte din memorie (vectori de

întrerupere etc.)

Adresare I/O scurtă.

Acest mod foloseşte o adresă de 6 biţi în codul instrucţiunii completată

cu unu. Sunt adresate ultimele 64 cuvinte din memorie.

EXEMPLU:

movep a1,x:$fffffd

A B C D E F X X X X X XX X A2 A1 A0


A B C D E F X X X X X XX X A2 A1 A0

::

X X X X X X::

Memoria X:

23 0

$ FFFFFD

::

A B C D E F::

Memoria X:

23 0$ FFFFFF

$ FFFFC0

Spaţiul pentruadresareaabsolută

scurtă I/O

$ FFFFFD

$ FFFFFF

$ FFFFC0

Adresare scurtă pentru salt.

Acest mod foloseşte o adresă de 12 biţi în codul instrucţiunii pentru

saltul în program. PC este modificat cu această adresă completata cu zero.

Sunt adresate ultimele 4096 cuvinte.


EXEMPLU:

jmp <$123


::

jmp $0123::

Memoria P:

23 0

$ 000000

Memoria P:

23 0

$ 000FFF

Spaţiu deadresă pentru

salt scurt

:::::::::::::

::::::::::

Instr. următ.Instr. următ.

::::::

$001FF9

$ 000000

$ 000FFF

PC

$000123PC

Adresare relativă la PC (Program Counter)

Adresa operandului este obţinută adunând un deplasament la adresa

instrucţiunii curente aflată în PC. Deplasamentul poate fi:

• scurt (9 biţi), conţinut în codul instrucţiunii.

• lung (24 biţi), conţinut în cuvântul extensie din codul instrucţiunii.

• conţinutul unui registru R.

Moduri de Modificare a Adresei

Registrele de modificare Mn definesc tipul de operaţie aritmetică a

adresării care urmează a fi efectuată şi permite utilizatorului să creeze diferite

structuri de date în memorie cum ar fi:

• liste (FIFO).


• linii de întârziere.

• buffere circulare.

• stive (LIFO).

• cadre în ordinea inversă a biţilor pentru FFT.

Tabelul de mai jos arată modurile de calcul a adresei în funcţie de valoarea

scrisă în Mn.

Registrul modificator Mn Modul de calcul al adresei

$XX0000 În ordinea inversată a biţilor (Bit-Reverse)

$XX0001 Modulo 2

$XX0002 Modulo 3

: :

$XX7FFE Modulo 32767 (215–1)

$XX7FFF Modulo 32768 (215)

$XX8001 Modulo 2 de la adresa de bază



: :

$XX9FFF Modulo 213 de la adresa de bază

$XXBFFF Modulo 214 de la adresa de bază

$XXFFFF Liniar (Modulo 224)


Modificarea liniară

Mn=$FFFFFF

Calculul adresei se face liniar pe 24 de biţi

Se poate folosi incrementarea, decrementarea sau ofsetul din registrul

Nn pentru calculul adresei.

EXEMPLU:

move x0, y:(r0)+n0

Registrulincrement

No$0000C3(195)

$0000B4(180)

Adresa de start $0000A5(165)

$0000D2(210

Memoria Y

Adresa de start:

$0000A5(165)R0

Increment:

$00000F(15)N0

Adresare liniară:

$FFFFFFM0

Modificarea modulo

Calculul adresei se face modulo M, forţând adresa să rămână într-un

interval de lungime M.


EXEMPLU:

move x0, x:(r0)+n0

Incrementul înregistrul N0

210 ($0000D2)

195 ($0000C3)

180 ($0000B4)

Adresa de start 165 ($0000A5)

135 ($000087)

Modululîn registrul

M0

Adresa dinregistrul

R0

Mj ≥2Lower Bound 128 ($000080)

XX…XX00…00 →← j

Limita maximă 217 ($0000D9)XX…XX00…00 + M -1

→← j

Adresa de start

R0 165 ($0000A5)

Increment

N0 15 ($00000F)

Modulo M=90

M0 89 ($000089)

Reguli pentru obţinerea unui cadru adresat circular:

• Valoarea scrisă în registrul modificator: 1M= −Mn

• Adresa de bază trebuie aleasă o putere a lui 2 care să îndeplinească

condiţia: 2 j M≥ . Astfel adresa de bază are j zerouri LSB.

• Adresa de sfârşit este: 2 1j M+ −

• Adresa iniţială din R nu trebuie neapărat să fie adresa de bază a cadrului,

putând fi oriunde în cadrul domeniului de adrese.

• Adresa de bază a cadrului sau cea de sfârşit nu sunt stocate. Numai

lungimea este scrisă în Mn. Adresa de bază este determinată de adresa

scrisă în Rn (anulând ultimii j biţi).


Acest tip de modificare a adresei este utilă în crearea de:

• liste circulare.

• linii de întârziere.

• cadre de eşantioane pe care se efectuează decimarea, interpolarea şi

generare de sinusoide.

Dacă adresarea circulară este folosită cu ofset (registrul N), acesta nu

trebuie să depăşească valoarea M.

O excepţie este cazul în care 2 jN p= ⋅ este un multiplu al lungimii

cadrului, adresa rezultată va avea aceeaşi poziţie relativă în bufferul de ordin

p.

Principalele aplicaţii sunt filtrarea IIR prin structuri paralele.

Modificarea modulo cu revenire la adresa de bază

Este cazul în care bitul 15 din registrul M este 1.

Depăşirea adresei maxime a cadrului va forţa adresa să ajungă la adresa

de bază, iar decrementarea sub adresa minime va duce adresa la adresa

maximă a cadrului.

Se foloseşte doar în cazul adresării cu ofset.

Modificarea în ordinea inversă a biţilor

Mn=$000000

Modificarea adresei este realizată hardware prin incrementarea şi

propagarea transportului în sens invers, de la MSB la LSB ai adresei.

Este echivalent cu inversarea ordinii biţilor registrelor Rn şi Nn,

adunarea ofsetului la adresă şi, reinversând ordinea biţilor, obţinerea

rezultatului.


Acest mod de adresare este util în calculul FFT la adresarea factorilor

de rotaţie dintr-un cadru de lungime 2kN = sau a ordonării datelor (decimare

în timp etc.).

Pentru un cadru de lungime 2kN = rezultă că ultimii k biţi ai adresei

vor trebui inversaţi.

Pentru aceasta registrul Nn trebuie să aibă valoarea 12k−=Nn .

Adresa de bază a secvenţei de intrare trebuie să fie putere întreagă a lui

2 îndeplinind condiţia 2m N≥ .

EXEMPLU:

M0 = $000000 R0 = $000008 N0 = 4 = 23–1

O secvenţă de intrare de 8 elemente are adresa de bază $8 = 1000.

Ultimii trei LSB ai adresei vor fi: 000,001,002,...,111.

Adresasecvenţeiiniţiale

Secvenţainiţială

Modificareaadresei cu

transport invers

Secvenţareordonată

$8 = 1000 #0.0 R0 = 1000 +N0 = 0100

$8 #0.0

$9 = 1001 #0.1 R0 = 1100 + 0100

$C #0.4

$A = 1010 #0.2 R0 = 1010 + 0100

$A #0.2

$B = 1011 #0.3 R0 = 1110 + 0100

$E #0.6

$C = 1100 #0.4 R0 = 1001 + 0100

$9 #0.1

$D = 1101 #0.5 R0 = 1101 + 0100

$D #0.5

$E = 1110 #0.6 R0 = 1011 + 0100

$B #0.3

$F = 1111 #0.7 R0 = 1111 + 0100

$F #0.7


EXEMPLU:

Adresade start

Indexulîn cadru

Increment

Bit Reverse

R0 3072 ($000C00) ( 0)

N0 512 ($000C00)

M0 0 ($000000)

move x:(r0)+n0, x0

R0 3584 ($000E00) (512)

move x:(r0)+n0, x0

R0 3328 ($000D00) (256)

move x:(r0)+n0, x0

R0 3840 ($000F00) (768)

Nk ≥2Adresa minimă 3072 ($000C00)

XX…XX00…00 →← k

Limita maximă 4095 ($000FFF)XX…XX11…11 →←k

CadruFFT delungimeN=1024

Memoria X

Instrucţiuni de transfer paralel al datelor

Este posibil transferul paralel al datelor pe magistralele de date X şi Y.

Aceasta permite operaţiilor ALU să fie efectuate în paralel cu transferul

datelor într-un singur ciclu de ceas.

Sunt permise transferuri paralele: de la registru la registru, de la

registru la memorie şi de la memorie la registru.


Pot fi specificate două adrese efective independente în transferul paralel

al datelor dacă una din adrese foloseşte bancul inferior al registrelor de adrese

(r0-r3) iar cealaltă adresă, bancul superior de registre (r4-r7).

EXEMPLU:

Transferuri în paralel

instrucţiune operanzisursa 1 →

destinaţia 1

sursa 2 →

destinaţia 2

add x0,a a,x:(r0)+n0 y:(r4)– ,y0

Pot fi:

1. Operaţii ALU

2. Operaţii logice

3. Rotunjiri convergente

Sunt suportate:

1. Coduri condiţionale

Pot fi:

1. Până la două transferuri de date

2. Două moduri de adresare diferite

3. Acces la memoria X, Y, L, XY.

Sunt suportate:

1. Scalarea

2. Limitarea

3. Extensie de semn sau completarea cu

zeroruri a acumulatorului

4. Două surse identice

5. NU E PERMISĂ aceeaşi destinaţie


EXEMPLU:

Transferuri în paralel cu instrucţiuni aritmetice

Instrucţiunesursa 1 →

destinaţia 1

sursa 2 →

destinaţia 2

Transfer cu date imediate add a,b #$44,a1Transfer între registre add x0,a a1,y0Actualizare registru adresă add y1,a (r0)+n0Transfer cu memoria X sau Y add x1,b b,x:$100Transfer cu registre şi cu

memoria X sau Yadd y0,a a,x1 y:(r2)–,y0

Transfer cu memoria L add x,a a10,L:$300Transfer cu memoria X şi Y add y,b b,x:(r3)+n3 y:(r7)+n7,y1

mac x0,y0,a x:(r0)+,x0 y:(r4)–,y0Instrucţiuni de multiplicare şi

adunare macr –y0,y0,b x1,x:(r1)+ b,y:(r5)–


3.5 UNITATEA DE CONTROL AL PROGRAMULUI (PCU)

PCU efectuează încărcarea şi decodificarea instrucţiunilor, controlul

ciclurilor DO şi REP şi procesarea situaţiilor de excepţie într-un cadru de

execuţie pe şapte niveluri pipeline.

Arhitectura PCU este formată din trei blocuri:

GDB PDB PAB GDB

Cereri de ÎntrerupereRESET

CONTROLER DEÎNTRERUPERE APROGRAMULUI

CONTROLER DEDECODIFICARE APROGRAMULUI

GENERATORDE ADRESE

DE PROGRAM

Controler de întrerupere a programului (Program Interrupt Controller)

- arbitrează toate cererile de întrerupere (interne sau externe) şi

generează adresa vectorului de întrerupere corespunzătoare.

Controler de decodificare a Programului (Program Decode Controller)

- decodifică cei 24 de biţi de instrucţiune încărcaţi într-un latch şi

generează toate semnalele de control pipeline.

Generator de adrese de program (Program Address Generator)

- conţine tot hardware-ul necesar pentru generarea adreselor de program,

stiva sistemului şi controlul ciclurilor.


Facilităţile oferite de PCU sunt:

• Moduri de adresare optimizate pentru aplicaţiile DSP;

• Controler pentru cache de instrucţiuni;

• Extensia stivei sistemului;

• Cicluri DO suprapuse;

• Revenire rapidă din întreruperi.

Operaţiile Pipeline

Arhitectura organizată pe şapte niveluri de pipeline permite execuţia

majorităţii instrucţiunilor la o rată de o instrucţiune pe ciclu de ceas.

PreFetch

Nivelul pipeline Descrierea operaţiilor

PreFetch I • Generarea adresei pentru instrucţiune

• Incrementarea PC

PreFetch II • Instrucţiunea este citită din memorie

Decodificare


Decodificare • Decodificarea instrucţiunii

Generarea Adreselor


Address Gen I • Generarea adresei pentru operaţii de transfer a

datelor

Address Gen II • Actualizarea pointerului de adresă


Execuţie


Execuţie I • Citirea operanzilor sursă pentru înmulţire sau

adunare

• Citirea registrelor sursă pentru scrierea în memorie

• Înmulţirea

• Scrierea registrelor destinaţie pentru citirea din

memorie

Execuţie II • Citirea operanzilor sursă pentru adunare dacă aceştia

au fost scrişi într-o operaţie ALU precedentă

• Adunarea

• Scrierea rezultatului adunării în registrul destinaţie

• Scrierea rezultatului înmulţirii în registrul destinaţie


Unele instrucţiuni necesită un timp suplimentar de execuţie şi anume:

• Toate instrucţiunile care ocupă două cuvinte de memorie.

• Instrucţiunile care folosesc un mod de adresare care necesită mai mult de

un ciclu pentru calculul adresei.

• Instrucţiunile care provoacă o schimbare în cursul programului.

Operaţiile pipeline ale PCU rămân ascunse utilizatorului, uşurând

programarea.

Hardware-ul prezent în fiecare unitate de execuţie a procesorului

detectează orice conflict pipeline şi opreşte desfăşurarea pipeline până când

rezultatele instrucţiunii precedente sunt disponibile pentru instrucţiunea

următoare.

Programatorul poate reduce întârzierile în pipeline şi îmbunătăţi viteza

de execuţie prin modificări adecvate ale programului.

Întârzieri datorate operaţiilor aritmetice

Apar când se încearcă citirea din acumulator dacă acelaşi acumulator

este destinaţia instrucţiunii aritmetice anterioare. Se poate introduce o altă

instrucţiune între cele două.

mac x0,y0,amove a1,x:(r0)+

mac x0,y0,a

mac x1,y1,bmove a1,x:(r0)+

Întârzieri datorate transferurilor de date

Apar când registrul sursă al unei instrucţiuni move este registrul

destinaţie al instrucţiunii move anterioare. Se poate introduce o altă

instrucţiune între cele două.


move y(r1)+,a1move a,x:(r0)+

move y(r1)+,a1

mac x1,y1,bmove a,x:(r0)+

Întârzieri datorate generării adreselor

Apar când o instrucţiune move foloseşte pentru generarea sau

calcularea adresei drept pointer unul din registrele de adresă R0-R7 şi una

din ultimele trei instrucţiuni modifică tripletul de registre R, N, M respectiv.

Se introduc până la trei instrucţiuni nop.

move $123456,r1move a,x:(r1)+ ; se introduc 3 instrucţiuni nop

Modelul de Programare PCU:

23 0 48 SSH 2423 SSL 0 23 0 0

CONTOR PROGRAM (PC) CONTOR CICLURI (LC)

23 16 15 8 7 0 23 16 15 8 7 0

REGISTRU MOD OPERARE (OMR) REGISTRU DE STARE (SR)

23 0 STIVA SISTEMULUI 4 0

REGISTRU ADRESĂ CICLU (LA) CONTOR STIVĂ (SC)

23 87 0 23 6 5 4 3 0 23 0

ADRESA DE BAZĂ A VECTORULUI INDICATOR STIVĂ (SP) DIMENSIUNEA STIVEI (SZ)DE ÎNTRERUPERI (VBA)

* BIŢII SUNT 0

SCS EOM COM

*

EMR MR CCR


Contor program (Program Counter)

Registru pe 24 de biţi care păstrează adresa din memoria de program a

instrucţiunii curente.

Este salvat în stivă

• la începerea unui ciclu hardware;

• la apelul unei subrutine;

• în cazul unei întreruperi lungi.

Contor ciclu (Loop Counter)

Contor pe 24 de biţi care specifică de câte ori este repetat un ciclu (DO

sau REP). Este stocat în stivă de instrucţiunea DO şi scos din stivă la sfârşitul

ciclului sau la ENDDO.

Registrul adresei de sfârşit de ciclu (Loop Address)

Registru pe 24 de biţi care indică adresa ultimei instrucţiuni din ciclu.

Este stocat în stivă de instrucţiunea DO şi scos din stivă la sfârşitul ciclului

sau la ENDDO.

Adresa de bază a vectorului de întreruperi (Vector Base Address)

Registru pe 24 de biţi (cu ultimii 8 LSB zero) care păstrează adresa de

bază a vectorului de întreruperi.

Stiva sistemului (System Stack)

Zonă de memorie de 16cuvinte pe 48 biţi împărţită în două zone (pe 24

biţi fiecare):

• System Stack High (SSH).

• System Stack Low (SSL).


Funcţiile stivei:

• păstrează adresa de revenire (PC) şi registrul de stare (SR) la apelul

unei subrutine.

• păstrează LA, LC, PC şi SR la efectuarea ciclurilor.

• păstrează variabile la apeluri de subrutine.

Stiva poate fi folosită pentru implementarea de cicluri suprapuse

deoarece la iniţierea unui ciclu hardware sunt stocate automat în stivă LA,

LC, PC şi SR anterioare, iar la terminarea ciclului acestea sunt restabilite

(permiţând continuarea unui eventual ciclu anterior).

endlp – 1

SYSTEM STACK (Registru adresa de salt)

(Contor ciclu)

(Registru de stare)

(Contor Program)

Comparator 0

LF=1 (Fanion ciclu) DO #count,endlp

PC

Ciclu

(Ultima LAInstructiune)

endlp instr

UNITATEA DE CONTROL AL PROGRAMULUI

COMPARATOR STIVA DE SISTEM 0

SP =

-1

(Contor ciclu) 15 ieşire la LC=1

LA

PC

LCSR

LA LC PC SR

instrinstrinstr:::::instrinstr


Dacă nu se realizează extensia stivei, se pot implementa 7 cicluri DO

suprapuse, 15 apeluri de subrutine sau 15 deserviri de întreruperi lungi, sau

combinaţii între ele.

La apelul unei subrutine (JSR) adresa de revenire (PC) este scrisă în

SSH iar registrul de stare (SR) este scris în SSL.

La revenirea din subrutină (RTS) numai PC este scris din stivă, SR

rămânând nemodificat.

La revenirea din subrutina de întrerupere (RTI), atât PC cât şi SR

sunt rescrise din stivă.

Extensia stivei poate fi activată de Stack Extension Enable (SEN),

bitul 20 din OMR.

Stack Extension Pointer (EP) aflat în AGU păstrează adresa din

memoria de date a extensiei de stivă.

Stack Size Register (SZ) determină numărul locaţiilor de memorie

alocate pentru extensia stivei în memoria de date.

Stack Counter Register (SC)

Registru pe 5 biţi folosit pentru a monitoriza câte intrări în stivă sunt

folosite.

Registrul indicator de stivă (Stack Pointer Register)

Registru care indică vârful stivei şi eventualele condiţii de eroare.

Ultimii 4 biţi sunt incrementaţi/decrementaţi la fiecare scriere/citire din

stivă.

Biţii 4 şi 5 indică posibile erori de tipul stivă goală sau plină precum şi

depăşirea limitelor stivei.


23 6 5 4 3 0

Indicator stivă Fanion Eroare-Stivă/P4 Fanion stivă goală/P5 P[23:6]

P[23:6] UF/P5 SE/P4 P[3:0]

Registrul de stare (Status Register)

Registru de 24 de biţi alcătuit din 3 părţi:

• Extended Mode Register (EMR)

• Mode Register (MR)

• Condition Code Register (CCR)

CP1 – Nivel Prioritate Bit 1 LF – Fanion buclă DO S – Bit scalare

CP0 – Nivel Prioritate Bit 0 DM – Înmulţire precizie dublă L – Limitare

RM – Mod de rotunjire SC – Copatibilitate 16-Biţi E – Extensie

SM – Saturare aritmetică S1 – Mod de scalare Bit 1 U – Nenormalizat

CE – Activare cache instr. S0 – Mod de scalare Bit 0 N – Negativ

SA – Aritmetică pe 16 biţi I1 – Mascare întreruperi Bit 1 Z – Zero

FV – Fanion DO-Forever I0 – Mascare întreruperi Bit 0 V – Depăşire

C – Depăşire

Registrul de condiţii (Condition Code Register)

Registru de control care defineşte rezultatele calculelor aritmetice

anterioare.

Biţii CCR sunt afectaţi de operaţii ALU, transferuri paralele sau

instrucţiuni care fac referire directă la acest registru.


Mode Register şi Extended Mode Register

Sunt registre de control care definesc starea curentă a sistemului.

Biţii MR şi EMR sunt afectaţi de resetarea procesorului, întreruperi,

DO, ENDDO, RTI şi alte instrucţiuni care modifică biţii din acest registru.

Instrucţiuni de ciclare

Repetarea unei instrucţiuni de n ori

REP n

n: valoarea aflată la o adresă efectivă sau absolută;

orice registru intern;

valoare imediată pe 8 biţi: #xxx;

Valoarea n este scrisă în LC şi decrementată la fiecare repetare a

instrucţiunii până când LC = 1.

Pentru instrucţiunea repetată se face fetch o singură dată, aceasta

rămânând în registrul de instrucţiune până la terminarea ciclului. De aceea

instrucţiunea REP este neîntreruptibilă.

Dacă LC este 0 instrucţiunea este repetată de 65536 ori.

Repetarea de n ori a instrucţiunilor aflate până la eticheta label

DO n,label




label: adresă absolută.


Pentru fiecare instrucţiune din ciclu face fetch de fiecare dată. De

aceea instrucţiunea DO este întreruptibilă.

Ciclurile DO pot fi suprapuse (efectuarea unui ciclu în interiorul altuia).

Adresa sfârşitului ciclului este calculată (şi scrisă în LA) prin evaluarea

adresei etichetei label şi scăzând unu (pentru cazul în care ultima instrucţiune

ocupă două cuvinte de memorie). De aceea eticheta sfârşitului de ciclu trebuie

să reprezinte adresa instrucţiunii de după ciclu.

Repetarea de n ori a instrucţiunilor aflate până la adresa PC+val

DOR n,val




val: valoarea relativă adunată la PC reprezentând

sfârşitul ciclului adresă absolută.

Repetarea continuă a instrucţiunilor aflate până la adresa etichetă

DO FOREVER,label

Repetarea continuă a instrucţiunilor aflate până la adresa PC+val

DOR FOREVER,val

Ieşirea din ciclurile DO, DOR, DO FOREVER, DOR FOREVER se

face cu instrucţiunile:

ENDDO se iese din ciclul curent înainte ca LC să ajungă la 1.

BRKcc se iese din ciclul curent dacă se îndeplineşte condiţia cc.


Condiţiile testate la execuţia instrucţiunilor condiţionale se determină

din biţii din registrul CCR (Condition Code Register) pe baza unor ecuaţii

prezentate mai jos:

Codul Condiţional Semnificaţia ‘cc’ Condiţia

CC(HS) Carry Clear (Higher or Same) C = 0

CS(LO) Carry Set (Lower) C = 1

EC Extension Clear E = 0

EQ EQual Z = 1

ES Extension Set E = 1

GE Greater than Equal N ⊕ V = 0

GT Greater Than Z + (N ⊕ V) = 0

LC Limit Clear L = 0

LE Less than or Equal Z + (N ⊕ V) = 0

LS Limit Set L = 1

LT Less Than N ⊕ V = 1

MI Minus N = 1

NE Not Equal Z = 0

NR NoRmalized Z + (U • E) = 1

PL PLus N = 0

NN Not Normalized Z + (U • E) = 1

Unde:

+ reprezintă operatorul SAU

⊕ reprezintă operatorul SAU-EXCLUSIV

• reprezintă operatorul ŞI


Alte instrucţiuni de control al programului



EXEMPLE DE PROGRAME:

Calculul sumei de produse

Să se realizeze programul care calculează suma de produse (convoluţie

sau corelaţie):

1

0

( ) ( ) ( )N

ks n x k y n k

−

=

= −∑

Pseudocodul pentru acest program este:

s(n)=0;

for (k=0,k<N,k++)

s(n) = s(n) + x(k) * y((n-k)%N);

În limbaj de asamblare suma se poate calcula repetând instrucţiunea

mac într-un ciclu do astfel:

...

clr a

do #N,_end

...

mac x0,y0,a

_end

• suma se calculează în acumulatorul a care se iniţializează cu 0.

• instrucţiunea mac calculează x0*y0 şi adună la valoarea din a.

În registrele de date x0 şi y0 trebuie transferaţi din memorie operanzii

( )x k şi ( )y n k− :

• avem nevoie de două registre de adresă r0 şi r4 care să fie

iniţializate cu adresele de start ale celor două şiruri şi să indice pe

parcurs adresa elementului ( )x k respectiv ( )y n k− din şir.


• considerăm stocate în memorie şirurile de N valori ( )x k şi ( )y n k− ;

Registru adresă Memoria X Memoria Y

r0 (0)x

r4 ( )y n

• se va folosi modificarea modulo N a adresei pentru ca la sfârşitul

ciclului, registrele r0 şi r4 să indice adresele de unde s-a pornit.

• registrul de adresă r0 este incrementat pentru următorul ( )x k .

• registrul r4 este decrementat pentru ( )y n k− .

Etichetă Instr. OperanziMagistralade date X

Magistralade date Y

Cicluriceas

N equ 14 0

org x:0 0

x_addr dsm N 0

org y:0 0

y_addr dsm N 0

org p:$100 0

move #x_addr,r0 1

move #N-1,m0 1

move #y_addr,r4 1

move m0,m4 1

clr a 1

do #N,_end 5

move x:(r0)+,x0 1

move y:(r4)-,y0 1

mac x0,y0,a 1

_end

TOTAL 3N+10


Optimizarea programului.

Optimizarea programului se poate face prin utilizarea transferurilor

paralele şi a instrucţiunii rep care repetă de N ori o singură instrucţiune.

Cele două instrucţiuni de transfer care se efectuau înaintea înmulţirii cu

acumulare pot fi efectuate în paralel cu aceasta. Diferenţa este că transferul

operanzilor din memorie în registre se face după citirea operanzilor din

registrele x0 şi y0 şi începerea efectuării înmulţirii. De aceea pentru prima

înmulţire din ciclu, operanzii trebuie iniţializaţi înaintea ciclului (în paralel cu

ştergerea acumulatorului, de exemplu).


Magistralade date Y

Cicluriceas

...

clr A x:(r0)+,x0 y:(r4)-,y0 1

rep #N-1 5

mac X0,y0,a x:(r0)+,x0 y:(r4)-,y0 1

macr X0,y0,a 1

TOTAL N+6

Ciclul este efectuat de 1N − ori pentru ca numărul transferurilor din memorie

să fie egale cu N. Ultima înmulţire şi acumulare se face în afara ciclului

folosind şi rotunjirea rezultatului pe 24 de biţi.


Calculul valorii unui polinom

Să se realizeze programul care calculează polinomul:

1

0

( ) ( )N

k

kp x a k x

−

=

= ⋅∑

Pseudocodul pentru acest program este:

x_k = x;

p(x) = a(0);

for (k=1,k<N,k++)

{ p(x) = p(x) + a(k) * x_k;

x_k = x_k * x;

}

• registrul de adresă r0 este iniţializat cu adresa coeficienţilor ( )a k .

• valoarea lui x este păstrată în registrul y1.

• calculul lui kx se face păstrând pe 1kx − în registrul x0 şi înmulţind

această valoarea cu valoarea lui x din registrul y1.

• noua valoare kx se transferă apoi în registrul x0 pentru următoarea

iteraţie.

• polinomul se calculează în acumulatorul a cu instrucţiunea

mac y0,x0,a. La valoarea anterioară din a se adună produsul între

coeficientul ( )a k din registrul y0 şi kx din registrul x0.



Magistralade date Y

Cicluriceas

N equ 10 0

org x:0 0

a_addr dsm N 0

org p:$100 0

move #a_adr,r0 1

move x:#val_x,y1 1

move x:(r0)+,a 1

move x:(r0)+,y0 1

move y1,x0 1

do #N-1,_end 5

mac y0,x0,a x:(r0)+,y0 1

mpyr x0,y1,b 1

move b,x0 2 i’lock

_end

TOTAL 4N+6

• deoarece rezultatul înmulţirii 1kx x− ⋅ este în acumulatorul b, acesta

trebuie transferat în registrul x0 (o instrucţiune de transfer

suplimentară).

• deoarece registrul sursă de transfer b este acelaşi cu destinaţia

instrucţiunii anterioare de înmulţire, apare o întârziere de o

instrucţiune în execuţia programului (transfer stall).


Optimizarea programului.

Se poate efectua în avans calculul 1kx x− ⋅ astfel ca transferul din b să

nu se facă pentru valoarea calculată în instrucţiunea anterioară, ci în paralel cu

aceasta (deci pentru valoarea din b înaintea înmulţirii).


Magistralade date Y

Cicluriceas

move #a_adr,r0 1

move x:#val_x,x0 1

move x:(r0)+,a 1

mpyr x0,x0,b x:(r0)+,y0 1

move b,y1 2 i’lock

do #N-1,_end 5

mac y0,x0,a x:(r0)+,y0 1

mpyr y1,x0,b b,x0 1

_end

macr y0,x0,a 1

TOTAL 2N+10

Succesiunea operaţiilor este:

x0 = x

a = a(0)

b = x2 y0 = a(1)

y1 = b = x2

a = a(1) * x + a(0) y0 = a(2)

b = x2 * x = x3 x0 = x2

a = a + a(2) * x2 y0 = a(3)

b = x2 * x2 = x4 x0 = x3

a = a + a(3) * x3 y0 = a(4)

b = x2 * x3 = x5 x0 = x4


Sortarea unui vector prin selecţie directă

Algoritmul sortează elementele unui vector aflate în memoria X. Sortarea este

efectuată “in place” (în aceeaşi zonă de memorie) şi nu necesită memorie

suplimentară.

Algoritmul caută minimul elementelor ne-sortate din vector pe care îl schimbă

cu primul element de după secvenţa sortată.

Timpul de execuţie este proporţional cu pătratul numărului de elemente din

vector şi este constant chiar dacă vectorul este deja ordonat crescător,

descrescător sau elementele sunt în ordine aleatoare.

iniţializării = 0j = 0

a>b

a = bk = j

j = j + 1

NU

DA

a = data[i]

j = i + 1k = i

b = data[j]

data[k] = data[i]data[i] = a

i = i + 1


Registre folosite:

• indexul elementelor: r0 = j , r1 = k , r2 = i

• ciclul de căutare a minimului (numărul de elemente nesortate): r4 = j.

Instrucţiunea cmp b,a face diferenţa între a şi b şi modifică biţii de

condiţii din CCR în funcţie de rezultatul scăderii. Dacă a – b < 0 bitul n = 1.

Instrucţiunea tge y0,a r0,r1 transferă valoarea din y0 în a şi valoarea

din r0 în r1 dacă rezultatul comparaţiei anterioare este mai mare sau egal ca

0.

move #N_ITEMS,r4

move #ARRAY,r2

move #-2,n1

nop

do #N_ITEMS-1,_loop2

lua (r2)+,r0

nop

nop

move x:(r2),a y:(r4)-,b

move x:(r0)+,b

move r0,r1

do r4,_loop1

cmp b,a x:(r0)+,b b,y0

tge y0,a r0,r1

_loop1

nop

move x:(r2),y0

move a,x:(r2)+

move y0,x:(r1+n1)

_loop2


Instrucţiunea IFcc

Execută instrucţiunea aritmetică dacă este îndeplinită condiţia din IFcc

(bazată pe operaţia anterioară). Altfel nu se execută instrucţiunea ALU.

move #>2,a ; a = 2

move #>1,x0 ; x0 = 1

add x0,a ; a = 2 + 1 = 3

sub x0,a ifne ; dacă rezultatul anterior

; nu e 0 se scade x0 din a

move #>-2,a ; a = -2

move x0,b ; b = 1

addl a,b ; b = 2*b + a = 0

sub x0,a ifne ; rezultatul anterior e 0

; nu se executa scaderea

nop

Instrucţiunea DEBUGcc

Dacă este îndeplinită condiţia se intră în modul “debug” (depanare) şi

se asteaptă o comandă OnCE (“run” sau “step” din debugger).

move y0,a ; init a

neg a ; a = -a

add y0,a ; a = 0

debugeq ; opreste executia si asteapta

nop ; comanda OnCE (run sau step)


Instrucţiunea BRKcc

Se iese condiţionat din ciclu do (dacă este îndeplinită condiţia cc).

a y0

a a – 1

a = 0? NU

LC = 1 NULC--

DABRKeqZ=0

DA

do #loop_c,loop1

loop1

move #>3,a ; init accumulator

do #6,loop1 ; init ciclu (LC = 6)

sub #1,a ; decrementare acumulator

brkeq ; iese din ciclu daca a=0

nop ; ultimele trei linii din cilu

nop ; nu trebuie sa contina brkcc

nop ; (conflict pipeline)

loop1

nop


3.6 CONTROLERUL DMA (DIRECT MEMORY ACCESS)

Controlerul de acces direct la memorie (DMA) asigură transferul de

date între memoria internă şi/sau externă sau dispozitive de I/O în orice

combinaţie fără nici o intervenţie externă.

Deoarece există magistrale de date şi adrese dedicate DMA, precum şi

datorită modului de împărţire a memoriei interne rezulta că operaţiile de acces

direct la memorie nu interferă cu restul operaţiilor ce au loc în interiorul

DSP56300.

Unitatea de interfaţă cu magistrala (BIU) primeşte comenzile necesare

de la controlerul DMA şi poate prelucra activităţile externe cu maximum de

flexibilitate şi performanţă.

Controlerul DMA are 6 canale, fiecare cu setul propriu de registre

mapate în zona memoriei interne de I/O.

Tipurile de transfer de date efectuate de controlerul DMA sunt:

Sursa / destinaţia transferuluiNumărul minim de cicluri de ceas

pentru transferul unui cuvânt

Memorie internă → Memorie internă 2

Memorie externă ↔ Memorie internă 2 + timp acces memoria externă

Memorie externă → Memorie internă 2 + timp acces memoria externă

Memorie internă ↔ Porturi I/O 2

Memorie externă ↔ Porturi I/O 2 + timp acces memoria externă

Porturi I/O → Porturi I/O 2


Transferul de date pentru un singur canal ocupă minimum 2 tacturi de

ceas pentru un singur cuvânt.

Numărul de tacturi de ceas per transfer poate fi mai mare dacă există un

conflict între activitatea DMA şi nucleul DSP56300 (de exemplu dacă ambele

accesează aceiaşi 1/4K de RAM intern în acelaşi tact de ceas, sau dacă ambele

vor să acceseze memoria externă).

Controlerul de DMA are 6 canale identice. Fiecare canal are 6 registre

dedicate:

• DSRi – registrul sursa DMA pentru canalul i care conţine adresa de bază

a sursei următorului transfer DMA.

• DDRi – registrul destinaţie DMA pentru canalul i care conţine adresa de

bază a destinaţiei următorului transfer DMA.

• DCOi – registrul contor DMA pentru canalul i care conţine numărul de

transferuri DMA rămase de executat.

• DCRi – registrul de control DMA pentru canalul i care conţine biţii

necesari controlului operaţiilor de pe canal.

Mai sunt 5 registre nededicate:

• 4 registre DMA de ofset (DOR0, DOR1, DOR2, DOR3) care conţin

ofseturile pentru adrese ce vor putea fi folosite de orice canal, dacă este

necesar, folosind modurile de adresare specifice.

• un registru read-only de stare DMA (DSTR).


Registrul de control DMA (DCR)


Registrul contor DMA (DCO)

Modul A – un singur contor (transfer unidimensional).

23 0

DCO

Numărul de transferuri este egal cu DCO+1. Înainte de fiecare transfer

DMA, registrul DCO este testat astfel:

• DCO > 0 – este iniţiat transferul de la adresa sursă, DCO este decrementat

şi registrul de adresă DSR este actualizat în funcţie de modul de adresare a

sursei din registrul de control DCR.

• DCO = 0 – ultimul transfer este iniţiat de la adresa sursă, registrul de

adresă este actualizat şi DCO este încărcat cu valoarea iniţială.

Înaintea transferului După transfer

DSR DCO Adresa sursă atransferului

DSR DCO

S 5 S S+1 4

S+1 4 S+1 S+2 3

S+2 3 S+2 S+3 2

S+3 2 S+3 S+4 1

S+4 1 S+4 S+5 0

S+5 0 S+5 S+6 5

În exemplul de mai sus am considerat că adresa sursă este modificată

(incrementată) în timpul transferului. Acelaşi lucru se poate întâmpla şi cu

adresa destinaţie a transferului în funcţie de modul de adresare destinaţie din

registrul de control DCR


Transferuri DMA multidimensionale

DMA-ul este capabil de transferuri de date aflate în structuri complexe.

Modul de adresare al sursei sau destinaţiei poate fi bi sau tridimensional (2D

sau 3D).

Transferul bidimensional (2D)

Pentru transferul 2D, numărătorul DCO este divizat în DCOL şi

DCOH.

Modul B – două contoare (transfer bidimensional):

23 12 11 0

DCOH DCOL

Un registru de ofset DOR este folosit pentru a calcula saltul de adresă.

Adresa transferului DMA este conţinută de registrul de adrese (DSRi

sau DDRi).

Acest mod este util în transferuri bidimensionale (de exemplu liniile

unei matrice). Înainte de fiecare transfer DMA, registrele DCOH şi DCOL

sunt testate dacă au ajuns la 0 astfel:

• DCOH > 0 şi DCOL > 0 – este iniţiat transferul de la adresa sursă, DCOL

este decrementat şi registrul de adresă DSR este incrementat.

• DCOH > 0 şi DCOL = 0 – este iniţiat transferul de la adresa sursă,

registrul de adresă DSR este incrementat cu valoarea aflată într-un registru

ofset DOR asociat transferului bidimensional în registrul de control,

DCOH este decrementat şi DCOL este încărcat cu valoarea iniţială.

• DCOH = 0 şi DCOL = 0 – ultimul transfer este iniţiat de la adresa sursă,

registrul de adresă este actualizat şi DCOH şi DCOL sunt încărcate cu

valorile iniţiale. Odată cu acest ultim transfer de bloc de date, DMA-ul ori


încetează să mai execute orice operaţie, ori aşteaptă o nouă declanşare a

transferului.


DSR DCOH:L Adresa sursă atransferului

DSR DCOH:L

S 1:2 S S+1 1:1

S+1 1:1 S+1 S+2 1:0

S+2 1:0 S+2 S+O+2 0:2

S+O+2 0:2 S+3 S+O+3 0:1

S+O+3 0:1 S+4 S+O+4 0:0

S+O+4 0:0 S+5 S+2O+4 1:2

Numărul total de transferuri efectuat este (DCOH + 1) x (DCOL + 1).

EXEMPLU:

Salt cu ofset

Transfer liniar 2D


Transferul tridimensional (3D)

Pentru transferul 3D, registrul contor este împărţit în trei registre

DCOH, DCOM şi DCOL, având dimensiuni diferite.

Modurile C, D, E – trei contoare (transfer tridimensional):

23 12 11 6 5 0

DCOH DCOM DCOL

23 18 17 6 5 0

DCOH DCOM DCOL

23 18 17 12 11 0

DCOH DCOM DCOL

Acest mod de transfer utilizează 2 registre de ofset pentru calculul

adresei de salt.

Înainte de fiecare transfer DMA, registrele contor sunt testate dacă au

ajuns la 0 şi se efectuează următoarele operaţii:

• DCOH > 0, DCOM > 0 şi DCOL > 0 – este iniţiat transferul de la adresa

sursă, DCOL este decrementat şi registrul de adresă este incrementat.

• DCOH > 0, DCOM > 0 şi DCOL = 0 – este iniţiat transferul de la adresa

sursă, registrul de adresă este incrementat cu valoarea aflată în primul

registru ofset DOR specificat pentru transferul 3D în registrul de control,

DCOM este decrementat şi DCOL este încărcat cu valoarea iniţială.

• DCOH > 0, DCOM = 0 şi DCOL = 0 – este iniţiat transferul de la adresa

sursă, registrul de adresă este incrementat cu valoarea aflată în al doilea

registru ofset DOR specificat pentru transferul 3D în registrul de control,

DCOH este decrementat şi DCOM şi DCOL sunt încărcate cu valorile

iniţiale.

• DCOH = 0, DCOM = 0 şi DCOL = 0 – ultimul transfer este iniţiat de la

adresa sursă, registrul de adresă este incrementat cu al doilea ofset şi


DCOH, DCOM şi DCOL sunt încărcate cu valorile iniţiale. După acest

ultim transfer, DMA-ul aşteaptă o nouă declanşare.


DSR DCO Adresa sursă atransferului

DSR DCO

S 1:1:2 S S+1 1:1:1

S+1 1:1:1 S+1 S+2 1:1:0

S+2 1:1:0 S+2 S+O0+2 1:0:2

S+O0+2 1:0:2 S+O0+2 S+O0+3 1:0:1

S+O0+3 1:0:1 S+O0+3 S+O0+4 1:0:0

S+O0+4 1:0:0 S+O0+4 S+O0+O1+4 0:1:2

S+O0+O1+4 0:1:2 S+O0+O1+4 S+O0+O1+5 0:1:1

S+O0+O1+5 0:1:1 S+O0+O1+5 S+O0+O1+6 0:1:0

S+O0+O1+6 0:1:0 S+O0+O1+6 S+2O0+O1+6 0:0:2

S+2O0+O1+6 0:0:2 S+2O0+O1+6 S+2O0+O1+7 0:0:1

S+2O0+O1+7 0:0:1 S+2O0+O1+7 S+2O0+O1+8 0:0:0

S+2O0+O1+8 0:0:0 S+2O0+O1+8 S+2O0+2O1+9 1:1:2

Numărul total de transferuri este (DCOH+1)x(DCOM+1)x(DCOL+1).


EXEMPLU:

Salt cu ofsetul 1

Salt cuofsetul 1

Salt cuofsetul 1

Salt cuofsetul 1

Salt cuofsetul 1

Salt cuofsetul 1

Salt cu ofsetul 2

Transfer 3D 2D

Registrul de stare DMA (DSTR)

23 22 21 20 19 18 17 16 15 14 13 12

11 10 9 8 7 6 5 4 3 2 1 0

DCH2 DCH1 DCH0 DACT DTD5 DTD4 DTD3 DTD2 DTD1 DTD0

• Biţii DCH indică ce canal DMA este activ (000 – 101 reprezintă canalele

DMA 0 - 5).

• Bitul DACT indică dacă există cel puţin un canal DMA activ.

• Biţii DTDi indică transfer terminat pe canalul i şi sunt setaţi la transferarea

ultimului cuvânt la destinaţie.


Exemple de folosire a DMA

În aceste exemple se foloseşte un singur canal DMA fără interferenţe

din alte surse, cum ar fi alte canale DMA, conflicte cu nucleul DSP56300 etc.

Transferul de la memoria de date x la y

Următorul program foloseşte canalul 0 al DMA pentru a transfera liniar

un bloc de N cuvinte din memoria interna X in memoria interna Y:

movep #source_addr,x:M_DSR0 ;adresa sursă

movep #dest_addr,x:M_DDR0 ;adresa destinaţie

movep #(N-1),x:M_DCO0 ;se vor efectua N transferuri

movep #%100110000000001011010100,x:M_DCR0

nop

nop

jclr #0,x:M_DSTR,* ;interogarea lui DTD0

În acest program, în DSR0 este înscrisă adresa primei valori ce

urmează să fie transferată.

Nu este necesar să specificăm că adresa este internă. Partea hardware a

DMA evaluează această informaţie în mod automat în concordanţă cu harta

memoriei.

Numărul N de transferuri de efectuat este (DCO+1), deci valoarea

scrisă în DCO0 este N-1.

Conţinutul registrului de control DCR0 este următorul:

• DE = 1 începe un transfer DMA.

• DIE = 0 dezafectează întreruperea către procesor la sfârşitul unui bloc.

• DTM = 011 transferul blocului este activat software de DE prin setarea

bitului DE.


• DPR = 00 nivel de prioritate zero (cel mai mic).

• DCON = 0 modul continuu nu este activat.

• DRS = 00000 in modul activat software acest câmp este ignorat.

• D3D = 0 mod ne-tridimensional.

• DAM = 101101 adresa sursă este post incrementată cu 1 (adresare

liniară), adresa destinaţie este de asemenea incrementată în mod liniar.

• DDS = 01 destinaţia este în memoria Y.

• DSS = 00 sursa în memoria X.

În acest exemplu, nucleul procesorului este inactiv în timpul în care

DMA-ul transferă blocurile de date.

Programul testează bitul DTD0 al acestui canal şi continuă execuţia

programului după ce DMA termină de transferat datele.

Datorită structurii de tip pipeline a execuţiei şi deoarece procesorul

interoghează bitul DTD0 până când acesta este egal cu 0, programul trebuie

să aştepte 2 cicluri de ceas până ce DE este scris iar DTD0 este resetat la

începutul blocului de transfer pentru a indica ocuparea canalului.

O altă opţiune este aceea de a interoga bitul DACT (bitul 8) din DSTR

până ce acesta este setat. Acest bit indică daca pe orice canal DMA se

efectuează un transfer de date. Programul trebuie să aştepte 3 cicluri de ceas

(3 instrucţiuni NOP) până când acest bit este setat şi poate fi interogat.

Transferul datelor de la portul ESSI

Canalul DMA5 este programat pentru a recepţiona date de la un port

periferic ESSI.


În acest caz adresa sursă trebuie să fie în modul "fără actualizare"

deoarece DMA-ul citeşte registrul de recepţie de date mapat la o adresă fixă

în memoria perifericelor.

Datele sunt transferate într-un buffer de tip circular în memoria X

internă. Buffer-ul circular este implementat folosind adresarea liniară; la

terminarea transferului este generată o întrerupere iar adresa destinaţie este

reiniţializată.

În acest exemplu se ignoră conţinutul contorului DCO5, care este însă

folosit pentru generarea unei întreruperi pentru a se face saltul la începutul

buffer-ului după ce acesta este umplut.

M_RX1 equ $ffffa8 ;registrul de recepţie ESSI1

movep #M_RX1,x:M_DSR5 ;adresa sursă

movep #$int_addr,x:M_DDR5 ;adresa destinaţie

movep #(N-1),x:M_DCO5 ;buffer circular de lungime N

movep #111011100110001011000000,x:M_DCR5

;transferul cuvintelor declanşat de ESSI1 Rx

;din memoria X fără actualizare in X act. liniara

;DE nu este şters la terminarea blocului

;intreruperea este generata la sfarsitul blocului

;prioritatea canalului este 3 (nu conteaza aici)

...

;rutina intreruperii terminării transferului pe DMA5

I_DMA5

movep #$int_addr,x:M_DDR5

;se modifică adresa de inceput a buffer-ului

;realizând o adresare circulară


Exemple pentru realizarea altor moduri de adresare cu DMA

Adresare circulară folosind transferul 2D

Se transferă un cuvânt de date pe cerere până la sfârşitul cadrului

circular, după aceea se efectuează un salt înapoi (registru de ofset are valoare

negativă) la începutul cadrului.

M_RX1 equ $ffffa8 ;registrul de recepţie

ESSI1

movep #-(N-1),x:M_DOR0 ;offset de salt inapoi

movep #M_RX1,x:M_DSR5 ;adresa destinatie

movep #int_addr,x:M_DDR5 ;adresa de inceput buffer

movep #$(fff000+(N-1)),x:M_DCO5

movep #$ae6040,x:M_DCR5

;transferul declansat de ESSI1 Rx

;x no update -> x 2D cu DOR0

;DE nu este resetat la sfarsitul blocului de date

;intreruperea nu este generata

;prioritate canal: 3 (nu conteaza aici)

În acest exemplu registrul contor DCO5 este încărcat cu N-1 în DCOL şi cu

$fff în DCOH pentru un număr total mare de transferuri.

Transfer cu ofset echidistant

Modul de adresare postincrementare cu ofset Nn care are sintaxa

(Rn)+Nn poate fi folosit, de exemplu, pentru a efectua o decimare a datelor.

Folosind DMA-ul pentru a efectua aceeaşi operaţie se poate elibera

registrul Rn.

Transfer 3D 2D


Se programează canalul DMA pentru transfer 2D cu DCOL=0. La

fiecare transfer, registrul de adrese este modificat cu ofsetul N aflat în

registrul de ofset DORi.

Programând acelaşi canal pentru transfer 3D cu DCOH=0 si DCOL=0,

dar cu DCOM>0 şi DORi=N (ofset) şi DORj=–(N*DCOM) se

implementează un buffer circular care efectuează un algoritm de decimare

asemănător (modul de adresare rezultat este similar cu cel rezultat în urma

folosirii adresării ((Rn) + Nn) mod Mn.

Operarea cu mai multe canale DMA

Deoarece un canal DMA poate fi controlat din 32 de surse, transferuri

DMA multiple pot fi efectuate în serie sau paralel.

Orice canal poate fi controlat de întreruperi venite din 32 de surse:

• 4 externe (IRQA, IRQB, IRQC şi IRQD),

• 22 de evenimente sosite de la periferice,

• 6 moduri "sfârşit de transfer pe canalul A declanşează transferul pe canalul

B".

Ultimele 6 moduri sunt folositoare în cazul în care 2 transferuri

trebuiesc efectuate secvenţial, adică un canal DMA efectuează un transfer,

timp în care celuilalt canal i se setează toţi parametrii necesari pentru un al

doilea transfer.

Când primul transfer s-a efectuat, începe al doilea, iar primul DMA este

setat pentru un nou transfer programat să înceapă când al doilea canal DMA

termină transferul.


EXEMPLU: Compresia imaginilor color

În televiziunea în culori fiecare pixel este reprezentat prin 3 octeţi

corespunzători culorilor roşu, verde, albastru.

În sistemul PAL reprezentarea RGB este transformată într-o

reprezentare YUV în care Y este luminanţa iar U si V sunt componentele de

crominanţă, conform ecuaţiilor:

Y = 0.299*R + 0.587*G + 0.114*B

U = (B – Y) / 2.03

V = (R – Y) / 1.14

Folosind sistemul YUV se poate ajunge la o compresie de 50% fără a

se reduce calitatea imaginii.

Datele sunt stocate conform standardului MPEG în cuvinte de 16 biţi

conform următoarei hărţi de memorie:

ADRESA DATA

000000 Y00, Y01

000001 Y02, Y03

000002 U0, V0

000003 Y10, Y11

000004 Y12, Y13

000005 U1, V1


Y00 Y01

Y02 Y03

U0 V0

Y10 Y11

Y12 Y13

U1 V1

Y20 Y21

Y22 Y23

U2 V2

Y30 Y31

Y32 Y33

Memoriasistemului

Y00 Y01

U0 V0

Y10 Y11

U1 V1

Y20 Y21

U2 V2

Y30 Y31

Memoria video(o linie de imagine)

Primul canal DMA transferă datele din Y00, Y01 deoarece acestea

diferă de structura celorlalte.

Al doilea canal DMA este declanşat de primul şi transferă din 2D în

liniar când DCOL=1 (o incrementare şi un salt).

Priorităţi între canale

Fiecare canal DMA are un nivel de prioritate definit de biţii DPR1,

DPR0 din DCR al canalului respectiv. Nivelul poate fi 0, 1, 2 sau 3.

Prorităţile sunt necesare deoarece un singur canal DMA poate efectua

un transfer într-un ciclu de ceas deoarece există o singură magistrală DMA de

adrese (DAB).

În cazul în care canalele DMA active au priorităţi diferite atunci

canalul cu prioritatea cea mai mare efectuează transferul, celelalte canale

aşteaptă.


Dacă sunt două canale active cu aceeaşi prioritate se foloseşte o

metodă în care fiecare canal transferă cate un cuvânt periodic. Acest

algoritm denumit "round-robin" nu asigură că numărul de cuvinte transferate

de canalul A este egal cu cele transferate de B în acelaşi timp. Aceasta

deoarece un al treilea canal cu o prioritate mai mare poate interveni, iar

sistemul nu îşi aminteşte care canal a efectuat ultimul transfer înainte de

intervenţie.

EXEMPLU:

0 0 0 1 0 1 2 2 2 3 2 3 4 4 4 4 4 2 3 5 2 3 5 2 3 5 3 5 3 5 3 5 5 5 0 1 0 1 0 1 1 1 1

↑ ↑ ↑ ↑ ↑ ↑ ↓ ↓ ↓ ↓ ↓ ↓

Sta

rt C

h0

Sta

rt C

h1

Sta

rt C

h2

Sta

rt C

h3

Sta

rt C

h4

Sta

rt C

h5E

nd C

h4

End

Ch2

End

Ch3

End

Ch5

End

Ch0

End

Ch1

Round robin

În acest exemplu:

• Canalele 0 şi 1 au prioritatea 0

• Canalele 2, 3 şi 5 au prioritatea 1

• Canalul 4 are prioritatea 2.

Modul de transfer continuu

Un canal DMA poate lucra în modul continuu dacă bitul DCON din

registrul de control al canalului respectiv este setat.

Celelalte canale cu aceeaşi prioritate nu pot interveni până când nu se

termină transferul unui bloc întreg sau a unei linii.

Canalele cu prioritate mai mare întrerup transferul canalului chiar

dacă acesta este în modul continuu.


EXEMPLU:

0 0 0 1 0 1 2 2 2 3 2 3 4 4 4 4 4 2 3 5 5 5 5 5 5 5 5 2 3 2 3 3 3 3 0 1 0 1 0 1 1 1 1

↑ ↑ ↑ ↑ ↑ ↑ ↓ ↓ ↓ ↓ ↓ ↓

Sta

rt C

h0

Sta

rt C

h1

Sta

rt C

h2

Sta

rt C

h3

Sta

rt C

h4

Sta

rt C

h5E

nd C

h4

End

Ch5

End

Ch2

End

Ch3

End

Ch0

End

Ch1

Modul continuu

În acest exemplu

• canalele 2, 3 şi 5 au prioritatea 1;

• canalul 5 este setat în modul continuu.

Capitolul 4 – Generarea semnalelor sinusoidale 119

CAPITOLUL 4

GENERAREA SEMNALELOR SINUSOIDALE

4.1 GENERAREA SEMNALELOR SINUSOIDALE FOLOSIND

DEZVOLTAREA ÎN SERIE TAYLOR A FUNCŢIEI SINUS

Pentru calculul funcţiei sin( )x se poate folosi dezvoltarea în serie

Taylor dată de ecuaţia:

3 5 7 9

sin( )1! 3! 5! 7! 9!

≈ − + − +x x x x x

x (4.1)

Această formulă aproximează funcţia sinus cu o precizie de până la 14

biţi pentru valori ale lui x în intervalul: / 2 / 2π π− ≤ ≤x .

Pentru / 2π>x se va face substituţia:

, 0 / 2

, / 2

( ), 3 / 2

(2 ), 3 / 2 2

ππ π π

π π ππ π π

≤ ≤ − ≤ ≤= − − ≤ ≤− − ≤ ≤

x x

x xx

x x

x x

(4.2)

Pentru 0<x se va folosi relaţia de calcul:

sin( ) sin( )− = −x x (4.3)

Dacă | | 2π>x funcţia va returna 0.


x < 0

x < π/2

x = |x|

s1 = −1NU

DA

x = x − π/2

NU

x < π/2

s2 = −1x = x − π/2

NU

x < π/2

x = x − π/2

NU

x < π/2

sin = 0

NU

x = π/2 − x

sgn = s1 * s2x = sgn * x

DA

DAEchivalent cu

π/2 < x < π

Echivalent cuπ < x < 3π/2

Echivalent cu3π/2 < x < 2π

DA

DA

STOP

Calcul sin(x)

Figura 4.1. Organigrama pentru stabilirea intervalului de valori pentru x


Rutina de calcul pentru sin( )x va avea două părţi:

1. Stabilirea intervalului de valori pentru x şi realizarea substituţiilor

pentru obţinerea rezultatului corect. Organigrama este prezentată în

figura 4.1.

2. Calculul valorii sin( )x conform formulei (4.1).

Pentru generarea unui semnal sinusoidal 0sin( )ωn de frecvenţă 0ω ,

programul principal va calcula valoarea lui 0ω=x n pentru n întregi şi va

verifica dacă | | 2π<x . Apoi se apelează rutina de calcul pentru sin( )x .

Pentru procesoarele de semnal în virgulă fixă, această implementare

ridică unele probleme datorită reprezentării în format fracţionar pentru x.

Aceasta implică scalarea acestuia (deoarece / 2 / 2π π− ≤ ≤x ) în intervalul

[ 1,1)− , adică:

2

π=s

xx . (4.4)

De asemenea pentru o arhitectură cu acumulator (cum este cazul

familiei DSP56300) este mai avantajoasă formula de calcul ca sumă de puteri

ale lui 2x , adică:

3 5 7 9 2 4 6 8

sin( ) 11! 3! 5! 7! 9! 3! 5! 7! 9!

≈ − + − + = − + − +

x x x x x x x x xx x (4.5)

Dacă avem în vedere şi scalarea lui x obţinem:

( )2 4 6 81 2 3 4sin( ) 1

2

π= + + + +s s s s sx x a x a x a x a x (4.6)

Unde constantele includ semnul şi factorii de scalare:

21

0.41123353! 2

π = − = −

a , 4

2

10.0507339

5! 2

π = =

a ,

6

3

10.0029804

7! 2

π = − = −

a ,8

4

10.0001021

9! 2

π = =

a .


În continuare este prezentat programul în limbaj de asamblare pentru

familia DSP56300:

move #xaddr,r4 ;adresa lui x

move #const,r0 ;adresa constantelor ai

move #sinrez,r1 ;adresa rezultatului

move #1.0,a x:(r4),x1 ; x1=x

mpyr x1,x1,b

move b,x1 ; x1=x^2

mpyr x1,x1,b x:(r0)+,x0 ; b=x^4, x0=a1

mac x0,x1,a x:(r0)+,x0 b,y1 ; a=1+a1*x^2, x0=a2

mpyr x1,y1,b ; b=x^6, y1=x^4

mac x0,y1,a x:(r0)+,x0 b,y1 ; a=a+a2*x^4, x0=a3

mpyr x1,y1,b ; b=x^8, y1=x^6

mac x0,y1,a x:(r0)+,x0 b,y1 ; a=a+a3*x^6, x0=a4

macr x0,y1,a x:(r4),x1 ; a=a+a4*x^8

move a,x0

mpyr x1,x0,a ; a=x*a

Pentru un procesor de semnal care foloseşte registre de uz general

pentru stocarea rezultatelor operaţiilor aritmetice şi nu mai este nevoie de

transferul din acumulator în registru de date, descompunerea în serie Taylor

se mai poate face folosind formula:

3 5 7 9 2 2 2 2

sin( ) 1 1 1 11! 3! 5! 7! 9! 2 3 4 5 6 7 8 9

≈ − + − + = − − − − ⋅ ⋅ ⋅ ⋅

x x x x x x x x xx x (4.7)


4.2 GENERAREA SINUSULUI CU AJUTORUL UNUI TABEL

DE CĂUTARE

Generarea sinusului este folositoare în comunicaţii şi aplicaţii de

control. Odată cu introducerea procesoarelor digitale de semnal cu viteză şi

precizie ridicate se poate genera digital un sinus stabil şi cu distorsiuni mici la

orice frecvenţă folosind un tabel de căutare cu interpolare pentru reducerea

distorsiunilor. În continuare vom descrie trei metode de generare a sinusului si

vom obţine Frecventa Sintetizabilă Maximă (FSM) pentru fiecare din cazuri.

Valorile folosite pentru generarea sinusului sunt înmagazinate într-un

tabel în memorie după cum urmează:

1= −i N [ ]sin ( 1) 2 /π− ⋅N N

.

.

→i [ ]sin ( ) 2 /π⋅i N

.

.

2=i [ ]sin (2) 2 /π⋅ N

1=i [ ]sin (1) 2 /π⋅ N

ADRESA DE START:0=i

[ ]sin (0) 2 /π⋅ N

unde:

N = lungimea tabelului;

i = indexul în tabel, 0 1≤ ≤ −i N ;

sin( 2 / ) ( )π⋅ =i N S i = valoarea înmagazinată la locaţia i din tabel.


Frecvenţa sinusului generat digital depinde de intervalul de timp şi de

pasul delta (∆) dintre două valori succesive din tabel. Dacă 1∆ = (intrările

sunt citite succesiv) şi tabelul este accesat la fiecare sT secunde ( sT =

perioada de eşantionare), frecvenţa fundamentală a sinusului sintetizat va fi:

1= =

⋅S

f

FF Hz

N T N(4.8)

Pe de altă parte, dacă 1∆ > , de exemplu 2∆ = , fiecare a doua intrare

este citită, şi tabelul este accesat la fiecare sT secunde, atunci frecvenţa

sinusului sintetizat va fi:

= ∆ ⋅ fF F Hz (4.9)

Dacă ∆ este întreg, doar multiplii ai fF pot fi generaţi.

Dacă ∆ este raţional atunci orice frecvenţă mai mică decât FSM poate fi

generată. Valoarea maximă pentru ∆ este / 2N deoarece pentru sintetizarea

sinusului fără aliere sunt necesare cel puţin două eşantioane pe perioadă.

Valoarea eşantionului de ieşire ( )x n , va depinde de faza iniţială f şi de

timp (sau indexul de eşantionare) n, după cum urmează:

( ) sin( 2 / )π= + ⋅ ∆ ⋅x n f n N , 0, 1, 2,= …n (4.10)

4.2.1 Căutarea în tabel cu delta întreg

Această implementare este o metodă de căutare directă în tabel cu delta

fiind un număr întreg şi pozitiv. Deoarece delta este întreg, toate eşantioanele

cerute sunt conţinute în tabel; nu sunt necesare aproximări. Figura de mai jos

ilustrează această metodă pentru 8=N şi 2∆ = .


1 2 3 4 5 6 7 8

-1

-0.8

-0.6

-0.4

-0.2

0

0.2

0.4

0.6

0.8

1

2=∆

Valorile din tabel

Valorile generate

Figura 4.2. Generarea eşantioanelor sinusului pentru delta întreg

În această rutină tabela cu valorile sinusului are lungime 256=N şi

este încărcată în memoria X începând de la adresa 0. Ieşirea poate fi citită din

locaţia de memorie Y:$100.

Harta memoriei:

X Data

TABELSINUS

NR1

adresa de bază = $0

Y Data

ieşire y:$100

Program

Start = $100

Figura 4.3. Harta memoriei pentru programul de generare a sinusului cu delta

întreg


Programul de asamblare pentru generarea sinusului când delta este

întreg este prezentat mai jos:

N equ 256 ; lungimea tabelei

table equ 0 ; adresa de început a tabelei

delta equ 2 ; delta = 2

pi equ 3.141592654

angle set 0.0

inc set 2.0*pi/N

org x:table

dup N

dc 0.5*@sin(angle) ; generarea unei perioade a

angle set angle+inc ; sinusului de 256 eşantioane

endm

org y:$100

y_dat ds $50 ; rezervam memorie Y pentru ieşire

org p:$100

start

move #table,r1 ; inceputul tabelei

move #y_dat,r4 ; adresa de iesire

move #N-1,m1 ; setarea adresarii modulo N

move #delta,n1 ; deplasare = delta

sineg

move x:(r1)+n1,x0 ; pune eşantionul sinusului în x0

move x0,y:(r4)+ ; mută eşantionul la ieşire

jmp sineg ; buclă infinită

Instrucţiunea MOVE utilizează modul de adresare modulo cu

postindexare a procesorului DSP56300. Trei registre de adrese ai unităţii


aritmetice sunt folosite în această rutină: registrul de adresă R1 pentru indexul

din tabela sinusului, registrul de deplasare N1 conţine valoarea lui delta, şi

registrul modificator M1 conţine valoarea 1−N pentru setarea bufferului

modulo.

Frecvenţa sintetizabilă maximă este dată prin formula:

1

2=

⋅ ⋅FSM

lcyc CIS(4.11)

unde:

CIS = numărul total de cicluri ale instrucţiunilor pentru generarea unui

eşantion al sinusului.

lcyc = timpul de execuţie al unui ciclu instrucţiune

Dacă considerăm 50=lcyc ns şi 4=CIS cicluri, valoarea FSM este cea

mai mare care s-ar putea obţine. Avem:

2,5=FSM MHz (4.12)

4.2.2 Căutarea în tabel cu delta raţional

Această implementare este o metodă directă de căutare în tabel cu delta

număr raţional pozitiv, adică, un număr compus dintr-o parte întreagă şi o

parte fracţionară. Când partea fracţionară este nenulă, eşantioanele din

punctele aflate între două elemente din tabel trebuie estimate folosind valorile

din tabel. Cea mai directă estimare este cea care foloseşte valoarea anterioară

din tabel. Această abordare este descrisă în această secţiune şi este ilustrată în

figura următoare pentru 8=N şi 2,5∆ = .


1 2 3 4 5 6 7 8

-1

-0.8

-0.6

-0.4

-0.2

0

0.2

0.4

0.6

0.8

1

5,2=∆

Valorile din tabel

Valorile generate

Figura 4.4. Generarea eşantioanelor sinusului pentru delta raţional

Delta este acum un număr raţional. Modul standard de adresare modulo

al procesorului DSP56300 nu poate fi folosit şi de aceea o schemă de adresare

modulo trebuie implementată software. În continuare vom descrie o metodă

de implementare a unei asemenea scheme. Aceasta foloseşte ambele registre

acumulator.

În această rutină partea întreagă a lui delta este stocată în partea

superioară a acumulatorului (B1 pentru exemplul dat). Trebuie avută grijă ca

partea fracţionară să fie stocată corect. Numărul mutat în B0 ca rezultat al

extragerii părţii întregi din delta, de exemplu ∆-@cvi(∆), este o fracţie cu

semn, de exemplu pozitiv. Acest lucru este nedorit cât timp bitul de semn

trebuie asociat părţii întregi. De aceea o deplasare către stânga trebuie

realizată pentru a elimina bitul de semn lăsând partea fracţionară din B0 fără

semn.


Separarea părţilor întregi şi fracţionare este realizată folosind directiva

de conversie la întregi a asamblorului: @cvi(“ConVert to Integer”). Funcţia

CVI converteşte numere raţionale în numere întregi prin simpla trunchiere a

părţii fracţionare a numărului raţional. De aceea:

• @cvi(D) returnează partea întreagă a lui delta.

• ∆-@cvi(∆) returnează partea fracţionară cu semn a lui delta.

Aceasta presupune că delta nu este o variabilă de lucru. Dacă se cere ca

delta să fie o variabilă de lucru, o separăm într-un întreg cu semn şi o fracţie

fără semn pe care le stocăm în B1 şi respectiv B0.

Al doilea acumulator, A în acest exemplu, conţine numărul raţional

pozitiv folosit pentru a încărca registrul de deplasare N1 care este folosit la

deplasarea pointerului R1. R1 este folosit pentru a adresa locaţia corectă din

tabela sinusului. Atât timp cât indexul tabelului trebuie să fie un întreg, doar

A1 este mutat în N1. Adunarea lui delta este făcută atât în partea întreagă cât

şi fracţionară a acumulatorului A. Punctul binar este unul imaginar între cele

două părţi A1 şi A0 ale acumulatorului. Trebuie notat că adresarea cu

registrul R1 este făcută prin indexarea cu registrul offset N1, lăsând astfel

neschimbată valoarea originală a lui R1 (adresa de bază).

Ca exemplu sunt arătate evoluţiile registrelor A şi N1 pentru 2,5∆ = şi

lungimea tabelei sinusului 8=N . Valoarea lui A1 este calculată modulo 8

prin mascare (operaţia “and”) cu valoarea 1 7− =N (111 în binar).

2,5∆ = B1 = 2 B0 = 0.5 (fără semn)

MASK = 7 (111) B1 00 … 00010 B0 10000 … 00 R1 = 0

A = 0 A1 00 … 00000 A0 00000 … 00 N1 = 0

A = A + B A1 00 … 00010 A0 10000 … 00

A = A and 111 A1 00 … 00010 A0 10000 … 00 N1 = A1 = 2


1

A = A + B A1 00 … 00101 A0 00000 … 00

A = A and 111 A1 00 … 00101 A0 00000 … 00 N1 = A1 = 5

A = A + B A1 00 … 00111 A0 10000 … 00

A = A and 111 A1 00 … 00111 A0 10000 … 00 N1 = A1 = 7

1

A = A + B A1 00 … 01010 A0 00000 … 00

A = A and 111 A1 00 … 00010 A0 00000 … 00 N1 = A1 = 2

A = A + B A1 00 … 00100 A0 10000 … 00

A = A and 111 A1 00 … 00100 A0 10000 … 00 N1 = A1 = 4

Programul în limbaj de asamblare pentru generarea sinusului cu delta

raţional este:


table equ 0 ; adresa de început a tabelei

delta equ 2.5

pi equ 3.141592654

angle set 0.0

inc set 2.0*pi/N

org x:table

dup N


angle set angle+inc ; sinusului de 256 eşantioane

endm

org y:$100

y_dat ds $50


org p:$100

start

move #table,r1 ; r1 = începutul tabelei

move #y_dat,r4 ; r4 = pointerul ieşirii

move #(delta-@cvi(delta)),b0 ; partea fracţionara în b0

asl b ; elimina bitul de semn

move #@cvi(delta),b1 ; partea întreagă în b1

clr a #0,n1 ; iniţializează a şi n1

move #>N-1,x1 ; setează masca modulo

sineg

add b,a x:(r1+n1),y0 ; actualiz. a, y0 = sinus

and x1,a y0,y:(r4) ; mask a

move a1,n1 ; actualiz. reg. ofset n1

jmp sineg ; buclă infinită

Harta memoriei pentru acest program este:

X Data

TABELSINUS

N(R1+N1)


Y Data

ieşire y:$100

Program

Start = $100

Figura 4.5. Harta memoriei pentru programul de generare a sinusului cu delta

raţional

Frecvenţa sintetizabilă maximă este:

11,667

2 50 6= =

⋅ ⋅FSM MHz (4.13)


4.2.3 Căutarea în tabel cu interpolare liniară

Pentru a sintetiza sinusul de orice frecvenţă cu distorsiuni mici, o

metodă de interpolare trebuie folosită împreună cu căutarea în tabel. Folosind

interpolarea, valorile sinusului aflate între elementele din tabel pot fi

reprezentate mai precis. Cea mai uşoară tehnică de interpolare este

interpolarea liniară. Pentru interpolarea liniară presupunem că valoarea

sinusului într-un punct dintre două intrări succesive ale tabelei se află pe o

dreaptă între cele două valori. Acest lucru este ilustrat în figura următoare

pentru 8=N şi 2,5∆ = .

1 2 3 4 5 6 7 8

-1

-0.8

-0.6

-0.4

-0.2

0

0.2

0.4

0.6

0.8

1

5,2=∆

Valorile din tabel

Valorile generate

Eroarea fără interpolare liniară

Eroarea cu interpolare liniară

Figura 4.6. Generarea eşantioanelor sinusului prin interpolare liniară


Algoritmul folosit pentru interpolarea liniară se bazează pe ecuaţia

dreptei în două puncte:

1 1( )− = −y y m x x (4.14)

Pentru interpolarea liniară avem:

• [ 1] [ ]= + −m S i S i este panta segmentului de dreaptă între două

elemente, i si 1+i succesive ale tabelului;

• 1 [ ]=y S i este valoarea din tabelul sinusului de la adresa de bază +

deplasamentul i;

• [ ]= +y S i f este eşantionul aproximat;

• 1= −f x x este partea fracţionară a lui delta, 0 1< <f .

De aceea avem:

( )[ ] [ ] [ 1] [ ]+ = + ⋅ + −S i f S i f S i S i (4.15)

Diagrama de desfăşurare a programului de generare a sinusului cu

interpolare liniară este prezentată în figura 4.7.

Tabela sinusului este înmagazinată în memoria X începând de la adresa

0. Pointerul adresă R1 indică valoarea curentă a sinusului, în timp ce poinerul

adresă R2 indică valoarea următoare valorii curente a sinusului, R2 = R1 + 1.

Panta dintre două valori succesive este determinată prin diferenţa valorilor din

memorie de la adresele din R2 şi R1.

Pentru generarea eşantionului sinusului folosind interpolarea liniară,

partea fracţionară a aproximării liniare f, este înmagazinată în acumulatorul

A0 iar partea întreagă este înmagazinată în A1. A1 este mutat în N1 care este

folosit pentru indexarea registrului R1. Aceeaşi valoare care este mutată în N1

este mutată şi în N2 care este folosit pentru indexarea registrului R2. De

remarcat că spre deosebire de metoda anterioară de generare cu delta raţional,

conţinutul lui A0 trebuie deplasat la dreapta astfel încât să reprezinte un


număr în format fracţionar corect, cu semn pozitiv, pentru a realiza înmulţirea

care generează aproximarea liniară.

Iniţializări registrede adrese

Separare delta: parteîntreagă → Y1

fracţionară → Y0

Iniţializare adresătabelă sinus

Calculeazăm, f

Efectueazăinterpolarea liniară

[ ]S i f+

Generează eşantionieşire x(n)

Actualizează pointertabel sinus (modulo)

Figura 4.7. Organigrama pentru generarea sinusului cu interpolare liniară

Delta poate fi orice număr raţional pozitiv între 0 şi / 2N .

Acumulatorul B este mai întâi folosit pentru a separa delta într-un întreg cu

semn şi o fracţie fără semn şi apoi este folosit pentru a calcula valoarea

eşantionului interpolat. De remarcat că o adresare imediată lungă (de exemplu

folosind semnul “>”) trebuie specificată la salvarea părţii întregi în Y1

deoarece (@CVI(∆)) trebuie să fie interpretată ca o fracţie cu semn.


Partea de program pentru generarea sinusului foloseşte 6 registre ale

unităţii aritmetice, pe lângă registrele R1, R2, R4, N1, N2, M2. Registrul M2

este folosit mai întâi pentru a memora masca înainte de a fi folosit în operaţia

“and” de mascare (această operaţie de mascare obligă R1 + N1 să fie în

regiunea de memorie dorită, implementând adresarea modulo). M2 este

folosit apoi pentru actualizarea aritmetică modulo a lui R2 + N2. Este necesar

să avem grijă în cazul special când R1 + N1 indică $1FF. Deoarece R2 + N2

= R1 + N1 + 1, va trebui să indice $200 în loc de $100 fără operaţia

aritmetică modulo.

Programul de asamblare este prezentat mai jos:


table equ 0 ; adresa de inceput a tabelei

delta equ 5.35

pi equ 3.141592654

angle set 0.0

inc set 2.0*pi/N

org x:table

dup N


angle set angle+inc ; sinusului de 256 esantioane

endm

org y:$100

y_dat ds $50

org p:$100

start

move #table,r1 ; r1 = adresa de start a tabelei

move #y_dat,r4 ; iesirea in memoria Y


move #(delta-@cvi(delta)),b0 ;parte fractionara delta

asl b ; elimina bitul de semn

move #>@cvi(delta),y1 ; partea intreaga delta

in y1

move b0,y0 ; partea fractionara fara semn

clr a #0,n1 ; initializeaza a si n1

move #N-1,n0 ; valoarea masca modulo

move #0,n2 ; initializeaza n2

move #table+1,r2 ; r2 = r1+1

sineg move a0,b ; delta fract. in b1, b0 = 0

lsr b x:(r1+n1),x0 ; b1 = f, x0 = S[i]

move b1,x1 ; x1 = f

move x:(r2+n2),b ; b1 = S[i+1]

sub x0,b ; panta m = S[i+1] – S[i]

move b,x0 ; x0 = m

move x:(r1+n1),b ; b1 = S[i]

macr x0,x1,b ; S[i+f] = m * f + S[i]

add y,a b,y:(r4) ; delta se aduna la a

move n0,x1 ; x1 valoarea masca modulo

and x1,a ; masca a1 = modulo

move a1,n1 ; actualiz. registrul ofset n1

move a1,n2 ; actualiz. registrul ofset n2

jmp sineg ; bucla infinita


Harta memoriei este:

X Data

TABELSINUS

N

(R2+N2)

(R1+N1)


Y Data

ieşire y:$100

Program

Start = $100

Figura 4.8. Harta memoriei pentru programul de generare a sinusului cu

interpolare liniară

Resursele necesare pentru această subrutină sunt:

Frecvenţa sintetizabilă maximă este:

10.625

2 50 16= =

⋅ ⋅FSM MHz (4.16)


4.3 METODA OSCILATORULUI DIGITAL

O metodă utilă de generare a unei sinusoide de o anumită frecvenţă este

folosirea unui rezonator aflat la limita stabilităţii care are o pereche de poli

complex conjugaţi pe cercul de rază unitate. Metoda oscilatorului recursiv

este cea mai eficientă şi precisă metodă de generare a semnalelor sinusoidale.

Fie sistemul digital care are răspunsul la impuls de forma:

0( ) sin( ) ( )ω=h n A n u n (4.17)

unde ( )u n este treapta unitate, A este amplitudinea sinusoidei generate,

iar 0ω este frecvenţa unghiulară.

Funcţia de transfer a sistemului (considerând 1=A ) se obţine aplicând

transformata Z ecuaţiei (4.17):

( )( )

0 0

0 0 0 0

1

1 1 1 2

1 1 1( )

2 1 1 2 1

ω ω

ω ω ω ω

− −

−− − − − −

− = − = − − − + +

j j

j j j j

e e zH z

j e z e z j e e z z(4.18)

Evident acest sistem are polii 0ωje şi 0ω− je aflaţi pe cercul de rază

unitate. Efectuând calculele rezultă:

10

1 20

( ) sin( )

( ) 1 2cos

ωω

−

− −= =− +

Y z zH z

X z z z(4.19)

Ecuaţia cu diferenţe finite este:

0 0( ) 2cos ( 1) ( 2) sin ( 1)ω ω= − − − + −y n y n y n x n (4.20)

Dacă la intrarea sistemului se aplică impulsul unitate pentru 2≥n ,

ieşirea ( )y n poate fi calculată recursiv astfel:

0( ) 2cos ( 1) ( 2), 2ω= − − − ≥y n y n y n n (4.21)

cu condiţiile iniţiale 0(1) sinω=y şi (0) 0=y .


Deoarece termenul 02cosω poate avea valori supraunitare algoritmul

va calcula ieşirea ( )y n astfel:

1. 0( 1)cosω= −a y n (instrucţiunea mpy)

2. ( ) 2 ( 2)= − −y n a y n (instrucţiunea subl)

0cos2 ω

1−1−z

1−z

)(ny

)1(1 −= nys

)2(2 −= nys

Figura 4.9. Structura oscilatorului digital

Erorile care apar în acest sistem sunt date de reprezentarea valorii

0cosω pe un număr finit de biţi (24 de biţi în cazul Motorola DSP56300) şi la

trunchierea rezultatului după adunare (scădere de fapt).

Dacă valoarea 0cosω este cuantizată pe 24 de biţi eroarea (deviaţia) de

frecvenţă unghiulară este:

( )230 0 0arccos cos 2ω ω ω −∆ = − − (4.22)

ceea ce, pentru o frecvenţă de eşantionare de 48 kHz conduce la o

diferenţă de frecvenţă faţă de valoarea nominală de maxim 0.01 Hz pentru

frecvenţe situate în intervalul 500 Hz – 23 kHz şi de maxim 0.1 Hz în afara

acestui interval.

În urma cuantizării coeficientului 0cosω este afectată numai frecvenţa

sinusoidei generate nu şi amplitudinea acesteia deoarece se modifică numai

argumentul polilor, modulul rămânând 1.


Exemplu: Generarea unui sinus de 60Hz:

Fs set 48000.0 ;Frecvenţa de eşantionare

PI set 2.0*@asn(1.0) ;PI calculat ca 2.0*arcsin(1.0)

freq_a set 60.0 ;Frecvenţa dorită în Hertzi

amp_a set 0.3 ;Amplitudinea (0-1)

omega set 2.0*PI*freq_a/Fs ;Pulsaţia unghiulară normată

s1_a set amp_a*@sin(omega) ;Valori iniţiale y(1) şi y(0)

s2_a set 0.0

coeff_a set @cos(omega) ;Calcul coeficient cos

org x:

DOSC_BUFF_BASE EQU *

coeff ds 1 ;Adresa coeficient

s1 ds 1 ;Adresa s1

s2 ds 1 ;Adresa s2

org p:$100

START

;Iniţializări Oscilator Digital

move #coeff_a,x0

move x0,x:DOSC_BUFF_BASE

move #s1_a,x0

move x0,x:DOSC_BUFF_BASE+1

move #s2_a,x0

move x0,x:DOSC_BUFF_BASE+2

loop

move #DOSC_BUFF_BASE,r5

jsr dosc_sin ;Apel subrutină oscilator

move a,x0 ;Copiază noul eşantion în x0

jmp loop ;Buclă infinită


dosc_sin

move x:(r5)+,x0

move x:(r5)+,y0

move x:(r5)-,b ;r5 e decrementat pentru a indica s1

mpy x0,y0,a ;cos*s1

subl b,a ;(cos*s1 - s2)=sin_val

move a,x:(r5)+ ;Salvează noul s1

move y0,x:(r5) ;Salvează noul s2

rts


4.4 GENERAREA SEMNALELOR SINUSOIDALE ÎN

CUADRATURĂ

O altă soluţie simplă, rapidă, de tip recursiv de generare a sinusului este

propusă în rândurile următoare. Avantajul este că se pot genera simultan o

sinusoidă şi o cosinusoidă de aceeaşi frecvenţă (necesare în aplicaţii unde se

cer semnale modulatoare în cuadratură) iar rezultatele sunt de mare precizie.

Operaţiile efectuate de sistem sunt de fapt două formule binecunoscute

din trigonometrie şi anume cosinusul şi sinusul unei sume de arce.

Recursivitatea se scrie:

cos ( 1) cos cos sin sinα α α α α+ = −n n n (4.23)

sin ( 1) cos sin sin cosα α α α α+ = +n n n (4.24)

unde 02α πω=

Pentru generarea frecvenţei dorite trebuie iniţializate valorile cos0 1=

şi sin 0 0= . Calculul celor două forme de undă se realizează apoi doar prin

patru multiplicări, o adunare şi o scădere. Parametrii de intrare sunt locaţiile

de memorie folosite pentru cosαn şi sinαn şi cele două constante cosα şi

sinα ce dau frecvenţa de oscilaţie.

cosα

sinα

1−z 1−z

nαcos nαsin

-sinα

cosα

Figura 4.10. Structura generatorului de semnale sinusoidale în

cuadratură


Frecvenţa va fi dată deci de incrementul de fază 02α πω= . În cazul

procesorului DSP56300 precizia frecvenţelor generate depinde de precizia

reprezentării lui cosα şi sinα pe 24 de biţi.

cosα

sinα

1−z 1−z

nαcos

nαsin

-sinα

cosα

)(sin)(cos 22 nn αα + )(sin)(cos 22 nn αα +

1

-

1

err

nαcos

nαsin

Figura 4.11. Compensarea amplificării în generatorul de semnale sinusoidale

în cuadratură

Recursivitatea necesită controlul ciclurilor limită pe termen lung. Din

cauza faptului că sinusul şi cosinusul sunt generate recursiv, erorile se pot

propaga foarte rapid. Pentru a preveni ca amplitudinea să scadă sau să crească

în decursul timpului, se adaugă un sistem de compensare a amplificării.

Acesta se realizează prin calcularea unui semnal de eroare, semnal ce este dat

de diferenţa între amplitudinea dorită (1 de exemplu) şi amplitudinea actuală

(cea generată), care se calculează cu formula:

2 2cos ( ) sin ( )α α+n n (4.25)


Semnalul de eroare este apoi utilizat ca o reacţie negativă, pentru

controlul amplitudinii, ceea ce conferă acestui algoritm o mare precizie la

generarea sinusoidelor. Semnalul eroare va fi calculat după formula:

2 21 cos ( ) sin ( )α α= − +err n n (4.26)

Pot apare trei cazuri de-a lungul desfăşurării programului :

1. Dacă 0=err , deci suma de sub radical va fi 1, semnalul nu va avea

nici o eroare, iar semnalele sin( )αn şi cos( )αn vor fi amplificate cu

1, păstrându-şi astfel valoarea.

2. Dacă sinusoida are tendinţa să scadă în amplitudine, de exemplu

dacă radicalul ia valoarea 0,9 , va rezulta un semnal de eroare

0,1=err . Acesta se va aduna cu 1 şi se va înmulţi cu valorile

anterioare ale sin( )αn şi cos( )αn , pentru a se mări amplitudinea.

3. Dacă sinusoida are tendinţa să crească în amplitudine, de exemplu

dacă radicalul ia valoarea 1,1, va rezulta un semnal de eroare

0,1= −err . Acesta se va aduna cu 1 şi se va înmulţii cu valorile

anterioare alesin( )αn şi cos( )αn , pentru a scădea amplitudinea.

Capitolul 5 – Realizarea filtrelor digitale 145

CAPITOLUL 5

REALIZAREA FILTRELOR DIGITALE

5.1 IMPLEMENTAREA FILTRELOR CU RĂSPUNS FINIT LA

IMPULS (FIR)

Funcţia de transfer a unui filtru cu răspuns finit la impuls de lungime N

este de forma:

1 10 1 1

( )( ) ..

( )N

N

Y zH z h h z h z

X z− −

−= = + + + (5.1)

Ecuaţia cu diferenţe finite este:

1

0

( ) ( )N

kk

y n x n k h−

=

= −∑ (5.2)

unde ( )x n este intrarea filtrului la momentul n, ( )y n este ieşirea, kh

sunt coeficienţii funcţiei pondere şi N este lungimea filtrului.

5.1.1 Forma transversală

Ecuaţia (5.2) poate fi implementată într-o structură transversală ca în

figura următoare.


0h

( )x n 1z− 1z−

( 1)x n − ( 1)x n − 1z−

1h 2h 1Nh −

( 1)x n N− +

( )y n

Figura 5.1. Forma transversală pentru FIR

Pentru calculul ieşirii ( )y n trebuie memorate stările filtrului şi

coeficienţii funcţiei pondere. De exemplu, pentru implementarea filtrelor FIR

pe procesoarele din familia DSP56300, memoria este organizată după cum

urmează:

• stările filtrului (ultimele N eşantioane de intrare) în memoria de date

X, într-un buffer circular de lungime N.

• coeficienţii filtrului în memoria de date Y începând de la adresa $0,

de asemenea într-un buffer circular de lungime N.

Memoria X

r0

Memoria Y

1Nh −

1h

0h

( 1)x n −

( )x n

( 1)x n N− +

Adresa de bază: $0 $0 r4

Figura 5.2. Organizarea memoriei pentru filtrul FIR


Registrul r4 indică adresa coeficienţilor filtrului. r4 este incrementat

modulo N, astfel că la terminarea sumei (după N incrementări) el revine la

adresa primului coeficient 0h .

Registrul r0 indică adresa celui mai recent eşantion ( )x n . La sfârşitul

efectuării sumei, r0 (incrementat tot modulo N) va ajunge în aceeaşi poziţie,

de aceea el trebuie decrementat pentru a indica adresa celui mai vechi

eşantion ( 1)x n N− + . Astfel, următorul eşantion de intrare va fi scris în locul

acestuia, eşantionul anterior devenind ( 1)x n − etc.

Programul de calcul al ieşirii ( )y n este dat sub forma unui macro în

care:

- acumulatorul a este şters, eşantionul ( )x n este salvat din x0 în memorie la

adresa indicată de r0, coeficientul 0h este adus din memorie în registrul

y0. Aceste trei operaţii se efectuează în paralel într-un singur ciclu maşină.

- se face suma primelor 1N − produse. Înmulţirea şi sumarea operanzilor se

face cu instrucţiunea mac x0,y0,a rezultatul sumei fiind în acumulatorul a.

În paralel cu aceasta sunt transferaţi din memorie operanzii următori:

eşantionul ( )x n k− în x0 şi coeficientul kh în y0.

- după terminarea ciclului rep se face ultima înmulţire cu acumulare şi

rotunjire pentru ca ( )y n să fie pe 24 de biţi, precum şi decrementarea lui

r0.


fir macro ntaps

;------------------------------------------------

; eşantionul de intrare în x0

; ieşirea în acumulatorul a

; registrul r0 indică adresa esantionului x(n)

; registrul r4 indică adresa coeficientului h0

; parametru de intrare ntaps = lungimea filtrului

;------------------------------------------------

clr a x0,x:(r0)+ y:(r4)+,y0

rep #ntaps-1

mac x0,y0,a x:(r0)+,x0 y:(r4)+,y0

macr x0,y0,a (r0)-

endm

Programul principal trebuie să iniţializeze adresele pentru stările şi

pentru coeficienţii filtrului, precum şi modul de adresare circulară. Eşantionul

de intrare este transferat în x0, iar ieşirea este citită din a.

datin equ $ffffff

datout equ $fffffe

ntaps equ 4 ;lungimea filtrului

org x:0 ;rezervă memorie pentru

states dsm ntaps ;stările filtrului

org y:0

coef dc .1,.3,-.1,.2 ;coeficienţii filtrului

org p:$100

start

move #states,r0 ;adresa stărilor filtrului

move #ntaps-1,m0 ;adresare modulo(ntaps)


move #coef,r4 ;adresa coeficienţilor

move #ntaps-1,m4 ;adresare modulo(ntaps)

filtr movep y:datin,x0 ;eşantionul de intrare

fir ntaps ;calculează fir

movep a,y:datout ;ieşirea

jmp filtr

end

Programul este valabil pentru orice tip de FIR. Toţi coeficienţii sunt

consideraţi în format fracţionar (de modul subunitar). Dacă în urma proiectării

filtrului FIR apar şi coeficienţi de modul supraunitar, atunci toţi coeficienţii

trebuie scalaţi prin împărţirea cu:

( )max km h= (5.3)

De asemenea, pentru a evita depăşirea capacităţii registrelor, dacă

eşantioanele intrării sunt în intervalul ( 1,1)− , atunci trebuie îndeplinită

condiţia:

1

0

1N

kk

s h−

=

= ≤∑ (5.4)

Dacă nu este îndeplinită condiţia (5.4) atunci fie intrarea ( )x n , fie

coeficienţii kh trebuie scalaţi cu factorul s. Dacă intrarea este împărţită la s,

atunci gama dinamică a semnalului la intrare se micşorează, deci şi raportul

semnal-zgomot al structurii se micşorează. Pe de altă parte, dacă sunt scalaţi

coeficienţii, aceştia vor putea fi reprezentaţi pe mai puţini biţi şi este afectat

răspunsul în frecvenţă al filtrului. Aceste implicaţii trebuie evaluate în funcţie

de aplicaţie şi aleasă una din variante.


5.2 IMPLEMENTAREA FILTRELOR CU RĂSPUNS INFINIT

LA IMPULS (IIR)

Pentru un filtru IIR avem funcţia de transfer de forma:

0

1

( )( )

( ) 1

Mk

kk

Nk

kk

b zY z

H zX z a z

−

=

−

=

= =+

∑

∑ (5.5)

Coeficienţii numărătorului kb şi ai numitorului ka se determină printr-

una din metodele de proiectare a filtrelor digitale cu răspuns infinit la impuls

(folosind eventual mediul MATLAB) în funcţie, bineînţeles, de condiţiile de

proiectare cerute.

Notând cu ( )x n secvenţa de la intrarea filtrului şi cu ( )y n secvenţa de

la ieşirea filtrului, rezultă ecuaţia cu diferenţe finite:

0 1

( ) ( ) ( )M N

k kk k

y n b x n k a y n k= =

= − − −∑ ∑ (5.6)

Pentru calculul ieşirii ( )y n există mai multe posibilităţi de

implementare în funcţie de structura aleasă. Performanţele implementării

(complexitate aritmetică memorie ocupată, transferuri paralele) diferă în

funcţie de structura aleasă.

De asemenea, în proiectare şi implementare trebuie evaluate efectele

reprezentării semnalelor utilizând un număr finit de biţi. În cazul reprezentării

numerelor în formate cu virgulă fixă apare o depăşire dacă rezultatul unei

operaţii aritmetice este de modul supraunitar. Acest lucru este posibil după

operaţiile de însumare şi de înmulţire cu o constantă de modul supraunitar.


Analiza posibilităţii depăşirilor comportă două aspecte:

• analiza funcţiei de transfer, ( )H z şi eventual scalarea acesteia astfel

încât să se elimine sau să se reducă suficient de mult probabilitatea

ca semnalul de ieşire să fie de modul supraunitar;

• analiza posibilităţii depăşirilor în toate nodurile reţelei, conducând

(dacă este necesar) la o scalare a semnalului compensată în final,

astfel încât să nu afecteze realizarea funcţiei de transfer impuse.

În filtrele digitale atât amplitudinea semnalului cât şi coeficienţii sunt

valori discrete sau cuantizate cu un număr finit de biţi. Deşi astfel de sisteme

sunt neliniare, efectele acestor cuantizări pot fi interpretate ca fiind surse de

zgomot aditiv. Erorile de cuantizare ale coeficienţilor modifică funcţia de

transfer a filtrului şi se produc astfel variaţii ale zerourilor şi polilor, variaţii

care schimbă nedorit răspunsul în frecvenţă al filtrelor. Erorile de cuantizare a

semnalului pot fi privite ca surse de zgomot aditiv în diferite noduri ale

reţelei.

Principala sursă de zgomot de cuantizare o reprezintă rotunjirea sau

trunchierea rezultatului înmulţirii. Rezultatele înmulţirii şi adunării sunt

stocate în registrele acumulator, care la familia DSP56300 sunt de 56 de biţi.

Dacă se doreşte salvarea rezultatului în memorie este necesară limitarea

acestuia la 24 de biţi. În acest caz este de preferat o rotunjire în loc de

trunchiere, pentru o eroare mai mică. Alte surse sunt cuantizarea intrării la

convertorul analog-digital şi limitarea numărului de biţi la ieşire, de exemplu

trecerea de la o reprezentare internă pe 24 de biţi la 16 biţi pentru un

convertor digital-analog.

Cuantizarea coeficienţilor are efecte diferite de cuantizarea semnalului

din punct de vedere al zgomotului. Cuantizarea coeficienţilor produce erori în

răspunsul în frecvenţă şi în amplitudine ale filtrului, fiind erori deterministe.


Aceste erori pot fi minimizate folosind structuri de filtre mai puţin sensibile,

cu aceeaşi funcţie de transfer şi alocând un număr suficient de biţi pentru

coeficienţi.

Cuantizarea semnalului are efecte în diferite noduri ale filtrului, putând

fi considerate ca surse de zgomot alb, aditiv, înrăutăţind RSZ al ieşirii. Aceste

erori pot fi minimizate realizând înmulţirea şi acumularea rezultatului în

registre de lungime dublu-cuvânt.

O cale de mijloc pentru evitarea înrăutăţirii raportului semnal-zgomot

(RSZ) şi, pe de altă parte, evitarea depăşirii gamei dinamice (overflow) este

scalarea. Nu este nevoie de scalare în fiecare nod al reţelei deoarece

semnalele în unele noduri sunt doar întârzieri ale semnalelor din alte noduri.

De asemenea, dacă rezultatul final al adunării semnalelor din mai multe

noduri este subunitar, în cazul adunării în complement faţă de doi în final se

obţine rezultatul corect indiferent dacă în diferite noduri apar depăşiri la

sumele parţiale. Trebuie astfel realizată o tehnică de scalare a semnalului la

intrare pentru a evita depăşirile numai în nodurile unde acestea pot apare.

Se presupune că semnalul de intrare este în modul subunitar:

( ) 1x n ≤ (5.7)

Fie ( )mH z funcţia de transfer de la intrare la nodul m. Pentru a nu avea

depăşire în nodul m trebuie îndeplinită condiţia:

( ) 1my n ≤ (5.8)

Avem:

0 0 0

( ) ( ) ( ) ( ) ( ) ( )m m m m mk k k

y n h k x n k h k x n k h k k∞ ∞ ∞

= = =

= − ≤ − ≤ =∑ ∑ ∑ (5.9)

Nodurile în care pot apare depăşiri sunt în partea recursivă a structurii

şi, bineînţeles, la ieşirea filtrului. Scalarea este necesară dacă cel puţin unul


din coeficienţii mk este supraunitar. Coeficientul cu care se face scalarea la

intrarea structurii va fi:

1 2

1 1 1min , ,...,

m

sk k k

⎛ ⎞≤ ⎜ ⎟

⎝ ⎠ (5.10)

În cazul în care intrarea este zero sau o constantă, există posibilitatea ca

ieşirea filtrului, în loc de o apropiere asimptotică de o valoarea constantă, să

oscileze cu amplitudini relativ mici. Aceste oscilaţii sunt numite cicluri

limită. Aceştia pot fi reduşi la amplitudini acceptabile crescând numărul de

biţi de reprezentare cu virgulă fixă a semnalului.

Oscilaţiile în depăşiri sunt produse de caracteristica circulară a

sumatorului în complement faţă de 1 sau faţă de 2. Aceste oscilaţii pot

produce depăşiri ale gamei dinamice a filtrului IIR. Soluţia acestei probleme

este folosirea aritmeticii cu saturaţie la adunare ceea ce limitează rezultatul

adunării în modul subunitar.

Un alt factor ce influenţează implementarea software a filtrelor IIR este

numărul de instrucţiuni pe ciclu (aceasta mai ales pentru implementări în timp

real). Alţi factori ţin de natura procesorului (de exemplu: stocarea datelor şi

programelor în memorie, utilizarea registrelor, folosirea autoscalării, etc.).

Prima şi cea mai importantă problemă implică reducerea ciclurilor de

instrucţiune în programul de implementare a filtrului. Acest lucru este facilitat

de arhitectura pipe-line a procesorului, de multiplicarea cu acumulare

efectuată într-un singur ciclu şi de modurile de adresare ce se desfăşoară

paralel cu instrucţiunile aritmetice.

Pentru implementarea unui filtru digital pe DSP56300 trebuie mai întâi

proiectat filtrul şi obţinuţi coeficienţii pentru o formă particulară (directă,

latice, etc.) ce va fi implementată.


O procedură generală de utilizare a unui macro:

1. Definirea locaţiilor datelor pentru coeficienţii filtrului şi stările

acestuia;

2. Scrierea coeficienţilor în zona de memorie rezervată;

3. Scrierea stărilor iniţiale ale filtrului (la momentul 0n = );

4. Apelul macroului pentru calculul ieşirii;

5. Stările şi coeficienţii nu trebuie modificate între două apeluri

succesive ale macro-ului.

Când se foloseşte un macro într-o buclă pentru a genera o secvenţă de

eşantioane la ieşire prin prelucrarea eşantioanelor de la intrare, stările şi

coeficienţii sunt stocaţi în memorie, iar macro-ul este apelat în buclă. Bucla

va citi intrarea, va face apelul macro-ului şi va depune eşantioanele de la

ieşire în locaţia specificată (de obicei în acumulator). Pentru implementarea

aceluiaşi filtru se poate alege dintre mai multe macro-uri. În acest caz se

selectează macro-ul care are cele mai puţine cicluri de instrucţiuni.

5.2.1 Forma directă 1

Scriind relaţia intrare-ieşire sub forma:

0

( ) ( )M

kk

k

W z X z b z−

=

= ⋅∑ (5.11)

1

( )( )

1N

kk

k

W zY z

a z−

=

=+∑

(5.12)

Rezultă ecuaţiile cu diferenţe finite:

0

( )M

kk

k

w n b z−

=

=∑ (5.13)

1

( ) ( ) ( )N

kk

y n w n a y n k=

= − −∑ (5.14)


Astfel, pentru un filtru de ordin N rezultă schema de mai jos:

( )x n 0b ( )y n

1z−

1z−

1z−

1b

2b

Mb

( )w n

( 1)x n −

( )x n M−

1z−

1z−

1z−

1a−

2a−

Na−

( 1)y n −

( )y n N−

Figura 5.3. Filtru IIR forma directă 1

Evident, pentru calculul lui ( )w n se foloseşte macroul de fir.

Să considerăm acum implementarea unui filtru de ordin 2 numai cu

poli, cu funcţia de transfer de forma:

1 2

1 2

1( )

1H z

a z a z− −=+ +

(5.15)

Ieşirea va fi calculată cu formula:

1 2( ) ( ) ( 1) ( 2)y n x n a y n a y n= − ⋅ − − ⋅ − (5.16)

Organizarea memoriei:

Memoria X

r0

Memoria Y

2a−

1a−

( 2)y n −

( 1)y n − r4

Figura 5.4. Organizarea memoriei pentru un filtru de ordin 2 numai cu poli


Registrele modulo m0 şi m4 sunt setate –1 pentru adresare liniară.

Coeficienţii 1a şi 2a se consideră de modul subunitar. Înainte de apelul

macro-ului se scrie în registrul acumulator a valoarea eşantionului de intrare

( )x n .

iir1 macro

iir1 ident 1,0

;

; IIR1 - Implementare filtru IIR de ordin 2 numai cu poli

; x(n) este stocat în acumulatorul a

;

move x:(r0)+,x0 y:(r4)+,y0 ; x0 = y(n-1) y0 = -a1

mac x0,y0,a x:(r0),x1 y:(r4)-,y0

; x1 = y(n-2), y0 = -a2

; r4 este decrementat la adresa de bază a coeficienţilor

macr x1,y0,a ; a = y(n)

move x0,x:(r0)- ; y(n-1) se scrie în locul lui y(n-2)

move a,x:(r0) ; si y(n) în locul lui y(n-1)

endm

În exemplul anterior am considerat coeficienţii numitorului de modul

subunitar. Fie un filtru de ordin 2 stabil. Polii funcţiei de transfer sunt în

cercul de rază unitate, deci de modul subunitar.

Avem:

1 2 1 2

1 2 1 2

1 1( )

1 (1 )(1 )H z

a z a z p z p z− − − −= =+ + − −

(5.17)

Folosind relaţiile între coeficienţii şi rădăcinile polinomului de la

numitor obţinem:


1 1 2 1 2

2 1 2

2

1

a p p p p

a p p

= + ≤ + ≤

= ≤ (5.18)

Aceasta înseamnă că, în cazul unui filtru de ordin 2 coeficienţii

numitorului sunt de modul mai mic ca 2. Pentru a-i putea reprezenta în virgulă

fixă, în complement faţă de 2, este necesară scalarea coeficienţilor cu 2.

Structura echivalentă este prezentată mai jos:

( )x n 1/ 2 ( )y n

1z−

1z−

1 / 2a−

2 / 2a−

2

Figura 5.5. Filtru IIR de ordin 2 numai cu poli cu coeficienţii scalaţi

Ecuaţia cu diferenţe finite devine:

1 2( )( ) 2 ( 1) ( 2)

2 2 2

x n a ay n y n y n⎡ ⎤= − − − −⎢ ⎥⎣ ⎦

(5.19)

Vom folosi modul de scalare automată implementat în unitatea ALU a

DSP56300. Pentru acesta trebuie setat modul de scalare corespunzător cu biţii

S1 şi S0 din registrul de mod (MR). Dacă S1=1 şi S0=0, atunci, când se

citeşte rezultatul din acumulatorul a sau b, valoarea citită este deplasată cu un

bit la stânga astfel ca ieşirea ( )y n să fie înmulţită cu 2.

Registrul de mod (MR)

7 6 5 4 3 2 1 0

LF DM SC 0 S1 S0 I1 I0

În exemplul următor este implementat un filtru IIR de ordin 2, numai

cu poli, cu coeficienţii scalaţi cu 2. Programul este similar celui anterior,


numai că la începutul macroului este setat modul de scalare iar la sfârşit se

dezactivează acest mod.

Organizarea memoriei:

Memoria X

r0

Memoria Y

2 / 2a−

1 / 2a−

( 2)y n −

( 1)y n − r4

Figura 5.6. Organizarea memoriei pentru un filtru de ordin 2 numai cu poli cu

coeficienţii scalaţi

iir2 macro

iir2 ident 1,0

;

; IIR2 - Implementare filtru IIR de ordin 2 numai cu poli

; x(n) se considera scalat cu 2 si este stocat in a

;

ori #$08,mr ;setare mod scalare

move x:(r0)+,x0 y:(r4)+,y0

mac x0,y0,a x:(r0),x1 y:(r4)-,y0

macr x1,y0,a x0,x:(r0)-

nop

move a,x:(r0)

andi #$f7,mr ;dezactivare mod scalare

endm

Pentru cazul general al unui filtru de ordin N implementat în forma

directă 1, secţiunea nerecursivă trebuie calculată separat cu macroul de fir, iar

pentru secţiunea recursivă macroul va avea un ciclu în care se realizează

1N − operaţii de multiplicare şi acumulare.


( )x n ( )y n

1z−

1z−

1z−

1a−

2a−

Na−

( 1)y n −

( )y n N−

Figura 5.7. Filtru IIR de ordin N numai cu poli

Acest filtru poate fi implementat eficient prin utilizarea adresării

modulo şi a două adresări în paralel cu doi pointeri r0 şi r4. Harta memoriei

este prezentată mai jos:

Memoria X

r0

Memoria Y

Na−

2a−

1a−

( 1)y n −

( )y n

( 1)y n N− +

r4

m0 = N – 1

m4 = N – 1

Figura 5.8. Organizarea memoriei pentru un filtru de ordin N numai cu poli


Macroul primeşte ca argument numărul coeficienţilor. Pentru adresarea

modulo, registrele m0 şi m4 trebuie iniţializate cu 1N − . Registrul r0 nu

trebuie modificat în afara macroului deoarece păstrează adresa stării ( 1)y n − .

iir3 macro ncoef

iir3 ident 1,0

;

; IIR3 - Implementare filtru IIR numai cu poli

;

move x:(r0)+,x0 y:(r4)+,y0 ;y(n-1) si -a1

rep #ncoef-1 ;repetă de N–1 ori

mac x0,y0,a x:(r0)+,x0 y:(r4)+,y0

macr x0,y0,a (r0)- ;r0 este adus la adresa

nop ;celei mai vechi ieşiri

move a,x:(r0) ;unde se scrie ieşirea

y(n)

endm

5.2.2 Forma directă 2

Relaţia intrare-ieşire se scrie:

1

( )( )

1N

kk

k

X zW z

a z−

=

=+∑

(5.20)

0

( ) ( )M

kk

k

Y z W z b z−

=

= ∑ (5.21)

De unde rezultă ecuaţiile cu diferenţe finite:

0

( ) ( ) ( )N

kk

w n x n a w n k=

= − −∑ (5.22)

0

( ) ( )M

kk

y n b w n k=

= −∑ (5.23)


Aceste relaţii conduc la structura din figura următoare (cunoscută şi cu

denumirea de forma canonică):

( )x n 0b ( )y n

1b

2b

Mb

( )w n

1z−

1z−

1z−

1a−

2a−

Na−

Figura 5.9. Filtru IIR forma directă 2

Se observă pentru această structură o reducere a numărului celulelor de

întârziere faţă de forma directă 1, deci o reducere a memoriei necesare.

Să considerăm pentru început un filtru de ordin 2 cu 0 1b = . Funcţia de

transfer poate fi scrisă:

1 2

1 21 2

1 2

1( )

1

b z b zH z

a z a z

− −

− −

+ +=

+ + (5.24)

Filtrul implementat în forma directă 2 are structura de mai jos şi se mai

numeşte şi filtru biquad:

( )x n ( )y n

1b

2b

( )w n

1z−

1z−

1a−

2a−

Figura 5.10. Filtru IIR biquad


Pentru filtrul de mai sus, harta memoriei pentru stările filtrului şi

coeficienţi este prezentată în figura următoare:

Memoria X

r0

Memoria Y

2b

1b

2a−

1a−

( 2)w n −

( 1)w n − r4

m4 = 3m0 = –1

Figura 5.11. Organizarea memoriei pentru filtrul biquad

Registrul de adresă r0 este iniţializat să indice prima stare a filtrului, iar

r4 coeficienţii filtrului. Registrul modulo m0 este setat cu –1 pentru adresare

liniară, iar m4 cu 3 pentru adresare modulo 4.

iir4 macro

iir4 ident 1,0

;

; IIR4 - Implementare filtru biquad

;

move x:(r0)+,x0 y:(r4)+,y0

;x0=w(n-1), y0=-a1

mac x0,y0,a x:(r0),x1 y:(r4)+,y0

;a=x(n)-a1*w(n-1), x1=w(n-2), y0=-a2

macr x1,y0,a x0,x:(r0)- y:(r4)+,y0

;a=a-a2*w(n-2), w(n-1) e scris

;în locul lui w(n-2), y0=b1

nop

mac x0,y0,a a,x:(r0) y:(r4)+,y0

;a=w(n)+b1*w(n-1), w(n) e scris

;în locul lui w(n-1), y0=b2

macr x1,y0,a ;y(n)=a+b2*w(n-2)

endm


Trebuie menţionat că în cazul unei funcţii de transfer cu 0 1b ≠ se poate

face o normare a coeficienţilor numărătorului cu 0b , normare care poate fi

compensată la ieşire prin înmulţirea cu o constantă corespunzătoare.

Ca şi în cazul formei directe 1, pentru coeficienţi mai mici ca 2 în

modul poate fi implementat un program cu scalare automată cu 2 pornind de

la ecuaţia cu diferenţe finite:

1 2 1 2( )( ) 2 ( 1) ( 2) ( 1) ( 2)

2 2 2 2 2

x n b b a ay n x n x n y n y n⎡ ⎤= + − + − − − − −⎢ ⎥⎣ ⎦

(5.25)

şi având structura:

( )x n ( )y n

1 / 2b

2 / 2b

( )w n

1z−

1z−

1 / 2a−

2 / 2a−

1/ 2 2

Figura 5.12. Filtru biquad cu coeficienţii scalaţi

Harta memoriei pentru stările filtrului şi coeficienţi este prezentată în

figura următoare:

Memoria X

r0

Memoria Y

2 / 2b

1 / 2b

2 / 2a−

1 / 2a−

2 ( 2)w n⋅ −

2 ( 1)w n⋅ − r4

m4 = 3m0 = –1

Figura 5.13. Organizarea memoriei pentru filtrul biquad cu coeficienţii scalaţi


Coeficienţii sunt stocaţi împărţiţi la 2. Când stările filtrului ( )w n k−

sunt salvate din acumulator în memorie, ele sunt înmulţite cu 2 (prin scalare

în sus). Astfel, la înmulţirea stărilor cu coeficienţii scalarea se compensează.

iir5 macro

iir5 ident 1,0

;

; IIR5 - Implementare filtru biquad cu scalare

;

ori #$08,mr ;setare mod scalare

move x:(r0)+,x0 y:(r4)+,y0

mac x0,y0,a x:(r0),x1 y:(r4)+,y0

macr x1,y0,a x0,x:(r0)- y:(r4)+,y0

nop

mac x0,y0,a a,x:(r0) y:(r4)+,y0

macr x1,y0,a

andi #$f7,mr

endm

5.2.3 Realizarea în cascadă

Se realizează factorizarea funcţiei de transfer în funcţii de ordin 2 cu

coeficienţi reali implementate cu structuri biquad:

1 2

,1 ,21 2

1 1,1 ,2

1( ) ( )

1

p pk k

kk kk k

b z b zH z H z

a z a z

− −

− −= =

+ += =

+ +∏ ∏ (5.26)

Coeficienţii secţiunilor de ordin 2 au garantat modulul mai mic decât 2

dacă filtrul este stabil şi de fază minimă. Aceasta permite implementarea

eficientă pe DSP56300 folosind scalarea automată cu un bit.

Forma cascadă pentru două structuri biquad este prezentată mai jos:


( )x n ( )y n

1,1b

1,2b

1( )w n

1z−

1z−

1,1a−

1,2a−

2,1b

2,2b

2 ( )w n

1z−

1z−

2,1a−

2,2a−

Figura 5.14. Forma cascadă cu structuri biquad

În macroul de filtru, eşantionul de intrare este stocat în acumulatorul a

iar ieşirea se află tot în a. Aceasta permite calculul următoarei secţiuni

pornind tot de la valoarea din a, programul de filtru biquad fiind repetat într-

un ciclu DO pentru numărul total de secţiuni.

Harta memoriei pentru forma cascadă cu două secţiuni biquad este

prezentată mai jos. Trebuie observat cum sunt stocate stările filtrului. Primul

element este ( 2)w n − şi al doilea este ( 1)w n − . De asemenea coeficienţii sunt

stocaţi similar; primul element este 2a− apoi 1a− urmaţi de 2b şi 1b . În acest

mod registrul adresă r0 poate fi incrementat să treacă direct la următoarea

secţiune.

Memoria X

r0

Memoria Y

2,1 / 2b

2,2 / 2b

2,1 / 2a−

2,2 / 2a−

1,1 / 2b

1,2 / 2b

1,1 / 2a−

1,2 / 2a−

22 ( 1)w n⋅ −

22 ( 2)w n⋅ −

12 ( 1)w n⋅ −

12 ( 2)w n⋅ − r4

m4 = –1m0 = –1a 2-a secţiune

prima secţiune

prima secţiune

a 2-a secţiune

Figura 5.15. Organizarea memoriei pentru forma cascadă


Macroul pentru implementarea formei cascadă cu secţiuni biquad este

prezentat în continuare. Macroul primeşte ca argument numărul de secţiuni.

iir6 macro nsec

iir6 ident 1,0

;

; Implementare forma cascadă cu secţiuni biquad

;

ori #$08,mr ;mod scalare

move x:(r0)+,x0 y:(r4)+,y0 ;r0->w(n-2) r0+

do #nsec,_ends ;repetă fiecare secţiune

mac x0,y0,a x:(r0)-,x1 y:(r4)+,y0 ;r0->w(n-1) r0+

macr x1,y0,a x1,x:(r0)+ y:(r4)+,y0 ;r0->w(n-2) r0+

nop

mac x0,y0,a a,x:(r0)+ y:(r4)+,y0 ;r0->w(n-1) r0+

mac x1,y0,a x:(r0)+,x0 y:(r4)+,y0 ;r0->w(n-2) din

;următoarea secţiune

_ends

rnd a ;rotunjire rezultat

andi #$f7,mr ;dezactivare mod scalare

endm

5.2.4 Realizarea în forma latice

Forma latice unui filtru IIR de ordinul 3:

eb

ef

z-1z-1z-1

k1k2

-k1-k2-k3

k3

y(n)

Figura 5.16. Forma latice pentru filtru IIR numai cu poli


Pentru filtrul de mai jos (ordin 3), pointerii r0 si r4 sunt iniţializaţi

astfel:

1s

2s

3s

Memoria X

r0

Memoria Y

3k

2k

1k r4m0 = 2

m4 = 2

Figura 5.17. Organizarea memoriei pentru forma latice

Registrele modulo sunt fixate la numărul coeficienţilor minus 1 (în

acest exemplu sunt 3 coeficienţi). Eşantioanele de intrare se pun în registrul

a şi apoi este apelat macro-ul filtrului. Rezultatul filtrării se depune în a.

Se presupune că registrele r0, r4, m0 şi m4 au fost iniţializate

corespunzător. Eşantioanele de intrare sunt în registrul a, iar filtrul se

apelează în programul principal cu:

latiir order ;apel latice iir

unde 'latiir' este numele macro-ului şi 'order' este numărul de coeficienţi

de reflexie.

latiir macro order

latiir ident 1,0

;

; Latice IIR

;

move x:(r0)-,x0 y:(r4)+,y0 ;primul k, prima stare

macr -x0,y0,a x:(r0)-,x0 y:(r4)-,y0

;prima secţiune

do #order-1,_endlat ;restul secţiunilor

macr -x0,y0,a ;a=a-k*s


nop

tfr y0,b a,x1 b,y:(r4)+n4

;transferă a pentru înmulţire

;transferă starea în b

;salvează starea anterioară

macr x1,x0,b x:(r0)-,x0 y:(r4)-,y0

;următoarea stare, următorul k

_endlat

nop

move b,y:(r4)+ ; salvează a doua ultima stare

move x:(r0)+,x0 a,y:(r4)+ ;actualizare r0

;salvează ultima stare

endm

Explicarea programului:

1. Eşantionul de intrare este în registrul a şi pointerii r0 şi r4 sunt

iniţializaţi corect. Ieşirea din stânga-jos a secţiunii nu este necesară la

această implementare şi nici nu se va calcula.

2. Primul move încarcă primul k (k3) în registrul de produs x0 şi

decrementează pointerul r0 pentru următorul coeficient. Simultan, se

încarcă starea filtrului şi pointerul r4 este incrementat pentru a indica

spre următoarea stare.

3. Prima secţiune a filtrului este generată de instrucţiunea mac.

Coeficientul k aflat în x0 este înmulţit cu starea y0 şi rezultatul se scade

din registrul a care conţine valoarea intrării. Următorul coeficient k (k2)

este apoi încărcat în x0 şi pointerul r0 e din nou decrementat.

Următoarea stare se încarcă în y0 şi pointerul r4 se decrementează

pentru a indica spre starea anterioară. Acum, r4 indică înapoi spre

starea folosită în instrucţiunea precedentă. Deoarece această valoare nu

mai e necesară, în această locaţie se va memora noua stare calculată.


4. Bucla do va calcula celelalte secţiuni ale filtrului. Prima secţiune a fost

calculată în afara buclei, deci au rămas numai 1N − secţiuni.

5. Primul macr va calcula valoarea ieşirii de sus scăzând din valoarea

care se află în a produsul dintre k (x0) şi starea (y0).

6. Valoarea din a este apoi mutată în registrul x1 astfel încât să poată fi

multiplicată ulterior. Registrul b este încărcat cu variabila stării curente

care a fost stocată în y0. Starea iniţial calculată b se salvează în

variabila stării precedente, iar pointerul către variabilele de stare (r4) se

incrementează cu 2 pentru a indica spre noua variabilă de stare.

7. Noua stare se calculează prin adunarea produsului dintre prima valoare

din a şi coeficientul k (x0) la valoarea stării curente (b). Se încarcă un

nou coeficient k, iar r0 e decrementat pentru a indica spre următorul

coeficient k. Se aduce noua stare, iar r4 se decrementează pentru a

indica spre starea precedentă. În acest punct se observă că în următorul

pas al ciclului do starea care tocmai a fost calculata (b) este salvată în

memorie.

8. La sfârşitul buclei, valoarea ieşirii se rotunjeşte, a doua stare se

salvează şi este incrementat r4.

9. Pointerul către coeficienţii k se incrementează. Deoarece r0 este

decrementat de două ori înaintea buclei, iar bucla îl decrementează de

1N − ori rezultă că numărul de decrementări este 1N + . Aceasta

înseamnă că se depăşeşte memoria ocupată de coeficienţi şi pointerul

trebuie decrementat pentru a-l indica pe k3. Valoarea de ieşire din a este

de asemenea salvată ca ultima stare şi pointerul r4 este incrementat la

următoarea locaţie. Este interesant de observat că în acest punct că

valoarea din acumulatorul a a fost salvată peste valoarea necunoscută

din bufferul de stări scrisă în primul etaj. Registrul r4 indică apoi către

următoarea stare care este folosită pentru următorul eşantion de intrare.


CAPITOLUL 6

TRANSFORMATA FOURIER RAPIDĂ ŞI APLICAŢII

6.1 APLICAŢII ALE TRANSFORMATEI FOURIER

Din cauza naturii de bază a conceptului de frecvenţă, aplicaţiile practice

ale transformatei Fourier abundă. Pe măsură ce metode eficiente din punct de

vedere al costului vor fi disponibile să calculeze transformata Fourier,

numărul aplicaţiilor practice bazate pe frecvenţă vor fi mai numeroase. În

aceste aplicaţii bazate pe frecvenţă un procesor de semnal digital poate

calcula în mod eficient transformata Fourier şi poate efectua prelucrări

specifice domeniului frecvenţei, precum eliminarea unor anumite componente

ale frecvenţei.

Există trei tipuri generale ale aplicaţiilor transformatei Fourier:

1. Aplicaţii bazate pe calcule numerice – majoritatea aplicaţiilor care

analizează spectrul necesită evaluarea directă a transformatei Fourier.

Deoarece transformata Fourier e o expresie matematică aceste aplicaţii

sunt bazate pe calcule numerice. Exemplele se întind de la analiza

spectrului instrumentelor de laborator şi al echipamentului audio

profesional până la estimarea vitezei la radar. De observat ca în aplicaţiile

bazate pe numere, acurateţea calculelor e de importanţa vitală pentru

Capitolul 6 – Transformata Fourier rapidă şi aplicaţii 171

performanţele întregului sistem. De exemplu, aplicaţiile audio de calitate

necesită o precizie de cel puţin 16 biţi pentru a elimina distorsiunile audio.

2. Aplicaţii de recunoaştere – multe probleme implică recunoaşterea şi

detectarea semnalului cu un conţinut de frecvenţă specific (un model

spectral predefinit). De exemplu, vorbitul constă în secvenţe de sunete cu

caracteristici specifice ale frecvenţei. În acest tip de aplicaţie conversia în

domeniul frecvenţă e adesea doar un pas în tot sistemul. E important ca

procesul de conversie să fie rapid pentru a avea timp suficient pentru a

aplica restul tehnicilor de analiză şi recunoaştere. În plus faţă de viteza

calculelor transformatei Fourier procesorul în discuţie trebuie să fie rapid

la operaţii de prelucrare generale pentru a realiza o varietate de calcule în

domeniul frecvenţă.

3. Aplicaţii bazate pe convoluţie – a treia clasă de aplicaţii a transformatei

Fourier foloseşte transformarea ca pe un instrument matematic simplu

pentru a realiza filtrarea generală într-o manieră foarte eficientă. Acest

concept e bazat pe proprietatea că transformata Fourier a convoluţiei a

două semnale în timp e egală cu produsul transformatelor celor două

semnale. Volumul calculelor implicate în produsul de convoluţie devine

mare dacă lungimea filtrului este foarte mare. Astfel, dacă transformata

Fourier a semnalului de la intrarea filtrului se poate calcula eficient,

filtrarea se realizează prin înmulţirea acesteia cu funcţia de transfer în

frecvenţă a filtrului (care poate fi precalculată). Numărul de calcule pentru

transformata Fourier directă şi inversă şi pentru filtrare în domeniul

frecvenţei poate fi mai mic decât pentru convoluţie mai ales pentru filtre

cu funcţii de transfer simple (trece jos, trece bandă, etc.) unde înmulţirea în

domeniul frecvenţă poate fi înlocuită cu o simplă operaţie de mascare care

elimină benzile de oprire (spectrul ieşirii este 0) şi lasă spectrul semnalului

de intrare în benzile de trecere nemodificat.


6.2 ALGORITMI RAPIZI PENTRU CALCULUL

TRANSFORMATEI FOURIER DISCRETE

Fie secvenţa complexă ( )x n de suport finit, 0,1,..., 1n N= − . Se

defineşte transformata Fourier discretă (TFD) a acestei secvenţe prin:

1

0

( ) TFD{ ( )}( ) ( )N

nkN

n

X k x n k x n W−

=

= =∑ , 0,1,..., 1k N= − (6.1)

unde 2

jN

NW eπ

−= se numesc coeficienţi de rotaţie.

Cunoscând ( )X k se poate determina secvenţa ( )x n cu ajutorul

transformatei Fourier discretă inversă (TFDI) definită de relaţia:

1

0

1( ) TFDI{ ( )}( ) ( )

Nnk

Nk

x n X k n X k WN

−−

=

= = ∑ , 0,1,..., 1n N= − (6.2)

Pentru efectuarea transformatei Fourier discrete, conform formulei

(6.2), sunt necesare 2N înmulţiri complexe şi ( 1)N N − adunări complexe. O

înmulţire complexă necesită patru înmulţiri şi două adunări reale. Rezultă un

număr de 24N înmulţiri reale şi 24 2N N− adunări reale. Complexitatea

aritmetică este de forma 2( )O N deci creşte cu 2N . Astfel, pentru 1024N =

sunt necesare 4.194.304 înmulţiri reale care, pe un procesor de semnal cu un

ALU, necesită un număr aproape dublu de cicluri maşină.

Există algoritmi care permit efectuarea TFD cu un număr mai mic de

operaţii. Să observăm întâi câteva proprietăţi ale coeficienţilor de rotaţie NW :

1kNNW = , 2 1

Nj

NW e π−= = − (6.3)

de aici rezultând o formulă mai generală:

2 ( 1)N

N NW Wα β β α+

= − (6.4)


De asemenea printr-o simplă schimbare de notaţie obţinem:

2 2

/j nk j n

nk nN N kN N

k

W e e Wπ π

− −= = = (6.5)

Dacă alegem 1 2N N N= ⋅ , se poate descompune transformarea de ordin

N în transformări de ordin 1N şi 2N care la rândul lor se calculează pornind

de la o descompunere similară.

Un caz important este acela în care MN R= , R numindu-se bază. De

exemplu, dacă 2R = avem algoritmi în baza 2, cu N putere întreagă a lui 2,

etc.

Pornind de la o reprezentare a indicilor sub forma:

1 1 2 2

3 1 4 2

n K n K n

k K k K k

≡ +≡ +

(6.6)

în cazul algoritmilor în baza R sunt posibile următoarele moduri de

reprezentare a indicilor:

1 2 1 2

1 2 1 2

, 0,1,..., 1, 0,1,..., 1

, 0,1,..., 1, 0,1,..., 1

Nn Rn n n n R

RN N

k k k k k RR R

≡ + = − = −

≡ + = − = −(6.7)

ceea ce conduce la algoritmi cu decimare în timp şi

1 2 1 2

1 2 1 2

, 0,1,..., 1, 0,1,..., 1

, 0,1,..., 1, 0,1,..., 1

N Nn n n n n R

R RN

k R k k k k RR

≡ + = − = −

≡ + = − = −(6.8)

ceea ce conduce la algoritmi cu decimare în frecvenţă.


6.2.1 Algoritmi FFT cu decimare în timp în baza 2

Aceşti algoritmi au fost introduşi de Cooley şi Tukey pentru 2MN = ,

M ∈N .

În acest caz indicii se vor scrie:

1 2 1 2

1 2 1 2

2 , 0,1,..., 1, 0,12

, 0,1,..., 1, 0,12 2

Nn n n n n

N Nk k k k k

≡ + = − =

≡ + = − =(6.9)

şi rezultă:

1 2 1 2

1 2

112 (2 ) ( )

21 2 1 2

0 0

( ) ( ) (2 )2

NN

n n k k

Nn n

NX k X k k x n n W

−+ +

= =

= + = +∑∑ (6.10)

sau:

1 21 1 1 1

1 1

1 12 2

21 2 1 1

0 02 2

( ) (2 ) (2 1)2

N NN

k kn k n kN N N

n n

NX k k x n W W x n W

− −+

= =

+ = + +∑ ∑ (6.11)

Dar:

( )1 1 2 12 1N

k k k kN NW W

+= − (6.12)

aşa încât, scriind separat pentru 2 0k = şi 2 1k = :

{ } { }

1 1 1 1 1

1 1

1

1 12 2

1 1 10 02 2

1 1

2 2

( ) (2 ) (2 1)

TFD (2 ) TFD (2 1)

N N

n k k n kN N N

n n

kN N N

X k x n W W x n W

x n W x n

− −

= =

= + + =

= + +

∑ ∑(6.13)

{ } { }

1 1 1 1 1

1 1

1

1 12 2

1 1 10 02 2

1 1

2 2

( ) (2 ) (2 1)2

TFD (2 ) TFD (2 1)

N N

n k k n kN N N

n n

kN N N

NX k x n W W x n W

x n W x n

− −

= =

+ = − + =

= − +

∑ ∑(6.14)


Fiecare din sumele ce apar în cele două relaţii de mai sus, reprezintă

câte o TFD în / 2N puncte, primele pentru secvenţa formată cu eşantioanele

pare, a doua, cu eşantioanele impare. Rezultă schema din figura 0.1:

0

TFDN/2 k1

N/2-1

X(k1)x(2n1)

X(k1+N/2)-1x(2n1+1)

0

TFDN/2 k1

N/2-1

1kNW

Figura 0.1. Descompunerea TFD de ordin N în transformate de ordin / 2N

Trecerea de la transformatele de ordin / 2N la transformata de ordin N

se face prin intermediul unor structuri de tip fluture (figura 0.2). Această

structură este constituită dintr-o înmulţire cu factorul kNW , şi o transformată

Fourier discretă de ordinul doi.

A

-1kNW

B

A'

B'

Figura 0.2. Fluturele pentru FFT în baza 2 DIT

Procedeul descris mai înainte se va aplica recursiv pentru

transformatele de ordin / 2N până se ajunge la transformate de ordinul 2.

Rezultă că pentru o transformată de ordin 2MN = sunt necesare M

etaje, fiecare conţinând / 2N fluturi, deci în total sunt necesari 22logN N

fluturi.


Graful complet al unei transformate în baza 2 cu decimare în timp în

opt puncte este ilustrat în figura 0.3.

X(0)

X(1)

X(2)

X(3)

X(4)

X(5)

X(6)

X(7)

-1

-1

-1

-1

-1

-1

-1

-1

-1

-1

-1

-1

x(0)

x(4)

x(2)

x(6)

x(1)

x(5)

x(3)

x(7)

W0

W1

W2

W3

W0

W2

W0

W2

W0

W0

W0

W0

Figura 0.3. Graful unei FFT în baza 2 cu decimare în timp în opt puncte

Din graful transformatei se observă că ieşirile sunt ordonate secvenţial

iar intrările nu. Aceasta se datorează divizării repetate a intrării în sub-

secvenţe de eşantioane de ordin par şi impar. Dacă indicii eşantioanelor de

intrare sunt reprezentaţi în formă binară se observă că aceştia sunt în ordinea

inversă a biţilor (bit-reversed).

Putem reordona intrările din graful anterior, x(4) şi x(6) în locul lui x(1)

şi lui x(3), rezultând un graf pentru transformata în 8 puncte cu intrările în

ordinea firească ca în figura 0.4:

Se observă însă că după această rearanjare, coeficienţii de rotaţie

precum şi ieşirile grafului vor fi în ordine bit-reversed.


X(0)

X(4)

X(2)

X(6)

X(1)

X(5)

X(3)

X(7)

-1

-1

-1

-1

-1

-1

-1

-1

-1

-1

-1

-1

x(0)

x(1)

x(2)

x(3)

x(4)

x(5)

x(6)

x(7)

W0

W0

W0

W0

W0

W0

W2

W2

W0

W2

W1

W3

Figura 0.4. Rearanjarea grafului pentru calculul FFT cu decimare în timp

6.2.2 Algoritmi FFT cu decimare în frecvenţă în baza 2

În acest caz se reprezintă indicii sub forma:

1 2 1 2

1 2 1 2

, 0,1,..., 1, 0,12 2

2 , 0,1,..., 1, 0,12

N Nn n n n n

Nk k k k k

≡ + = − =

≡ + = − =(6.15)

deci:

1 2 1 2

1 2

112 ( ) (2 )

21 2 1 2

0 0

(2 ) ( )2

NN

n n k k

Nn n

NX k k x n n W

−+ +

= =

+ = +∑∑ (6.16)

din care rezultă pentru 1 0k = şi 2 1k = :

1 1

1

12

1 1 10 2

1 1

2

(2 ) [ ]2

TFD [ ] [ ]2

N

n kN

n

N

NX k x n x n W

Nx n x n

−

=

= + + =

= + +

∑(6.17)


1 1 1

1

1

12

1 1 10 2

1 1

2

[2 1] [ ]2

TFD [ ] [ ]2

N

n n kN N

n

nN N

NX k x n x n W W

Nx n x n W

−

=

+ = − + =

= − +

∑(6.18)

Se constată iarăşi descompunerea transformatei de ordin N în două

transformate de ordin / 2N (figura 0.5).

0

TFDn1 N/2

N/2-1

X(2k1)x(n1)

X(2k1+1)-1

x(n1+N/2)

0

TFDn1 N/2

N/2-11k

NW

1

Figura 0.5. Descompunerea TFD de ordin N în transformate de ordin

/ 2N

În continuare fiecare din cele două grupuri de câte / 2N semnale ce

constituie intrările transformatelor în / 2N puncte se desparte în două, după

acelaşi procedeu (primele / 4N şi următoarele / 4N ).

De exemplu pentru 8N = , se obţine graful din figura 0.6.


X(0)

X(4)

X(2)

X(6)

X(1)

X(5)

X(3)

X(7)

-1

-1

-1

-1

-1

-1

-1

-1

-1

-1

-1

-1

x(0)

x(1)

x(2)

x(3)

x(4)

x(5)

x(6)

x(7)

W0

W1

W2

W3

W0

W2

W0

W2

W0

W0

W0

W0

Figura 0.6. Graful unei FFT în baza 2 cu decimare în frecvenţă în opt puncte

Ca şi în cazul precedent, rezultă 2log N etaje, în fiecare efectuându-se

/ 2N operaţii de tip “fluture”. Structura fluturelui este însă cea din figura 0.7.

A

-1B

'A

'BnNW

Figura 0.7. Fluturele pentru FFT în baza 2 DIF

Evident complexitatea, exprimată prin numerele de înmulţiri reale şi de

adunări reale este aceeaşi ca în algoritmul precedent.

În acest caz eşantioanele semnalului se iau în ordinea naturală, iar ale

ieşirii, rezultă în ordinea inversată a biţilor.


6.3 IMPLEMENTAREA FFT PE PROCESOARELE DIN

FAMILIA MOTOROLA DSP56300

6.3.1 Resursele hardware necesare calculului FFT

Principalul element de calcul al rutinei FFT este fluturele din figura 0.2

pentru decimare în timp (DIT) şi din figura 0.7 pentru decimare în frecvenţă

(DIF). Acesta include înmulţiri şi adunări/scăderi complexe (atât intrările

fluturelui cât şi factorii de rotaţie sunt numere complexe). De aceea este

necesară o arhitectură capabilă să suporte reprezentarea şi operaţiile

aritmetice cu numere complexe.

Pentru înmulţire şi adunare arhitectura DSP56300 oferă instrucţiunea

MAC (multiplicare şi acumulare) precum şi două registre acumulator. De

asemenea, intrările şi ieşirile fluturelui sunt mutate între unitatea aritmetică a

procesorului şi memorie ceea ce necesită operaţii de transfer eficiente.

Pentru reprezentarea numerelor complexe, DSP56300 are două zone de

memorie pentru date: X şi Y. Astfel, partea reală şi partea imaginară a

numerelor complexe pot fi stocate în memoria X, respectiv Y. De asemenea,

pot fi efectuate simultan două citiri şi scrieri în memorie într-un singur ciclu

maşină.

Algoritmul de calcul FFT implică repetarea structurii de tip fluture de

un număr de ori depinzând de numărul de puncte N. Pentru un program de

calcul al FFT, este importantă o implementare eficientă a repetării fluturilor.

O soluţie hardware este dată de instrucţiunea DO loop, fără a fi

necesare alte operaţii de iniţializare (zero overhead). Fiecare iteraţie este

astfel realizată fără întârzieri suplimentare în execuţie.


Aşa cum s-a observat în prezentarea algoritmului FFT, intrările, ieşirile

sau factorii de rotaţie pot surveni în ordinea inversată a reprezentării binare a

indecşilor. Aceasta implică o reordonare a operanzilor conform algoritmului

bit-reversed. Procesoarele de semnal din familia DSP56300 au facilitatea de a

adresa în ordinea inversată a biţilor adresei.

Alt aspect privitor la resursele hardware îl reprezintă numărul de

registre interne disponibile pentru stocarea rezultatelor intermediare, avându-

se în vedere că stocarea acestora în memorie necesită mai mult timp de

procesare.

Datele de la intrarea FFT sunt în general eşantioane primite de la un

convertor A/D. Achiziţia datelor trebuie efectuată în paralel cu calculul FFT

pentru o aplicaţie de timp-real. De aceea DSP trebuie să ofere o interfaţă

simplă cu diversele convertoare A/D precum şi tehnici de întreruperi sau

DMA pentru stocarea datelor achiziţionate fără a interfera cu calculul FFT.

În concluzie, obţinerea unei implementări eficiente a FFT pe DSP

depinde de următorii factori hardware:

1. Instrucţiune de multiplicare/acumulare;

2. Transferul datelor dual în memorie într-un singur ciclu maşină;

3. Instrucţiune de ciclare fără overhead;

4. Mod de adresare bit-reversed;

5. Număr suficient de registre;

6. Interfaţă rapidă I/O pentru achiziţia datelor în timp real.


6.3.2 Caracteristicile fluturilor pentru FFT în baza 2 DIT şi DIF

Să considerăm reprezentarea datelor de la intrarea şi ieşirea fluturilor

precum şi a factorilor de rotaţie sub forma complexă: parte reală şi parte

imaginară.

2 2 2cos sin

r i

j kk N

N

W W

W e k j kN N

π π π− = = + − (6.19)

Ecuaţiile de calcul ale ieşirilor complexe ale fluturilor pentru DIT şi

DIF sunt date în tabelul următor:

A

-1kNW

B

kNWBAA ⋅+='

kNWBAB ⋅−='

Fluturele pentru FFT în baza 2 DIT

A

-1B

BAA +='

nNWBAB ⋅−= )('n

NW

Fluturele pentru FFT în baza 2 DIF

( )( )( )( )

'

'

'

'

r r r r i i

i i i r r i

r r r r i i

i i i r r i

A A B W BW

A A BW B W

B A B W BW

B A BW B W

= + +

= + −

= − +

= − −

Ecuaţiile ieşirilor fluturelui DIT

( ) ( )( ) ( )

'

'

'

'

r r r

i i i

r r r r i i i

i r r i i i r

A A B

A A B

B A B W A B W

B A B W A B W

= +

= +

= − − −

= − + −

Ecuaţiile ieşirilor fluturelui DIF

Teoretic, aşa cum rezultă din ecuaţiile de calcul ale ieşirilor, fluturii

pentru DIT şi DIF în baza 2 au aceeaşi complexitate aritmetică: trei adunări,

trei scăderi şi patru înmulţiri. Pe procesoarele de semnal care nu efectuează în

paralel înmulţirea şi adunarea sunt necesare zece instrucţiuni pentru un

fluture.


Pentru familia DSP56300 instrucţiunea MAC efectuează o înmulţire şi

o adunare în paralel. Pentru fluturele DIT patru dintre adunări pot fi efectuate

în paralel cu înmulţirile rămânând de efectuat două adunări. Pentru fluturele

DIF însă, numai două dintre adunări pot fi efectuate în paralel cu înmulţirea,

rămânând de efectuat patru adunări. Din acest punct de vedere arhitectura

DSP Motorola implementează mai eficient fluturele pentru DIT.

A

-1kNW

B

kNWBAA ⋅+='

kNWBAB ⋅−='

Fluturele pentru FFT în baza 2 DIT

A

-1B

BAA +='

nNWBAB ⋅−= )('n

NW

Fluturele pentru FFT în baza 2 DIF

1

'1

' '

2

'2

' '

2

2

r r r

r i i

r r r

i r i

i i r

i i i

T A B W

A T BW

B A A

T A B W

A T BW

B A A

= +

= +

= −= −

= +

= −

MAC

MAC

SUBL

MAC

MAC

SUBL

'

1

'

2

3 1

'3 2

4 2

'4 1

r r r

r r

i i i

i i

r

r i

r

i i

A A B

T A B

A A B

T A B

T TW

B T T W

T T W

B T TW

= += −

= += −=

= −=

= +

ADD

SUB

ADD

SUB

MPY

MAC

MPY

MAC


6.3.3 Programul pentru calculul fluturelui DIT pe DSP56300

Ecuaţiile pentru programul de calcul al fluturelui pentru DIT sunt:

( )( )

'

'

' '

' '

2

2

r r r r i i

i i i r r i

r r r

i i i

A A B W BW

A A BW B W

B A A

B A A

= + +

= + −

= −

= −

(6.20)

unde indicii r şi i reprezintă partea reală, respectiv imaginară.

Primele două ecuaţii reprezintă o sumă de produse şi sunt obţinute cu

instrucţiunea MAC. Ultimele două ecuaţii se bazează pe instrucţiunea SUBL

care realizează deplasarea la stânga (înmulţire cu 2) şi scăderea

acumulatorilor.

Valorile iniţiale ale registrelor sunt date în tabelul de mai jos:

r0 Ar , Ai r4 Ar' , Ai' b = Ai

r1 Br , Bi r5 Br' , Bi' x1 = Br y1 = Bi

r6 Wr , Wi m6 = 0 (bitreversed)

x0 = Wr y0 = Wi

Datele sunt stocate în memoria de date X pentru partea reală şi Y

pentru partea imaginară. Registrele de adresă permit adresarea duală în

memoria de date X şi Y.

Programul în limbaj de asamblare pentru calculul fluturelui este

prezentat în continuare. Timpul de execuţie este de şase cicluri instrucţiune

sau douăsprezece cicluri de ceas. Aceasta este posibil datorită arhitecturii

paralele a DSP56300 care permite până la două operaţii ALU

(înmulţire/acumulare) în paralel cu două transferuri cu memoria şi două

modificări ale registrelor de adresă într-un singur ciclu instrucţiune.


mac x1,y0,b y:(r1)+,y1 ; b=Ai+BrWi, y1=Bimacr -x0,y1,b a,x:(r5)+ y:(r0),a ; b=b-BiWr , a=Aisubl b,a x:(r0),b b,y:(r4) ; a=2Ai–b , b=Armac -x1,x0,b x:(r0)+,a a,y:(r5) ; b=Ar+BrWr, a=Armacr -y1,y0,b x:(r1),x1 ; b=b–BiWi , x1=Brsubl b,a b,x:(r4)+ y:(r0),b ; a=2Ar–b , b=Ai

6.3.4 Caracteristicile unei transformate DIT

Pornim de la graful pentru DIT cu intrările rearanjate în ordine naturală.

Fiecare pereche de săgeţi reprezintă un fluture. Întregul calcul al FFT este

efectuat cu fluturi organizaţi în diferite structuri numite grupuri şi etaje.

Primul etaj are un singur grup de patru fluturi, al doilea etaj are două grupuri

cu doi fluturi, iar ultimul etaj are patru grupuri cu un singur fluture. Fiecare

etaj conţine / 2N (patru în acest exemplu) fluturi. Fiecare fluture are două

intrări, numite nod primar şi nod dual. Spaţiul între aceste noduri este numit

distanţa între nodurile duale. Fiecărui fluture îi este asociat un factor de

rotaţie W, al cărui exponent depinde de grupul şi etajul în care este fluturele.

Din graful transformatei se observă că ieşirile sunt ordonate în ordinea inversă

a biţilor indexului ieşirii. Reordonarea secvenţei de ieşire se face cu un

procedeu numit inversarea ordinii biţilor care va fi descris ulterior.


Etaj 1 Etaj 2 Etaj 3

X(0)

X(4)

X(2)

X(6)

X(1)

X(5)

X(3)

X(7)

-1

-1

-1

-1

-1

-1

-1

-1

-1

-1

-1

-1

x(0)

x(1)

x(2)

x(3)

x(4)

x(5)

x(6)

x(7)

W0

W0

W0

W0

W0

W0

W2

W2

W0

W2

W1

W3

000

001

010

011

100

101

110

111

000

100

010

110

001

101

011

111

Indexbinar

Indexbinar

Distanţa întrenodurile duale



Figura 0.8. Gruparea fluturilor pentru calculul FFT DIT

Caracteristicile unei transformate în N puncte cu decimare în timp sunt

descrise în tabelul următor:

Etajul 1 Etajul 2 Etajul 3 Etajul log2N

Număr degrupuri

1 2 4 N / 2

Număr defluturi pe grup

N / 2 N / 4 N / 8 1

Distanţa întrenoduri duale

N / 2 N / 4 N / 8 1

Exponentulcoeficienţilor W

(N/2)k,

k=0

(N/4)k,

k=0, 1

(N/8)k,

k=0, 1, 2, 3

k,

k=0 .. N/2-1

Pentru fiecare etaj, datele sunt citite din memorie, este calculat

fluturele, iar rezultatele sunt scrise înapoi în memorie. Ieşirile complexe ale


fluturelui devin intrări în etajul următor al FFT. Deoarece fiecare etaj are

acelaşi număr de fluturi, numărul de intrări şi de ieşiri ale fluturilor rămâne

constant de la un etaj la altul. Ieşirile fluturelui sunt pe aceleaşi poziţie ca şi

intrările. Această implementare “in-place” scrie rezultatul de la ieşirea

fluturelui în locul intrării corespunzătoare. O astfel de implementare ocupă în

final numai memoria iniţială.

6.3.5 Programul pentru calculul FFT în baza 2 DIT pe DSP56300

Se observă că sunt 2log N etaje. Numărul de grupuri se dublează de la

un etaj la altul, în timp ce numărul de fluturi pe grup se înjumătăţeşte. Factorii

de rotaţie sunt aceiaşi pentru un grup de fluturi, iar ordinul acestora se

modifică de la un grup la altul în ordine “bit-reversed”. Aceasta este

implementată prin setarea registrului modificator M6 egal cu 0 şi a registrului

offset N6 egal cu / 4N (jumătate din lungimea vectorului coeficienţilor).

Datele sunt organizate în memorie după cum urmează:

Registrul adresă Memoria de date X Memoria de date Y

R0 Partea reală a nodului A Partea imaginară a lui A

R1 Partea reală a nodului B Partea imaginară a lui B

R6 Tabela cosinusului Tabela sinusului

Programul va avea trei cicluri DO incluse unul în altul. Ciclul exterior

controlează succesiunea etajelor, ciclul din mijloc controlează grupurile dintr-

un etaj iar ciclul intern calculează toţi fluturii dintr-un grup. Programul este

prezentat mai jos.


; Rutina de calcul FFT in baza 2 cu decimare in timp

;

fftr2a macro points,data,coef

fftr2a ident 1,0

;

;points număr de puncte de calcul FFT (putere a lui 2)

;data adresa de început a cadrului de date

;coef adresa de început a tabelelor de cosinus si sinus

;

move #points/2,n0 ;număr iniţial de fluturi pe grup

move #1,n2 ;număr iniţial de grupuri pe etaj

move #points/4,n6 ;offsetul în tabela Cos-Sin

move #-1,m0 ;adresare liniară pentru A şi B

move m0,m1

move m0,m4

move m0,m5

move #0,m6 ;adresare bit-reversed pentru Cos-Sin

;

; Calculul etajelor FFT cu trei cicluri DO

;

do #@cvi(@log(points)/@log(2)+0.5),_end_pass

move #data,r0 ;pointerul intrărilor A

move r0,r4 ;pointerul ieşirilor A’

move n0,n1 ;offset fluturi

move n0,n4

lua (r0)+n0,r1 ;pointerul intrarilor B

move #coef,r6 ;pointerul tabelei Cos-Sin

move n0,n5

lua (r1)-,r5 ;pointerul ieşirilor B

do n2,_end_grp

move x:(r1),x1 y:(r6),y0 ;valorile -sin şi -cos

move x:(r5),a y:(r0),b ;încarcă data de intrare


move x:(r6)+n6,x0 ;actualizare pointer Cos-Sin

do n0,_end_bfy ;Fluturele DIT

mac x1,y0,b y:(r1)+,y1

macr -x0,y1,b a,x:(r5)+ y:(r0),a

nop

subl b,a x:(r0),b b,y:(r4)

mac -x1,x0,b x:(r1),x1

macr -y1,y0,b x:(r0)+,a a,y:(r5)

subl b,a

move b,x:(r4)+ y:(r0),b

_end_bfy

move a,x:(r5)+n5 y:(r1)+n1,y1 ;actualizare

move x:(r0)+n0,x1 y:(r4)+n4,y1 ;intrări A şi B

_end_grp

move n0,b1

lsr b n2,a1 ;împarte cu 2 număr fluturi pe grup

nop

lsl a b1,n0 ;înmulţeşte cu 2 nr. de grupuri pe etaj

nop

move a1,n2

_end_pass

endm


6.4 SCALAREA DATELOR FFT PENTRU IMPLEMENTAREA

PE PROCESOR ÎN VIRGULĂ FIXĂ

În implementarea diverşilor algoritmi pe procesoarele de semnal

trebuie să se ţină seama de precizia finită a calculelor datorată numărului de

biţi pe care sunt reprezentate numerele. Pentru a preveni depăşirile în calculul

ieşirilor fluturilor FFT se realizează scalarea intrărilor prin shiftare la dreapta

(împărţire cu o putere a lui 2).

Una din următoarele metode de scalare poate fi aplicată:

- Scalarea datelor de la intrarea FFT;

- Scalarea datelor la ieşirea din fiecare fluture;

- Scalare condiţionată a datelor pe blocuri.

Prima metodă care asigură că nu apar depăşiri este să se includă

suficienţi biţi de gardă pentru datele de la intrarea FFT. Aceasta înseamnă că

prin shiftare la dreapta a datelor, cei mai semnificativi biţi permit creşterea

numerelor de la un etaj la altul.

În modul, ieşirile fluturelui pot creşte cu un bit la fiecare etaj aşa cum

rezultă din ecuaţia:

'A A BW= + (6.21)

şi având în vedere ca factorii de rotaţie jW e θ−= au modulul unitar,

adunarea poate produce creşterea cu un bit (dublare).

Părţile reale şi imaginare se calculează cu o ecuaţie de tipul:

' cos sinA A B Cθ θ= + + (6.22)

Pentru / 4θ π= datele pot creşte cu un factor maxim de 2.4 de la

intrarea la ieşirea fluturelui ceea ce înseamnă o creştere cu doi biţi. Totuşi,

numai două grupuri de fluturi au factorul de rotaţie maxim într-un etaj şi nu se

înregistrează o creştere cu acest factor maxim în două etaje consecutive.


Numărul de biţi de gardă necesar pentru a compensa creşterea maximă

posibilă a biţilor într-o transformată în N puncte este egal cu numărul de etaje

adică 2log N biţi. De exemplu, într-o transformată în 1024 de puncte (care are

10 etaje) trebuie să fie introduşi 10 biţi de gardă în datele de intrare, rămânând

14 biţi de informaţie. Această metodă de scalare este simplă şi eficientă

pentru FFT de lungimi mici. Cu cât lungimea FFT creşte, numărul de biţi de

gardă necesari creşte înrăutăţindu-se raportul semnal-zgomot.

Aşa cum s-a arătat, o creştere medie de un bit se înregistrează după

fiecare etaj. O altă metodă de compensare a creşterii biţilor constă în scalarea

ieşirilor cu 2 după fiecare etaj. Numărul de împărţiri cu 2 fiind egal cu

numărul de etaje, pentru a obţine rezultatul corect al FFT trebuie înmulţite

ieşirile ultimului etaj cu N. Această metodă are un raport semnal-zgomot mai

bun ca metoda anterioară deoarece se porneşte cu date de intrare mai precise.

Totuşi, în etajele care nu au creşteri ale numărului de biţi scalarea nu este

necesară, apărând astfel o pierdere de informaţie.

A treia metodă de scalare tratează un etaj ca pe un bloc de date,

atribuind un exponent pentru fiecare bloc. Această metodă se mai numeşte

scalare condiţionată în virgulă mobilă pe bloc. Dacă apare o creştere a

numărului de biţi la o ieşire, întregul bloc de date este shiftat la dreapta şi

exponentul blocurilor este incrementat. La sfârşitul FFT trebuie determinat

numărul de scalări efectuate pentru a avea un rezultat corect. Implementarea

pe DSP56300 foloseşte bitul de scalare (bitul 7 din registrul de stare) pentru

testarea apariţiei creşterii biţilor şi actualizarea exponentului. Sunt adăugate

cinci instrucţiuni la sfârşitul fiecărui etaj. Această metodă asigură cel mai bun

raport semnal-zgomot dar este şi cea mai costisitoare din punct de vedere al

complexităţii programului.


6.5 ADRESAREA ÎN ORDINE INVERSĂ A BIŢILOR

Inversarea ordinii biţilor este o tehnică de adresare utilizată în calculul

FFT pentru reordonarea datelor în ordine secvenţială. Un exemplu de

inversare a ordinii biţilor este prezentat mai jos. Inversarea ordinii biţilor

operează asupra indexului binar care reprezintă poziţia unui eşantion într-un

cadru. În exemplul dat avem opt date, deci sunt necesari trei biţi pentru

reprezentarea celor opt indecşi. Prin inversarea ordinii celor trei biţi se obţine

secvenţa reordonată secvenţial.

Indexul iniţial Indexul cu biţii inversaţiSecvenţainiţială Decimal Binar Decimal Binar

Secvenţaordonată

x(0) 0 000 0 000 x(0)

x(4) 4 100 1 001 x(1)

x(2) 2 010 2 010 x(2)

x(6) 6 110 3 011 x(3)

x(1) 1 001 4 100 x(4)

x(5) 5 101 5 101 x(5)

x(3) 3 011 6 110 x(6)

x(7) 7 111 7 111 x(7)

Pe familia DSP56300 acest mod de adresare este selectat prin

încărcarea registrului Mn cu zero (Mn = $000000). Modificarea adresei este

realizată hardware prin incrementarea şi propagarea transportului în sens

invers (reverse-carry), de la MSB la LSB. Aceasta este echivalentă cu

inversarea conţinutului registrelor Rn şi Nn, adunarea ofsetului din registrul

Nn şi reinversarea ordinii biţilor rezultatului.


Pentru un cadru de lungime 2kN = rezultă că ultimii k biţi ai adresei

vor trebui inversaţi. Pentru aceasta registrul Nn trebuie să aibă valoarea:

1Nn 2k−= (6.23)

De asemenea adresa de bază a secvenţei de intrare trebuie să fie putere

întreagă a lui 2 îndeplinind condiţia:

2m N≥ (6.24)

De exemplu, o secvenţă de intrare de 8 elemente are adresa de bază $8

= 1000. Ultimii trei LSB vor fi 000,001,002,...,111.

M0 = $000000. R0 = 1000. N0 = 0100 = 23-1.

Adresasecvenţeiiniţiale

Secvenţainiţială

Modificarea adreseireverse-carry

Secvenţareordonată

$8 = 1000 0 R0 = 1000 +N0 = 0100

0

$9 = 1001 1 R0 = 1100 +N0 = 0100

4

$A = 1010 2 R0 = 1010 +N0 = 0100

2

$B = 1011 3 R0 = 1110 +N0 = 0100

6

$C = 1100 4 R0 = 1001 +N0 = 0100

1

$D = 1101 5 R0 = 1101 +N0 = 0100

5

$E = 1110 6 R0 = 1011 +N0 = 0100

3

$F = 1111 7 R0 = 1111 +N0 = 0100

7

În mod normal, pentru reordonarea datelor este necesar un cadru de

memorie suplimentar pentru transferul direct (cum apare în tabelul de mai

sus). În situaţiile în care spaţiul de memorie este mai critic decât timpul de


execuţie se preferă o metodă “in place” (fără memorie suplimentară) de

ordonare în ordinea inversă a biţilor. După cum se poate observa, dacă

indexul binar este simetric (este acelaşi şi cu biţii inversaţi) data respectivă nu

trebuie schimbată. În celelalte cazuri se pot forma perechi de date care îşi

schimbă poziţia una în locul celeilalte (1 cu 4, 3 cu 6 din exemplul anterior).

Iniţializărir0 = data + N/2m0 = 0 (bit reversed)n0 = N/2r1 = data + 1

r1r0 ≤

a = x:(r0)b = x:(r1)x:(r0) = bx:(r1) = a

(r0)+n0 (bit reversed)(r1)+ (liniar)

DANU

do N-1 points

Figura 0.9. Algoritmul “in place” de reordonare a datelor.

Algoritmul este prezentat în figură. Registrul r0 este folosit pentru

adresarea bit-reversed, iar r1 pentru adresare liniară. Dacă r0 = r1 (index

simetric) sau dacă r0 < r1 (ca să nu fie schimbată de două ori aceeaşi pereche)

nu se schimbă datele între ele.


6.6 OPTIMIZAREA PERFORMANŢELOR FFT

6.6.1 Optimizarea

Judecarea performanţelor oricărui program necesită luarea în

considerare a complexităţii atât a timpului de execuţie cât şi a spaţiului

ocupat. Totdeauna există un compromis între acestea două. Complexitatea

timpului de execuţie arată cât de repede poate fi implementat un algoritm pe

un procesor specificat, în timp ce complexitatea spaţiului arată câtă memorie

poate fi necesară. Optimizarea poate să reducă necesarul de memorie sau să

minimizeze timpul de rulare al unui algoritm. Deoarece costurile memoriei

sunt într-o continuă descreştere, optimizarea timpului de execuţie devine din

ce în ce mai importantă. O metodă de evaluare a complexităţii timpului de

execuţie a unui algoritm este comparaţia complexităţii teoretice, complexităţii

implementării ideale şi complexităţii practice. Complexitatea teoretică se

referă la numărul de adunări şi înmulţiri cerute de algoritmul dat independent

de arhitectura procesorului. Acest tip de evaluare e bun doar pentru o

comparaţie de nivel înalt între algoritmi şi nu reflectă performanţele reale ale

algoritmului pe procesorul dat. Nu e surprinzător faptul că un algoritm cu o

complexitate teoretică mică are o complexitate implementată ideală mai mare.

Complexitatea implementată ideală se referă numai la implementarea

nucleului algoritmului în funcţie de posibilităţile instrucţiunilor procesorului

dat cum ar fi: tipuri de instrucţiuni disponibile, moduri de adresare, transferuri

paralele ale datelor, etc. Complexitatea implementării ideale arată

performanţele fără overhead ale algoritmului dat pe procesor şi furnizează o

estimare optimistă a performanţei algoritmului. Complexitatea practică

reprezintă complexitatea implementării ideale plus structura de overhead


datorată procesorului. Overhead-ul include toate instrucţiunile necesare

neasociate nucleului algoritmului. Iniţializarea pointerilor, pregătirea

ciclurilor, salturile la subrutine sunt structuri tipice de overhead în procesor.

Prin distingerea diferitelor grade de complexitate se poate determina uşor care

procesor e compatibil pentru fiecare aspect şi care instrucţiune sau mod de

adresare e critic pentru algoritmii specifici. De exemplu, complexitatea

teoretică pentru radix-2 e de patru multiplicări şi şase adunări sau scăderi.

Pentru procesoarele din familia DSP56300, instrucţiunea MAC efectuează o

înmulţire şi o adunare în paralel, deci complexitatea implementării ideale pe

DSP56300 e de şase cicluri (4 MAC şi 2 SUBL). Dacă fiecare fluture are

nevoie de o medie de 1/6 instrucţiuni pentru a completa un ciclu DO,

complexitatea practică a fluturelui DIT în bază 2 e de 6.17 instrucţiuni.

Raportul între complexitatea implementării ideale şi cea practice reflectă

eficienţa microprocesorului în efectuarea unei funcţii. De exemplu, eficienţa

lui DSP56300 de a efectua un fluture DIT complex ar fi raportul

implementării ideale şi a celei practice, adică: 0.97. Cu alte cuvinte, overhead-

ul pentru acest exemplu e de 3%. Pentru algoritmii FFT ar trebui să fie între

3% şi 15%. Dacă procesorul are un overhead mai mare, nu poate fi numit

DSP. Daca e mai mic de 3%, e probabil un circuit integrat specific unei

aplicaţii (ASIC).

6.6.2 Minimul de memorie ocupată – implementarea “in place”

Deşi fiecare fluture are două date complexe de intrare şi două de ieşire,

calcularea fluturelui poate fi efectuată folosind aceeaşi zonă de memorie

numită calcularea “in place”. Necesarul de memorie poate fi minimizat în

cazurile:


• Aranjarea datelor în ordinea inversă a biţilor. Acest lucru poate fi făcut

in-place deoarece datele sunt interschimbate pe perechi. Astfel, doar o

zonă de date de lungime 2N e necesară.

• Prin reducerea tabelului factorilor de rotaţie de la N locaţii la / 2N

locaţii reale pentru intrările ordonate în ordine normală. / 2N numere

complexe pot fi combinate în perechi de câte două ce diferă prin

factorul / 4NNW j= − . Cu alte cuvinte, factorul de rotaţie din al doilea

grup poate fi obţinut prin multiplicarea cu –j cu factorul din primul

grup. Optimizarea poate fi implementată printr-o modificare minoră a

programului fluturelui. Toate grupurile de index par vor folosi factorii

de rotaţie negaţi, cu părţile reală şi imaginară schimbate între ele.

Astfel, numărul grupurilor într-un etaj se poate reduce la jumătate la fel

întâmplându-se şi cu timpul de acces la memoria factorilor W.

• Folosind trei cicluri DO intercalate pentru a minimiza spaţiul de

memorie de program.

6.6.3 Optimizarea pentru o execuţie mai rapidă

Deşi programul discutat anterior se execută foarte rapid, anumite

aplicaţii impun cerinţe mai puţin stringente referitoare la mărimea memoriei,

dar cer o execuţie mai rapidă. O execuţie rapidă poate fi obţinută prin

optimizarea algoritmului anterior. În următoarele rânduri vom prezenta câţiva

paşi de a atinge această optimizare:

Deoarece în primul şi al doilea etaj sunt factori de rotaţie triviali (care

nu implică operaţii aritmetice) de tipul:

0 1NW = şi / 4NNW j= − (6.25)


se pot combina primul şi al doilea etaj într-un fluture de ordin 4 ca în

figura 0.10.

-1

-1-1

-1

A

B

C

D

1

1

1

–j

A’

B’

C’

D’

Figura 0.10. Fluturele de ordin 4 obţinut prin gruparea primelor două

etaje FFT

Prin această grupare vor fi calculaţi / 4N fluturi cu următoarele ecuaţii:

( ) ( )( ) ( )( ) ( )( ) ( )( ) ( )( ) ( )( ) ( )( ) ( )

'

'

'

'

'

'

'

'

r r r r r

r r r r r

r r r i i

r r r i i

i i i i i

i i i i i

i i i r r

i i i r r

A A C B D

B A C B D

C A C B D

D A C B D

A A C B D

B A C B D

C A C B D

D A C B D

= + + +

= + − +

= − + −

= − − −

= + + +

= + − +

= − − −

= − + −

(6.26)

Se observă că în ecuaţia (6.26) trebuie efectuate 8 adunări şi 8 scăderi,

ceea ce înseamnă că pentru un procesor din familia DSP56300 cu o singură


unitate ALU şi două transferuri paralele, durează cel puţin 16 instrucţiuni

pentru efectuarea calculelor.

După combinarea primelor două etaje, numărul ciclurilor instrucţiune

necesar pentru calculul FFT devine:

( ) ( )/ 4 . 2 / 2 . .TRIV N nr etaje N nr instr fluture⋅ + − ⋅ ⋅ (6.27)

unde TRIV este numărul instrucţiunilor pentru fluturele trivial.

Factori de rotaţie triviali există şi în etajele rămase. Există două tipuri

de fluturi triviali.

Tipul 1: 0 / 41, NN NW W j= = − (6.28)

Tipul 2: /8 3 /8 2 2

2 2N N

N NW W j= − = − (6.29)

Tipul 1 nu implică multiplicări. Pentru a folosi aceste relaţii simple în

etajele rămase, trebuie să utilizăm fluturi diferiţi care trebuie inseraţi într-un

etaj. Această schimbare are ca rezultat un cod mai mare de program şi

instrucţiuni suplimentare (overhead), cum ar fi actualizarea registrelor de

adresă, cicluri DO diferiţi, si adresare circulară.

Tipul 2 de factori nu sunt cu adevărat triviali dar se reduce teoretic

complexitatea fluturelui de ordin 2 la două multiplicări şi şase adunări sau

scăderi reale. Totuşi, pentru procesoarele din familia DSP56300 care au o

singură unitate MAC tot şase instrucţiuni sunt necesare, ca mai înainte.

Fiecare grup din ultimul etaj constă într-un singur butterfly. În acest caz

ciclul de fluturi poate fi eliminat.

O altă alternativă e combinarea ultimelor două etaje într-un fluture de

ordin 4. Deoarece fiecare fluture din ultimul etaj are nevoie de factori de

rotaţie diferiţi, o instrucţiune care să aducă factorul de rotaţie din memorie

trebuie inclusă în programul fluturelui.


6.7 TRANSFORMATA FOURIER INVERSĂ

Formula pentru transformata Fourier discretă inversă (TFDI) este:

1

0

1( ) TFDI{ ( )}( ) ( )

Nnk

Nk

x n X k n X k WN

−−

=

= = ∑ , 0,1,..., 1n N= − (6.30)

Se observă că diferenţele care apar între formula transformatei directe

şi cea a transformatei inverse sunt: împărţirea cu 1/ N şi conjugarea factorilor

de rotaţie NW .

Pentru factorii de rotaţie se poate utiliza un alt vector decât cel utilizat

la transformata directă, sau se poate folosi acelaşi vector, dar citirea valorilor

factorilor de rotaţie ai transformatei inverse să se facă de la sfârşitul la

începutul acestuia, avându-se în vedere formula:

22 2j kj kNNe eππ π − −

= (6.31)

Se poate calcula transformata Fourier discretă inversă folosind

transformata directă având în vedere următoarea relaţie:

( )**1TFDI{ ( )} TFD{ ( )}X k j j X k

N= ⋅ ⋅ (6.32)

Într-adevăr:

21

0

1TFDI{ ( )} ( )

N j nkN

k

X k X k eN

π−

=

= ∑ (6.33)

( )

( )

*21** *

0

* *2 21 1*

0 0

2 21 1*

0 0

TFD{ ( )} ( )

( ) ( )

( ) ( )

N j nkN

k

N Nj nk j nkN N

k k

N Nj nk j nkN N

k k

j j X k j j X k e

j X k je j X k je

X k j j e X k e

π

π π

π π

− −

=

− −− −

= =

− −

= =

⋅ ⋅ = ⋅ =

= = =

= ⋅ =

∑

∑ ∑

∑ ∑

(6.34)

de unde, înlocuind în (6.32) rezultă relaţia dorită.


Fie z a jb= + o variabilă complexă. Expresia *j z⋅ înseamnă:

( ) ( )*j a jb j a jb b ja⋅ + = ⋅ − = + (6.35)

adică o inversare între părţile reală şi imaginară.

Revenind la relaţia (6.32) programul care calculează transformata

Fourier inversă va avea următoarea organigramă:

Inversareparte reală –

parte imaginară

FFT(scalare cu 1/N)

( )X k

Inversareparte reală –

parte imaginară

( ) IFFT{ ( )}x n X k=

Figura 0.11. Algoritmul de calcul al IFFT folosind FFT.

Dacă datele sunt organizate în memorie cu partea reală în memoria X şi

partea imaginară în memoria Y (la aceeaşi adresă), inversarea părţilor reală şi

imaginară înseamnă transferul a doi vectori de lungime N din memoria X în Y

într-un macro de forma:


; Programul de inversare a părţilor reală şi imaginară

invreim macro puncte,date

invreim ident 1,0

;

; puncte număr de elemente din memorie

; date adresa de început a cadrului de date

;

move #date,r0

move r0,r4

move #-1,m0 ;adresare liniară

move m0,m4

do #puncte,end_inv

move x:(r0),a y:(r4),b

move b,x:(r0)+ a,y:(r4)+

end_inv

endm

6.8 TRANSFORMATA FOURIER PENTRU SECVENŢE REALE

În cazul secvenţelor reale există proprietatea:

*( ) ( )X k X N k= − (6.36)

deci

Re{ ( )} Re{ ( )}X k X N k= − , Im{ ( )} Im{ ( )}X k X N k= − − (6.37)

iar (0)X şi ( / 2)X N au valori reale. În consecinţă este suficient să se

calculeze un număr de N valori reale.

Există algoritmi specializaţi pentru date reale, care vor permite

reducerea complexităţii aritmetice precum şi a memoriei utilizate, cu preţul

unei anumite complicări a programului.


6.8.1 Algoritmi pentru o singură secvenţă reală

Vom utiliza algoritmul în bază doi cu decimare în timp:

1 21 1 1 1

1 1

1 12 2

21 2 1 1

0 02 2

( ) (2 ) (2 1)2

N NN

k kn k n kN N N

n n

NX k k x n W W x n W

− −+

= =

+ = + +∑ ∑ (6.38)

Pentru 2 0k = :

11 1 1( ) ( ) ( )k

NX k X k W X k′ ′′= + (6.39)

unde prin 1( )X k′ şi 1( )X k′′ s-au notat transformatele de ordin / 2N .

Pentru a pune în evidenţă simetria circulară pară a acestor transformate:

1 1( ) ( )2

NX k X k′ ′= − , 1 1( ) ( )

2

NX k X k′′ ′′= − (6.40)

evaluăm şi:

11 1 1( ) ( ) ( )

2 2 2k

N

N N NX k X k W X k′ ′′− = − − − (6.41)

Exprimând părţile reale şi imaginare se obţin:

1 1 1 1 1 1

1 1 1 1 1 1

1 1 1 1 1 1

1 1 1 1 1 1

Re ( ) Re ( ) cos Re ( ) sin Im ( )

Im ( ) Re ( ) sin Re ( ) cos Im ( )

Re ( ) Re ( ) cos Re ( ) sin Im ( )2

Im ( ) Im ( ) sin Re ( ) cos Im ( )2

X k X k k X k k X k

X k X k k X k k X k

NX k X k k X k k X k

NX k X k k X k k X k

θ θθ θ

θ θ

θ θ

′ ′′ ′′= + +′ ′′ ′′= − +

′ ′′ ′′− = − −

′ ′′ ′′− = − − +

(6.42)

unde

2

N

πθ = (6.43)

Vom utiliza primele două relaţii pentru eşantioanele de ordin

0,1, , / 4N… apoi ultimele două relaţii pentru exprimarea eşantioanelor de

ordin / 4 1, , / 2N N+ … .


Rezultă schema din figura 0.11:

0ReX’(k1)

TFD :

N/2 :ImX’(k1)

:

cos(θk1)

x(2n)ReX[k1]

ImX[k1]

ReX[N/2-k1]

ImX[N/2-k1]

-1

-1

x(2n+1)

0ReX’’(k1)

TFD :

N/2 :ImX’’(k1)

:-cos(θk1)

sin(θk1)sin(θk1)

2

N

πθ =

-1

-1

Figura 0.11. Descompunerea TFD pentru date reale

6.8.2 Algoritmi pentru două secvenţe reale

Dacă trebuie calculate simultan două secvenţe de date reale ( )x n şi

( )y n , se poate utiliza algoritmul pentru date complexe. TFD este o

transformată liniară astfel că, dacă notăm:

( ) ( ) ( )z n x n j y n= + ⋅ (6.44)

atunci:

[ ]( ) TFD{ ( )}( ) TFD{ ( ) ( )}( ) ( ) ( )

Re ( ) Im ( ) Re ( ) Im ( )

Z k z n k x n jy n k X k jY k

X k j X k j Y k j Y k

= = + = + =

= + + +(6.45)

sau

[ ] [ ]( ) Re ( ) Im ( ) Re ( ) Im ( ) Im ( ) Re ( )Z k Z k Z k X k Y k j X k Y k= + = − + + (6.46)

având în vedere formulele (6.37) rezultă:

[ ] [ ]( ) Re ( ) Im ( ) Im ( ) Re ( )Z N k X k Y k j X k Y k− = + − − (6.47)


Se pot separa transformatele fiecărei secvenţe din rezultatul

algoritmului FFT pentru date complexe cu formulele:

[ ] [ ]1 1( ) Re ( ) Re ( ) Im ( ) Im ( )

2 2X k Z k Z N k j Z k Z N k= + − + − − (6.48)

[ ] [ ]1 1( ) Im ( ) Im ( ) Re ( ) Re ( )

2 2Y k Z N k Z k j Z N k Z k= − + + − − (6.49)

Se observă că deoarece secvenţele sunt reale, TFD are simetrie circular

conjugat simetrică, deci este suficient calculul TFD pentru 0, / 2k N= … . De

asemenea, pentru 0k = şi / 2k N= avem:

(0) Re (0) ( / 2) Re ( / 2)

(0) Im (0) ( / 2) Im ( / 2)

X Z X N Z N

Y Z Y N Z N

= == =

(6.50)

Capitolul 7 – Procesorul de semnal StarCore 140 145

CAPITOLUL 7

PROCESORUL DE SEMNAL STARCORE 140

7.1 INTRODUCERE

Procesorul de semnal StarCore, produs al firmei Freescale, prezintă un

nou tip de arhitectură, cu un plus de putere de calcul. Numit SC140, poate fi

implementat pe o gamă largă de configuraţii SOC (System On Chip). Pe un

singur chip pot fi integrate, în funcţie de necesităţile clientului, zone de

memorie suplimentare, dar şi o gamă variată de porturi de I/O sau alte

periferice.

SC140 implementează un nou model de execuţie a instrucţiunilor numit

VLES (Variable-Length Execution Set) care permite folosirea mai multor

unităţi de adresare şi de calcul în paralel, în acelaşi ciclu-maşină.

Câteva caracteristici ale procesorului de semnal SC140 sunt:

• frecvenţa de ceas a nucleului este 300 MHz la 1,5V şi 120 MHz la 0,9V;

• până la 1200 Milioane operaţii MAC pe secundă (1,2 GMACS);

• până la 3000 RISC MIPS (MAC se consideră ca 2 instrucţiuni RISC);

• 4 unităţi logice-aritmetice (ALU – Arithmetic Logic Unit) care includ

circuite dedicate de înmulţire şi adunare şi unităţi de operare pe bit;

• circuitele MAC (Multiply and ACcumulate) din fiecare ALU, operează pe

40 biţi (16b × 16b + 40b);


• fiecare ALU conţine un shifter (structură de deplasare) pe 40 biţi;

• 16 Registre pe 40 biţi pentru operaţii cu numere întregi şi fracţionare;

• 16 Registre de adresă pe 32 biţi, dintre care 8 pot fi folosite ca adrese de

bază;

• 4 Registre de offset pentru adrese şi 4 Registre pentru adresare circulară;

• 2 unităţi de adresare cu operaţii aritmetice cu numere întregi;

• moduri de adresare specifice procesoarelor de semnal;

• suport hardware pentru tipurile de date întreg şi fracţionar;

• set de instrucţiuni ortogonal cu instrucţiuni codate pe 16 biţi;

• memoria poate fi accesată în cuvinte cu dimensiune variabilă (1 până la 4

octeţi);

• într-un ciclu-maşină pot fi executate până la 6 instrucţiuni;

• memorie comună de program şi de date cu trei magistrale (PAB, PDB,

XABA, XDBA, XABB, XDBB);

• logică CMOS caracterizată printr-un consum redus de putere..

Schema bloc a unei configuraţii tipice SOC este prezentată mai jos:


Zona de extindere a memoriei – Nivel 1 Memorie unificată de date şi program

ROM, RAM

DSP Engine Set de instrucţiuni pe 16-biţi

Nucleul DSP StarCore 140 Interfaţa cu memoria externă

DMA

CACHE

Zona de Periferice şi Acceleratoare Periferice standard Input/Output Acceleratoare specifice aplicatiilor Accelerator programabil de uz general

4 Unităţi ALU

Zona de extensie de sistem

Ctrl. de întreruperi

Variable Length Execution Set (VLES)

Memorie extinsă – Nivel 2

2 Unităţi de generare a adreselor

Figura 7-1 Schema bloc a unei configuraţii tipice SoC (System On Chip)

Pe lângă cele 4 zone din schema bloc mai poate exista încă o zonă de

memorie suplimentară, dar aceasta nu va funcţiona la frecvenţa nucleului.

Viteza maximă a acesteia va depinde de tehnologia în care este realizată.

Memoria de pe SC140 este de tip SRAM (Static RAM).

VLES este un model software în care instrucţiunile folosite de SC140

sunt grupate astfel încât să se obţină o performanţă maximă în realizarea

practică a programelor. Fiecare instrucţiune codifică o operaţie elementară.

Pentru a executa funcţii specifice procesării semnalelor, grupuri de

instrucţiuni poate fi executat în paralel, folosind un circuit dedicat din partea

de control a execuţiei programului numită PSEQ (Program SEQuencer Unit).


7.2 PREZENTAREA ARHITECTURII PROCESORULUI DE

SEMNAL SC140INTRODUCERE

Figura 7.2 prezintă schema bloc pentru nucleul procesorului de semnal

SC140, împreună cu principalele blocuri componente.

Instruction Bus

32 128 PAB

PDB

XA

BA

XD

BB

XD

BA

XA

BB

Secvenţiator de Program

Setul de registre pentru Generarea Adreselor

Registre ALU pentru date

2 AAU BMU 4 ALU

OnCE

Controlul Puterii

Generatorul de ceas

PLL

32 32 64 64 128

128

Spaţiul unificat de memorie pentru date şi program

24

Accelerator pentru setul de

instrucţiuni

StarCore 140

Figura 7-2 Schema bloc pentru nucleul procesorului de semnal SC140

Se observă spaţiul unificat de memorie, datele şi programul fiind

conţinute în aceeaşi memorie. Este o memorie multiport ceea ce nu

restricţionează debitul necesar aplicaţiilor de procesare de semnal. O parte

importantă a nucleului este dedicată logicii de control a programului pentru a

se permite efectuarea în paralel a mai multe instrucţiuni elementare.

În interiorul nucleului mai există suport hardware pentru power-

management şi debug (EOnCE - Enhanced On Chip Emulator).


7.2.1 Unitatea Aritmetică şi Logică de Date (DALU)

DALU, (Data Arithmetic Logic Unit), reprezintă unitatea funcţională

care realizează operaţiile logice şi aritmetice în interiorul procesorului de

semnal SC140.

Componentele DALU sunt următoarele:

- un set de 16 Registre fiecare de 40 biţi (D0 – D15)

- 4 unităţi aritmetice şi logice care operează în paralel, fiecare dintre

acestea conţinând o unitate MAC (Multiply and ACcumulate) şi BFU (Bit-

Field Unit)

- 8 registre shifter/limitatoare.

Schema de principiu a DALU este prezentată în figura de mai jos:

Figura 7-3 Schema de principiu a DALU

Toate unităţile MAC şi BFU pot accesa oricare dintre cele 16 registre,

fiecare este partiţionat în 3 părţi: două de 16 biţi (părţile high şi low ale

registrului) şi una de 8 biţi (partea de extensie). În funcţie de instrucţiune,

accesul la aceste registre se poate face pe 8, 16, 32 sau 40 biţi.


Cele două magistrale de date dintre registrele DALU şi memorie

(XDBA şi XDBB) sunt pe 64 de biţi. Accesul la memorie, pe aceste

magistrale, pe 64 biţi, se poate realiza simultan.

Instrucţiunile move pot varia ca lărgime de acces de la 8 la 64 de biţi şi

pot transfera de asemenea cuvinte multiple, dar care nu depăşesc 64 de biţi

(de exemplu 4 cuvinte de 16 biţi sau două de 32 de biţi). Deoarece se pot

executa câte două instrucţiuni move în fiecare ciclu maşină se poate atinge o

rată maximă de transfer cu memoria de 4.8 Go/s (la 300 MHz, frecvenţa de

lucru a nucleului).

Modelul de programare al DALU este prezentat mai jos.

1 39 32 31 16 15 0 L0 D0.e D0.h D0.l D0 L1 D1.e D1.h D1.l D1 L2 D2.e D2.h D2.l D2 L3 D3.e D3.h D3.l D3 L4 D4.e D4.h D4.l D4 L5 D5.e D5.h D5.l D5 L6 D6.e D6.h D6.l D6 L7 D7.e D7.h D7.l D7 L8 D8.e D8.h D8.l D8 L9 D9.e D9.h D9.l D9

L10 D10.e D10.h D10.l D10 L11 D11.e D11.h D11.l D11 L12 D12.e D12.h D12.l D12 L13 D13.e D13.h D13.l D13 L14 D14.e D14.h D14.l D14 L15 D15.e D15.h D15.l D15

Figura 7-4 Modelul de programare DALU

Un registru poate fi sursă pentru până la 4 instrucţiuni simultane, dar nu

se permit scrieri simultane în acelaşi registru. Rezultatul unei operaţii

aritmetice poate fi folosit ca sursă pentru o alta fără nici o restricţie temporală.


Prin D0 ne referim la întregul registru (toţi cei 40 biţi), în timp ce D0.e

se referă la cei 8 biţi de extensie, iar D0.h şi D0.l se referă la cei 16 biţi ai

părţii superioare (cei mai semnificativi 16 biţi) respectiv ai părţii inferioare

(cei mai puţin semnificativi 16 biţi). Fiecare registru are asociat câte un bit

etichetă de limitare notat de la L0 la L15, la fel ca registrele corespondente.

Registrele DALU (la care ne vom referi în general cu acronimul Dn

unde 0,15n = ) sunt registre de uz general, fiecare dintre ei putând fi folosit

ca: operand sursă, operand destinaţie sau acumulator.

Registrele DALU pot fi folosite ca zone tampon între cele două

magistrale de acces la memoria XDBA şi XDBB şi la ALU, permiţând noilor

operanzi să fie încărcaţi pentru următoarea instrucţiune în timp ce conţinutul

lor este folosit de instrucţiunea curentă.

Biţii de limitare Ln sunt folosiţi pentru a se determina dacă partea de

extensie a fiecărui registru este folosită sau nu. Practic acest bit este

concatenat cu Dn.e formând un operand pe 9 biţi.

Pentru instrucţiunile de transfer ale datelor fracţionare, transferul unui

registru Dn în memorie este protejat la depăşire (overflow) prin înlocuirea

valorii pentru care s-a constatat depăşirea cu o valoare constantă maximă sau

minimă, după caz. Acest lucru se întâmplă pentru valoarea transferată pe

magistralele XDBA sau XDBB, conţinutul registrului sursă rămânând acelaşi.

Limitarea are loc după ce conţinutul registrului a fost shiftat în

concordanţă cu modul de scalare folosit. Shiftarea şi limitarea sunt realizate

numai pentru o subclasă a instrucţiunilor move şi anume pentru moves şi de

asemenea doar dacă registrul conţine o valoare fracţionară cu semn. Dacă pe

magistralele de acces la memorie este transferată o valoare de tip întreg, nu

sunt realizate operaţii de shiftare şi limitare.


Pentru transferurile din memorie în registre este folosită în mod

automat extinderea până la 40 biţi a semnului valorii transferate. Această

extindere înseamnă pur şi simplu copierea valorii bitului de semn până la

atingerea dimensiunii de 40 biţi pentru operand.

Pentru o valoare fracţionară pe 16 biţi care este transferată din memorie

se realizează următoarele operaţii:

• cei 16 biţi ai valorii sunt transferaţi în Dn.h (partea superioară a

registrului sursă)

• Dn.l h (partea inferioară a registrului sursă) este resetată

• Dn.e (partea de extensie a registrului sursă) este extinsă prin

copierea bitului de semn

• Ln este la rândul său resetat.

Pentru o valoare de tip întreg, cei 16 biţi sunt transferaţi în Dn.l iar

Dn.h şi Dn.e pot fi extinse cu semnul operandului sau cu zero după cum

specifică instrucţiunea. Mai există instrucţiuni speciale pentru scrierea sau

citirea părţii extinse a registrelor, dar acestea sunt folosite doar în anumite

calcule cu precizie extinsă.

Unitatea MAC este partea aritmetică a ALU şi conţine un multiplicator,

un sumator, precum şi alte circuite aritmetice pentru realizarea rotunjirii,

comparării, saturării sau shiftării. Operanzii sursă ai unităţii MAC pot fi

registre sau valori imediate din corpul instrucţiunii, iar numărul lor maxim

este de 3. Operandul destinaţie nu poate fi decât un registru de 40 biţi din cele

descrise mai sus.

Multiplicatorul execută o înmulţire a unor operanzi de 16 biţi, care

reprezintă numere în complement faţă de 2, cu sau fără semn, întregi sau

fracţionare. Ieşirea multiplicatorului (32 de biţi) poate fi adunată la registrul

destinaţie.


Sumatorul poate executa adunări sau scăderi. Toate instrucţiunile

realizate de unitatea MAC se desfăşoară pe durata unui sigur ciclu-maşină.

Unitatea BFU este partea logică a ALU şi conţine un shifter

bidirecţional de 40 de biţi, o unitate de generare a măştilor şi o unitate logică.

Aici se pot realiza următoarele operaţii:

• shiftare aritmetică sau logică cu unul sau mai mulţi biţi, la stânga

sau la dreapta

• rotaţie la stânga sau dreapta cu un singur bit

• operaţii logice (and, or, xor)

• operaţii de extindere a semnului sau cu zero

• operaţie de numărare a celor mai semnificativi biţi de 0 sau 1.

Registrele de shiftare/limitare oferă post-procesări speciale ale valorilor

care trebuie scrise în memorie. Din cele 8 astfel de registre 4 sunt folosite

pentru bus-ul XDBA şi 4 pentru XDBB, permiţând transferuri cu memoria a

până la 4 cuvinte care au fost shiftate şi limitate după caz. Funcţiile oferite de

aceste circuite diferă de aritmetica cu saturaţie care poate fi folosită de ALU.

Unitatea DALU este o unitatea de execuţie a SC140, are asociate o

serie de instrucţiuni specifice, numite instrucţiuni DALU, diferite de

instrucţiunile altor unităţi de execuţie (de exemplu AGU). Se pot executa până

la patru instrucţiuni într-un singur ciclu-maşină. Diferenţierea între tipurile de

instrucţiuni ale fiecărei unităţi de execuţie este făcută la nivelul PSEQ.

Funcţiile DALU

Registre de shiftare/limitare pot efectua următoarele operaţii:

• scalare prin înmulţire – datele sunt shiftate cu un bit la stânga;

• scalare prin împărţire – datele sunt shiftate cu un bit la dreapta;

• datele nu sunt scalate.


Modulul de scalare se setează prin intermediul biţilor S0 şi S1 din

registrul de stare al procesorului SC140 (SR – Status Registrer). Scalarea

afectează numai datele transferate în memorie, nu şi datele din registre.

Scalarea afectează modul de calcul al bitului de limitare Ln şi nu se poate

folosi atunci când este utilizată aritmetica cu saturaţie.

Capabilităţile de limitare şi cele de scalare sunt folosite numai pentru

instrucţiunile moves.

Operaţia de limitare se desfăşoară în doi paşi:

• în primul pas este calculat bitul Ln atunci când registrul este scris de

către o operaţie ce a avut loc în ALU

• în al doilea pas are loc limitarea datelor de pe bus, dacă bitul Ln este

setat.

Calculul valorii bitului Ln este realizat în ideea că va urma o

instrucţiune de tip moves. Bitul Ln este determinat pe baza biţilor din partea

de extensie a registrului, aceştia fiind biţii care se află la stânga virgulei

(considerată implicit) din număr. Bitul Ln este setat dacă aceşti biţi nu au toţi

valoarea 0, sau 1. Constanta cu care este înlocuită pe bus valoarea care trebuie

limitată este fie cea mai pozitivă valoare posibilă, fie cea mai negativă în

funcţie de bitul de semn.

SC140 poate lucra cu numere întregi sau fracţionare, ambele

reprezentate în complement faţă de 2. Diferenţa principală dintre cele două

tipuri de valori constă în locul unde se afla implicit virgula care desparte

partea întreagă de cea zecimală. Pentru numere fracţionare aceasta se afla

întotdeauna la dreapta celui mai semnificativ bit a porţiunii superioare a

registrului (adică la dreapta bitului de semn). Pentru numere întregi aceasta se

află întotdeauna la dreapta celui mai puţin semnificativ bit.


Operand pe 16 biţi

în memorie

Reprezentarea pe 40

de biţi (D0 – D15)

Reprezentarea numerelor fracţionare cu semn

Operand pe 16 biţi

în memorie

Reprezentarea pe 40

de biţi (D0 – D15) Reprezentarea numerelor întregi cu semn

Figura 7-5 Reprezentarea numerelor fracţionare şi întregi în registrele de date

Tipurile de date cu care se poate lucra pe SC140 sunt deci:

• numere fracţionare cu semn

• numere întregi cu semn

• numere întregi fară semn.

Deosebirea dintre acestea este redată în tabelul următor (numere pe 16 biţi):

Numere fracţionare cu semn

Numere întregi cu semn

Numere întregi fără semn

Reprezentare internă Valoare Reprezentare

internă Valoare Reprezentare internă Valoare

0x7FFF 1-2-15 0x7FFF 215 – 1 0x7FFF 216 – 1 … … … … 0x7FFE 216 – 2 … … … … … …

0x0001 2-15 0x0001 1 … … 0x0000 0 0x0000 0 … … 0xFFFF -2-15 0xFFFF -1 … …

… … … … … … … … … … 0x0001 1

0x8000 -1 0x8000 -215 0x0000 0


Multiplicarea şi majoritatea operaţiilor aritmetice sunt realizate cu

aceleaşi circuite pentru valori fracţionare şi pentru valori întregi.

Există operaţii care fac necesară existenţa circuitelor specializate:

operaţiile de multiplicare între întregi fără semn, sau între un întreg cu semn şi

unul fără semn. Modul de comparare între valori cu semn şi fără semn este

diferit pentru numere pozitive şi negative. Ne referim în special la comparaţii

de tipul mai mare pentru care există instrucţiuni diferite pentru valori fără

semn şi cele cu semn. Pentru înmulţirea numerelor întregi şi fracţionare există

mici deosebiri, chiar dacă se realizează cu acelaşi circuit.

ÎNMULŢIREA NUMERELOR CU SEMN N x N –> 2N – 1 BIŢI

S

INTREG FRACŢIONAL

S

REZULTAT 2N – 1EXTENSIE DE SEMN

2N BIŢI

ÎNMULŢIRE CU SEMN

S MSP LSPS

S S

REZULTAT 2N – 1COMPLETARE CU ZERO

2N BIŢI

ÎNMULŢIRE CU SEMN

S MSP LSP 0

Figura 7-6 Înmulţire întreagă (stânga) şi respectiv fracţionară (dreaptă)

DALU poate realiza rotunjirea valorii din registru, dacă acest lucru este

cerut prin instrucţiune. Partea superioară a registrului este rotunjită în funcţie

de partea inferioară iar apoi partea inferioară este resetată. Limita între cele

două porţiuni este determinată de modul de scalare folosit. Se oferă suport

pentru două tipuri de rotunjire: rotunjire convergentă şi rotunjire în

complement faţă de 2, prin intermediul bitului RM (Rounding Mode) din SR.

Normal este folosită rotunjirea convergentă. Dacă partea inferioară a

registrului este mai mare ca 1/2 atunci numărul este rotunjit la prima valoare

mai mare, altfel este rotunjit la prima valoare mai mică. Problema care apare


este la ce valoare trebuie să se rotunjească dacă partea inferioară are exact

valoarea 1/2. Dacă este aleasă una dintre cele două opţiuni disponibile

rezultatul final va avea, după terminarea calculelor, un offset în direcţia

aleasă. Rotunjirea convergentă rezolvă această problemă prin rotunjire în sus,

daca porţiunea superioară este impară (LSB = 1) şi porţiunea inferioară este

1/2 şi prin rotunjire în jos, dacă porţiunea superioară este pară (LSB = 0) şi

porţiunea inferioară este 1/2. În celelalte cazuri rotunjirea convergentă se

comportă exact ca rotunjirea normală.

În rotunjirea în complement faţă de 2, toate valorile pentru care partea

inferioară este mai mare sau egală cu 1/2 sunt rotunjite în sus iar celelalte

valori sunt rotunjite în jos. Apare un mic offset pozitiv în valorile finale.

Dacă nu este folosit nici un mod de scalare, partea superioară a

registrului este reprezentată de biţii 39:16, iar partea inferioară de biţii 15:0.

Pentru scalarea prin înmulţire, partea superioară este reprezentată de biţii

39:15 iar cea inferioară de biţii 14:0. Pentru scalarea prin împărţire partea

superioară este reprezentată de biţii 39:17 iar cea inferioară de biţii 16:0.

Aritmetica cu saturaţie este modul de lucru prin care rezultatele

calculelor aritmetice ale ALU vor fi limitate la cei 32 de biţi mai puţin

semnificativi şi este folosit pentru a oferi compatibilitate cu algoritmii care nu

recunosc, sau nu pot ţine seama de biţii de extensie. Aritmetica cu saturaţie

este similară cu operaţia de limitare descrisă mai sus. Dacă cei 8 biţi de

extensie nu sunt toţi 0 sau toţi 1 valoarea corespunzătoare celor 32 de biţi mai

puţin semnificativi este setată fie la cea mai pozitivă valoare posibilă, fie la

cea mai negativă valoare posibilă. Acest lucru este determinat de bitul 39

(bitul de semn). Aritmetica prin saturaţie se alege prin setarea bitului SM

(Saturation Mode) din SR. La detectarea unei saturaţii este setat bitul DOVF

(DALU Overflow) din registrul EMR (Exception and Mode Registrer).

Funcţionarea saturării aritmetice nu este afectată de modul de scalare. Pentru


majoritatea instrucţiunilor, dacă se foloseşte aritmetica cu saturaţie nu se mai

calculează bitul de limitare Ln, totuşi există unele instrucţiuni pentru care nu

se poate ignora acest bit. Dacă se întâlnesc aceste instrucţiuni în decursul

programului, modul de aritmetică cu saturaţie este dezactivat pe durata

execuţiei lor. Dacă rezultatul acestor instrucţiuni trebuie saturat, este necesară

o instrucţiune specială de saturare pentru registrul care conţine acel rezultat.

De asemenea printre funcţiile oferite de DALU, dar de mai mică

importanţă în aplicaţia curentă, sunt suportul pentru calcule cu număr sporit

de biţi (de exemplu înmulţiri între numere pe 32 biţi) şi suportul pentru

împărţire (prin folosire iterativă a instrucţiunii div).

7.2.2 Unitatea de generare a adreselor (AGU)

AGU (Address Generation Unit) realizează calculul adreselor necesare

pentru funcţionarea programelor, prin folosirea operaţiilor aritmetice potrivite

pentru adresarea operanzilor în memorie. Conţine registrele folosite pentru

generarea acestor adrese. Unitate funcţională operează în paralel cu celelalte

resurse de pe chip pentru a minimiza timpul necesar generării unei adrese. Tot

această unitate este responsabilă cu generarea adreselor de salt în program şi

cu actualizarea registrului de stivă.

Componentele principale ale AGU sunt prezentate în cele ce urmează:

• 8 registre inferiori de adrese (R0 – R7)

• 8 registre superiori de adrese (R8 – R15) sau alternativ, după tipul

de adresare, registre pentru adresele de bază (B0 – B7)

• 2 registre de stivă (care indică spre adresa în care se află primul

element al stivei), dintre care doar unul este activ la un moment dat

(NSP – Normal Stack Pointer şi ESP – Exception Stack Pointer)

• 4 registre de offset (N0 – N3)


• 4 registre modificatori (M0 – M3)

• registrul de control al adresării (MCTL – Modifier ConTroL

Registrer)

• 2 unităţi aritmetice (AAU – Address Arithmetic Unit)

• o unitate BMU (Bit-Mask Unit)

Figura 7-7 Schema bloc a AGU (Address Generation Unit)

Cele 16 registre de adresă, la care ne vom referi cu Rn sau Bn unde

0,15n = sau 0,7n = precum şi registrele de stivă se folosesc în mod normal


pentru generarea adreselor în modul de adresare indirect cu registru. Registrul

conţine adresa la care se află operandul în memorie şi nu operandul propriu

zis – de unde numele de mod de adresare indirectă. Cele patru registre de

offset (Ni, 0,3i = ) pot fi folosite de oricare dintre registrele de adresă.

Registrele modificatoare (Mj, 0,3j = ) pot fi folosite doar de registrele

inferioare de adresă. Registrele pentru adresa de bază sunt asociate în mod

unic cu registrele inferioare de adresă (B0 este asociat cu R0, B1 cu R1, etc.).

Unitatea BMU este folosită pentru operaţii de setare, resetare,

schimbare a unor biţi din operandul destinaţie în funcţie de o mască definită

în corpul instrucţiunii. Operandul sursă este încărcat în BMU pe unul din

magistralele de date XDBA sau XDBB, iar rezultatul este oferit tot pe unul

din aceste magistrale în ciclul-maşină următor. Tipic, în cazul operanzilor pe

16 biţi toate instrucţiunile BMU sunt executate în doi cicli maşină. Aceşti

operanzi pot fi o locaţie de memorie sau una din partiţiile unui registru (partea

high sau low).

Într-un ciclu-maşină cele două AAU (Address Arithmetic Unit) pot

genera o adresă în zona de program a memoriei (în cazul instrucţiunilor de

salt) sau două adrese în zona de date a memoriei (una pe XABA şi una pe

XABB). Această adresă poate fi folosită pentru accesul unui operand

reprezentat pe octet, pe cuvânt (16 biţi), pe cuvânt lung (32 biţi) sau pe dublu

cuvânt lung (64 de biţi). Tot într-un ciclu maşină fiecare AAU poate actualiza

un registru de adresă potrivit modului de calcul specificat în MCTL.

Cele două AAU sunt identice şi fiecare din ele poate realiza

următoarele operaţii:

• adunare sau scădere a două registre AGU

• adunarea unei valori imediate la un registru

• incrementarea sau decrementarea unui registru AGU


• adunare la PC (Program Counter)

• adunare cu propagare inversă a bitului de carry (reverse-carry).

Pe lângă circuitele necesare pentru realizarea acestor operaţii în AAU

mai există un sumator pentru offset care poate realiza operaţii de comparare

sau shiftare. Valoarea offsetului trebuie shiftată cu 1, 2 sau 3 biţi în funcţie de

numărul de octeţi pe care este reprezentat operandul pentru ca acesta să poată

fi accesat corect. De asemenea mai există un sumator pentru aritmetica

modulo care este folosit în adresarea bufferelor circulare.

Modelul de programare a AGU este descris mai jos:

R0 N0 R1 N1 R2 N2 R3 N3 R4 R5 M0 R6 M1 R7 M2 R8 M3 R9 R10 NSP,OSP (nsp, osp) R11 ESP,OSP (esp, osp) R12 R13 R14 R15

Figura 7-8 Modelul de programare AGU


Registrele de stivă au asociate registrele “cache” care conţin o versiune

decrementată a acestora. Instrucţiunea pop (de scoatere din stivă) necesită,

pentru execuţie, un singur ciclu-maşină. Registrul cache este invalidat dacă

are loc o rescriere a registrului stivă corespunzător. Prima instrucţiune de tip

pop executată după modificarea conţinutului registrului de stivă durează două

cicluri-maşină, primul din acestea fiind folosit pentru decrementarea

registrului şi actualizarea registrului cache. Toate celelalte instrucţiuni pop

vor dura un ciclu-maşină până la următoarea modificare a registrului stivă.

Registre modificatoare conţin de obicei dimensiunea bufferului

circular, pentru modul de adresare modulo. Dacă nu mai sunt disponibile alte

registre pot fi folosite ca registre de uz general şi registre offset.

Registrul de control MCTL, reprezentat pe 32 biţi, este folosit pentru a

programa modul de calcul al adresei pentru fiecare dintre cele 8 registre

inferioare de adresă. Registrele superioare nu pot funcţiona decât în modul de

adresare liniară. Structura acestui registru este cea de mai jos:

Biţii AM (Addressing Mode) asociaţi cu fiecare registru inferior de

adresă pot lua valorile din tabelul de mai jos, cu semnificaţiile aferente

acestora. Toate celelalte combinaţii sunt rezervate.


AM3 AM2 AM1 AM0 Mod de adresare 0 0 0 0 Adresare liniară 0 0 0 1 Adresarea reverse-carry 1 0 0 0 Adresare în buffer circular – se foloseşte m0 1 0 0 1 Adresare în buffer circular – se foloseşte m1 1 0 1 0 Adresare în buffer circular – se foloseşte m2 1 0 1 1 Adresare în buffer circular – se foloseşte m3

1 1 0 0 Adresare modulo cu întoarcere multiplă – se foloseşte m0




Modurile de adresare ale AGU

SC140 oferă 4 moduri de adresare a memoriei. Modurile de adresare se

referă la determinarea locaţiei la care operandul poate fi găsit în memorie şi la

modul în care este făcut calculul acesteia.

Fiecare din cele 4 moduri de adresare va fi descris în detaliu, deoarece

modurile de adresare sunt o parte importantă a arhitecturii unui procesor,

chiar o măsură a performanţei acestuia, pe lângă numărul de operaţii pe

secundă, memoria internă, tipul de arhitectură, ş.a.m.d.

A. Mod de adresare direct cu registru

Acest mod de adresare implică faptul că operandul se găseşte în unul

sau mai multe registre DALU, AGU, sau de control şi se mai numeşte

referinţă la registru.

1) Modul de adresare direct cu registru de date sau control.

Operandul se află într-unul, două sau patru registre ai DALU, sau într-

unul din registrele de control pentru anumite instrucţiuni speciale.


Un exemplu este: mac d4,d5,d6

care înseamnă că operanzii se găsesc în registrele d4, d5 şi d6 ai DALU şi se

realizează operaţia d6 = d6 + (d4 × d5).

2) Modul de adresare direct cu registru de adresă.

Operandul se găseşte într-unul din cele 27 de registre AGU. Un

exemplu este: addl1a r0,r1 Operanzii se găsesc în registrele AGU r0 şi r1 şi se realizează operaţia

r1 = r1 + (2 × r0).

B. Modul de adresare indirect cu registru

Un registru de adresă este folosit pentru a indica o locaţie de memorie,

locaţie care conţine operandul căutat. Registrul de adresă conţine adresa

efectivă în memorie la care se află operandul. Acest mod de adresare se mai

numeşte şi referinţă la memorie. Termenul index se referă la offsetul care este

reţinut într-un registru, iar termenul deplasament se referă la offsetul imediat

din corpul unei instrucţiuni.

1) Modul de adresare fără actualizare.

Adresa operandului se află într-un registru de adresă al AGU. Conţinutul

acestui registru rămâne acelaşi după efectuarea instrucţiunii. Pentru registrele

de adresă inferiorioare nu se ţine cont de modul de calcul al adresei specificat

în MCTL.

Un exemplu este: bmclr.w #$004F,(r4)


Un cuvânt este citit de la adresa conţinută în r4 (operandul căutat), iar

asupra lui este efectuată o operaţie de resetare a biţilor setaţi în masca

specificată de instrucţiune după care este scris din nou în locaţia din care a

fost citit. La sfârşitul acestor operaţii r4 nu-şi schimbă valoarea.

2) Modul de adresare cu post-incrementare.

După ce adresa operandului este folosită este incrementată

corespunzător cu tipul accesului la memorie (adică cu 1, 2, 4 sau 8) şi

actualizată în acelaşi registru de adresă. Tipul accesului depinde de

dimensiunea operandului care este transferat din memorie de instrucţiunea în

care este specificat acest mod de adresare (1, 2, 4 sau 8 octeţi). Tipul de

calcule după care se actualizează adresa din registrele inferioare este

specificat de conţinutul MCTL.

Un exemplu este: move.f (r3)+,d2

în care cuvântul aflat la adresa din r3 este transferat în registrul d2, după care

la valoarea curentă a lui r3 se adaugă 2.

3) Modul de adresare cu post-decrementare.

Este similar cu modul precedent de adresare, singura diferenţă fiind

faptul că adresa operandului este decrementată corespunzător tipului

operandului la care se face acces.

Un exemplu este move.l (r3)-,d2

în care după transferul unui cuvânt dublu în registrul d2, din valoarea curentă

a adresei conţinute în r3 se scade 4.


4) Modul de adresare cu post-incrementare cu offset.

După ce adresa operandului este folosită, la acesta este adunat

conţinutul registrului de offset ni (care poate fi pozitiv sau negativ) pre-shiftat

corespunzător la stânga cu dimensiunea operandului la care se face acces

(adică cu 0,1, 2 sau 3 octeţi). Rezultatul este memorat în acelaşi registru.

Modul de calcul pentru registrele inferioare de adresă este determinat de

conţinutul lui MCTL. Conţinutul registrului ni rămâne neschimbat.

Un exemplu este: move.b d6,(r5)+n2

în care la r5 este adunat conţinutul lui n2 fără ca acesta să fie shiftat deoarece

în acest caz dimensiunea operandului este de 1 octet.

5) Modul de adresare indexat.

Adresa operandului rezultă din suma dintre registrul de adresă şi

numărul cu semn din registrul offset n0, preshiftat cu 0, 1, 2 sau 3 biţi la

stânga în funcţie de dimensiunea operandului care este accesat. Modul de

calcul pentru registrele inferioare de adresă este determinat de conţinutul lui

MCTL. Conţinutul celor doi registre rămâne neschimbat după efectuarea

instrucţiunii.

Un exemplu este: move.b d6,(r3+n0) Acest mod de adresare nu poate fi folosit decât cu registrul offset n0.

6) Modul de adresare indexat cu un registru adresă.

Acest mod este similar cu cel precedent cu singura diferenţă că în locul

registrului offset n0 este folosit un alt registru de adresă.

Un exemplu este: move.l (r0+r2),d6


în care adresa din r0 este adunată la conţinutul registrului r2 shiftat cu 2 biţi la

stânga. În acest mod de adresare nu se pot utiliza ca index decât registrele

inferioare de adresă.

7) Mod de adresare cu deplasament scurt.

Adresa operandului este suma dintre registrul de adresă şi un

deplasament scurt imediat, care ocupă 3 biţi în corpul instrucţiunii. Acest

deplasament (număr fără semn) trebuie shiftat la stânga corespunzător cu

dimensiunea operandului pentru care se realizează accesul la memorie.

Deplasamentul poate lua valori în intervalul [0, 7]. Conţinutul registrului de

adresă nu este schimbat. Calculul pentru registrele inferioare se realizează în

funcţie de modul de adresare setat în MCTL.

Un exemplu este: move.l d4,(r3+$1C) în care deplasamentul este 7 şi deoarece se accesează un operand pe 4

octeţi acesta trebuie shiftat la stânga cu 2 biţi rezultând 4×7 = 28 = 1Ch.

8) Mod de adresare cu deplasament lung.

Este similar cu modul de adresare precedent, dar în acest caz

deplasamentul este un număr cu semn pe 16 biţi pentru care este necesar încă

un cuvânt la codarea instrucţiunii. Deplasamentul ia valori în intervalul [-

16384, 16383] pentru operanzi reprezentaţi pe un octet, în intervalul [-8192,

8191] pentru operanzi reprezentaţi pe un cuvânt, ş.a.m.d.

9) Mod de adresare cu deplasament scurt pentru SP.

Similar cu cele precedente, doar că se referă la registrul de stivă şi

deplasamentul poate fi un număr fără semn reprezentat pe 5 sau 6 biţi, în

funcţie de tipul de acces la memorie (operand pe 2 sau 4 octeţi).


Un exemplu este: move.l #$FFFF,(sp-$3E)

10) Mod de adresare cu deplasament lung pentru SP.

Similar cu cele prezentate la punctul 8), dar valabil doar pentru

registrul de stivă.

C. Mod de adresare relativ la PC

Este folosit pentru calculul următoarei adrese în zona de memorie

folosită de program în cazul unei instrucţiuni de salt. Prin codarea

instrucţiunii aceasta conţine deplasament cu semn. Adresa operandului este

obţinută prin shiftarea la stânga a deplasamentului şi adunarea rezultatului la

valoarea curentă a PC. Deplasamentul este shiftat deoarece adresele

instrucţiunilor în zonă de memorie a programului sunt aliniate pe cuvinte.

Modul de calcul este întotdeauna liniar. Numărul de biţi ocupat de

deplasament diferă în funcţie de instrucţiunea folosită. Instrucţiunile de salt se

referă la salturi condiţionate sau la accesul subrutinelor. Salturile

necondiţionate nu folosesc acest mod de adresare ci unul din cele prezentate

mai jos.

D. Mod de adresare special

Aceste moduri de adresare nu folosesc un registru de adresă când

specifică o adresă efectivă. În locul acestui registru se foloseşte o valoare

imediată care este inclusă în codul instrucţiunii, sau se foloseşte un registru

care este implicit folosit de instrucţiune.


1) Valoare imediată scurtă.

Un operand reprezentat pe 5, 6 sau 7 biţi face parte din cuvântul de cod

al instrucţiunii. Un operand pe 5 biţi este folosit pentru instrucţiunile

aritmetice ale DALU sau AGU. Un operand pe 6 biţi este folosit de

instrucţiunile DALU care transferă un operand imediat într-un registru LCn.

Un operand pe 7 biţi este folosit pentru transfer imediat într-un registru.

Un exemplu este doen2 #$2

2) Cuvânt imediat.

Acest mod necesită un cuvânt în plus în codarea instrucţiunii în rest

este similar cu precedentul.

3) Valoare imediată lungă.

Acest mod necesită două cuvinte în plus în codarea instrucţiunii în rest

este similar cu punctul 1).

4) Adresă absolută.

Acest mod de adresare necesită un cuvânt în plus pentru codarea

instrucţiunii. Adresa ocupă 16 biţi şi este extinsă cu 0 pentru a forma o adresă

normală de 32 de biţi.

Un exemplu este: move.w ($1),d0

5) Adresă absolută lungă.

Similar cu 4) dar este nevoie de două cuvinte pentru a coda adresa în

corpul instrucţiunii.


6) Adresă absolută pentru salt necondiţionat.

Ca şi pentru modul de adresare precedent este nevoie de o extensie de

două cuvinte pentru codarea instrucţiunii.

Un exemplu este: jmp lbl4

în care la codarea instrucţiunii se foloseşte adresa din program

corespunzătoare etichetei lbl4.

7) Referinţă implicită.

Unele instrucţiuni se referă implicit la unul din următoarele registre:

PC, SR, Registre de stivă sau Registre asociaţi buclelor de program. Folosirea

unuia dintre aceştia este indicată prin instrucţiunea folosită.

Un exemplu este: tfra osp,r2

care transferă valoarea din registrul de stivă care nu este folosit în registrul de

adresă r2.

E. Moduri de adresare specifice procesoarelor de semnal

Adresarea reverse-carry

Adresarea reverse-carry reprezintă un mod de calcul al adresei folositor

pentru implementarea în procesorul de semnal a funcţiilor care realizează FFT

sau IFFT.

• Modificarea adresei se face hardware prin propagarea, în sumator, în

sens invers a bitului de carry (de la MSB către LSB). Actualizarea

adresei prin reverse-carry este echivalentă cu:

• inversarea conţinutului lui rn (inversare pe biţi, adică MSB devine

LSB, MSB-1 devine LSB+1 ş.a.m.d)


• shiftarea lui ni cu 0, 1, 2 sau 3 biţi la stânga corespunzător

dimensiunii operandului accesat

• inversarea lui ni (similar cu rn)

• adunarea celor doi operanzi

• inversarea rezultatului.

Acest mod de adresare poate fi folosit la ordonarea bit-reverse a

eşantioanelor de intrare sau de ieşire în FFT (în funcţie de algoritmul

implementat, cu decimare în timp sau în frecvenţă), sau la adresarea factorilor

de rotaţie. Cu SC140 pot fi realizate FFT în maxim 232 puncte.

Adresarea în buffer circular

Se permite realizarea de bufere circulare, structuri FIFO sau linii de

întârziere. Trebuie configurate mai multe registre, nu este suficientă doar

scrierea biţilor corespunzători în MCTL. Fiecare registru pentru adresa de

bază este asociat cu un registru inferior de adresă.

Configurarea unui registru de adresă, folosit în adresarea în buffer

circular, urmează următorii paşi:

• registrul pentru adresa de bază trebuie încărcat cu adresa de bază

(cea mai mică) a bufferului

• în MCTL trebuie specificat modul de adresare şi care dintre registrii

mj este asociat cu registrul de adresă folosit

• în registrul mj determinat mai devreme se încarcă dimensiunea

bufferului care trebuie realizat

• în rn se încarcă o adresă din interiorul bufferului

Adresele posibile pentru rn vor fi în intervalul [bn, bn+mj-1]. Dacă

valoarea rn creşte peste valoarea bn+mj-1 din aceasta va fi scăzut astfel încât

valoarea adresei să revină în interiorul limitelor specificate. Din acest motiv


se mai numeşte şi adresare modulo, numărul care specifică valoarea faţă de

care se fac operaţiile de adunare modulo este mj (Figura de mai jos).

7.2.3 Unitatea de control a programului

Deoarece SC140 este o structură cu mai multe ALU, se pot trimite până

la 6 instrucţiuni la 6 unităţi de execuţie în acelaşi timp. Când două sau mai

multe instrucţiuni sunt trimise simultan spre execuţie în acelaşi ciclu-maşină

se spune că ele sunt grupate. Compilatorul C sau asamblorul pot specifica în

codul sursă care instrucţiuni sunt grupate. Fiecare grup de instrucţiuni trimis

spre execuţie într-un ciclu-maşină se numeşte set de execuţie. Fiecare 8

cuvinte citite din zona de memorie de program şi asociate cu o adresă sunt

numite set de fetch.

Structura pipe-line

Pentru SC140 structura pipe-line constă în 5 etaje:

• pre-fetch

• fetch

• decodare

• generarea adreselor

• execuţie


Primele 3 etaje sunt implementate sub forma unui circuit numit PSEQ

(Program Sequencer unit). Ultimele două etaje sunt implementate în AGU şi

DALU.

Primele 2 etaje sunt responsabile cu citirile din memoria de program a

setului de fetch. În etapa de pre-fetch adresa acestui set este pusă pe bus-ul

PAB, şi în timp ce este citit setul de fetch, counter-ul de fetch din PSEQ este

actualizat pentru următoarea citire din memorie. Aceste operaţii se execută în

paralel.

Adresa de citire poate fi generată de către PSEQ pentru:

• execuţia normală a programului

• execuţia unei excepţii

• buclă hardware

• instrucţiuni de salt.

Etapa de fetch este dedicată aşteptării realizării accesului la memorie.

Acesta este complet când PSEQ eşantionează valoarea citită din memorie pe

cei 128 de biţi ai PDB (8 cuvinte adică un set de fetch). Un set de execuţie se

poate întinde pe mai multe seturi de fetch, mai multe astfel de seturi sunt

reţinute într-un buffer, deoarece tot setul de execuţie trebuie decodat odată.

După citirea setului de fetch, PSEQ detectează care instrucţiuni sunt

grupate împreună şi vor fi decodate în paralel astfel încât numărul de cicli

maşină cerut de cea mai lungă instrucţiune va determina numărul de cicli

maşină necesar pentru execuţia întregului set. Decodarea constă în

determinarea tipului de instrucţiuni (dacă sunt instrucţiuni DALU sau AGU)

şi trimiterea acestora către unităţile de execuţie corespunzătoare.

Etapa generării de adrese este implementată în AGU şi DALU. În

DALU această etapă include decodarea instrucţiunilor specifice. În AGU

această etapă include actualizarea registrelor de adresă precum şi realizarea


accesului propriu zis la memorie. Aici se calculează şi adresele necesare

pentru instrucţiunile de salt folosite mai departe de PSEQ.

În etapa execuţiei se realizează calculele cerute în DALU. Dacă este

executată o instrucţiune de salt, SC140 trebuie să aştepte reumplerea structurii

pipe-line, începând cu un nou pre-fetch din memorie. Ciclii maşină pierduţi în

timpul acestei aşteptări se numesc slot-uri de întârziere. Deoarece este

posibilă utilizarea acestora pentru a permite continuarea execuţiei

instrucţiunilor care se găsesc deja în structura pipe-line au fost prevăzute

instrucţiuni speciale de salt întârziat. Acestea folosesc o parte sau toate

sloturile de întârziere pentru execuţia unui set adiţional de execuţie.

Pe lângă structura pipe-line mai există şi alte instrucţiuni de control al

programului:

• execuţia condiţionată a unui set de execuţie

• instrucţiuni pentru forţarea intrării chipului în starea de excepţie

• instrucţiuni pentru forţarea intrării chipului în starea de debug.

Execuţia condiţionată este controlată de starea bitului T din cadrul SR.

Folosirea acestor instrucţiuni permite execuţia condiţională a unui întreg set

de execuţie sau execuţia condiţională a unor subseturi ale acestuia. Anumite

restricţii se aplică acestor subseturi în ceea ce priveşte numărul şi lungimea

instrucţiunilor componente.

Execuţia buclelor hardware

Una din cele mai importante caracteristici ale unui algoritm de

procesare de semnal este execuţia eficientă a buclelor de program. SC140 are

un mecanism optimizat de buclare care permite până la 4 nivele de imbricare

a buclelor. Acest mecanism este o parte a PSEQ, şi modelul de programare

este următorul:


SA0 LC0 SA1 LC1 SA2 LC2 SA3 LC3

Fiecare pereche de registre este asociată unei bucle, regitrul SAn (Start

Address) conţine adresa de start a buclei, dată de o etichetă, iar LCn (Loop

Counter) conţine numărul de repetări ale buclei.

În SR există 5 fanioane asociate cu execuţia buclelor după cum

urmează:

• SLF (Short Loop Flag) este un bit setat când bucla este inţializată ca

o buclă scurtă şi resetat la terminarea acesteia

• LF0, LF1, LF2, LF3 sunt biţi care sunt setaţi de fiecare dată când

bucla corespunzătoare este inţializată şi resetaţi la terminarea buclei

corespunzătoare.

Pentru buclele care se pot realiza în SC140 există următoarea

terminologie:

• corpul buclei reprezintă seturile de execuţie care sunt parcurse în

timpul execuţiei buclei

• buclă lungă este o buclă al cărei corp constă în trei sau mai multe

seturi de execuţie

• buclă scurtă este o bulcă al cărei corp constă din unul sau două

seturi de execuţie

• adresa de start este adresa primului set de execuţie din corpul buclei.

Adresa de start este definită de o instrucţiune de tipul dosetupn care

indică o etichetă, şi de directiva de asamblare loopstartn. Aceste

două definiţii trebuie să fie consistente.


• ultima adresă este adresa ultimului set de execuţie din corpul

funcţiei. Aceasta este definită de instrucţiunea loopendn. În cazul

unei bucle scurte cu o singur instrucţiune aceasta coincide cu adresa

de start

LPMARKA şi LPMARKB sunt doi biţi marker în cuvântul prefix care

identifică diferitele condiţii de buclare. Aceşti biţi sunt completaţi de

assembler şi nu sunt accesibili user-ului.

Pentru iniţializarea şi execuţia unei bucle hardware sunt necesari

următorii paşi:

• executarea unei instrucţiuni dosetupn în decursul programului

înaintea primului set de execuţie din cadrul buclei

• executarea unei instructiuni doenn sau doenshn pentru încărcarea

counterului corespunzător cu valoarea care arată de câte ori este

repetată bucla. Flag-ul corespunzător din SR precum şi SLF (după

caz) sunt setate în acest moment.

În cazul unei bucle scurte, instrucţiunile sunt reţinute în bufferele

interne şi astfel nu este nevoie de fetch pentru buclele scurte. Buclele se pot

realiza una în alta cu singura restricţie că într-o buclă nu pot fi executate decât

buclele cu numere mai mari decât a celei curente. În bucla 2 nu poate fi

executată decât bucla 3. O singura buclă poate fi activă la un moment dat şi

aceasta este cea cu numărul mai mare dintre toate cele pentru care flag-ul

aferent acesteia este setat.

Există de asemenea instrucţiuni de întrerupere care provoacă încheierea

prematură a unei bucle, sau de salt la sfârşitul unei iteraţii a buclei.

Adresa de start trebuie să fie aliniată în zona de memorie a

programului, în caz contrar un ciclu de întârziere va fi adăugat la execuţia

buclei pentru fiecare parcurgere a acesteia. Pentru alinierea adresei de start se

poate folosi directiva falign.


7.3 PREZENTAREA MEDIULUI DE DEZVOLTARE A

PROGRAMULUI. CODEWARRIOR

Pentru realizarea programului care simulează modul de funcţionare şi

implementarea pe procesorul de semnal StarCore SC140 se poate utiliza

mediul de dezvoltare al firmei Metrowerks, numit CodeWarior. Acest mediu

de dezvoltare integrează toate programele necesare pentru elaborarea

aplicaţiei: compilator, asamblor, linker şi în cele din urmă simulator.

Una din caracteristicile principale este abilitatea de a folosi programe

scrise în C ca sursă pentru obţinerea codului în asamblare. În figura de mai jos

este prezentată interfaţa programului când avem deschis un anumit proiect.

Figura 7-9 Interfaţa mediului de dezvoltare CodeWarrior


La deschiderea unui anumit proiect, mediul de dezvoltare CodeWarrior

prezintă o fereastră principală unde putem vedea numele proiectului, precum

şi fişierele incluse în acesta, după cum se poate observa în jumătatea stângă

din figura de mai sus.

Jumătatea din dreapta figurii 7.10 prezintă două ferestre în care pe de o

parte putem vedea codul scris în fiecare din fişierele sursă (partea de sus a

figurii), iar pe de altă parte putem fi informaţi cu privire la diversele erori,

warning-uri sau remarci din partea mediului de dezvoltare după lansarea

procedurii de compilare a proiectului (partea de jos a figurii).

Pe lângă aceste ferestre amintite mai sus mediul de dezvoltare

Codewarrior prezintă şi alte ferestre cum ar fi cea aferentă procedurii de

depanare a proiectului sau fereastra de afişare a diferitelor rezultate, aşa cum

se prezintă în figurile de mai jos.

Figura 7-10 Fereasta pentru depanare proiect


Figura 7-11 Fereastra pentru afişarea de rezultate

Mediul de dezvoltare de aplicaţii pentru procesoarele de semnal SC140,

CodeWarrior, prezintă mai multe facilităţi. Cea mai importantă dintre ele este

aceea potrivit căreia există posibilitatea de a scrie cod de program nu numai în

instrucţiunile de asamblare specifice procesorului utilizat ci şi în format C.

Graţie compilatorului programele scrise în limbajul C sunt convertite în

instrucţiuni de asamblare care pot rula pe procesor.

O scriere a codului fişierelor sursă în limbaj C presupune o muncă mai

puţină din partea unui programator, însă resursele procesorului nu vor mai fi

folosite cu eficienţă maximă.

Pentru rezolvarea compromisului dintre facilitatea de a scrie cod în

limbaj C şi folosirea eficientă a resurselor procesorului de semnal putem să ne

folosim de facilităţile de optimizare oferite de mediul de dezvoltare sau de

tehnici speciale de optimizare în C.

Figura 7.12 prezintă fereastra aferentă setărilor simulatorului

CodeWarrior, mai exact secţiunea nivelelor de optimizare disponibile.

Compilatorul oferă mai multe nivele de optimizarea şi anume:

• Level 0, cel mai simplu nivel de optimizare,când prectic nu este

activat nici un element pentru optimizare;

• Level 1, un nivel de otimizare mai ridicat, care nu prezintă însă şi

optimizări de tip “schedulling”, “pipelining” şi “bundling”;


• Level 2, un nivel de optimizare similar celui anterior, care însă

presupune prezenţa şi celorlate tipuri de optimizări (“schedulling”,

“pipelining” şi “bundling”);

• Level 3, presupune o optimizare şi mai eficientă deoarece la

elementele specifice nivelului 2 se mai adaugă şi o alocare globală a

registrelor;

• Level 3 + Space, reprezintă un nivel de optimizare similar celui

anterior, cu deosebirea că se mai adaugă şi optimizarea privind

spaţiul ocupat de program în momoria procesorului de semnal.

Figura 7-12 Nivelele de optimizare oferite de mediul CodeWarrior

Mediul de dezvoltare Code Warrior presupune prezenţa mai multor

nivele de optimizare, începând de la cel mai simplu – care nu face nici o


optimizare, până la cele cu opţiuni mai complexe în care se ţine cont atât de

cerinţele viteză cât şi de cele de spaţiu ocupat de program. Se oferă o opţiune

de optimizare globală, pentru proiectele extinse care conţin mai multe fişiere

sursă, prin aceasta realizându-se o optimizare a întregii aplicaţii şi nu o serie

de optimizări ale fişierelor componente. Dacă alegerea nivelului de optimizare

este una dintre importantele facilităţi ale programului CodeWarrior,

posibilitatea de vizualizare a stării registrelor şi a memoriei reprezintă o altă

importantă facilitate oferită celor care dezvoltă aplicaţii.

În figura 7.13 este prezentată starea registrelor de uz general aferente

procesorului de semnal SC140.

Figura 7-13 Vizualizarea stării registrelor procesorului de semnal


Posibilitatea de a vizualiza starea acestor registre este bine venită în

procedurile pentru depanarea proiectelor în lucru, şi ajută programatorul în

identificarea mai rapidă a diverselor erori de proiectare.

7.4 TEHNICI DE OPTIMIZARE ÎN C PENTRU PROCESORUL

DE SEMNAL SC140

Una dintre cele mai mari provocări în procesul de dezvoltare a unei

aplicaţii pentru procesoarele de semnal o constituie încadrarea timpului de

execuţie a programului într-un interval bine stabilit. La această cerinţă se

adaugă şi aceia ca memoria de program ocupată de aplicaţie să se încadreze la

rândul ei în limitele oferite de procesorul de semnal.

Cele două aspecte menţionate mai sus reprezintă o motivaţie importantă

în vederea luării în considerare a necesităţii de găsire de metode de optimizare

a programelor sub ambele aspecte, atât din punct de vedere al timpilor de

execuţie dar şi a memoriei de program ocupate de aplicaţie.

Implementarea unor proceduri de optimizare de cod presupune pe lângă

cele două aspecte prezentate şi obţinerea altor rezultate importante în ceea ce

priveşte utilizarea eficientă a procesorului, cum ar fi:

• reducerea structurilor de date utilizate în aplicaţia dezvoltată pe

procesorul de semnal

• reducerea mărimii memoriei ocupate în stivă

• reducerea puterii electrice consumate, ceea ce implică pe de o parte

o autonomie mai mare de lucru pentru echipamentele mobile, iar pe

de altă parte şi o durată de viaţă mai mare a sistemului electronic

proiectat.


Limbajul C nu poate produce un cod în asamblare suficient de optim,

de fapt care să utilizeze la maximum resursele procesorului, deoarece limbajul

C nu posedă o suprapunere perfectă cu trăsăturile unui procesor de semnal.

Astfel spre deosebire de caracteristicile procesorului de semnal

StarCore SC140, în limbajul C nu avem prezente următoarele elemente:

• lucrul în virgulă fixă;

• nu este prezent suportul pentru arhitecturi duale de memorie;

• nu sunt prezente porturi speciale de intrare/ieşire, şi nici instrucţiuni

specializate;

• nu este prezent suportul pentru instrucţiuni de tipul SIMD (Single

Instruction Multiple Data).

Poate fi făcut ca limbajul C să fie eficient pentru un procesor de

semnal? Răspunsul la această întrebare este afirmativ, însă în condiţiile în

care programatorul, cel care dezvoltă aplicaţii pentru procesoarele de semnal,

înţelege şi stăpâneşte următoarele aspecte:

• extensiile compilatorului

• tehnicile de programare

• comportamentul compilatorului.

În cele ce urmează vom prezenta acele elemente de optimizare comune

unei clase suficient de largi de procesoarelor de semnal.

Funcţiile Intrinseci.

Sunt funcţii specifice prin care se realizează o extindere a operatorilor

din C. Această categorie de funcţii presupune definirea unor mulţimi de noi

tipuri de date (de exemplu precizie simplă, dublă şi extinsă pentru numere


fracţionale). Utilizarea acestor funţii intrinseci asigură emularea programelor

şi pe alte platforme.

Utilizarea Pragmelor.

Prin pragma se înţelege un mod standard de comunicare cu un

compilator. Aceasta descrie nu numai caracteristicile codului scris în limbaj C

dar şi a datelor utilizate. Utilizarea pragmelor nu afectează cu nimic valoarea

rezultatelor, dar influenţează într-o măsură deosebit de importantă

performanţele programului, prin eficientizarea lui.

Asamblarea in linie.

Presupune tehnica prin care în interiorul codului scris în limbaj C se pot

introduce directive de asamblare, instrucţiuni de asamblare. Acest lucru se

poate realiza fie sub forma unei singure instrucţiuni în limbaj de asamblare,

fie sub forma unei întregi funcţii. Utilizarea directivelor de asamblare

presupune faptul că avem un acces special la unele caracteristici ale

procesorului, imposibil de utilizat în cazul folosirii funcţiilor intrinseci.

Elementele de optimizare prezentate mai sus se caracterizează prin

faptul că presupun introducerea unor linii de program de altă natură decât a

celor deja existente în cadrul codului sursă.

În cele ce urmează vom prezenta acele tehnici de optimizare care se

folosesc de codul existent, fără a introducere elemente suplimentare de altă

natură decât a celor deja existente.

Astfel avem următoarele tehnici de optimizare în C specifice

procesoarelor de semnal de uz general:

• loop merging;

• loop unrolling;


Loop Merging.

Această tehnică presupune combinarea a două bucle într-una singură în

cazul în care cele două bucle sunt caracterizate de acelaşi număr de iteraţii.

Utilizarea acestei tehnici poate conduce la diminuarea timpului necesar

executării celor două bucle. Mai mult decât atât presupune o creştere a

eficienţei în ceea ce priveşte utilizarea cache-ului. Ca rezultat final, folosirea

tehnici de optimizare loop merging reduce mărimea codului aferent

programului scris în limbajul C. Figura 5.1 prezintă un exemplu de tehnică de

optimizare loop merging.

Figura 7-14 Exemplu de tehnică de optimizare loop merging

Loop Unrolling.

Este o tehnică de optimizare în C care presupune repetarea corpului

unei bucle în vederea asigurării premizelor necesare unei rulări în paralel a

mai multor instrucţiuni, în cadrul unui aceluiaşi ciclu instrucţiune. Este ştiut

faptul că în cazul procesoarelor de semnal sunt prezente blocuri specifice care

pot lucra în paralel, fiind astfel posibil realizarea, de exemplu, a două


transferuri sau a patru instrucţiuni de calcul în paralel pe durata unui singur

ciclu instrucţiune.

Figura 7-15 Exemplu de tehnică de optimizare loop unrolling

Din figura 5.2, datorită faptului că am repetat o linie de program, reiese

faptul că programul nostru va ocupa mai mult în memoria de program a

procesorului. Cu toate acestea, datorită directivelor de aliniere a datelor, prin

utilizarea acestei tehnici vom obţine un timp de execuţie mai mic decât în

cazul în care aceasta nu ar fi folosită.

În cele ce urmează se vor prezenta două tehnici de optimizare în C

specifice arhitecturii familiei de procesoare de semnal StarCore. Este vorba de

următoarele tehnici de optimizare:

• split computation;

• multisample.

SplitComputation reprezintă o tehnică de optimizare în C utilizată în

aplicaţii care împlică calculul energiei şi erorii pătrate medii, sau în situaţii în

care se doreşte determinarea unui maxim.


Figura 7-16 Exemplu de tehnică de optimizare split computation

Folosirea acestei tehnici de optimizare conduce la creşterea eficienţei,

în ceea ce priveşte utilizarea unităţii de calcul aritmetico-logice, DALU. Split

computation generează un cod care ocupă o zonă de memorie mai mare, însă

utilizată împreună cu directivele de aliniere a datelor, determină o

îmbunătăţire semnificativă în ceea ce priveşte timpul de execuţie.

Multisample reprezintă ultima tehnică de optimizare în C din cele

prezentate în acest paragraf. Domeniul de aplicabilitate al acestei tehnici de

optimizare este reprezentat de situaţiile în care o buclă operează în interiorul

alteia. Această tehnică de optimizare în limbajul C este una destul de

complexă, deoarece presupune o combinaţie între tehnicile de optimizare deja

prezentate mai sus:

• loop unroling pentru bucla exterioară;

• loop merging pentru bucla din interior;

• loop unroling pentru bucla din interior la care s-a aplicat tehnica

anterioară.


Figura 7-17 Exemplu de tehnică de optimizare multisample

În urma aplicării acestei tehnici atât bucla cu numărul 1, cât şi bucla cu

numărul 2 se vor executa într-un singur ciclu instrucţiune, fiind posibilă

execuţia simultană a 4 operaţii de tip înmulţire cu acumulare, mac şi a două

operaţii de tip transfer, mov.

Această tehnică de optimizare mai este caracterizată şi de alte

trăsături. Este vorba în primul rând de faptul că utilizarea acestei metode nu

impune restricţii privind alinierea datelor. A doua caracteristică, evidenţiază

faptul că tehnica multisample, reduce numărul operaţiilor de transfer utilizate.

Limbajul C, prin tehnicile amintite, poate fi transformat într-un limbaj

C pentru procesoarele de semnal, adică un C care presupune o utilizare la

maxim a resurselor procesorului, în vederea obţinerii de performanţe maxime

în ceea ce priveşte dimensiunea codului din memoria de program şi mai ales

în ceea ce priveşte timpul de execuţie.

Introducere în arhitectura SC140Procesorul de semnal StarCore 140, produs al firmei Freescale, prezintă un nou tip de arhitectură, cu un plus de putere de calcul.

SC140 poate fi implementat pe o gamă largă de configuraţii SOC (System On Chip).

Pe un singur chip pot fi integrate, în funcţie de necesităţi, zone de memorie suplimentare, dar şi o gamă variată de porturi de I/O saualte periferice.

Schema bloc a unui sistem cu SC140

Level-1 Memory Expansion Area

Unified Data and Program MemoryROM, RAM

DSP Engine

True 16-bit instruction set

Star*Core 140 DSP Core

System

External Memory

DMA

CACHE

Peripheral and Accelerators Expansion AreaStandard Input/Output PeripheralsApplication Specific AcceleratorsGeneral Purpose Programmable Accelerator

4 Arithmetic

Expansion Area

Interface

Interrupt Ctrl.

Variable Length Execution Set (VLESTM) Model

Level-2 Memory Expansion

2 AddressArithmetic Units& Logic Units

Caracteristici ale SC140• frecvenţa de ceas a nucleului este 300 MHz la 1,5V şi 120 MHz la 0,9V;• până la 1200 Milioane operaţii MAC pe secundă (1.2 GMACS);• până la 3000 RISC MIPS (MAC se consideră ca 2 instrucţiuni RISC);

• 4 unităţi aritmetico-logice (ALU – Arithmetic Logic Unit) care includ circuitededicate de înmulţire şi adunare şi unităţi de operare pe bit;• circuitele MAC (Multiply and ACcumulate) din fiecare ALU, operează pe 40 biţi(16b � 16b + 40b);

• fiecare ALU conţine un shifter (structură de deplasare) pe 40 biţi;

• 16 Registre pe 40 biţi pentru operaţii cu numere întregi şi fracţionare;

• Moduri de adresare specifice procesoarelor de semnal;

• 16 Registre de adresă pe 32 biţi, dintre care 8 pot fi folosite ca adrese de bază;

• 4 Registre de offset pentru adrese şi 4 Registre pentru adresare circulară;

• 2 unităţi de adresare cu operaţii aritmetice cu numere întregi;

Oneinstruction

Set de instrucţiuni ortogonal cu instrucţiuni codate pe 16 biţi;

Model de executie Variable Length Execution Set (VLES)•Up to 6 instructions (8 words) can be executed in a single clock cycle.•Very rich 16-bit wide Orthogonal Instruction Set.

Zero overhead Hardware Loops with nesting of up to four loops.

Caracteristici ale SC140

Four instructions Six instructions • • •• • •

Schema Bloc a Nucleului

Instruction Bus

32 128 PAB

PDB

XA

BA

XD

BB

XD

BA

XA

BB

Secvenţiator de Program

Setul de registre pentru Generarea Adreselor

Registre ALU pentru date

2 AAU BMU 4 ALU

OnCE

Controlul Puterii

Generatorul de ceas

PLL

32 32 64 64 128

128

Spaţiul unificat de memorie pentru date şi program

24

Accelerator pentru setul de

instrucţiuni

StarCore 140

Reprezentarea datelor în precizie simplă:1 word = 16 biţi

-215 214 213

• • •

14 1315

21 20

1 0

Most Positive Integer215 - 1 = $7FFF

Most Negative Integer- 215 = $8000

• BinaryPoint

SIGN

Intregi cu semn:


Intregi făra semn:

215 214 213

• • •

14 1315

21 20

1 0

Largest Unsigned Integer216 - 1 = $FFFF

Smallest Unsigned Integer0 = $0000

•


Numere fracţionare cu semn:

-20 2-1 2-2

• • •

14 1315

2-14 2-15

1 0Bit

Number

Largest Signed Fraction1 - 2-15 = $7FFF

Most Negative Fraction-1 = $8000

•

RadixPoint Fraction

SIGN

Interpretarea valorilor operanzilor pe 16-biţi

The following equation shows the relationship between a 16-bit integer and a fractional value:

Fractional Value = Integer Value / (215)

BinaryRepresentation

HexadecimalRepresentation

Integer Value(Decimal)

FractionalValue (Decimal)

0.100 0000 0000 0000 0x4000 16384 0.50.010 0000 0000 0000 0x2000 8192 0.250.001 0000 0000 0000 0x1000 4096 0.1250.000 0000 0000 0000 0x0000 0 0.01.100 0000 0000 0000 0xC000 -16384 -0.51.110 0000 0000 0000 0xE000 -8192 -0.251.111 0000 0000 0000 0xF000 -4096 -0.125

Reprezentarea datelor în precizie dublă:format long = 32 biţi

Numere întregi cu semn:

-231 230 229

• • •

30 2931

21 20

1 0

Most Positive Integer231-1 = $7FFFFFFF

Most Negative Integer- 231 = $80000000

•

SIGN


Numere întregi fără semn:

231 230 229

• • •

30 2931

21 20

1 0

Largest Unsigned Integer232 -1 = $FFFFFFFF

Smallest Unsigned Integer0 = $00000000

•


Numere fracţionare cu semn:

-20 2-1 2-2

• • •

30 2931

2-30 2-31

1 0Bit

Number

Largest Signed Fraction1 - 2-31 = $7FFFFFFF

Most Negative Fraction-1 = $80000000

•

RadixPoint Fraction

SIGN

Arhitectura ALU de date

Memory data bus 1 (XDBA)Memory data bus 2 (XDBB)

64 64

40 4040 40

64 64

Data Register File

ALU ALU ALUALU

Shifter/Limiter

40 40

40 4040 40

L0 D0.e D0.h D0.lL1 D1.e D1.h D1.lL2 D2.e D2.h D2.lL3 D3.e D3.h D3.lL4 D4.e D4.h D4.lL5 D5.e D5.h D5.lL6 D6.e D6.h D6.lL7 D7.e D7.h D7.lL8 D8.e D8.h D8.lL9 D9.e D9.h D9.lL10 D10.e D10.h D10.lL11 D11.e D11.h D11.lL12 D12.e D12.h D12.lL13 D13.e D13.h D13.lL14 D14.e D14.h D14.lL15 D15.e D15.h D15.l

Modelul de programare Data ALU

39 32 16 15 0

Reprezentarea în registrele de date:d0 – d15 (40 biţi)

Numere întregi cu semn:

-239

• • •

38 3239

21 20

1 0

Most Positive Integer239 -1 = $7FFFFFFFFF

Most Negative Integer-239 = $8000000000

•

SIGN

• • •

31

231238

Reprezentarea în registrele de date:d0 – d15 (40 biţi)

Numere raţionale cu semn:

-28 2-1

• • •

38 3239

2-30 2-31

1 0Bit

Number

Largest Value256 - 2-31 = $7FFFFFFFFF

Most Negative Value-256 = $8000000000

•

RadixPoint Fraction

SIGN

• • •

31

2027

Integer

Reprezentarea în registrele de date:d0 – d15 (40 biţi). Exemple.

Decimal Fraction 40-Bit Binary Value

Hexadecimal Representation

12.5 000001100.1000000 • • • 0000 $06400000001.5 000000001.1000000 • • • 0000 $00C00000000.5 000000000.1000000 • • • 0000 $0040000000-0.5 111111111.1000000 • • • 0000 $FFC0000000-1.5 111111110.1000000 • • • 0000 $FF40000000-12.5 111110011.1000000 • • • 0000 $F9C0000000

Transferul operanzilor pe 16 biţi în registrele de date

Reprezentarea numerelor fracţionare cu semn

Reprezentarea numerelor întregi cu semn

Operand pe 16 biţi în memorie

Reprezentarea pe 40 de biţi (D0 – D15)

Operand pe 16 biţi în memorie

Reprezentarea pe 40 de biţi (D0 – D15)

MOVE.F (R0),D0

MOVE.W (R0),D0

1 0...0 0 0 . . . 0 0

150 1 1 ... 1 11 0 0 ... 0 0

1 0 0 ... 0 0

Aritmetica cu saturare

Făra limitare:

Dx = +1.0

= -1.0

|Error| = 2.0

0...0 0 0 . . . 0 015 01632

Dx.h

31

= +0.9999999

|Error| = 0.0000001

Cu limitare:

15 0

Dx.lDx.e

391 0 0 ... 0 0 Dx = +1.0

15 01632

Dx.h

31

0

Dx.lDx.e

39

Lx1Lx

MOVE.F D0,(R0) MOVES.F D0,(R0)

Unitatea de Generare a Adreselor (AGU)

Modelul de Programare AGU031

ADDRESS REGISTERS

R0

R2R3

R1

R4R5R6R7

SP (NSP, ESP)

MODIFIER and MODIFIER CONTROL REGISTERS

031M0M1M2

MCTLM3

ADDRESS REGISTERS / BASE ADDRESS REGISTERS

031R8 / B0

R10 / B2R11 / B3

R9 / B1

R12 / B4R13 / B5R14 / B6R15 / B7

N0N1

031

N2N3

OFFSET REGISTERS

Transferul pe magistralele de date

• Two data memory buses are used for all data transfers between the core and memory.•32-bit data memory address bus A (XABA) and 64-bit data memory data bus A (XDBA) •32-bit data memory address bus B (XABB) and 64-bit data memory data bus B (XDBB)

• Data are byte-addressable by the two data memory buses.

Unified Data / Program

Memory

XABA

XDBA

XABB

XDBB

32

64

64

32

Core

Transferul pe magistralele de date

• Four data width accesses are supported: byte (8 bits), word (16 bits), long word (32 bits), and double-long word or four-word (64 bits).

$0 MOVE.B ($4),D0

$10 MOVE.W ($16),D0

$18 MOVE.2W (R0),D0:D1 ;R0=$18

$20 MOVE.4W (R0),D0:D1:D2:D3 ;R0 =$20

$30 MOVE.L ($30),D0

$38 MOVE.2L (R0),D0:D1 ;R0 = $38

Interfaţa memorie - nucleu

Unitatea de control a execuţiei programului

PC

LC3LC2LC1LC0

SA3SA2SA1SA0

EMRSR

PROGRAM COUNTER

LOOP COUNTER REGISTERSSTART ADDRESS REGISTERS

STATUS REGISTER EXCEPTION AND MODE REGISTER

31 0

31 0 31 0

31 0 31 0

Status Register

31 30-27 26-24 23-21 20 19 18 17-12 11-8 7 6 5 4 3 2 1 0SLF LF[3:0] Rsvd I[2:0] OVE DI EXP Rsvd VF[3:0] Rsvd S S1 S0 RM AS T C

SLF - Short Loop FlagLF[3:0] - Loop Flags

I[2:0] - Interrupt MaskOVE - Overflow Exception Enable

DI - Disable InterruptsEXP - Exception Mode bit

VF[3:0] - Viterbi FlagsS - Scaling Bit

S1, S0 - Scaling Mode BitsRM - Rounding Mode

AS -Arithmetic Saturation ModeT - True Bit

C - Carry Bit*Rsvd - Reserved (derivative dependant)

Exception and Mode Register

31-24 23-17 16 15-4 3 2 1 0Reserved GP[6:0] BEM Reserved NMID DOVF ILST ILN

GP - General Purpose FlagsBEM - Big Endian Memory

NMID - NMI DisableDOVF - DALU overflow

ILST - Illegal Execution SetILN - Illegal Instruction

Execuţia PipelinePROGRAMPRE-FETCH

PROGRAMFETCH

DISPATCH& DECODE

ADDRESSGENERATION

EXECUTE

- Short, efficient pipeline

- No arithmetic interlocks

- Short change of flow

- Consistent pipeline

Etapele PipelineMagistrala de instrucţiuni

• A 128-bit Program Data Bus (PDB) and a 32-bit Program Address bus (PAB) areused to carry program words from memory to the core.

• A fetch set, an eight-word instruction set, is fetched from memory every clock cycle. • The Program Sequence Controller Unit (PSEQ) in the core automatically detects

that a portion of the fetch set, called an execution set, can be executed in parallel.

32 128PAB PDB

Unified Data/Program Memory

Core

128-bit Fetch Set

Eight-word Fetch Set32-bit Address

Fetch Set and Execution Set

Instr#N

Instr#N+1

Instr#N+2

Instr#N+3

Instr#N+4

Instr#N+5

Instr#N+6

Instr#N+7

Instr#N

Instr#N+1

Instr#N+2

Instr#N+3

Instr#N+4

Instr#N+5

Instr#N+6

Instr#N+7

Variable Length Execution Set - VLES

Instruction Fetch Set (8 words)

Program Memory Data Bus - PDB

End of VLES #M-17 words

VLES #M4 words

Start of VLES #M+18 words

Exemple de seturi de execuţie

Long Loop:dosetup0 _ start0doen0 #$10move.w (r3)+,d1skipls _end0loopstart0

SA _start0mac d0,d1,d2 move.w (r0)+,d0add d5,d6,d4 move.w (r1)+,d5sub d3,d2,d4 inc d5 LPMARKBmac d0,d1,d6 move.w (r0)+,d7

LA sub d5,d4,d4 inc d7loopend0

_end0

Loop Examples Loop ExamplesShort Loop, two execution sets:

doensh0 #$10...loopstart0

SA mac d0,d1,d2 move.w (r0)+,d0 LPMARKBLA add d5,d6,d4 move.w (r1)+,d5

loopend0

Short Loop, one execution set:

doensh0 #$10...loopstart0

SA, LA mac d0,d1,d2 move.w (r0)+,d0 LPMARKAloopend0

CONT LBL

Iteration and Termination of Loops (1 of 2)

LBL LBL

LC > 1 LC ≤ 1

SA

Jumps to SA and decrements LC Jumps to LBL and clears active LF and LC.

.

.

.

.

CONT LBL

.

.

.

.

loostart0

loopend0

loostart0

loopend0

Iteration and Termination of Loops (2 of 2)

LBL

Jumps to LBL and clears the active LF.

BREAK LBL

loopstart0

loopend0

Looping Restrictions

Loop nesting:

• Nested loops can’t end in the same last address.• Loops must be nested in a specific order: a loop can be nested only inside a loop with a smaller number.

Loop 0

Loop2

Loop3

Stack Support (1 of 4)Normal mode stack:

Exception mode stack:

Increasingaddresses

ESP

Shadow ESPShadow ESPShadow ESP

Last stacked value - 8 bytes

Last stacked value - 8 bytes

Increasingaddresses

NSP

ShadowShadowShadow NSPNSPNSP1Valid bit

1Valid bit

Stack Support (2 of 4)

Increasingaddresses

SP

DeIncreasingaddresses

SP

PUSH De

De → (SP)SP + 8 → SP

Do

PUSH Do

Do → (SP+4)SP + 8 → SP


Increasingaddresses

SP

DeIncreasingaddressesSP

POP De

(SP - 8) → DeSP-8 → SP

Do

POP Do

(SP - 4) → DoSP-8 → SP


• Special Push and Pop instructions that access the normal stack regardless of mode- Allows the OS to use the normal stack in the “exception” mode

PUSHN DePUSHN Do

• Transfer instruction to move to or from the “OSP” (Other Stack Pointer)- Allows the stack pointers to be written

TFRA R0,OSP ; If current SP is ESP, then OSP will be NSP

Fast Return from Subroutine

PC (return address) and SRSP

PC (return address)RAS

Active Stack

SP

XXXX..……….XXXRAS

Active Stack

Jump to Subroutine:Before: After:

Return from Subroutine (RTS):

PC (return address) and SRSP

PC (return address)RAS

Active Stack

SP decrements by 8 bytes

RAS value is put into PCRAS becomes invalid

0 1

0

Valid bitValid bit

Valid bit

Uneltele de dezvoltare software

• Pentru realizarea de programe pe SC140 există un compilator C capabil să convertească codul din C în limbaj de asamblare optimizat.

• Într-un proiect pot fi incluse funcţii scrise în C şi programe (optimizate) scrise în limbaj de asamblare

• Pentru operaţiile cu numere fracţionare sunt introduse tipuri noi de date si funcţii intrinseci care emulează aritmetica în virgulă fixă.

Date fracţionare Tip echivalent în CWord16 shortWord32 long/int

• Iniţializarea variabilelor cu valori de tip fracţionar se face cu macrourile WORD16() sau WORD32(). De exemplu:

Word16 x = WORD16(0.5)iniţializează variabila x cu valoarea hexa 0x4000

• Funcţiile intrinseci diferenţiază operaţiile cu întregi de operaţiile cu numere fracţionare:

• Funcţiile intrinseci şi tipurile de date asociate numerelor fracţionare sunt declarate în fişierul prototype.h

Word16 mult(Word16 var1, Word16 var2);mult

Word16 max(Word16 var1, Word16 var2);max

Word16 mac_r(Word32 L_var3,Word16 var1, Word16 var2);mac_r

Word32 L_msu(Word32 L_var3, Word16 var1, Word16 var2);L_msu

Word32 L_mac(Word32 L_var3, Word16 var1, Word16 var2);L_mac

Word16 extract_l(Word32 L_var1); extract_l

Word16 extract_h(Word32 L_var1); extract_h

Word16 div_s(Word16 var1, Word16 var2);div_s

Word16 add(Word16 var1, Word16 var2)add

Word16 abs_s(Word16 var1)abs_s

Tehnici de optimizare C pentru StarCore SC140

Creat de Bogdan Costinescu

Dezvoltarea de aplicaţii pe DSP

• Compromis între: – încadrarea timpului de execuţie a programului într-un

interval bine stabilit şi – cerinţa ca memoria de program ocupată de aplicaţie să se

încadreze în limitele impuse de procesorul de semnal.

• Necesitatea de găsire de metode de optimizare a programelor sub ambele aspecte, atât din punct de vedere al timpilor de execuţie dar şi a memoriei de program ocupate de aplicaţie.

Ce înseamnă optimizarea?

• reducerea timpului de execuţie• reducerea dimensiunii codului• reducerea dimensiunii datelor• reducerea memoriei alocate stivei• reducerea consumului de memorie

Limbajul C pentru programarea DSP

• C este un limbaj de programare structurat gândit să realizeze o translaţie compactă şi eficientă a unui program în limbaj maşină

• Limbaj de nivel înalt dar apropiat de nivelul de asamblare

• Există o gama largă de medii de dezvoltare C• Flexibil, portabil => programele pot fi reutilizate

Arhitecturi DSP “prietenoase” pentrucompilatorul C

• număr mare de registre• set de registre ortogonale• moduri de adresare flexibile• puţine restricţii de execuţie a instrucţiunilor• suport pentru for diversele tipuri de date

Exemplu - StarCore SC140

• Arhitectura Variable Length Execution Set (VLES)– un set de execuţie poate efectua până la:

• patru instrucţiuni DALU• două instrucţiuni AGU

• arhitectură scalabilă cu set bogat de instrucţiuni• set de registre ortogonal (independente)

– 16 registre de date DALU (d0 – d15)– 16 + 4 + 4 registre AGU (r0 – r15, n0 – n3, m0 – n3)

• etape puţine pipeline => nu apar conflicte• suport hardware pentru întregi şi fracţionare

Exemplu - StarCore SC140[move.4f (r0)+,d0:d1:d2:d3move.4f (r1)+,d4:d5:d6:d7]

LOOPSTART3 [

mac d0,d4,d8mac d1,d5,d9mac d2,d6,d10mac d3,d7,d11move.4f (r0)+,d0:d1:d2:d3move.4f (r1)+,d4:d5:d6:d7

]LOOPEND3

[mac d0,d4,d8mac d1,d5,d9mac d2,d6,d10mac d3,d7,d11

]

Este C potrivit pentru DSPuri?

• Limbajul C nu poate produce un cod în asamblare optim, care să utilizeze la maximum resursele procesorului.

• De exemplu în limbajul C nu sunt prezente:– lucrul în virgulă fixă;– nu este prezent suportul pentru arhitecturi duale de

memorie;– nu sunt prezente porturi speciale de intrare/ieşire, şi nici

instrucţiuni specializate;– nu este prezent suportul pentru instrucţiuni de tipul SIMD

(Single Instruction Multiple Data).

Eficienţa C pentru paralelism

• practic, NU EXISTĂ• C = un limbaj de programare secvenţial

– nu pot fi exprimate acţiuni în paralel– nu există echivalent pentru instrucţiuni SIMD

• Compilatorul trebuie să analizeze planificarea operaţiilor independente– analiza depinde de stilul de programare

c = a * b;d = b + c;e = a * a;

sunt independente, pot fi efectuate în paralel

depinde de rezultatul operaţiei anterioare

Poate fi făcut C eficient pentru DSP?

DA,• în condiţiile în care programatorul, cel care

dezvoltă aplicaţii pentru procesoarele de semnal, înţelege şi stăpâneşte următoarele aspecte:– extensiile compilatorului– tehnicile de programare– comportamentul compilatorului.

Extensiile compilatorului

• funcţiile intrinseci – acces eficient la setul de instrucţiuni

• tipuri noi de date– folosirea formatelor de date specifice DSP în C

• pragme– indică informaţii suplimentare compilatorului

• asamblare inline– soluţia la o problemă “imposibil” de rezolvat în C

Funcţii intrinseci

• Sunt funcţii speciale prin care compilatorul realizează o mapare în C a instrucţiunilor din asamblare specifice operaţiilor pe precizie finită.

• Această categorie de funcţii presupune definirea unor mulţimi de noi tipuri de date– precizie simplă, dublă şi extinsă pentru numere

fracţionale.

• Utilizarea acestor funţii intrinseci asigură emularea programelor şi pe alte platforme.

Tipuri de date

• pentru DSP există mai multe formate de date– identice cu tipurile de bază C

• integers– de aceeaşi lungime dar cu semnificaţie diferită

• fractionare pe 16 şi 32 biţi– specifice DSP (de ex. incluzând partea de extensie)

• fractionare pe 40 biţi

• pentru toate tipurile specifice DSP sunt definite seturi de operaţii

Tipuri de date C pentru nr. fracţionare

• convenţii:– Word16 pentru fracţii pe 16 biţi– Word32 pentru fracţii pe 32 biţi– Word40 pentru fracţii pe 40 biţi (32 biţi plus 8 biţi gardă)– Word64 pentru fracţii pe 64 biţi (nu sunt direct

reprezentabile pe SC140)

• Funcţiile intrinseci sunt cele care stabilesc formatul fracţionar pentru operanzi

Tipuri fracţionare şi Operatori

• introduşi prin funcţiile intrinseci fracţionare• operatorii standard (ITU-T, ETSI)

– adunare, înmulţire– saturare, rotunjire– scalare, normalizare

• operează pe tipuri specifice de dateWord16 add(Word16, Word16);Word32 L_add(Word32, Word32);Word40 X_add(Word40, Word40);Word64 D_add(Word64, Word64);

Pragme• Prin pragme se înţelege un mod standard de

comunicare cu un compilator. • Acestea descriu nu numai caracteristicile

codului scris în limbaj C dar şi a datelor utilizate.

• Utilizarea pragmelor nu afectează cu nimic valoarea rezultatelor, dar influenţează într-o măsură deosebit de importantă performanţele

#pragma align signal 8#pragma loop_unroll 4#pragma inline#pragma loop_count (20, 40, 4)

Pragme pentru alinierea datelor

• #pragma align ptr 8– pentru alinierea în memorie la declararea vectorilor

• Permit folosirea transferurilor cu mai multe cuvinte

Word16 x[12] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};#pragma align x 8

08

16

x[0]x[1]x[2]x[3]x[4]x[5]x[6]x[7]x[8]x[9]x[10]x[11]

move.4f (r0)+,d0:d1:d2:d3

Pragme pentru alinierea datelor• #pragma align *ptr 8

– pentru parametri transmişi funcţiilor prin adresă– compilatorul consideră că vectorii au fost aliniaţi în

programul care apelează funcţia

#define LENGTH 10Word16 x[LENGTH], y[LENGTH];#pragma align x 8#pragma align y 8int main(void){Word32 result;…

result = Prod(&x[0],&y[0]);…return 0;}

Word32 Prod(Word16 a[], Word16 b[]){#pragma align *a 8#pragma align *b 8Word16 j;Word32 res_rout = 0;for(j=0; j<LENGTH; j++)

{res_rout += a[j] * b[j];}

return res_rout;}

Asamblarea Inline

• Presupune tehnica prin care în interiorul codului scris în limbaj C se pot introduce directive de asamblare, instrucţiuni de asamblare.

• Acest lucru se poate realiza:– sub forma unei singure instrucţiuni

• asm(“ di”);– sub forma unei întregi funcţii.

• Acces dificil la simboluri locale în funcţii– datele globale pot fi accesate prin numele lor

Asamblarea Inline

• Utilizarea directivelor de asamblare presupune faptul că avem un acces special la unele caracteristici ale procesorului, imposibil de utilizat în cazul folosirii funcţiilor intrinseci.

• convenţii de apelare speciale• integrarea rapidă a funcţiilor în asamblare cu

programele C

Asamblare Inline - Exempluasm Flag GetOverflow(void){asm_header

return in $d0;.reg $d0,$d1;asm_body

clr d0 ; extra cycle needed to allow DOVF to ; be written even by the instructions; in the delay slot of JSRD

bmtsts #$0004,EMR.L ; test the Overflow bit from EMRmove.w #1,d1tfrt d1,d0 ; if Overflow return 1, else return 0

asm_end}

Optimizări făcute de compilator

• optimizările standard din C• optimizări (low level) specifice arhitecturii• mai multe niveluri de optimizarea disponibile

– pentru un cod mai rapid– pentru un cod mai mic

• optimizări globale– toate fişierele sunt analizate ca un întreg

Obţinerea de aplicaţii optimizate pe DSP

• arhitectură DSP performantă• compilator cu grad mare de optimizare• stilul de scriere a codului sursă C

⇒singurul factor dependent de programator• scrierea codului C trebuie să respecte unele

tehnici de programare precizate în manualul compilatorului pentru– eliminarea dependenţelor datelor– completarea operaţiilor făcute de compilator pentru

structurarea codului

Tehnici de programare pentru SC140

• tehnici generale aplicabile DSP– loop merging– loop unrolling– loop splitting

• tehnici specifice StarCore– split computation– multisample

Loop Merging

• combinarea a două bucle într-una singură– dacă cele două bucle sunt caracterizate de acelaşi număr

de iteraţii. – se poate diminua timpul necesar executării celor două

bucle.

• reduce întârzierile pentru iniţializarea buclelor• creşte utilizarea registrelor DALU• reduce mărimea codului

Loop Merging - Exemplu/* scaling loop */for ( i = 0; i < SIG_LEN; i++){

y[i] = shr(y[i], 2);}/* energy computation */e = 0;for ( i = 0; i < SIG_LEN; i++){

e = L_mac(e, y[i], y[i]);}

/* Compute in the same time the *//* energy of the scaled signal */e = 0; for (i = 0; i < SIG_LEN; i ++) {

Word16 temp;temp = shr(y[i], 2);e = L_mac(e, temp, temp); y[i] = temp;

}

Loop Unrolling

• repetarea conţinutului unei bucle • permite gruparea mai multor instrucţiuni pentru

ca acestea sa se execute în paralel, în cadrul unui aceluiaşi ciclu instrucţiune.

• creşte utilizarea DALU• creşte dimensiunea codului• depinde de

– dependenţele datelor între iteraţii– alinierea elementelor vectorilor– presiunea pe registrele DALU pe iteraţie– numărul de itaraţii

• păstrează precizia operaţiilor

Loop Unrolling -Exemplu

int i;Word16 signal[SIGNAL_SIZE];Word16 scaled_signal[SIGNAL_SIZE];/* ... */for(i=0; i<SIGNAL_SIZE; i++){

scaled_signal[i] = shr(signal[i], 2);}/* ... */ int i;

Word16 signal[SIGNAL_SIZE];#pragma align signal 8Word16 scaled_signal[SIGNAL_SIZE];#pragma align scaled_signal 8/* ... */for(i=0; i<SIGNAL_SIZE; i+=4){

scaled_signal[i+0] = shr(signal[i+0], 2);scaled_signal[i+1] = shr(signal[i+1], 2);scaled_signal[i+2] = shr(signal[i+2], 2);scaled_signal[i+3] = shr(signal[i+3], 2);

}/* ... */

Compiler generated code; Without loop unrolling : 6 cycles ; inside the looploopstart3 L5[ add #<2,d3 ;[20,1]move.l d3,r2;[20,1]move.l <_signal,r1 ;[20,1]] move.l <_scaled_signal,r4adda r2,r1 [ move.w (r1),d4 adda r2,r4 ] asrr #<2,d4move.w d4,(r4)loopend3

; With loop unrolling : 2 cycles inside; the loop. ; The complier uses software pipelining[move.4f (r0)+,d0:d1:d2:d3move.l #_scaled_signal,r1

][

asrr #<2,d0 asrr #<2,d3asrr #<2,d1 asrr #<2,d2

]loopstart3

[moves.4f d0:d1:d2:d3,(r1)+move.4f (r0)+,d0:d1:d2:d3

][

asrr #<2,d0 asrr #<2,d1asrr #<2,d2 asrr #<2,d3

]loopend3

moves.4f d0:d1:d2:d3,(r1)+

Loop unrolling

• permite specificarea explicită a folosirii de către compilator a operaţilor în paralel

• factroul de desfacere a buclei depinde de – alinierea datelor– numărul de transferuri cu memoria– numărul de operaţii aritmetice– numărul de iteraţii

• se face unroll până nu mai rezultă nici o îmbunătăţire

• în general se face unroll cu un factor 2 sau 4

Loop Unroll Factor – example 1#include <prototype.h>#define VECTOR_SIZE 40Word16 example1(Word16 a[], Word16 incr) {

short i;Word16 b[VECTOR_SIZE];for(i = 0; i < VECTOR_SIZE; i++) {b[i] = add(a[i], incr);

}return b[0];

}

Loop Unroll Factor - example 2#include <prototype.h>#define VECTOR_SIZE 40Word16 example2(Word16 a[], Word16 incr) {#pragma align *a 8

int i;Word16 b[VECTOR_SIZE];#pragma align b 8for(i = 0; i < VECTOR_SIZE; i++) {b[i] = add(a[i], incr);

}return b[0];

}

; compiler generated codemove.4f (r0)+,d4:d5:d6:d7...loopstart3 [

add d4,d8,d12add d5,d8,d13add d6,d8,d14add d7,d8,d15moves.4f d12:d13:d14:d15,(r1)+move.4f (r0)+,d4:d5:d6:d7

]loopend3

Loop Unroll Factor - example 3#include <prototype.h>#define VECTOR_SIZE 40Word16 example3(Word16 a[], Word16 incr) {#pragma align *a 8

int i;Word16 b[VECTOR_SIZE];#pragma align b 8for(i = 0; i < VECTOR_SIZE; i++) {b[i] = a[i] >> incr;

}return b[0];

}

; compiler generated codeloopstart3 [

move.4w d4:d5:d6:d7,(r1)+move.4w (r0)+,d4:d5:d6:d7

][

asrr d1,d4asrr d1,d5asrr d1,d6asrr d1,d7

]loopend3

Split Computation

• aplicaţii tipice în calculul:– energiei– erorii pătratice medii– maximului

• creşte utilizarea DALU• creşte dimensiunea codului• poate necesita alinierea datelor• poate influenţa precizia

Split Computation

• De exemplu calculul energiei unui semnal:

• Formula este echivalentă cu separarea în 4 sume

( )1

2

0

N

e x i−

= ∑

( ) ( ) ( ) ( )1

2 2 2 2

0,4,8...1 3 3

N

ie x i x i x i x i

−

=

= + + + + + +∑

int i; Word32 e;Word16 signal[SIGNAL_SIZE];/* ... */ e = 0;for(i = 0; i < SIGNAL_LEN; i++) {

e = L_mac(e, signal[i], signal[i]);}/* the energy is now in e */

int i; Word32 e0, e1, e2, e3;Word16 signal[SIGNAL_SIZE];#pragma align signal 8/* ... */e0 = e1 = e2 = e3 = 0;for(i = 0; i < SIGNAL_LEN; i+=4) {

e0 = L_mac(e0, signal[i+0], signal[i+0]);e1 = L_mac(e1, signal[i+1], signal[i+1]);e2 = L_mac(e2, signal[i+2], signal[i+2]);e3 = L_mac(e3, signal[i+3], signal[i+3]);

}e0 = L_add(e0, e1);e1 = L_add(e2, e3);e0 = L_add(e0, e1);/* the energy is now in e0 */

Split Computation Example

Câte separări?

• depinde de alinierea în memorie• numărul de iteraţii trebuie să fie multiplu de

numărul de separări a sumei• sumele calculate separat trebuie recombinate

pentru a obţine rezultatul final

Multisample

• transformarea codului pentru bucle efectuate una în interiorul alteia

• Etape– loop unroling pentru bucla exterioară;– loop merging pentru bucla din interior;– loop unroling pentru bucla din interior la care s-a aplicat

tehnica anterioară.

• păstrează precizia rezultatelor• nu necesită alinierea datelor în memorie• reduce numărul de operaţii de transfer al

datelor

Multisample Example - Step 1Word32 acc;Word16 x[], c[];int i,j,N,T;assert((N % 4) == 0);assert((T % 4) == 0);for (j = 0; j < N; j++) {acc = 0; for (i = 0; i < T; i++) {

acc=L_mac(acc,x[i],c[j+i]);}res[j] = acc;

}

for (j = 0; j < N; j += 4) {acc0 = 0; for (i = 0; i < T; i++)

acc0 = L_mac(acc0, x[i], c[j+0+i]);res[j+0] = acc0;acc1 = 0; for (i = 0; i < T; i++)



acc3 = L_mac(acc3, x[i], c[j+3+i]);res[j+3] = acc3;

}

1 2

Outer loop unrolling

for (j = 0; j < N; j += 4) {acc0 = 0; for (i = 0; i < T; i++)




acc3 = L_mac(acc3, x[i], c[j+3+i]);res[j+3] = acc3;

}

Multisample Example - Step 2

for (j = 0; j < N; j += 4) {acc0 = 0; acc1 = 0;acc2 = 0; acc3 = 0; for (i = 0; i < T; i++)

acc0 = L_mac(acc0, x[i], c[j+0+i]);for (i = 0; i < T; i++)



acc3 = L_mac(acc3, x[i], c[j+3+i]);res[j+0] = acc0;res[j+1] = acc1;res[j+2] = acc2;res[j+3] = acc3;

}

23

Rearrangement

Multisample Example - Step 3for (j = 0; j < N; j += 4) {acc0 = 0; acc1 = 0;acc2 = 0; acc3 = 0; for (i = 0; i < T; i++)




acc3 = L_mac(acc3, x[i], c[j+3+i]);res[j+0] = acc0;res[j+1] = acc1;res[j+2] = acc2;res[j+3] = acc3;

}

3

for (j = 0; j < N; j += 4) {acc0 = 0; acc1 = 0;acc2 = 0; acc3 = 0; for (i = 0; i < T; i++) {

acc0 = L_mac(acc0, x[i], c[j+0+i]);acc1 = L_mac(acc1, x[i], c[j+1+i]);acc2 = L_mac(acc2, x[i], c[j+2+i]);acc3 = L_mac(acc3, x[i], c[j+3+i]);

}res[j+0] = acc0;res[j+1] = acc1;res[j+2] = acc2;res[j+3] = acc3;

}

4

Inner loop mergingMultisample Example - Step 4

for (j = 0; j < N; j += 4) {acc0 = 0; acc1 = 0;acc2 = 0; acc3 = 0; for (i = 0; i < T; i++) {

acc0 = L_mac(acc0, x[i], c[j+0+i]);acc1 = L_mac(acc1, x[i], c[j+1+i]);acc2 = L_mac(acc2, x[i], c[j+2+i]);acc3 = L_mac(acc3, x[i], c[j+3+i]);

}res[j+0] = acc0;res[j+1] = acc1;res[j+2] = acc2;res[j+3] = acc3;

}

4

Inner loop unrolling

for (j = 0; j < N; j += 4) {acc0 = 0;acc1 = 0;acc2 = 0;acc3 = 0; for (i = 0; i < T; i += 4) {

acc0 = L_mac(acc0, x[i+0], c[j+0+i]);acc1 = L_mac(acc1, x[i+0], c[j+1+i]);acc2 = L_mac(acc2, x[i+0], c[j+2+i]);acc3 = L_mac(acc3, x[i+0], c[j+3+i]);acc0 = L_mac(acc0, x[i+1], c[j+1+i]);acc1 = L_mac(acc1, x[i+1], c[j+2+i]);acc2 = L_mac(acc2, x[i+1], c[j+3+i]);acc3 = L_mac(acc3, x[i+1], c[j+4+i]);/* third loop body for x[i+2] *//* fourth loop body for x[i+3] */

}res[j+0] = acc0; res[j+1] = acc1;res[j+2] = acc2; res[j+3] = acc3;

}

5

Multisample Example - Step 5Explicit scalarizationfor (j = 0; j < N; j += 4) {

acc0 = 0;acc1 = 0;acc2 = 0;acc3 = 0; for (i = 0; i < T; i += 4) {

acc0 = L_mac(acc0, x[i+0], c[j+0+i]);acc1 = L_mac(acc1, x[i+0], c[j+1+i]);acc2 = L_mac(acc2, x[i+0], c[j+2+i]);acc3 = L_mac(acc3, x[i+0], c[j+3+i]);acc0 = L_mac(acc0, x[i+1], c[j+1+i]);acc1 = L_mac(acc1, x[i+1], c[j+2+i]);acc2 = L_mac(acc2, x[i+1], c[j+3+i]);acc3 = L_mac(acc3, x[i+1], c[j+4+i]);/* third loop body for x[i+2] *//* fourth loop body for x[i+3] */


}

5 for (j = 0; j < N; j += 4) {acc0=acc1=acc2=acc3=0; xx = x[i+0];c0 = c[j+0]; c1 = c[j+1];c2 = c[j+2]; c3 = c[j+3];for (i = 0; i < T; i += 4) {acc0 = L_mac(acc0, xx, c0);acc1 = L_mac(acc1, xx, c1);acc2 = L_mac(acc2, xx, c2);acc3 = L_mac(acc3, xx, c3);xx = x[i+1]; c0 = c[j+4+i];acc0 = L_mac(acc0, xx, c1);acc1 = L_mac(acc1, xx, c2);acc2 = L_mac(acc2, xx, c3);acc3 = L_mac(acc3, xx, c0);xx = x[i+2]; c1 = c[j+5+i];/* similar third and fourth loop */


}

6

Multisample Example - Final Resultfor (j = 0; j < N; j += 4) {acc0=acc1=acc2=acc3=0; xx = x[i+0];c0 = c[j+0]; c1 = c[j+1];c2 = c[j+2]; c3 = c[j+3];for (i = 0; i < T; i += 4) {

acc0 = L_mac(acc0, xx, c0);acc1 = L_mac(acc1, xx, c1);acc2 = L_mac(acc2, xx, c2);acc3 = L_mac(acc3, xx, c3);xx = x[i+1]; c0 = c[j+4+i];acc0 = L_mac(acc0, xx, c1);acc1 = L_mac(acc1, xx, c2);acc2 = L_mac(acc2, xx, c3);acc3 = L_mac(acc3, xx, c0);xx = x[i+2]; c1 = c[j+5+i];/* similar third and fourth loop */


}

one cycle (4 macs + 2 moves)

one cycle (4 macs + 2 moves)

Search Techniques Adapted for StarCore SC140

• finding for maximum• finding the maximum and its position• finding the maximum ratio• finding the position of the maximum ratio

Maximum search• reduction operation => split maximum

#include <prototype.h>Word16 max_search(Word16 vector[], unsigned short int length ) {#pragma align *vector 8

signed short int i = 0; Word16 max0, max1, max2, max3;max0 = vector[i+0]; max1 = vector[i+1];max2 = vector[i+2]; max3 = vector[i+3];for(i=4; i<length; i+=4) {

max0 = max(max0, vector[i+0]); max1 = max(max1, vector[i+1]);max2 = max(max2, vector[i+2]); max3 = max(max3, vector[i+3]);

}max0 = max(max0, max1); max1 = max(max2, max3);return max(max0, max1);

}

Maximum search - Comments

• presented solution works for both 16-bit and 32-bit values

• better solution for 16-bit (asm only)– based on max2 instruction (SIMD style)– fetches two 16-bit values as a 32-bit one– eight maxima per cycle

Maximum Search – ASM with max2

move.2l (r0)+n0,d4:d5 move.2l (r1)+n0,d6:d7move.2l (r0)+n0,d0:d1 move.2l (r1)+n0,d2:d3

FALIGNLOOPSTART3[

max2 d0,d4 max2 d1,d5max2 d2,d6 max2 d3,d7move.2l (r0)+n0,d0:d1 move.2l (r1)+n0,d2:d3

]LOOPEND3[

max2 d0,d4 max2 d1,d5max2 d2,d6 max2 d3,d7

]

Maximum position

• based on comparisons– around N cycles– in C, two maxima required

• based on maximum search– around N/2 cycles

• based on max2-based maximum search– around N/4 cycles

• care must be taken to preserve the original semantics

Maximum ratio

• given Word16 a[ ] and Word16 b[ ] vectors of positive values, compute max{a[i]/b[i]}

• division is very expensive on StarCore• ideas:

– a/b < c/d a*d < b*c– keep a[ ] and b[ ] intermixed

• two 16-bit values form a 32-bit one– use cross multiplication (mpyus, mpysu)

• final solution in N cycles

Max ratio position

• based on max ratio search, plus– movet, tfrt instructions– position is kept as pointer, not index

• software pipelining plus loop unrolling three times

DSP Coding Recommendations

• use loops with a fixed number of iterations– enables the detection of hardware loops

• provide extensive static information– pragmas, constants

• use only supported data types• do not mix integer and fractional operations on

the same value

DSP Coding Recommendations (2)

• replace tests with computations– small tests are ok due to predicative execution

• use synonym operations if more flexible in the target architecture

• use modulo addressing• alignment in data structures should be

provided using field arrangement• use custom calling conventions

Software Development Notes

• SDN database contains coding guidelines– try different solutions for the same problem– analyze the generated assembly file– save the best solution in the SDN database

• SDN DB captures team experience• leverage organizational development skills

Speed versus Size

• typically cannot be both optimized• follow the 80%-20% rule

– speed optimize 20% of the code– size optimize 80% of the code

• loop merging may optimize both• a high register pressure may kill both• multisample provides best speed

– but also significant kernel size increase

Diet Speed Optimization

• compile for speed only time-consuming loops– compile for size the rest

• try speed and size optimizations combined

• reduce the unroll factors in the multisampletransformation

• avoid register pressure that creates spill code

C Optimization Limits

• effort concentrated on loops– no packed moves outside loops– loops and ifs delimit optimization blocks

Conclusions

• complexity of future DSP applications require development using C

• C can be transformed in efficient DSP C– compiler extensions are a must

• the coding style is programmer’s key• optimized C code is suitable for high

performance applications• assembly remains for critical sections

Documents

Aplicatii Ale Procesoarelor de Semnal in Comunicatii