IMPLEMENTERING AV
CORDIC-ALGORITMER
Examensarbete utfört i Elektroniksystem
vid Linköpings Tekniska Högskola
av
Rikard Hellberg
LiTH-ISY-EX-3576-2004
Handledare: Lars Wanhammar
Examinator: Lars Wanhammar
Institutionen för systemteknik
581 83 LINKÖPING
2004-03-05 Språk Language Rapporttyp Report category ISBN X Svenska/Swedish Engelska/English Licentiatavhandling X Examensarbete ISRN LITH-ISY-EX-3576-2004 C-uppsats D-uppsatsSerietitel och serienummer
Title of series, numbering ISSN
Övrig rapport
URL för elektronisk version
http://www.ep.liu.se/exjobb/isy/2004/3576/
Titel
Title
Studie av konstruktion och implementering av CORDIC-algoritmer Survey and Implementation of High-Speed CORDIC Algorithms
Författare
Author
Rikard Hellberg
Sammanfattning
Abstract
CORDIC (Coordinate Rotation Digital Computer) is an iterative algorithm for the calculation of a two-dimensional vector in circular, linear or hyperbolic coordinate systems. This paper presents a survey of known CORDIC algorithms and architectures for the rotation and vectoring mode in the circular cordinate system. In addition an implementation of the differential CORDIC algo-rithm in VHDL has been done. The implementation is designed to keep the fast timing and throughput characteristic known for on-line redundant arithmetic.
Nyckelord
Keyword CORDIC
Innehåll
1
Inledning . . . 9
1.1 Syfte och målsättning. . . .10
1.2 Specifikation . . . .10 1.3 Rapportens upplägg . . . .10
2
CORDIC-algoritmen . . . 11
2.1 CORDIC-moder . . . .13 2.1.1 Framåtrotationsmoden . . . .14 2.1.2 Bakåtrotationsmoden . . . .15 2.2 Konvergens . . . .16 2.2.1 Utvidgning av konvergensområdet . . . .16 2.3 Skalfaktorskompensation . . . .17 2.4 Generella CORDIC-algoritmen . . . .18 2.4.1 Utvidgning av CORDIC-algoritmen . . . .203
Noggrannhet i CORDIC-algoritmen . . . 21
3.1 Felkällor i CORDIC-algoritmen . . . .22 3.1.1 Approximationsfel . . . .22 3.1.2 Avrundninsfel . . . .23 3.1.3 Rotationsriktningsfel . . . .233.2 Maximala felet i cordic . . . .24
3.2.1 Intern ordbredd . . . .25
3.3 Fel i beräkning av arctan . . . .25
3.3.1 Normalisering . . . .26
4
CORDIC-arkitekturer . . . 29
4.1 Bit-Parallell Iterativ CORDIC . . . .30
4.2 Bit-Seriell Iterativ CORDIC . . . .31
5
CORDIC- implementeringar . . . 33
5.1 Sekventiell framtagning av di . . . 36
5.1.1 Korrektionsiterationer. . . 36
5.1.2 Dubbelrotation . . . 37
5.1.3 On-Line CORDIC. . . 37
5.1.3.1 Lin och Sips. . . 37
5.1.3.2 Hamill et.al. . . 38
5.1.3.3 Ercegovac och Lang . . . 38
5.1.3.4 Bruguera et.al . . . 40 5.1.4 Överlappad CORDIC . . . 40 5.1.5 Branching . . . 41 5.1.6 Hög Radix CORDIC. . . 42 5.1.6.1 Radix 2-4. . . . 42 5.1.6.2 Radix-4. . . 43 5.1.6.3 Radix-16. . . 46 5.1.6.4 Radix 2-4-8.. . . 48 5.1.6.5 Radix-512. . . 48 5.1.7 Householder CORDIC . . . 50 5.1.8 Skalningsfria algoritmer . . . 53
5.1.8.1 Eckhard Grass et.al.. . . 53
5.1.8.2 Tso Bing Juang . . . 54
5.1.9 Merged CORDIC . . . 56
5.1.10 Critically Damped CORDIC (CD-CORDIC) . . . 58
5.2 Parallell framtagning av di . . . 59
5.2.1 Timmermann. . . 59
5.2.2 Antelo et.al.. . . 61
5.2.3 Lin & Chen . . . 63
5.2.4 Hybrid CORDIC . . . 64
5.2.5 Nahm och Sung. . . 65
5.2.6 Swartzlander . . . 66 5.2.7 Iterationsreduceringstekniker . . . 66 5.2.8 P-CORDIC . . . 68 5.2.9 Flat CORDIC . . . 71 5.2.10 Unidirectional CORDIC . . . 72 5.3 Variationer på CORDIC . . . 74 5.3.1 Vinkelkvantiserings CORDIC . . . 74
5.3.2 Differential CORDIC (DCORDIC) . . . 75
5.3.3 Area reducerade CORDIC-arkitekturer . . . 77
6 CORDIC-applikationer . . . 81
7
Rekommendationer . . . 83
7.1 FPGA, ASIC och Full custom . . . .84
7.2 Val av algoritm för implementation. . . .85
8
Implementation, verifiering och simulering . . . 87
8.1 Arkitektur . . . .88
8.2 Implementationsresolution. . . .89
8.2.1 SDA och kodning . . . .89
8.2.2 Inputnormalisering . . . .89 8.2.3 Pseudo-overflow/intern ordbredd . . . .89 8.2.4 R2B- och B2R-konvertering . . . .90 8.2.5 Utvidgning av konvergensområdet . . . .91 8.2.6 Skalning . . . .91 8.3 Verifiering . . . .91 8.3.1 Verifierings strategi . . . .92 8.4 Simulering . . . .92
Appendix A
CORDIC-funktioner . . . 95
A.1 Linjära koordinatsystemet . . . .95
A.2 Cirkulära koordinatsystemet . . . .96
A.3 Hyperboliska koordinatsystemet . . . .97
Appendix B
Redundanta nummersystem . . . 99
B.1 BSD nummer representation . . . .100
B.1.1 Kodning . . . .101
B.2 Redundant aritmetik . . . .101
B.2.1 Hybrid addition och subtraktion . . . .102
B.2.2 Binär SD addition och subtraktion . . . .104
B.3 Konvertering . . . .105
B.3.1 Icke-redundant till redundant konvertering . . . .105
B.3.2 Redundant till icke-redundant konvertering . . . .106
B.3.2.1 Kongruens mellan adderare och konvertering. . . 107
B.3.3 On-the-fly konverterare . . . .109
B.4 On-line. . . .110
B.4.1 On-line fördröjning . . . .110
B.4.2 Överlappning . . . .111
B.4.3 Definition av on-line algoritmer . . . .112
Appendix C
Diskussion/val av algoritm . . . 113
Appendix D
Matlab-implementeringar . . . 119
D.1 Program A . . . 119 D.1.1 Simulering . . . 119 D.1.2 Filer/program . . . 120 D.2 Program B (MSDF) . . . 121 D.2.1 Simulering . . . 121 D.2.2 Filer/program . . . 122 D.3 Kod Program A . . . 123 D.3.1 CORDIC_processor . . . 123 D.3.2 Normalization.m . . . 124 D.3.3 Pre_rot.m . . . 124 D.3.4 Post_rot.m . . . 125 D.3.5 BinToRed.m. . . 125 D.3.6 RedToBin.m. . . 125 D.3.7 BsdAbs.m. . . 126 D.3.8 XY_block.m/Skift . . . 127 D.3.9 P_block.m . . . 127 D.3.10 HybridAdd.m . . . 128 D.3.11 Add_sub.m . . . 128 D.3.12 Arctan.m. . . 129 D.3.13 Ppm.m . . . 129 D.3.14 Mmp.m. . . 130 D.4 Kod program B (MSDF) . . . 130 D.4.1 DCORDIC.m . . . 130 D.4.2 Initializer.m . . . 134 D.4.3 Arctangens.m . . . 136 D.4.4 Pre_rot.m . . . 137 D.4.5 Post_rot.m . . . 137 D.4.6 BinToRed.m. . . 138 D.4.7 RedToBin.m. . . 138 D.4.8 Skew.m. . . 138 D.4.9 Bsd_abs.m . . . 138 D.4.10 Shifter.m. . . 139 D.4.11 Ppm.m/Mmp.m . . . 139 D.4.12 PseudoXY.m . . . 139 D.4.13 PseudoP.m . . . 140 D.4.14 AddSub.m . . . 140Appendix E
VHDL-implementering . . . 143
E.1 Input steg . . . .144
E.2 CORDIC . . . .144 E.2.1 Skew-inputformat . . . .144 E.2.2 XYP-block . . . .145 E.2.3 X-block/Y-block . . . .145 E.2.4 P-block . . . .146 E.2.5 HybridAdderN. . . .147 E.2.6 AdderN . . . .148 E.2.7 AbsolutN . . . .149 E.2.8 Shift-pipe. . . .150 E.2.9 Pipe/Pipe2. . . . .151
E.2.10 Output steg . . . .151
E.3 VHDL-KOD . . . .152 E.3.1 CORDIC_processor . . . .152 E.3.2 Input_steg . . . .153 E.3.3 CORDIC . . . .155 E.3.4 Output_steg . . . .157 E.3.5 Normalization . . . .158 E.3.6 B2R . . . .159 E.3.7 Konvergensrotation . . . .159 E.3.8 Post(Korrektionsrotation) . . . .160 E.3.9 R2B . . . .161 E.3.10 Skew_inputformat . . . .162 E.3.11 XYP_block . . . .163 E.3.12 X_block . . . .165 E.3.13 Y_block . . . .166 E.3.14 P_block . . . .167 E.3.15 AdderN . . . .169 E.3.16 HybridAdderN. . . .171 E.3.17 AbsolutN . . . .172 E.3.18 Shift_pipe . . . .173 E.3.19 Pseudo_CorrXY_pipe . . . .174 E.3.20 Pseudo_CorrXY . . . .175 E.3.21 Pseudo_CorrP . . . .176 E.3.22 Calc_rot . . . .177 E.3.23 Delays . . . .177 E.3.24 Absolut . . . .178 E.3.25 Shift . . . .179 E.3.26 Ctrl_neg. . . .179 E.3.27 Ppm . . . .180 E.3.28 Mmp . . . .180
E.3.29 Pipe. . . 181
E.3.30 Pipe2 . . . 181
E.3.31 D_latch . . . 182
E.3.32 Xnor2 . . . 182
Terminologi
Akronym
Förklaring
ASIC Aplication Specific Integrated Circuit
ATR Arc Tangent Radix
B2R Binary to Redundant
BSD Binary Signed Digit
CFR Constant Factor Redundant
CLA Carry Look Ahead
CORDIC COordinate Rotation Digital Computer
CS Carry Save
CSA Carry Save Adder
CSD Canonical Signed Digit
FFT Fast Fourier Transform
FPGA Field Programmable Gate Array
LSB Least Significant Bit
LSD Least Significant Digit
MSB Most Significant Bit
MSD Most Significant Digit
MSDF Most Significant Digit First
QRD QR-Decomposition
R2B Redundant to Binary
RBA Redundant Binary Adder
ROM Read Only Memory
SD Signed Digit
SDA Signed Digit Adder
SDN Signed Digit Number
SVD Single Value Decomposition
TFA Latency i en heladderare
TG Transmission Gate
1
Inledning
CORDIC är en iterativ algoritm för att beräkna rotationen av en 2-dimensionell vektor i det linjära, cirkulära eller hyperboliska kordinatsystemet. En vektorrotation utförs genom en sekvens av flera mindre rotationer, så kallade mikrorotationer. Algoritmen kan operera i två olika moder, (i) framåtrotation och (ii) bakåtrotation. I framåtrotationsmoden roteras en vektor med en godtycklig vinkel, och i bakåtrotationsmoden roteras inputvektorn till positiva x-axeln, för ändamålet att beräkna initialvektorns fas och magnitud. CORDIC-algoritmens applikationsområden finner vi idag i digital signal behandling, bild behandling, filter, matris algebra etc [5].
Den grundläggande CORDIC-algoritmen beskrevs av Henry Briggs redan 1624 i Arith-metica Logarithmica [6], men då inte under namnet CORDIC. COrdinated Rotation Digital Computer, eller akronymen CORDIC utvecklades först 1959 av Jack E. Volder [7] för att lösa flygnavigeringsproblem digitalt i realtid. Volders algoritm löser multi-plikation, division, trigonometriskafunktioner och kan användas till transformation mellan polära/rektangulära kordinater. 1971 generaliserade John Walther [51] Volders algoritm till att även lösa hyperboliska och exponentialfunktioner. Sedan dess har intresset för CORDIC-algoritmen vuxit, mycket på grund av att den har en regelbunden design, som endast består av enkla skift- och additionsoperationer, vilka är enkla att implementera i VLSI-teknik. CORDIC-algoritmen lider dock av sin långsamma konvergens. Denna nackdel har angripits för att förbättra exekveringstiden av algoritmen. Flera olika implementerings föreslag har presenterats sedan Volder och Walthers dagar och i denna rapport ska vi ta oss en närmare titt på de senaste av dem.
1.1 SYFTE OCH MÅLSÄTTNING
Meningen med denna rapport är att presentera en överblick av olika CORDIC-processor-arkitekturer, som har utvecklats under modern tid, samt kort lista applikationer där CORDIC-algoritmen med fördel används. Det primära målet med rapporten är att den ska kunna användas som utgångspunkt av konstruktörer när val av CORDIC-arkitektur ligger för dörren samt inspirera läsaren till att arbeta för vidareutveckling av CORDIC-algoritmen och dess applikationsområden. Vidare ska en VHDL-implementation baserad på någon av CORDIC-arkitekturerna i översikten utföras.
Rapporten är en beställning från Institutionen för system teknik vid Linköpings tekniska högskola och bygger på ett tidigare examensarbete [100] där CORDIC-algoritmen utnyttjas i en prototyp av en IEEE802.11a synkroniserare.
1.2 SPECIFIKATION
VHDL-implemeteringen som ska genomföras ska infria följande krav/villkor: • Beräkna arctan av ett komplexttal.
• Inputoperanderna är begränsade: .
• Inputoperanderna är 16-bitars två komplements tal. • Resultatet ska ha 16-bitars noggrannhet.
• Klara av 20 Msample/s.
1.3 RAPPORTENS UPPLÄGG
Rapporten är organiserad enligt följande: Kapitel 2 presenterar teoretisk bakgrund av CORDIC-algoritmen, kapitel 3 presenterar felkällor i CORDIC-algoritmen och kapitel 4 behandlar grundarkitekturer för CORDIC-processorer. Kapitel 5 presenterar ytterligare arkitekturer, kapitel 6 presenterar applikationer som CORDIC-algoritmen kan användas till och i kapitel 7 presenteras verifiering, simulerings och design parametrar på den implementerade processorn. I appendix A illustreras funktioner CORDIC-algoritmen beräknar och i appendix B förklaras redundanta nummersystem och aritmetik. I appendix C diskuteras val av algoritm för implementering och i appendix D klarläggs Matlab-modeller som använts vid simulering och verifiering. I Appendix E presenteras slutligen en strukturell VHDL-implementering.
2
CORDIC-algoritmen
Den bakomliggande teorin för CORDIC-algoritmen är att rotationen av en vektor kan användas till att beräkna trigonometriskafunktioner. CORDIC-algoritmen genomför en vektorrotation till en godtycklig vinkel genom att iterativt rotera en vektor flera gånger. Algoritmen konvergerar genom att de iterativa rotationerna, även kallade mikro-rotationer, sker med efter hand mindre vinklar. Volders algoritm [7] är härledd från de generella ekvationerna för vektorrotation. Om vi har en vektor v(x,y) och roterar den med vinkeln φ blir resultatet:
(2.1)
Figur 2.1 Rotation av vektorn v med vinkeln φ. v′ x′ y′ x⋅cos( )φ –y⋅sin( )φ y⋅cos( )φ +x⋅sin( )φ = = y x v' v (x,y) (x',y')
Ekvation (2.1) kan skrivas om enligt följande:
(2.2) (2.3)
Om rotationsvinklarna begränsas, så att tan(φ) = ±2-i, reduceras multiplikationen med tangenstermen, tan(φ), till en enkel skiftoperation, 2-i. På grund av att cos(φ) = cos(-φ) och med φ = arctan(2-i) kan cosinustermen förenklas och blir en konstant för ett fixt antal mikrorotationer. Ekvation (2.2) och (2.3) kan nu skrivas om till de iterativa ekvationerna:
(2.4) (2.5)
där ri = cos(φ) = cos(arctan(2-i)) = 1/(1+2-2i)1/2 och di = ±1
Expansionskonstanten ri kan tas bort från de iterativa ekvationerna, räknas ut i förhand och appliceras senare i systemet. Produkten R av expansionskonstanterna ri närmar sig 0.6073 när antalet iterationer går mot oändligheten. Iterationsekvationerna (2.4) och (2.5) kommer då endast att bestå av additions/subtraktions samt skiftoperationer. CORDIC är således en effektiv algoritm att implementera i VLSI-teknik. Den exakta produkten av expansionskonstanterna beror på antalet mikrorotationer (n):
(2.6)
Ekvation (2.4) och (2.5) kan nu skrivas om till de två iterativa onormaliserade CORDIC-ekvationerna:
(2.7) (2.8)
På grund av att CORDIC använder onormaliserade mikrorotationer så kommer vektorn, som roteras, att förlängas med en faktor ki = 1/ri i varje iteration, se figur 2.2. När antalet iterationer går mot oändligheten kommer produkten av alla förlängningar att konvergera mot K∞= 1/0.6073. Den exakta skalfaktorn K beror på antalet iterationer (n):
(2.9) x′ = cos( )φ ⋅[x–y⋅tan( )φ ] y′ = cos( )φ ⋅[y+x⋅tan( )φ ] xi+1 = ri[xi–yi⋅ ⋅di 2–i] yi+1 = ri[yi+xi⋅ ⋅di 2–i] R ri i=0 n–1
∏
= xi+1 = xi–yi⋅ ⋅di 2–i yi+1 = yi+xi⋅ ⋅di 2–i K 1 R⁄ 1+2–2i n–1∏
= =Figur 2.2 Onormaliserad vektor rotation.
Den totala ackumulerade vinkelrotationen av mikrorotationerna blir:
där di = ±1 (2.10)
Efter n mikrorotationer: (2.11)
CORDIC-algoritmen är nu fullständig och består av ekvationerna (2.7), (2.8) och (2.10). Tecknet på , (1 ger en vektor rotation moturs och –1 medurs), väljs på sådant sätt att CORDIC-algoritmen konvergerar.
2.1 CORDIC-MODER
CORDIC-algoritmen kan användas i två olika moder; (i) den första moden kallas framåt-rotation eller alternativt för framåt-rotationsmoden, vilken roterar en vektor med en specifikt angiven vinkel z0. (ii) Den andra moden kallas för vektoriseringsmoden eller för bakåt-rotation. Metoden roterar en inputvektor till x-axeln under vilket zi+1 registrerar den ackumulerade vinkeln, som krävs för att utföra rotationen. De två namnen rotations-moden respektive vektoriseringsrotations-moden är en historisk kvarleva från den tiden då algoritmen utnyttjades till navigation och är således ej till någon hjälp för att förstå de olika metoderna. I fortsättningen kommer moderna att adresseras med de bättre namnen framåtrotation och bakåtrotation.
(xi, yi) (xi+1, yi+1) i y x vi vi+1 zi+1 = zi–di⋅atan( )2–i zn z0 di⋅atan( )2–i i=0 n–1
∑
– = di∈(–1,1)2.1.1 Framåtrotationsmoden
Bekant sedan tidigare (2.7), (2.8) och (2.10) initieras vinkelackumulatorn z0 med den önskade rotationsvinkeln φ i framåtrotationsmoden. Detta sker med avseendet att beräkna de slutliga kartesiska kordinaterna (x’,y’). Rotationsriktningen på varje mikrorotation i varje iteration beslutas genom att inspektera tecknet på zi. Målet med inspektionen är att reducera storleken på residualvinkeln zi+1 till noll. I figur 2.3 ser vi hur initialvektorn v0 roteras iterativt i framåtrotation mot den önskade slutvinkeln. Ekvation 2.12 beskriver framåtrotationsmoden:
(2.12)
Resultatet av mikrorotationerna blir:
(2.13)
Figur 2.3 Iterativ framåtrotation initierad med vektorn v. xi+1 =xi–yi⋅ ⋅di 2–i yi+1= yi+xi⋅ ⋅di 2–i zi+1 =zi–di⋅atan( )2–i di=sign z( )i x′=K⋅[x0⋅cos( )z0 –y0⋅sin( )z0 ] y′=K⋅[y0⋅cos( )z0 +x0⋅sin( )z0 ] z′= 0 K 1 R⁄ 1+2–2i n
∏
= = y x v0 v1 v2 v32.1.2 Bakåtrotationsmoden
I bakåtrotationsmoden är inte rotationsvinkeln given utan CORDIC-algoritmen roterar en godtyckligt given vektor mot x-axeln. Genom att minimera y-komponenten på initialvektorn på detta sätt erhålls en approximation av vektorns fas och magnitud som resultat i z- och x-komponenterna. Tecknet på den kvarvarande y-komponenten används för att bestämma åt vilket håll mikrorotationen ska utföras. I figur 2.4 ser vi hur initialvektorn v0 roteras iterativt i bakåtrotation mot x-axeln. Ekvation 2.14 beskriver bakåtrotationmoden:
(2.14)
Resultatet av mikrorotationerna blir:
(2.15)
Figur 2.4 Bakåtrotation initierad med vektorn v0. xi+1 =xi–yi⋅ ⋅di 2–i yi+1=yi+xi⋅ ⋅di 2–i zi+1=zi–di⋅atan( )2–i di= – ign xs ( iyi) x′=K⋅ x20 +y20 y′=0 z′=z0+atan(y0⁄x0) K 1 R⁄ 1+2–2i n
∏
= = y x v0 v1 v2 -45o +26.6o2.2 KONVERGENS
För att konvergens ska kunna ske för en godtycklig vektor inom ett konvergensområde måste sekvensen av elementärvinklar, i vårt fall φi = arctan(2-i), bilda en bas och samtidigt uppfylla villkoren:
(2.16)
(2.17)
Konvergensen för CORDIC-algoritmen sker på grund av att φi = arctan(2-i) är mindre än summan av alla dom följande vinklarna (2.16). Konvergensområdet för basen av elemen-tärvinklar ges av summan av alla elemenelemen-tärvinklarna och betecknas med bokstaven C:
(2.18)
Detta betyder att för en godtycklig vinkel ϕ inom konvergensområdet, ϕ<C, kon-vergerar CORDIC-algoritmen med upplösning av den minsta vinkeln φmin. För en mer detaljerad diskussion hänvisas läsaren till [51]. CORDIC-algoritmens framåtrotation- och bakåtrotationsmod har en begränsad konvergens enligt (2.18), de konvergerar för vinklar mellan –1.74 och 1.74. Ett kort bevis:
2.2.1 Utvidgning av konvergensområdet
Ett flertal forskare har angripit problemet med det begränsade konvergensområdet, som CORDIC-algoritmen dras med. I huvudsak så är det två olika metoder som har presen-teras: (i) den första är en argumentreducerings metod och (ii) den andra är utvidgning av konvergensområdet.
Den första argumentreduceringsmetoden presenterades av Walther [51]. Han använder matematiska identiteter för att transformera initialvärdena till konvergensområdet. Metoden består av tre steg: (i) Reducera argumentet till ett givet konvergensområde, (ii) utför CORDIC-iterationerna, och (iii) kombinera resultatet med den initiala trans-formationen. Metoder som bygger på matematisk transformation [51], [54] kräver ökad chiparea och mycket mer exekveringstid. Därför har den andra metoden, som gör en begränsad utvidgning av konvergensområdet genom att repetera vissa utvalda iterationer [52], [55] varit av större intresse. I [55] så görs bland annat en utvidgning av
elementär-φi φk+φn–1 k>i
∑
≤ φi≥φi+1 C φi+φn–1 i=0 n–1∑
=utvidgas CORDIC-algoritmen konvergensområdet i det cirkulära kordinatsystemet till
φmax=3.3141(189.9o). Vilket är mer än tillräckligt för att CORDIC-algoritmen ska kon-vergera inom ±180o.
I [53] har Dirk Timmerman et.al återupptagit argumentreduceringsmetoden och vidare-utvecklat den för alla moder i algoritmen. I kontrast med Walters CORDIC-baserade implementation av expansionen använder Timmermann en skalbaserad struktur implementerad som en konstant multiplikation.. Emellertid för bakåtrotationsmoden i det cirkulära kordinatsystemet används sedan länge den beprövade metoden att rotera input-vektorn med ±90o om operanden befinner sig i kvadrant 3 eller 4. Se Timmermann et.al [53] för en mer sofistikerad beskrivning av övriga moder och kordinatsystem
2.3 SKALFAKTORSKOMPENSATION
För att få det riktiga rotationsresultatet från CORDIC-algoritmen så är det nödvändigt att multiplicera resultatet, vektorn v’, med 1/K, eller skala initialvektorn med 1/K. Dock ska man undersöka väldigt noggrant om en skalfaktorskompensation krävs i den specifika applikationen, då den tar plats och tid att utföra. Speciellt om en arkitektur med variabel skalfaktor används, då krävs det generellt sett iterationer för den variabla skalfaktors-kompensationen, som är likvärdigt med hela CORDIC-algoritmen.
Två grundläggande strategier kan identifieras för skalfaktorskompensation: (i) multi-plikation eller (ii) ytterligare iterationer. Skalningsiterationer kan utföras före, efter eller till och med mellan oskalade CORDIC-iterationer. Antalet skalningsfaktorer och dess parametrar är en funktion med precision n, på sådant sätt att den kortaste sekvensen av skalningsiterationer hittas genom uttömmande sökning. Resultatet av denna sökning ger som bäst en lösning på n/4 iterationer och i sämsta fall n/2 iterationer [101]. Repetition av vanliga CORDIC-iterationer kan även utföras för att få en skalfaktor som är lättare att kompensera, t.ex när skalfaktorn får en bas lika med två. Förfarandet är möjligt ty ensamma mikrorotationer går att repetera utan att konvergensen förstörs, se ekv. 2.16. Att göra en jämförelse mellan alla kända skalningsalgoritmer ligger utanför ramen för detta examensjobb då målapplikationen ej har användning av skalfaktorskompensation. En bra början för att skapa sig en överblick över kända algoritmer rekommenderas rapportena [56], [57], [102] och [103].
I rapporten [57] studeras möjligheten till att minimera skalfaktorns exekveringstid i CORDIC-arkitekturer. En överblick över alla skalfaktorsalgoritmer kända från litteratur fram till 1991 återges i rapporten och argumentation leder fram till vilka strategier som är bäst. De bästa strategierna för parallell implementering och seriell implementering är ej lika. För parallell implementation föreslås två olika kompensationsstrategier och för seriell implementering en. Alla metoder som presenteras har dock gemensamt att de är beroende av ordlängden.
I rapporten [103] introduceras två stycken nya skalfaktorskompensationsalgoritmer och arkitekturer. Arkitekturerna är optimerade för CORDIC-algoritmens olika operations-moder. Den ena kompensationsalgoritmen är ämnad för framåtrotationsmoden imple-menterad i antingen redundant eller konventionell aritmetik. Den andra kompensations-algoritmen kan användas i både framåt- och bakåtrotationsmoden men är endast till-ämplig i konventionell aritmetik. Kompensationen reduceras med hjälp av dessa algoritmer till att endast bestå av ett fixt antal iterationer. Den första algoritmen introducerar två extra iterationer utöver antalet som CORDICen använder och den andra algoritmen kräver 3 extra iterationer.
I rapporten [102] presenteras två stycken algoritmer, carry-analysmetoden och dubbel iterationsmetoden. De båda algoritmerna som föreslås medför att skalfaktors-kompensationen reduceras till att endast bestå av ett fixt antal iterationer oberoende av ordbredden. Carry-analysmetoden är effektiv i både framåt- och bakåtrotationsmoderna och kan implementeras i både i redundant och konventionell CORDIC. Metoden gör så att det totala antalet behövliga iterationer blir n+2 inkluderat kompensation. Dubbel-iterationsmetoden är effektiv jämfört med carry-analysmetoden på bekostnad av ökad komplexitet och metoden är endast applicerbar i framåtrotationsmoden. Jämförelse i rapporten [102] mellan algoritmerna i [57] och [102] visar att både exekveringstiden och kretskomplexiteten är bättre i den senare.
2.4 GENERELLA CORDIC-ALGORITMEN
Hittills är CORDIC-algoritmen endast härledd för det cirkulära kordinatsystemet. För att kunna räkna ut andra funktioner än trigonometriska, vilket görs i det cirkulära systemet, kommer vi i denna undersektion att definiera den generella CORDIC-algoritmen. Den generella algoritmen:
(2.19)
där di betecknar rotationsriktningen, S(m,i) iterationssekvensen och φm,i elementär-vinkeln. Variabeln m{-1,0,1} specificerar hyperboliska, linjära respektive cirkulära kordinatsystem, figur 2.5 illustrerar förfarandet.
xi+1= xi–m⋅yi⋅ ⋅di 2–S m i( , ) yi+1=yi+xi⋅ ⋅di 2–S m i( , ) zi+1 =zi–di⋅φm i, di sign z( )i för framåtrotation (z —> 0) s – ign x( iyi) för bakåtrotation (y —> 0) =
Figur 2.5 Koordinatsystem beroende av variabeln m.
Elementärvinkeln φm,i kallas även för vinkelkonstanten eller Arc Tangent Radix (ATR). Elementärvinkeln är beroende av vilket kordinatsystem som används:
(2.20)
Walther [51] visade att för det hyperboliska kordinatsystemet (m = -1) så håller ej konvergensen om iterations sekvensen S(-1,i) = 0, 1, 2, …, n används. Lösningen så att konvergensen uppfylls även för hyperboliska kordinater är att upprepa iterationerna 4, 13, 40, 121, ..., k, 3k+1,… i skiftsekvensen: (2.21) y x x = 1 m = 1 m = 0 m = -1 v0 v1 v2 φm i, 1 m --- atan m 2⋅ –S m i( , ) 2–S(–1 i, ) ( ) om m = -1 atanh 2–S 0 i( , ) om m = 0 2–S(1 i, ) ( ) om m = 1 atan = ⋅ = S m i( , ) S 1 i( , )=0 1 2, , , ,… n S 0 i( , )=0 1 2, , , ,… n S(–1,i)=1 2 3 4 4 5, , , , , ,…där (3i+1–1)⁄( )2 upprepas =
Skalningsfaktorn Km beror på antalet iterationer:
(2.22)
CORDIC-algoritmen konvergerar för värden inom konvergensområdet Cm:
(2.23)
Den generella CORDIC-algoritmen löser en mängd funktioner. Tabell 2.1 illustrerar dessa funktioner. I appendix A presenteras ytterligare tabeller som mer specifikt illustrerar de lösbara funktionerna.
Tabell 2.1
2.4.1 Utvidgning av CORDIC-algoritmen
I [48] gör Lang en allmän utvidgning av CORDIC-algoritmen i bakåtrotationmoden så att det är möjligt att rotera en inputvektor till en koordinat, istället för till x-axeln som i en konventionell CORDIC. T.ex. kan vektorn roteras till y = t. Med denna teknik kan inversa kinematiska problem [49], [50] och ekvationer som bcos(φ)+asin(φ) = c beräknas.
Kordinatsystem etc. Framåtrotation (z → 0) Bakåtrotation (y → 0)
Cirkulär (m = 1) C1 ~ 1.74 K1 = 1/R1 ~1.64676 S(m,i) = 0, 1, 2, ..., n Linjär (m = 0) C0 = 1.0 K0 = 1/R0 =1.0 S(m,i) = 0, 1, 2, ..., n Hyperbolisk (m = -1) C-1 ~1.1182 K-1 = 1/R-1 ~ 0.82816 S(m,i) = 1, 2, 3, 4, 4, 5... Km 1 R⁄ m 1+m d⋅ 2i⋅2–2S m i( , ) i=0 n–1
∏
= = Cm φm i, φmin 1 m --- m y0 x0 ---⋅ atan ⋅ för yn—> 0 z0 för zn—> 0 ≥ + i=0 n–1∑
= x′= K1⋅[x0⋅cos( )z0 –y0⋅sin( )z0] y′= K1⋅[y0⋅cos( )z0 +x0⋅sin( )z0] x′ K1 x 2 y2 0 + 0 ⋅ = z′= z0+atan(y0⁄x0) x′= xo y′= (y0+x0⋅z0) x′=xo z′= (z0+y0⁄x0) x′= K–1⋅[x0⋅cosh( )z0 +y0⋅sinh( )z0 ] y′= K–1⋅[y0⋅cosh( )z0 +x0⋅sinh( )z0 ] x′ K–1 x 2 y2 0 – 0 ⋅ = z′= z0+atanh y( 0⁄x0)3
Noggrannhet i
CORDIC-algoritmen
I en hårdvaruimplementering av CORDIC-algoritmen kan endast ett begränsat antal iterationer utföras och endast ett begränsat antal bitar kommer att finnas tillgängliga för d a t a p r o c e s s e r i n g . P å g r u n d a v d e s s a b e g r ä n s n i n g a r k o m m e r s k i f t - o c h additionsoperationerna i CORDIC-processorn att inducera fel i systemet. För att uppnå en optimal prestanda/kostnad-kompromiss i en implementering och kunna uppskatta effekten den specificerade noggrannheten har på den implementerade hårdvaran så är det nödvändigt att känna till felkällorna i en given CORDIC-arkitektur.
Källan till felen i CORDIC-algoritmen har analyserats utförligt av Hu [58]. I rapporten analyserar Hu olika felkällor för alla moder i CORDIC-algoritmen. I [59] reformerar Bass et.al om Hus modell och lägger till ytterligare en felkälla som Hu försummade. I [60] analyserar Kota och Cavallaro det maximala felet i bakåtrotationsmoden och ett normaliserings schema för att reducera det uppkomna felet presenteras och i rapporten [61] presenterar Antelo et.al ytterligare en algoritm för att kompensera för felet i bakåtrotationsmoden.
3.1 FELKÄLLOR I CORDIC-ALGORITMEN
Felen som sker i CORDIC-aritmetiken kan delas upp i två delar enligt Hu [58]: (i) Det första felet är vinkelapproximationsfel, då antalet iterationer är begränsat kan en given vinkel ej representeras exakt av elementärvinklarna. (ii) Det andra felet är avrundnings-fel, då aritmetiken har begränsad precision kommer trunkeringsfel att uppstå. Storleken på dessa fel går emellertid att kontrollera: avrundningsfelet genom att addera extra guard bitar, och vinkelapproximationsfelet genom att utföra ytterligare iterationer. I rapporten [59] utvidgas antalet felkällor i CORDIC-implementeringar till att vara tre. Detta fel och uppkomsten av andra två felen som nämnts ovan kommer i de följande sektionerna att presenteras noggrannare och varifrån de härstammar.
3.1.1 Approximationsfel
Den första källan av fel enligt Hu [58] är approximationsfelet. Approximationsfelet är bundet till z-delen och är definierat som felet i resultatvektorn beroende på fel i approxi-mationen av den önskade vinkelrotationen. Felet består av två parter: (i) en part beror på det ändliga antalet mikrorotationer och (ii) den andra parten beror på den begränsade nummerrepresentationen av elementärvinklarna (ATR).
Den första parten av approximationsfelet kan tas fram om alla andra felkällor i CORDIC försummas utom vinkelfelet, då är noggrannheten av den n:te iterationens resultat begränsat av storleken på den sista elementärvinkeln. Det relativafelet på grund av vinkelapproximationen i det cirkulära koordinatsystemet för framåtrotationsmoden är bundet till [58], [60]:
(3.1)
Källan för den andra delen av det totala approximationsfelet finner vi i z-delen där felet orsakas av kvantiseringen av inputvinkeln z0 och den kvantiserade fixpunkts-representationen av elementärvinklarna. Felet är bundet av [106]:
(3.2)
där µ0 representerar det maximala absoluta inputfaskvantiseringsfelet och µ absoluta avrundningsfelet av elementärvinklarna αi. Approximationsfelet beror på precisionen (bråkdelen = b) i z-datavägen på följande vis: (µ0= 2-b, µ= 2-b) om trunkering används och (µ0= 2-b-1, µ =2-b-1) om rundning används för att få fixpunkts-representation.
δn 2 n–1 ( ) – för n ≥1 ≤ θn µ0+nµ för 0≤ ≤n b+1 µ0+(b+2)µ för n > b+1 ≤
3.1.2 Avrundninsfel
Det andra källan av fel enligt Hu [58] är det numeriska avrundningsfelet, som sker på grund av den begränsade ordbredden i mikrorotationerna. Felet är bundet till x/y-delen och härstammar från avrundnings-/trunkeringsfelet som induceras i skiften av x/y-variablerna. I varje CORDIC-iteration består avrundningsfelet av två komponenter: (i) avrundningsfelet propagerat från de tidigare iterationerna och (ii) det nya felet som introduceras i den pågående iterationen. En implementering utan avrundning eller trunkering kräver att datavägen för både x/y-datavägarna är 2n bitar, vilket blir orimligt. Metoden att föredra i CORDIC-algoritmen har visat sig vara avrundning, på grund av att metoden inducerar minst fel i CORDIC-processorn [62]. Läsaren hänvisas till [58], [59], [60] för en matematisk analys och bevis av de följande gränsvärdena. Trunkeringsfelet för en CORDIC-processor i det cirkulära koordinatsystemet blir [58]:
(3.3)
där ε0 är maximala absoluta inputkvantiseringsfelet i x0 och y0, ε är precisionen (bråkdelen) på fixpunkts-representationen i x/y-datavägarna definierad enligt: ε = 2-b, vilket är det maximala absoluta avrundningsfelet1 i xi och yi. Om vi antar att input-kvantiseringsfelet ε0 är noll så kanfn förenklas enligt följande [60]:
(3.4)
3.1.3 Rotationsriktningsfel
I [59] utvidgar Xiabo Hu antalet felkällor i CORDIC till tre. Hu [60] antog i sina analyser att mikrorotationssekvenserna var identiska i det ideala systemet och det verkliga systemet när han härledde formlerna för felkällorna i CORDIC. Detta är dock inte alltid fallet har Hu [59] visat. Avrundningsfel som ackumuleras i ett register, vars innehåll drivs mot noll kan få små positiva värden att se ut som små negativa värden eller vice versa. Detta medför att i det verkliga systemet kan en rotation di antas, som ej överensstämmer med rotationen som valts i det ideala systemet och således kommer rotation ske åt olika riktningar. Detta fel, som Xiabo Hu kallar di-fel, måste man ta med i beräkningarna när man uppskattar det totala felet i en CORDIC-implementation. Läsaren hänvisas till [59] för matematiskanalys.
1 Vilket i sin tur beror på bit trunkering i fixpunkts-aritmetiken som sker i varje iteration.
fn 2 ε0 k i( ) ε 1 k i( ) i=j n–1
∏
j=1 n–1∑
+ + i=0 n–1∏
, k(i) = 1+2–2i ⋅ ≤ fn <1.5⋅ ⋅ε n för n > 1Ett annat sorts rotationsriktningsfel än det som nämns ovan kan inträffa om två-komplements representation används i en CORDIC-implementering. Felet uppstår i implementeringar som använder trunkering och då vektorn (x,y) har en negativ komponent. I de sista iterationerna när stora högerskift av operanderna sker, kommer högerskiftningen av den negativa operanden konvergerar mot -1 istället för noll som förväntat. Emellertid så går det att enkelt kompensera för detta genom att använda rundning istället för trunkering, då försvinner problemet.
3.2 MAXIMALA FELET I CORDIC
I denna sektion presenteras ett uttryck för det maximala felet som uppstår i en CORDIC-processor. Utifrån de i sektionerna ovan givna uttrycken för felen kan teoretiskt sett antalet bitar som krävs för att få önskad noggrannhet beräknas. Emellertid är detta gränsvärde positivt uppskattat. I realiteten krävs det simuleringar för att inte överskatta ordbredden hos datavägarna och därigenom tillsätta onödig hårdvara.
Det maximala felet i x/y-komponenterna i en fix punkts CORDIC-processor är bundet och kan räknas ut enligt följande [60] [106]:
(3.5)
där v*n = [x* y*]T är den ideala outputvektorn teoretiskt producerad med oändlig precision, vn = [xn yn]T är outputvektorn beräknad i en verklig implementation, vin är inputvektorn i oändlig precision och Kn skalfaktorn i oändlig precision. δn är vinkel-approximationsfelet, θn beskriver felet orsakat av trunkeringen/avrundningen i zi och fn är avrundningsfelet i x/y -datavägarna.
Ekvation (3.5) kan skrivas om till [60]:
(3.6)
Om alla datavägar är lika breda kan ekvation (3.6) förenklas till [60]:
(3.7)
där n är antalet rotationer och b är bråkdelen i x/y/z-datavägarna. vn ∆ = v∗n –vn ≤ vin ⋅(δn + θn)⋅Kn+ fn vn ∆ v∗n –vn vin 2 n–1 ( ) – n 2⋅ –b + ( )⋅Kn+1.5 2⋅ –b⋅n ⋅ ≤ = vn ∆ <2–n+3.5 2⋅ –b⋅n
3.2.1 Intern ordbredd
Walther tillägnade en sektion i sin rapport [51] till att bedöma noggrannheten i CORDIC-processorn. Han analyserade x/y-iterationerna som om de ej var beroende av z-iterationerna och kom fram till att log(n) extra bitar på minst signifikanta sidan i CORDICen var tillräckligt för att få n-bitars noggrannheten av n iterationer.
Kota och Cavallaro [60] räknar emellertid fram ett annat värde. Med utgångspunkt från Hus rapport [58], i vilken Hu har gjort en grundlig matematisk härledning beräknar Kota och Cavallaro fram, med antagandet att x, y och z iterationerna ej är oberoende av varandra, att det krävs log(n) + 2 extra bitar på minst signifikanta sidan för att få n-bitars noggrannheten av n iterationer. Detta värde är numeriskt beräknat utifrån ekvation (3.7 ) och utgö r id ag en övre an alytiskg räns för no gg rannheten i CORDIC-implementeringar. Ytterligare bitar krävs dessutom på mest signifikanta sidan av CORDICen då vektormagnituden, som känt, ökar i varje iteration.
I realiteten appliceras värdet log(n) + 2 vid konstruktion. Emellertid då värdet utgör en teoretisk övre begränsning bör rimligtvis en stramare begränsning av ordbredden existera. Därav krävs det uttömmande simuleringar av CORDIC-processorn för att optimera ordbredderna på datavägarna.
3.3 FEL I BERÄKNING AV ARCTAN
I [60] har Kota och Cavallaro publicerat felanalys av kvantiseringsfelet i vinkel-ackumulatorn och problem som uppstår i arctangensberäkningar. De påvisar att fix punkts CORDIC-implementeringar, som löser arctangensfunktionen, kan ge oacceptabelt stora fel om inputvektorn är för liten. Förklaringen till felet är att de successivt större högerskiften i x/y-datavägarna kan resultera i förlust av alla signifikanta bitar om inte x0 och y0 är tillräckligt stora. Ekvation 3.8 illustrerar felet.
(3.8)
där
I ekvation (3.8) är θ det sanna arctangens värdet som ska evalueras medans ϕ är den verkliga ackumulerade vinkeln i z-kordinaten i en implementering. Kn är skalfaktorn, µ är precisionen i z-datavägen, yn är avrundningsfelet i y-kordinaten och ε = 2-b.
θ ϕ– yn Kn x2+y2 --- asin nµ 0 0 + < yn<1.5εn
Ekvation (3.8) visar att felet ökar om magnituden på inputvektorn minskar och att stora fel-resultat kommer att erhålls då både x0 och y0 går mot 0. Felet är med andra ord ej bundet till en konstant. Den första termen i (3.8) härstammar från approximation och avrundningsfel i y-kordinaten och den andra termen beror på avrundnigsfel i z-datavägen.
3.3.1 Normalisering
För att råda bot på felet i bakåtrotationsmoden föreslår Kota & Cavallaro [60] inputnormalisering; inputvektorn skalas före den första CORDIC-iterationen. Normaliseringen utförs genom att vänsterskifta operanden så att den största kordinaten hamnar inom intervallet [0.5,1). Felet kommer då att vara bundet av en övre gräns [60]:
(3.9)
där n är antalet rotationer, µ är precisionen i z-datavägen och m är den totala ordbredden i x/y-datavägarna. Notis: formeln 3.9 är grundad på att x/y-datavägarna har en teckenbit och två stycken guardbitar i msb, se [60] för ytterligare analys och förklaring.
Implementationen av normaliseringen är emellertid komplex och kräver relativt stor implementerings area. Operationen kräver två stycken “leading zeros detection“ avkodare för att ta reda på hur mycket varje komponent kan skiftas. En komparator för att välja den minsta av de två skift-parametrarna, som noll avkodarna levererar och där efter barrelskiftare som utför skiftoperationen. Operationen bör pipelinas för att erhålla en bättre throughput och skiftoperationen bör implementeras med endast ett antal utvalda fördefinierade skift för ändamålet att reducera kostnaden av en implementation. I [118] presenterar Antelo et.al en mindre area krävande normaliseringskrets som är lämplig för CORDIC-algoritmen. Metoden reducerar arean samtidigt som exekveringstiden bevaras. I rapporten [60] föreslås en alternativ lösning till normalisering; partiell normalisering. Partiell normalisering innebär att normaliseringsskiften är distribuerade bland mikrorota-tionerna. Efter varje CORDIC-iteration skiftas x- och y-kordinaten vänster ett antal bitar med hjälp av kontroll logik tills det totala önskade skiftet är uppnått. Då normaliseringen är distribuerad bland mikrorotationerna finns endast ordbredden på CORDICens dataväg tillgängligt för att utföra normaliseringen. Konsekvensen av detta är att det resulterande felet blir oacceptabelt stortom inputoperanden har avrundats för att passa inputformatet i CORDICen. Emellertid om exakta inputoperander beaktas kommer felet att vara acceptabelt.
Figur 3.1 illustrerar en normaliserad CORDIC med w-bitars inputoperander. Om inputoperanden är exakt kommer exekveringen att alstra acceptabla resultat. Om däremot inputoperanden måste avrundas för att passa ordlängden i CORDICen måste 2n bitar finns tillgängliga vid normaliseringen för att resultatet ska vara acceptabelt [60].
θ ϕ– n
2m–4 ---+nµ
Figur 3.1 Normaliserad CORDIC.
Partiell normalisering är begränsad till iterativa icke-redundanta CORDIC-processorer. Att metoden ej är kompatibel med redundans beror på att fler jämförelser krävs i normaliseringssteget om redundant nummerrepresentation används och metoden blir då ineffektiv. En pipelinad design bör heller ej använda sig av partiell normalisering. Detta beror på att två stycken barrelskiftare måste implementeras i varje steg för att utföra operationen, vilket är orimligt.
I rapporten [61] föreslås en alternativ lösning till både normalisering och partiell norma-lisering. Metoden är en enklare form av normalisering och består av ett initialsteg som skalar inputoperanderna. Skalningsoperationen realiseras enligt följande algoritm:
(3.10)
Skalningen utför endast när inputoperanden är liten, därför definieras M som:
(3.11)
där s1 och s2 väljs på lämpligt sätt, se rapporten [61].
Skalningen 3.11 kombinerar Antelo et.al [61] med en CORDIC som använder Langs modifierade CORDIC-rotation [42], [4] för bakåtrotationsmoden. Genom att använda Langs mikrorotationsalgoritm så minskar det totala felet drastiskt jämfört med om den
Normalisering w-bitar w-bitar Input-operander n bitar b bitar CORDIC x0,y0 ( ) = M⋅(xin,yin) M 1 om x0 ≥2–s1 eller y0 ≥2–s1 2s1 om 2–s2≤ x0 <2–s1 och 2–s 2≤ y0 <2–s 1 2s2 annars =
konventionella CORDIC-algoritmen används. Detta beror främst på att avrundningsfelet i w-kordinaten har eliminerats, vilket leder till ett mindre ackumulerat fel i resultatet, se avsnitt 5.1.3.3. En direkt följd av detta är att ordbredden i en CORDIC-realisation som använder sig av Langs-rotationer ej behöver vara lika breda som i en konventionell CORDIC-processor.
Om icke-redundant aritmetik används för att implementera metoden är designen enkel. Om redundant aritmetik däremot används för att implementera CORDICen och skalningen så uppstår vissa problem. Metoden [42] för variabel skalfaktor och [4], [41] för konstant skalfaktor använder sig av inputnormalisation, vilket vi har försökt att undvika. DCORDIC-algoritmen kräver emellertid ej inputnormalisering, se avsnitt 5.3.2. Genom att modifiera DCORDIC-algoritmen [13] till att använda Langs iterationsteknik [42] så erhåller vi en bättre lämpad algoritm för metoden 3.11, ekvationerna blir [61]:
(3.12)
Observera att om inputoperanden måste avrundas för att passa ordbredden i en CORDIC-processor så är det enbart vanlig normalisering som ger acceptabla fel och att 2n bitar måste finnas tillgängliga.
xi+1=xi+wi⋅2–2i wi+1= wi –xi
4
CORDIC-arkitekturer
Det existerar i princip två stycken grundläggande CORDIC-arkitekturer: (i) iterativ arkitektur och (ii) utbredd arkitektur. En utbredd arkitektur har fördelen av en hög throughput, men detta kommer på bekostnad av mycket hårdvara. En iterativ design däremot minimerar hårdvarubehoven genom att algoritmen endast utnyttjar en enhet. Emellertid kräver en iterativ design komplex styrlogik och dynamiska skiftoperationer. En CORDIC-processor består av två funktionsmoduler; (i) CORDIC-iterationerna och (ii) vinkeluppdateringsackumulatorn. Dessa moduler kan implementeras på en mängd olika vis och valet av implementation beror på konstruktörens behov/begränsning av throughput, latency och area. CORDIC-implementationer uppvisar en prestanda/die-area kompromisskurva och i realiteten så väljs en av ytterligheterna fullt pipelinad eller seriell implementering. I de följande undersektionerna kommer tre stycken olika karaktäristiska/ grundläggande arkitekturer av CORDIC-algoritmen att presenteras.
4.1 BIT-PARALLELL ITERATIV CORDIC
En iterativ CORDIC-arkitektur erhålls enkelt om man implementerar de två modulerna som realiserar en CORDIC-processor, se figur 4.1. En bit-parellell design använder ett block av hårdvara för alla n-mikrorotationer. Latencyn blir därav n-klockcykler mellan initieringen av datan till att resultatet finns tillgängligt.
Tecknen på mikrorotationsriktningana di, drivs av z- eller y-registren, beroende på vilken operations mod som används. Steg ett är att initialvärdena x0, y0 och z0 laddas in i x, y och z-registren via multiplexrar. De följande n klockcyklerna passerar värdena från registren först genom skift- och additionsoperationerna och sedan placeras värdena i registren igen. Skiftoperationerna modifieras för varje iteration för att åstadkomma den önskade skiftningen. Därtill räknas adressen upp för varje iteration som sker, så att rätt elementärvinkel induceras till adderaren z-datavägen. En enkel tillståndsmaskin behövs för att hålla rätt på iterationerna, och att välja rätt antal skift samt ROM-adress till varje iteration. Efter sista iterationen läses resultatet direkt från adderarna/subtraherarna.
Figur 4.1 Strukturen av en bit-parallell iterativ implementation.
Add/Sub Add/Sub Add/Sub
2-i 2-i Reg Reg ROM Reg sign(z) sign(yi) x0 y0 z0
xi+1 yi+1 zi+1
4.2 BIT-SERIELL ITERATIV CORDIC
En mer kompakt design är möjlig om man använder bit-seriell aritmetik. Den enklare logiken och bussarna i en bit-seriell design tillåter den att arbeta med mycket högre frekvens jämfört med motsvarande bit-parallella design. Den bit-seriella designen består av tre bit-seriella adderare, tre skiftregister och ett seriellt ROM. Dessutom krävs det multiplexrar för att välja ut bitar till korstermen, som ska höger skiftas, ur skiftregistren. Den bit-seriella arkitekturen illustreras i figur 4.2.
Figur 4.2 Strukturen hos en bit-seriell iterativ arkitektur.
Initialvärdena laddas genom att multiplexrar till vänster öppnas. Datan skiftas sedan höger in genom den seriella adderaren/subtraheraren och vidare tillbaks in i skiftregisteret igen. Varje iteration kräver (w) stycken klockpulser för att återvända till registret. I början på varje iteration läser tillståndsmaskinen av tecknet på y eller z registret och sätter di samt bestämmer vilka bitar som ska ingå i korstermen. Designen medför att kors-kopplingarna endast blir en bit vida, vilket innebär att arean reduceras jämfört med en bit-parellell design.
4.3 BIT-PARALLELL UTBREDD CORDIC
Istället för att återanvända samma resurs om och om igen så kan modulerna enkelt kaskadkopplas. Då erhålls en parallell utbredd CORDIC-processor, se illustration i figur 4.3. Genom att stegen numera är separata kan två stycken förenklingar göras: (i) Den första är att skiftoperationerna, som består av barellskiftare, kan tas bort. Skiftningen implementeras genom ”hardwired shifts”, vilka är mindre area- och tidskrävande än
Seriell add/sub x0 y0 z0 xi+1 yi+1 zi+1 Mux Mux Mux Mux Register Register Seriell add/sub
Mux Register Seriell
add/sub Seriellt ROM
barrelskiftare. (ii) Den andra förenklingen är att rotationsvinklarna kan distribueras till adderarna/subtraherarna.
Figur 4.3 Strukturen hos en bit-parallell utbredd CORDIC.
En rent utbreddarkitektur består endast av kombinatoriska komponenter och alla rotationsoperationer utförs på en klockcykel. En pipelinad parallell implementering är precis som beskriven ovan med skillnaden att varje mikrorotation är buffrad med register. En fullt pipelinad arkitektur leder till en regelbunden arkitektur med hög throughput. Pipeliningen kan sättas in på olika nivåer i designen med konsekvensen av olika kostnad och prestanda. I rapporterna [76] och [77] definierar och utvärderar Swartzlander et.al. olika pipelinenivåer i CORDIC-processorer. Genom att variera antalet mikrorotationer, som utförs i varje pipelinesteg tar de fram kretskomplexiteten vs. prestanda i implementationer. Därtill presenteras prestanda samt kretskom-plexitet i CORDIC-implementationer som använder olika sorters adderare. Rapporterna kan användas som vägledning för att välja den optimala arkitekturen med hänsyn till behov och begränsningar på den specifika applikationen.
Add/Sub Add/Sub Add/Sub
20 20
x0 y0 z0
x' y' z'
sign
Add/Sub Add/Sub Add/Sub
2-1 2-1 sign
tan-12-0
tan-12-1
Add/Sub Add/Sub Add/Sub
2-(n-1) 2-(n-1)
sign tan -12-(n-1)
5
CORDIC-
implementeringar
CORDIC-algoritmen lider av fyra nackdelar. Den första är behovet av en skalfaktor, den andra nackdelen är att CORDIC-algoritmen är beroende av carry-propagate-adderare och är därför långsam. Den tredje nackdelen är dess iterativa natur, vilken begränsar eval-ueringshastigheten och den fjärde och sista nackdelen är dess begränsade konvergens. Traditionellt sett så utfördes CORDIC-implementeringen i radix-2 bit-seriell iterativ design med konventionell icke-redundant aritmtik med fix punkts representation. Pipelining av implementeringarna har sedan skett för att öka throughputen på dessa arkitekturer. I kapitel 4 gavs exempel på andra konventionella arkitekturer för CORDIC-algoritmen. Alla dessa implementationer är carry-ripple beroende och är i sammanhanget relativt långsamma. Genom att applicera snabba adderare1 kan emellertid dessa arkitek-turer göras attraktiva och användas framgångsrikt.
För att öka exekveringshastigheten i CORDIC-arkitekturen har radix-2 redundant teknik införts för att rationalisera bort carry-propagate fördröjningarna i de konventionella adderarna. Olika arkitekturer med CSA eller signed-digit adderare (SDA) har present-erats. Dessa tekniker levererar överlägsen hastighet på grund av att ingen carry-propagation från LSB till MSB är nödvändig. Se appendix B för klarläggning.
Tyvärr så introducerar teknikerna problem: tecknet på ett tal kan inte avläsas lika lätt i redundant teknik. Den mest signifikanta biten i redundant teknik kan vara noll. Detta innebär att rotationsriktningen kan sättas till noll, vilket i sin tur medför att den fixa skalfaktorn ej längre blir konstant. Komplexiteten ökar då det krävs ytterligare hårdvara för att kompensera för denna variabla skalfaktor. För att råda bot på den variabla skalfaktorn måste helt enkelt fler bitar kontrolleras för att bestämma tecknet i redundant teknik. I absolut värsta fall måste alla bitar kontrolleras, från mest signifikanta biten till den minst signifikanta biten. Detta medför att den ökade hastigheten som erhålls med redundant teknik går helt förlorad.
För att överkomma problemen som redundansen skapar utnyttjar de flesta CORDIC-lösningar ett fönstersystem där endast ett antal MSD inspekterades. I t.ex. Takagis metod [2] kan ett fönster av 3 siffror inspekteras för att bestämma tecknet. Figur 5.1 illustrerar en parallell CORDIC-arkitektur som använder sig av redundanta adderare.
Figur 5.1 Parallell redundant CORDIC-arkitektur i framåtrotationsmoden.
I varje iteration skiftas fönstret åt höger en bit. Om åtminstone en av siffrorna i fönstret är skild från noll kan tecknet bestämmas på residuevinkeln. Emellertid då inte alla siffror inspekteras finns möjligheten att det ej går att fastställa tecknet korrekt, vilket medför att konvergensen blir förstörd på grund av att rotation kan ske åt fel håll. Detta kompenserar man genom att repetera en iteration efter ett visst antal mikrorotationer.
4-2 CSA alt. SDA
x0
xw-1
y0
yw-1
4-2 CSA alt. SDA 4-2 CSA alt. SDA
3-2 CSA alt. Hybrid SDA
Val av d
i
zw-1
z0
ATR
3-2 CSA alt. Hybrid SDA
Val av d
i
4-2 CSA alt. SDA
3-2 CSA alt. Hybrid SDA
Val av d i Konvertering Konvertering Skalning Skalning xresultat yresultat
sign sign sign sign
Tekniken ovan, som kallas korrektionsiterationsmetoden, är pionjären för redundanta CORDIC-processorer med konstant skalfaktor, CFR. Ytterligare CFR tekniker har presenterats. Ofta har dock CFR-systemen resulterat i antingen ökat antal iterationer [2], [3], svårighet att pipelina [11], eller en stor implementeringsarea [8], [10].
Många förslag har givits för att lösa de ovan nämnda problemen och för att förbättra prestandan i processorer. Populära tekniker för att snabba upp CORDIC-implementationer är följande:
• Redundant addition, t.ex. [2] m.fl.
• Snabb bestämning av rotationsriktningar genom inspektion av ett par MSB, [2] m.fl. • Hoppa över onödiga iterationer, t.ex. [91] m.fl.
• Effektiv avkodning av rotationsvinkeln för att reducera antalet iterationer, [80] m.fl. • Applicera högre radix. t.ex. [24] m.fl.
• Parallell framtagning av rotationsriktningar, t.ex [11] m.fl.
I undersektionerna nedan följer en genomgång av CORDIC-processorer som bland annat använder sig av dessa sex tekniker. För vårt behov är det tillräckligt att endast använda det cirkulära koordinatsystemet och därför är de följande undersektionerna koncentrerade till realisationen av “cirkulära“ CORDIC-processorer. Avsnittet är uppdelat i tre delar: (i) den första delen behandlar CORDIC-arkitekturer som är baserade på snabb bestämning av rotationsriktningarna genom inspektion av ett par MSD. I den andra (ii) delen behandlas CORDIC-arkitekturer som är baserade på parallell framtagning av rotationsriktningarna och i den tredje (iii) delen behandlas arkitekturer som ej passar in i de andra två undersektionerna
5.1 SEKVENTIELL FRAMTAGNING AV D
I
Avsnittet behandlar CORDIC-arkitekturer som är baserade på snabb bestämning av rotationsriktningarna genom inspektion av ett antal MSB.
5.1.1 Korrektionsiterationer
Korrektioniterationsmetoden [2], [3] är en teknik som gör så att skalningsfaktorn förblir konstant trots att redundant aritmetik används. I korrektioniterationsmetoden för framåt-rotation, presenterad i [2] och [3] är ej fallet di = 0 tillåtet. Om inte tecknet på zn residuen går att fastställa genom inspektion av ett fönster bestående av ett antal MSB så utförs det en mikrorotation ändå. Då väljs di = +1 (en liknande algoritm får man om man väljer –1). Genom att utföra denna rotation utförs ett fel, men felet är litet då det var svårt att säker ställa tecknet på zn. Felet rättas till genom att utföra extra rotationer. En relation mellan antalet inspekterade MSB och antalet iterationer som måste dubbleras existerar. För p inspekterade bitar måste vart (p-1) iteration upprepas [2]. Om tre MSB används till att bestämma rotationsriktningen leder detta till att 50% ytterligare itera-tioner måste utföras. I Nolls [3] arkitektur är en dubblering av varannan iteration nödvändigt när en inspektion av 4-msb sker.
I [4], [41] presenterar Lang et.al. en utvidgning av Takagis modell [2] till att även operera i bakåtrotationsmoden. CORDIC-processorn är uppdelad i två delar: (i) Den första delen av CORDICen består av Takagis kompensationsiterationsmetod där t bitar används för att bestämma rotationsriktningen. Operationen att ta fram rotationsriktningen ur dessa bitar kan till exempel utföras genom att addera de redundanta bitarna och detektera tecknet. Intervallet mellan korrektionsiterationerna måste vara mindre eller lika med (t-2) för att algoritmen ska konvergera. Då korrektionsiterationerna ej behöver inkluderas exakt varje t-2 iteration skänker detta flexibilitet och hjälper till att minimera det totala antalet iterationer. (ii) I den andra hälften av iterationerna (i ≥ n/2) visar Lang att valet av di (-1, 0, 1) inte längre påverkar magnituden på vektorn, och således krävs ej korrektions-iterationer därefter. Denna del implementeras därför i en snabbare CORDIC-metod, som annars skulle ge en variabel skalfaktor [42]. En ytterligare kompensationsrotation krävs emellertid efter (n) iterationer för att konvergens villkoret ska vara uppfyllt. Prestandan i implementationen är dock inte vidare bra jämfört med andra bakåtrotations CORDICar. Latencyn i arkitekturen är ca 4.5n TFA.
Att valet av di ej påverkar magnituden på vektorn för iterationer i ≥ n/2 kan även exploateras i korrektionsiterationsmetoden när den arbetar i framåtrotationsmoden. Istället för att använda mikrorotationer baserade på radix-2 aritmetik kan rotationer baserade på till exempel radix-4 nummer systemet användas för att reducera det totala antalet iterationer i arkitekturerna [2], [3]. På detta sätt kan antalet iterationer i andra hälften minskas med 50% utan att skalfaktorn påverkas.
5.1.2 Dubbelrotation
En dubbelrotations teknik i det redundanta talsystemet för framåtrotationmoden har föreslagits av Takagi [1], [2]. Tekniken garanterar en konstant skalfaktor medan endast 3 MSB inspekterades. Grundidén bakom dubbelrotationsmetoden är att varje mikrorotation består av två stycken subrotationer. En vanlig mikrorotation med rotationsvinkeln arctan(2-i) halveras istället och exekveras två gånger istället. En mikrorotation består antingen av två negativa (di = -1), två positiva (di = 1) eller en positiv följt av en negativ subrotation (di = 0). Fallet då di = 0 undviks därav smidigt i beräknandet av skalfaktorn, och således förblir skalfaktorn konstant, (di2 = 1). Rotationerna blir:
Nackdelarna med implementationen är att man får en ökning av ungefär 50% hårdvara och nästan en dubblering av exekveringstiden i varje mikrorotationssteg. Denna dubblering krävs emellertid endast för första hälften av det totala antalet rotationer och således reduceras komplexiteten för iterationerna i andra hälften.
Prestandan i Takagis dubbeliterationsmetod är snarlik korrektionsiterationsmetoden, som för övrigt är en generalisation av dubbeliterationsmetoden. Den totala exekveringstiden motsvarar cirka 3.75n TFA. För en snabbare och bättre implementering av Takagis dubbeliterationsmetod se sektion 5.1.7.
5.1.3 On-Line CORDIC
Generellt sett så fungerar on-line CORDIC-algoritmer genom att processa msd först med en siffra i taget och resultatet genereras i samma format med en låg latency. Rotations-riktningarna på mikrorotationerna di bestäms genom inspektion av ett antal msb.
Motivering för användandet av on-line implementeringar är att den reducerar den totala implementerings arean och reducerar kommunikations bandvidden. Den stora fördelen med en on-line implementering jämfört med en parallell är att de areaförbrukande skiften i en parallell implementering ersätts med mycket mindre areakrävande D-latchar. Läsaren hänvisas till appendix B för utförligare fundamenta om on-line tekniken.
5.1.3.1 Lin och Sips [45] lockades av den reducerade arean och den låga latencyn, som
en on-line CORDIC-algoritm kan ge, emellertid resulterade deras algoritm i en icke önskvärd variabel skalfaktor på grund av den redundanta radix-2 nummer representa-tionen i algoritmen. Lin och Sips transformerar CORDIC-iterationssekvensen till en on-line version enligt:
För di= ±1 d→ i⋅atan(2–i–1) och di⋅atan(2–i–1) För di= 0 → 2atan( –i–1) och –atan(2–i–1)
(5.1)
där xi+δ, yi+δ och zi+δ är de nya inputsiffrorna av X, Y och Z producerade vid i:te iterationen. ∆Xi+1 och ∆Yi+1 är korrektionstermer som krävs för att korrigera fel som introduceras på grund av att termerna xi+δ och yi+δ saknas i tidigare iterationer. För ytter-ligare utvidgning och förklaringar hänvisas läseren till [45]. Algoritmen som Lin och Sips föreslår är applicerbar både i framåtrotation- och bakåtrotationsmoden.
5.1.3.2 Hamill et.al. [43], [44] modifierade Lin och Sips on-line CORDIC till att få en
konstant skalfaktor med den positiva konsekvensen att implementeringsarean minskar. Hamills CORDIC-processor är baserad på Takagis dubbelrotations metod [2]. Algorit-men är för bakåtrotationsmoden och är lämplig för VLSI impleAlgorit-mentering då den är regelbunden och kräver endast ett mindre antal enkla celler. Därtill så reducerar även algoritmen latencyn jämfört med Lin och Sips implementation. .
5.1.3.3 Ercegovac och Lang [42] har framfört användandet av on-line CORDIC och har
presenterat implementationer av on-line CORDICar för både framåt- och bakåtrotation. Likt Lin och Sips algoritm resulterar även Lang et.als implementering [42] i en variabel skalfaktor på grund av att rotationsriktningarna tillåts anta värden ur det redundanta setet {-1, 0, 1}. Emellertid så förbättrar Lang et.al. CORDIC-algoritmen genom att modifiera parametern yi enligt:
(5.2)
Då kan CORDIC-iterationerna för bakåtrotationsmoden skrivas om till:
(5.3)
Transformationen (5.2) gör så att endast skiftoperationen i x-datavägen blir kvar. Därtill kan vi notera att värdet på xi inte ändras efter iteration i = n/2. Det betyder att xn = xn/2 för n bitars precision. Fler positiva egenskaper är att rotationsriktningbestämningsalgoritmen förenklas. För SD-nummer blir den [42]:
X′i+1=X′i+di⋅Y′i⋅2–i+∆Xi+1(xi+δ,yi+δ) Y′i+1=Y′i+di⋅X′i⋅2–i+∆Yi+1(xi+δ,yi+δ) Z′i+1=Z′i–di⋅θi+zi+δ⋅2–(i+δ) wi = 2i⋅yi xi+1 =xi+di⋅2– i2 ⋅wi wi+1= 2 w( i+di⋅xi) zi+1 =zi+di⋅atan( )2–i
(5.4)
där är en uppskattning (trunkering) av wi till 3 MSD. Emellertid kräver metoden/ algoritmen att antingen x0 eller w0 är normaliserad med magnituden > 1/2. Dessutom måste x0 > 0 om algoritmen ska konvergera.
Lang et.als algoritm kan vara av intresse om enbart arctangens beräkningar ska utföras. Om däremot sin, cos eller magnituden ska beräknas måste en skalningsoperation imple-menteras. Detta kommer att påverkar latencyn och arean negativt och bättre metoder finns då att tillgå.
Jämförelse mellan implementeringarna [41] och [42] talar om att exekveringstiden är ungefär lika för de båda algoritmerna. Detta beror på att i implementationen med konstant skalfaktor [41] krävs det ytterligare korrektionsiterationer för att garantera konvergensen. Emellertid så är Langs implementering [41] lite snabbare och har fördelen att den totala implementeringsarean är markant reducerad jämfört med [42], detta på grund av att skalfaktorn hålls konstant. Om däremot tekniken att sätta in radix-4 iterationer i andra hälften av [42] blir den ca 14% snabbare än implementeringen i [41].
Figur 5.2 CORDIC i bakåtrotationsmoden enligt ekvation 5.3. di 1 då wˆi≥1 2⁄ 0 då wˆi= 0 1 – då wˆi≤–1⁄2 = wˆi
4-2 CSA 4-2 CSA 3-2 CSA
ROM Val av di Skift 2-2i xi wi zi xi+1 wi+1 zi+1 2
5.1.3.4 Bruguera et.al presenterar i rapporten [19] en framåtrotations on-line algoritm,
som är baserad på radix-4 mikrorotationer, se sektion 5.1.6 för förklaring av radix-4 algoritmer. Rotationsriktningen i varje iteration bestäms genom inspektion av sex stycken MSB siffror. För iterationer i≥n/6 så exploaterar Bruguera faktumet att det ej längre är nödvändigt att implementera inspektionskretsen då alla resterande rotations-riktningar kan bestämmas parallellt direkt ur vinkelresiduen. Detta är baserat på faktumet att approximationen arctan(4-i) = 4-i gäller med n-bitars precision för iterationer i≥n/6. Till följd av radix-4 iterationerna så får denna CORDIC mer än dubbelt så bra latency än alla on-line radix-2 varianterna ovan.
Ytterligare on-line implementeringar av intresse har tagits fram. Till exempel har Hsiao et.al. i rapporterna [65], [66], [67] presenterat en algoritm, som liknar Hamills dubbel iterations on-line algoritm både framåt- och bakåtrotation. Se sektion 5.1.7.
5.1.4 Överlappad CORDIC
I rapporterna [26] och [27] presenterar Swartzlander et.al en ny CORDIC-arkitektur för bakåtrotation. Arkitekturen som är en modifierad variant av de båda metoderna [4], [42], minskar latencyn i en iteration med ungefär 40%. Detta är möjligt genom att utföra processeringsordningen baklänges, se figur 5.3. I arkitekturen utförs additionen/ subtraktionen parallellt och överlappat med rotationsriktningsbestämningsoperationen, istället för sekventiellt som i en konventionell CORDIC. Som en följd av detta reduceras exekveringstiden i CORDIC-rotationen då kritiska vägen blir kortare.
Figur 5.3 CORDIC-arkitektur i bakåtrotationsmoden med reducerad latency.
6-4 CSA 6-4 CSA 4-4 CSA
ROM Val av di Skift 2-2i xi wi zi
xi+1 wi+1 zi+1
2 Skift
2
