Filtry cyfrowe o skończonej odpowiedzi impulsowej FIR - realizacje

Filtry cyfrowe o skończonej odpowiedzi impulsowej FIR - realizacje wersja: 01.2015 1

FPGA zalety i wady Ogromny wzrost wydajności niektórych algorytmów Elastyczność architektury Możliwości znacznego zrównoleglenia algorytmów ostosowanie rozmiaru danych Ponowne wykorzystanie zasobów dla wielu zadań Rekonfigurowalność Proces projektowy nieznany wielu projektantom Niedoskonałość narzędzi projektowych 2

Ograniczenia wydajności tradycyjnych układów SP Tradycyjne Układy SP 256 razy Stała nieelastyczna architektura Typowo 1-4 jednostki MAC Stała szerokość danych Przetwarzanie szeregowe ogranicza przepustowość Współdzielone w czasie jednostki MAC uże częstotliwości taktowania stawiają duże wyzwania projektantom systemów Przykład: Filtr FIR 256 rzędu = 256 operacji mnóż i przechowaj (MAC: Multiply- ACcumulate) na pojedynczą próbkę danych Źródło: Xilinx, Voice over IP, Emerging Standards & Protocols 3

Zalety układów FPGA Wszystkie 256 operacje MAC w jednym cyklu zegara FPGA Elastyczna architektura Rozproszone zasoby (komórki UT, rejestry, układy mnożące, bloki pamięci) Przetwarzanie równoległe maksymalizuje przepustowość Możliwość zrównoleglenia o dowolnym stopniu Optymalny balans między wydajnością i kosztami Układy FPGA pozwalają także na przetwarzanie szeregowe Przykład : Filtr FIR 256 rzędu = 256 operacji mnóż i przechowaj (MAC: Multiply- ACcumulate) na pojedynczą próbkę danych Źródło: Xilinx, Voice over IP, Emerging Standards & Protocols 4

Architektura FPGA a SP Wydajność kosztem powierzchni Żródło: WP116, Xilinx Spartan-II FIR Filter Solution, 2000 5

Realizacja filtrów w FPGA i SP MSPS=Million Samples Per Second Źródło: WP116, Xilinx Spartan-II FIR Filter Solution, 2000 6

Realizacja filtrów w FPGA i SP vs MCU Źródło: http://www.mil-embedded.com/pdfs/quickfilter.sep07.pdf 7

Filtr cyfrowy FIR Filtr cyfrowy FIR każda próbka odpowiedzi nie zależy od odpowiedzi poprzednich próbek, a jedynie od próbek wymuszenia brak pętli sprzężeń zwrotnych odpowiedź impulsowa ma zawsze skończoną liczbę próbek zazwyczaj odpowiedź jest liniowa w fazie 8

Filtr o skończonej odpowiedzi impulsowej FIR -1 y[n] = x[n] * h[n] = Σ x[k]h[n-k] k=0 rząd filtru, h[n] współczynnik, z -1 element opóźniający FIR Finite Impulse Response Realizacja: równoległa Koszt: -1 sumowań, mnożeń 9

Filtr FIR o programowalnych współczynnikach Przykład filtru o programowalnych współczynnikach: filtr 4-rzędu, wejście 9-bitowe ze znakiem, wyjście 11-bitowe ze znakiem (podzielone przez 256), współczynniki 9-bitowe ze znakiem (ułamek*256), mnożenie stałopozycyjne ze znakiem Wynik jest podzielony przez 256, ponieważ współczynniki były wymnożone przez 256 (zakładamy że współczynniki są ułamkami) Sumator musi mieć długość 2*X + log2() 1 = 2*9 + log2(4) 1 = 19, gdzie: 2*X wynik mnożenia dwóch słów 9-bitowych log2() bity zabezpieczające przed przepełnieniem 1 dla liczb ze znakiem 10

Filtr FIR programowalny realizacja V [ ] BEGIN oad: PROCESS BEGIN WAIT UNTI clk = '1'; IF (oad_x = '0') TEN c(-1) <= x_in; -- oad data or coefficient -- Store coefficient in register FOR I IN -2 OWNTO 0 OOP -- Coefficients shift one c(i) <= c(i+1); EN OOP; ESE x <= x_in; -- Get one data sample at a time EN IF; EN PROCESS oad; moduł mnożenia potok 3 stopnie potok 1 stopień SOP: PROCESS (clk, load_x, a) -- Compute sum-of-products BEGIN IF clk'event AN (clk = '1') TEN FOR I IN 0 TO -2 OOP -- Compute the transposed a(i) <= (p(i)(w2-1) & p(i)) + a(i+1); -- filter adds EN OOP; a(-1) <= p(-1)(w2-1) & p(-1); EN IF; y <= a(0); EN PROCESS SOP; -- Instantiate pipelined multiplier -- only a register MulGen: FOR I IN 0 TO -1 GENERATE -- First TAP has Muls: lpm_mult -- Multiply p(i) = c(i) * x; C FF f [Mz] t_clk [ns] GENERIC MAP ( PM_WITA => W1, PM_WITB => W1, PM_PIPEINE => Mpipe, 794 592 40,82 24,5 746 264 31,35 31,9 PM_REPRESENTATION => "SIGNE", PM_WITP => W2, PM_WITS => W2) PORT MAP ( clock => clk, dataa => x, datab => c(i), result => p(i)); EN GENERATE; y_out <= y(w3-1 OWNTO W3-W4); EN arch_fir; 11

Filtr FIR programowalny realizacja Verilog module fir_prog(clk, load_x, x_in, y_out); parameter w1=9; //Input bit width parameter w2=18; //Multiplier bit width 2*W1 parameter w3=19; //Adder width = W2+log2()-1 parameter w4=11; //Output bit width parameter l=4; //Filter length parameter mpipe=3; //Pipeline steps of multiplier input clk, load_x; input [w1-1:0] x_in; output [w4-1:0] y_out; reg [w1-1:0] x; wire [w3-1:0] y; reg [w1-1:0] c [l-1:0]; //array reg [w2-1:0] p [l-1:0]; //array reg [w3-1:0] a [l-1:0]; //array integer i; always@(posedge clk) //oad data or coefficient begin if(!load_x) begin end end else c[l-1] <= x_in; // Store coefficient in register for (i = 0; i <= l-2 ; i=i+1) begin c[i] <= c[i+1];// Coefficients shift one end x <= x_in; always@(posedge clk) //Compute sum-of-products begin a[l-1] <= {p[l-1][w2-1],p[l-1]}; //First TAP has only a register for (i = 0; i <= l-2 ; i=i+1) begin a[i] <= {p[i][w2-1],p[i]} + a[i+1]; // filter adds end end assign y = a[0]; 12

Filtr FIR programowalny realizacja Verilog genvar j; // Instantiate pipelined multiplier generate for (j = 0; j <= l-1; j=j+1)//multiply p(i) = c(i) * x begin : mults lpm_mult mult_j(.clock(clk),.dataa(x),.datab(c[j]),.result(p[j])); // defparam mult_j.lpm_widtha=w1; defparam mult_j.lpm_widthb=w1; defparam mult_j.lpm_pipeline=mpipe; defparam mult_j.lpm_representation="signe"; defparam mult_j.lpm_widthp=w2; defparam mult_j.lpm_widths=w2; end endgenerate endmodule; assign y_out = y[w3-1:w3-w4]; 13

Filtr FIR programowalny symulacja Współczynniki: G( z) 0,48301 0,8365z 1 0,2241z 2 0,1294z 3 (124 214z 1 57z 2 33z 3 ) / 256 124 256 214 256 z 1 57 256 z 2 33 256 z 3 14

Filtr FIR programowalny symulacja Matlab Plik fir_1.m: [B] = [0.48301 0.8365 0.2244-0.1294] B in = [zeros(1,2),100*ones(1,5), zeros(1,4)]; out=filter(b,1,in); in out Okno Command: >> run fir_1 B = 0.4830 0.8365 0.2244-0.1294 in = 0 0 100 100 100 100 100 0 0 0 0 out = Columns 1 through 9 0 0 48.3010 131.9510 154.3910 141.4510 141.4510 93.1500 9.5000 Columns 10 through 11-12.9400 0 >> 15

Filtr FIR programowalny symulacja Scilab 16

Przykład filtru FIR 4-rzędu o stałych współczynnikach Zadanie: Zrealizować filtr 4-rzędu o współczynnikach: h[k] = {-1,0 3,75 3,75 1,0} Współczynniki można zakodować jako 4-bitowe ułamki, np. 3,75 = 2 + 1 + ½ + ¼ = 11,11 2 ługość akumulatora wyznaczona jest sumą długości próbek wejściowych oraz bitów protekcji G 1 log G h[ k] 2 k0 log (9,5) 3,247928 4 2 Założenie: projektowany system ma zaimplementowaną 8-bitową architekturę (ścieżka danych), dlatego próbki wejściowe powinny być ograniczone do wartości -128/9,5 +127/9,5 co daje -13 +13 (dla 4-bitów danych: -8 +7) 17

Przykład filtru FIR 4-rzędu realizacja V BEGIN p1: PROCESS BEGIN -- The coefficients are [-1 3.75 3.75-1]. WAIT UNTI clk = '1'; y <= 2 * tap(1) + tap(1) + tap(1) / 2 + tap(1) / 4 + 2 * tap(2) + tap(2) + tap(2) / 2 + tap(2) / 4 - tap(3) - tap(0); FOR I IN 3 OWNTO 1 OOP tap(i) <= tap(i-1); -- Tapped delay line: shift one EN OOP; tap(0) <= x; EN PROCESS; EN fir; -- Registered input Realizacja: równoległa 18

Przykład filtru FIR 4-rzędu realizacja Verilog always@(posedge clk) begin //The coefficients are [-1 3.75 3.75-1]. /* y_out <= 2 * tap[1] + tap[1] + tap[1] / 2 + tap[1] / 4 + 2 * tap[2] + tap[2] + tap[2] / 2 + tap[2] / 4 - tap[3] - tap[0]; */ /* y_out <= {tap[1][n-2:0],1'b0} + tap[1] + {tap[1][n-1],tap[1][n-1:1]} + {tap[1][n- 1],tap[1][n-1],tap[1][n-1:2]} + {tap[2][n-2:0],1'b0} + tap[2] + {tap[2][n-1],tap[2][n-1:1]} + {tap[2][n-1],tap[2][n-1],tap[2][n-1:2]} - tap[3] - tap[0]; */ y_out <= (tap[1]<<1) + tap[1] + (tap[1]>>>1) + (tap[1]>>>2) + (tap[2]<<1) + tap[2] + (tap[2]>>>1) + (tap[2]>>>2) - tap[3] - tap[0]; for(i=1; i<=3; i=i+1) begin end tap[i] <= tap[i-1]; tap[0] <= x_in; end endmodule Operatory * i / dają gorszą realizację Realizacja: równoległa 19

Przykład filtru FIR 4-rzędu symulacja C FF f [Mz] t_clk [ns] 142 40 18,48 54,1 20

Filtr FIR symetryczny Realizacja: równoległa Koszt: -1 sumowań, /2 mnożeń 21

Przykład filtru symetrycznego FIR 4- rzędu realizacja V BEGIN t0 <= tap(0) + tap(3); t1 <= tap(1) + tap(2); p1: PROCESS BEGIN WAIT UNTI clk = '1'; y <= 2 * t1 + t1 + t1 / 2 + t1 / 4 - t0; FOR I IN 3 OWNTO 1 OOP tap(i) <= tap(i-1); EN OOP; tap(0) <= x; EN PROCESS; EN fir; Realizacja: równoległa 22

Przykład filtru symetrycznego FIR 4- rzędu realizacja Verilog assign t0 = tap[0] + tap[3]; assign t1 = tap[1] + tap[2]; always@(posedge clk) begin //The coefficients are [-1 3.75 3.75-1]. y_out <= (t1<<1) + t1 + (t1>>>1) + (t1>>>2) - t0; for(i=1; i<=3; i=i+1) begin tap[i] <= tap[i-1]; end tap[0] <= x_in; // Input in register 0 end endmodule Realizacja: równoległa 23

Przykład filtru symetrycznego FIR 4- rzędu o stałych współczynnikach C FF f [Mz] t_clk [ns] 103 40 25,51 39,2 24

Kodowanie CS CS - Canonic Signed igit Algorytm optymalny tworzenia liczby CS złożonej z minimalnej liczby sum i odejmowań: 1) Zaczynając od najmłodszego bitu zamień sekwencję jedynek dłuższą niż dwie na sekwencję 10..01. Zamień również sekwencję 1011 na 1101. 2) Zaczynając od najstarszego bitu zamień sekwencję 101 na 011. ziałanie to zamienia odejmowanie na dodawanie, które ma mniejszy koszt. 1 Symbol oznacza odejmowanie. Przykład: 11.11 2 = 3.75 10 = (2+1).(0.5+0.25) = 100.0 2 = (4-0.25) 1 25

Przykład filtru symetrycznego FIR 4- rzędu o stałych współczynnikach CS BEGIN t0 <= tap(0) + tap(3); t1 <= tap(1) + tap(2); p1: PROCESS BEGIN WAIT UNTI clk = '1'; y <= 4 * t1 - t1 / 4 - t0; FOR I IN 3 OWNTO 1 OOP tap(i) <= tap(i-1); EN OOP; tap(0) <= x; EN PROCESS; EN fir; always@(posedge clk) begin //The coefficients are [-1 3.75 3.75-1]. y_out <= (t1<<2) - (t1>>>2) - t0; for(i=1; i<=3; i=i+1) begin tap[i] <= tap[i-1]; end tap[0] <= x_in; end endmodule Realizacja: równoległa 26

Przykład filtru FIR 4-rzędu symulacja C FF f [Mz] t_clk [ns] 80 40 29,76 33,6 27

Przykład filtru FIR 4-rzędu z potokiem V BEGIN p1: PROCESS BEGIN WAIT UNTI clk = '1'; t0 <= tap(0) + tap(3); t1 <= tap(1) + tap(2); t2 <= 4 * t1 - t1 / 4; t3 <= - t0; y <= t2 + t3; FOR I IN 3 OWNTO 1 OOP tap(i) <= tap(i-1); EN OOP; tap(0) <= x; EN PROCESS; EN fir; always@(posedge clk) begin //The coefficients are [-1 3.75 3.75-1]. t0 <= tap[0] + tap[3]; t1 <= tap[1] + tap[2]; t2 <= (t1<<2) - (t1>>>2); t3 <= -t0; y_out <= t2 + t3; for(i=1; i<=3; i=i+1) begin tap[i] <= tap[i-1]; end tap[0] <= x_in; end Realizacja: równoległa endmodule; 28

Symetryczny filtr FIR symulacja C FF f [Mz] t_clk [ns] 119 72 41,32 24,2 29

Symetryczny filtr FIR porównanie realizacji realizacja FIR komórek przerzutników f [Mz] t_clk [ns] programowalny z potokiem o stałych współczynnikach 794 592 40,82 24,5 142 40 18,48 54,1 ww. i symetria 103 40 25,51 39,2 ww. i CS 80 40 29,76 33,6 ww. i potok 119 72 41,32 24,2 30

Filtr FIR transponowany Aby uzyskać filtr transponowany należy: a) zamienić wejścia i wyjścia b) odwrócić kierunek sygnałów c) zastąpić sumator przez rozgałęzienie, i na odwrót Realizacja: równoległa 31

Filtr FIR o stałych współczynnikach i strukturze transponowanej Układy mnożące realizujące wspólne czynniki można zrealizować wykorzystując algorytm zredukowanego grafu sumatorów RAG (Reduced Adder Graph). Przykład realizacji iloczynu 93 w kodzie CS (koszt 3 sumatory) i przez faktoryzację (koszt 2 sumatory). 32

Filtr FIR o stałych współczynnikach i strukturze transponowanej W realizacjach filtrów w postaci transponowanej zdarza się, że współczynniki filtru mają wspólne czynniki. Przykład realizacji współczynników 9 i 11 koszt tylko dwa sumatory 33

Algorytm RAG Algorytm RAG jest problemem NP-zupełnym. Wykorzystując reguły heurystyczne można algorytm zapisać następująco: 1) Usunąć znak odejmowania odejmowanie jest realizowane na samym końcu w linii bloków opóźniających z -1 2) Usunąć współczynniki i czynniki przy potędze 2 realizacja działania przez przesunięcie bitowe 3) Zrealizować współczynniki o koszcie równym jeden sumator 4) Zrealizować pozostałe współczynniki używając do tego celu współczynników o koszcie jeden Ponieważ złożoność obliczeniowa punktu 4) rośnie wykładniczo, można posłużyć się regułą heurystyczną, czyli zaczynać od czynników o najmniejszym koszcie i najmniejszej wartości 34

Algorytm RAG Algorytm RAG jest problemem NP-zupełnym. Wykorzystując reguły heurystyczne można algorytm zapisać następująco: 1) Usunąć znak odejmowania odejmowanie jest realizowane na samym końcu w linii bloków opóźniających z -1 2) Usunąć współczynniki i czynniki przy potędze 2 realizacja działania przez przesunięcie bitowe 3) Zrealizować współczynniki o koszcie równym jeden sumator 4) Zrealizować pozostałe współczynniki używając do tego celu współczynników o koszcie jeden Ponieważ złożoność obliczeniowa punktu 4) rośnie wykładniczo, można posłużyć się regułą heurystyczną, czyli zaczynać od czynników o najmniejszym koszcie i najmniejszej wartości 35

Przykład filtru FIR transponowanego z wykorzystaniem RAG Filtr 11-rzędu o współczynnikach h[k]={3 0-25 0 150 256 150 0-25 0 3} Koszt realizacji filtru z użyciem współczynników w postaci kanonicznej wynosi 1 + 2 + 3 + 0 = 6 (odpowiednio dla współczynników 3 = 11 2, 25 = 1 1001 2, 150 = 1001 0110 2 i 256 = 1 0000 0000 2 ) 36

Koszt sumatorów w MAG U.Meyer-Baese: SP with FPGAs 37

Realizacja filtru FIR z wykorzystaniem RAG 38

Realizacja filtru FIR z wykorzystaniem RAG V ENTITY fir_rag IS PORT (clk : IN ST_OGIC; x : IN ST_OGIC_VECTOR(7 OWNTO 0); y : OUT ST_OGIC_VECTOR(17 OWNTO 0)); EN fir_rag; ARCITECTURE fir OF fir_rag IS SUBTYPE N17BIT IS ST_OGIC_VECTOR(17 OWNTO 0); TYPE ARRAY_N17BIT IS ARRAY (0 TO 10) OF N17BIT; SIGNA tap : ARRAY_N17BIT; SIGNA ta, tb, tc, td : ST_OGIC_VECTOR(17 OWNTO 0); SIGNA x_r : ST_OGIC_VECTOR(7 OWNTO 0); BEGIN -- 3 = 2 + 1 ta <= ("000000000" & x_r & '0') + ("0000000000" & x_r); -- 5 = 4 + 1 tb <= ("00000000" & x_r & "00") + ("0000000000" & x_r); tc <= tb + (tb(15 OWNTO 0) & "00"); -- 25 = 5 + 4*5 td <= (tb(13 OWNTO 0) & "0000") - tb; -- 75 = 16*5-5 p1: PROCESS BEGIN WAIT UNTI clk = '1'; EN PROCESS; EN fir; x_r <= x; -- registered input tap(0) <= tap(1) + ta; -- 3 tap(1) <= tap(2); tap(2) <= tap(3) - tc; -- -25 tap(3) <= tap(4); -- 150 tap(4) <= tap(5) + (td (16 OWNTO 0) & '0'); -- 256 tap(5) <= tap(6) + (" 00 " & x_r & "00000000"); -- 150 tap(6) <= tap(7) + (td(16 OWNTO 0) & '0'); tap(7) <= tap(8); tap(8) <= tap(9) - tc; -- -25 tap(9) <= tap(10); tap(10) <= ta; -- 3 y <= tap(0); Tylko dla liczb dodatnich Realizacja: równoległa 39

Program RAG Na stronie: http://tomaszewicz.zpt.tele.pw.edu.pl/ Materiały > Programy > Program i opis programu Wynik dla h[k]={3 0-25 0 150 256 150 0-25 0 3} 40

Realizacja filtru FIR z wykorzystaniem RAG Verilog // RAG algorithm module fir_rag(clk, x_in, y_out); parameter n=11; // filter lenght input clk; input [7:0] x_in; output [17:0] y_out; reg [17:0] x_r; reg [17:0] y_out; reg [17:0] tap [n-1:0]; //tap array wire [17:0] ta, tb, tc, td; assign ta = (x_r<<1) + x_r; // 3 = 2 + 1 assign tb = (x_r<<2) + x_r; // 5 = 4 + 1 assign tc = tb + (tb<<2); // 25 = 5 + 4*5 assign td = (tb<<4) - tb; // 75 = 16*5-5 always@(posedge clk) begin x_r[7:0] <= x_in; x_r[17:8] <= {10{x_in[7]}}; tap[0] <= tap[1] + ta; // 3 tap[1] <= tap[2]; tap[2] <= tap[3] - tc; // -25 tap[3] <= tap[4]; tap[4] <= tap[5] + (td<<1); // 150 tap[5] <= tap[6] + (x_r<<8); // 256 tap[6] <= tap[7] + (td<<1); // 150 tap[7] <= tap[8]; tap[8] <= tap[9] - tc; // -25 tap[9] <= tap[10]; tap[10] <= ta; // 3 y_out <= tap[0]; end endmodule Realizacja: równoległa 41

Realizacja filtru FIR z wykorzystaniem RAG C FF f [Mz] t_clk [ns] 389 202 14,25 70,2 42

Algorytm cub Na stronie: http://www.spiral.net Parallel multiple constant multiplication (MCM) - Multiplier Block Generator http://spiral.ece.cmu.edu/mcm/gen.html Inne on-line generatory 43

Algorytm cub min. sumatorów Algorithm: cub Auxiliary distance estimate: CS-Cost(z) epth bound: unlimited Secondary optimization: none, randomize (reload the webpage to see different random graphs) Bitwidth: 8 mantissa + 0 fractional = 8 total Integer constants: 3-25 150 256./synth/acm1 -expensive -b 8 '3' '-25' '150' '256' - dotcode./dags/dot1386167388 2>&1 >./dags/mcm1386167388 cat./dags/dot1386167388./dot.sh./dags/dag1386167388 /usr/bin/convert -resize 539x539./dags/dag1386167388.large.png./dags/dag1386167388.png // Cost: 3 adds/subtracts 5 shifts 1 negations // epth: 3 44

Algorytm cub min. poziomów Algorithm: cub Auxiliary distance estimate: CS-Cost(z) epth bound: 0 Secondary optimization: none, randomize (reload the webpage to see different random graphs) Bitwidth: 8 mantissa + 0 fractional = 8 total Integer constants: 3-25 150 256./synth/acm1 -maxdepth 0 -expensive -aux -b 8 '3' '-25' '150' '256' -dotcode./dags/dot1386167527 2>&1 >./dags/mcm1386167527 Solution infeasible with MAX_EPT=0. Increasing MAX_EPT=2. cat./dags/dot1386167527./dot.sh./dags/dag1386167527 /usr/bin/convert -resize 411x411./dags/dag1386167527.large.png./dags/dag1386167527.png // Cost: 4 adds/subtracts 6 shifts 1 negations // epth: 2 45

Operacje mnożenia i dodawania MAC y c, x 1 n0 c[ n] x[ n] Rejestr przesuwny c[0] x[0] c[1] x[1] c[ 1] x[ 1] Układ mnożący Sumator Akumulator X[-1] X[1] X[0] C[-1] C[1] C[0] + R Realizacja: szeregowa 46

Arytmetyka rozproszona istributed Arithmetic Arytmetyka rozproszona (istributed Arithmetic A): rozproszenie operacji mnożenia na poszczególne bity skalarów Jednym z częściej spotykanych w przetwarzaniu sygnałów jest realizacja sumy iloczynów. Iloczyn skalarów można znaleźć w procesie filtracji cyfrowej, dlatego przekształcenie to spełnia bardzo ważną rolę w procesie obliczeniowym i ma wpływ na wydajność systemu cyfrowego. Pierwsze wzmianki z roku 1971. A można najczęściej znaleźć w realizacji filtrów cyfrowych o stałych współczynnikach, ale także w realizacjach filtrów adaptacyjnych o zmiennych w czasie współczynnikach, transformacji FFT, CT i innych. W operacji A przekształcany jest jeden bit z wszystkich skalarów w jednym kroku. Jeżeli skalar ma długość B, to potrzebnych jest B kroków na otrzymanie wyniku przekształcenia. Przekształcenie to nie zależy od złożoności operacji, na przykład w operacji splotu nie zależy od długości filtru cyfrowego. 47

48 Jeżeli założymy, że filtr ma stałe współczynniki c n a x n jest zmienną próbką wejściową bez znaku o długości B: 1 0 2 ] [ B b b b n n x x gdzie x b [n][0,1] i oznacza bit b w wektorze x n Podstawiając powyższą sumę do równania y, otrzymamy: 1 0 1 0 2 ] [ B b b b n n n x c y Przekształcając równanie: ) 2 1] [ 2 1] [ 2 1] [ ( 1] [ ) 2 [1] 2 [1] 2 [1] ( [1] ) 2 [0] 2 [0] 2 [0] ( [0] 1] [ 1] [ [1] [1] [0] [0] 0 0 2 2 1 1 0 0 2 2 1 1 0 0 2 2 1 1 x x x c x x x c x x x c x c x c x c y B B B B B B B B B B B B Arytmetyka rozproszona istributed Arithmetic - teoria 1 0 n c n x n y Filtr typu FIR o długości :

49 Kontynuując przekształcenie... 0 0 0 0 2 2 2 2 1 1 1 1 2 1]) [ 1] [ [1] [1] [0] [0] ( 2 1]) [ 1] [ [1] [1] [0] [0] ( 2 1]) [ 1] [ [1] [1] [0] [0] ( x c x c x c x c x c x c x c x c x c y B B B B B B B B Powyższy wzór można zapisać: Arytmetyka rozproszona Teoria 1 0 1 0 1 0 1 0 ]) [ ], [ ( 2 ] [ ] [ 2 n b B b b n b B b b n x n c f n x n c y

Arytmetyka rozproszona w filtrze cyfrowym y 1 n0 c[ n] x[ n] Rejestr przesuwny Ukł. mnożący Akumulator X[-1] X[1] X[0] C[-1] C[1] C[0] + R Realizacja: szeregowa 50

Arytmetyka rozproszona w filtrze cyfrowym y B1 b0 2 b 1 n0 f ( c[ n], x b [ n]) Rejestr przesuwny X B-1 [0] X 1 [0] X 0 [0] ogika A Akumulator X B-1 [1] X 1 [1] X 0 [1] X B-1 [-1] X 1 [-1] X 0 [-1] UT + R shift (b) Realizacja: szeregowa 51

Arytmetyka rozproszona Wielkość pamięci UT ogika A UT Pamięć UT: -bitów wejściowych ( rząd filtru), czyli na raz przetwarzamy próbek wejściowych iczba bitów wyjściowych zależy od sumy współczynników c n Wartość próbki y jest wyliczona po B cyklach zegara (B - długość próbki). 52

Arytmetyka rozproszona Zawartość pamięci UT ogika A UT Na wejściu pojawią się 3-bitowe próbki: x[0]=7, x[1]=2, x[2]=1, Sprawdzenie: y = c[0]x[0] + c[1]x[1] + c[2]x[2] = 4 7+1 2+3 1 = 33. Przykład: Filtr 3-rzędu o 3-bitowych współczynnikach c[0]=4, c[1]=1, c[2]=3. x b [2] x b [1] x b [0] f(c[n], x[n]) 0 0 0 3 0 + 1 0 + 4 0 = 0 0 0 1 3 0 + 1 0 + 4 1 = 4 0 1 0 3 0 + 1 1 + 4 0 = 1 0 1 1 3 0 + 1 1 + 4 1 = 5 1 0 0 3 1 + 1 0 + 4 0 = 3 1 0 1 3 1 + 1 0 + 4 1 = 7 1 1 0 3 1 + 1 1 + 4 0 = 4 1 1 1 3 1 + 1 1 + 4 1 = 8 Pojemność pamięci UT w bitach: 2 3 (max{0,4,1,5,3,7,4,8}) 2 4 32 Krok b x b [2] x b [1] x b [0] f[b] 2 b + ACC(t 1) ACC(t) 0 1 0 1 7 2 0 + 0 7 1 0 1 1 5 2 1 + 7 17 2 0 0 1 4 2 2 + 17 33 3 53

Arytmetyka rozproszona Zastąpienie akumulatora przesuwającego Zamiast przesuwać w akumulatorze kolejne próbki x b o b-bitów (programowalny układ przesuwający barrel shifter), to można każdy bit przesunąć o B-pozycji (pomnożyć przez 2 B-1 ) i zawsze przesuwać akumulator w prawo o jeden bit. W efekcie dużo prostsza realizacja. Realizując filtr z użyciem akumulatora przesuwającego otrzymamy dla poprzedniego przykładu następujące wyliczenia: Krok b x b [2] x b [1] x b [0] f[b] 2 B-1 + ACC(t 1)>>1 ACC(t) 0 1 0 1 7 2 2 + 0 28 1 0 1 1 5 2 2 + 14 34 2 0 0 1 4 2 2 + 17 33 54

55 Arytmetyka rozproszona dla liczb ze znakiem la liczb ze znakiem wektor w kodzie U2: b B b b B B n n x n x x 2 ] [ 2 ] [ 2 0 1 1 Podstawiając do wzoru na sumę iloczynów: 1 0 2 0 1 1 ]) [ ], [ ( 2 2 ]) [ ], [ ( n b B b b B B n x n c f n x n c f y

Arytmetyka rozproszona dla liczb ze znakiem ogika A UT Na wejściu pojawią się 4-bitowe próbki: x[0]= 5, x[1]=2, x[2]= 1, Sprawdzenie: y = c[0]x[0] + c[1]x[1] + c[2]x[2] = ( 3) ( 5)+1 2 +( 1) ( 1) = 18. Przykład: Filtr 3-rzędu o 3-bitowych współczynnikach c[0]= 3, c[1]=1, c[2]= 1. x b [2] x b [1] x b [0] f(c[n],x[n]) 0 0 0 1 0 + 1 0 3 0 = 0 0 0 1 1 0 + 1 0 3 1 = 3 0 1 0 1 0 + 1 1 3 0 = 1 0 1 1 1 0 + 1 1 3 1 = 2 1 0 0 1 1 + 1 0 3 0 = 1 1 0 1 1 1 + 1 0 3 1 = 4 1 1 0 1 1 + 1 1 3 0 = 0 1 1 1 1 1 + 1 1 3 1 = 3 Krok b x b [2] x b [1] x b [0] f[b] 2 b + ACC(t 1) ACC(t) 0 1 0 1 4 2 0 + 0 4 1 1 1 1 3 2 1 + 4 10 2 1 0 0 1 2 2 + 10 14 f[b] 2 b + ACC(t 1) 3 1 0 1 ( 4 2 3 ) + 14 18 56

Arytmetyka rozproszona Zysk w szybkości obliczeń Założenie: koszt użycia układów mnożących ogólnego przeznaczenia oraz pamięci UT jest jednakowy i bloki te wprowadzają takie samo opóźnienie = (UT) = (MUT) Porównanie realizacji wykorzystujących bloki UT i MUT: Obliczenie iloczynu skalarów zajmuje B (UT) cykli dla arytmetyki rozproszonej Obliczenie iloczynu skalarów zajmuje (UT) cykli dla układu z blokami mnożącymi. Jeżeli długość słów wejściowych (próbek) B będzie mniejsza od długości filtru, to uzyskamy znaczne przyspieszenie w obliczeniach wykorzystując arytmetykę rozproszoną. 57

Modyfikacje A Pojemność pamięci Jeżeli liczba współczynników jest zbyt duża, aby zrealizować funkcję f w pamięci ROM (liczba współczynników jest liczbą linii adresowych pamięci), to należy podzielić tablicę UT na mniejsze części ze względu na wejścia. Wyniki pojawiające się na wyjściach mniejszych bloków pamięci należy sumować. rzewo sumatorów jest dodatkowym kosztem, który nie wpływa na przepustowość układu, ponieważ można wprowadzić rejestry pomiędzy stopnie drzewa sumatorów tworząc strukturę potokową. Podział pamięci UT wpływa w sposób wykładniczy na wielkość potrzebnej pamięci do realizacji tablicy A. 58

Modyfikacje A Pojemność pamięci la filtru trzeciego rzędu =3 o skończonej odpowiedzi impulsowej FIR dane są współczynniki: c[0]=4, c[1]=1, c[2]=3. Podzielmy współczynniki na dwie grupy: c[2] oraz c[1], c[0] otrzymując dwie tablice UT M i UT x b [2] f(c[2],x[2]) 0 3 0 = 0 1 3 1 = 3 x b [1] x b [0] f(c[1,0],x[1,0]) 0 0 1 0 + 4 0 = 0 0 1 1 0 + 4 1 = 4 1 0 1 1 + 4 0 = 1 1 1 1 1 + 4 1 = 5 Pojemność pamięci UT w bitach (2x mniej niż przed podzieleniem): 2 1 (max{0,3}) 2 2 (max{0,4,1,5}) 4 1216 la próbek wejściowych: x[0]=7, x[1]=2, x[2]=1 Krok b x b [2] x b [1] x b [0] f[2][b] + f[1,0][b] + ACC(t 1) ACC(t) 0 1 0 1 3 2 0 +4 2 0 + 0 7 1 0 1 1 0 2 1 + 5 2 1 + 7 17 2 0 0 1 0 2 2 + 4 2 2 + 17 33 59

Arytmetyka rozproszona Przetwarzanie równoległe Zwiększenie przepustowości układu realizującego sumę iloczynów przez przetwarzanie w jednym kroku większej liczby bitów w ten sposób zwiększamy szybkość przetwarzania słów wejściowych. Maksymalną szybkość obliczeń osiąga się przez zastosowanie w pełni zrównoleglonej architektury A. Kosztem jest dodatkowa liczba pamięci ROM o wejściach i jednakowej zawartości oraz drzewo sumatorów. Ścieżkę krytyczną można skrócić włączając rejestry pomiędzy stopnie w drzewie sumatorów. Realizacja przewyższa szybkością obliczeń wszystkie komercyjne programowalne procesory sygnałowe. 60

Arytmetyka rozproszona Przetwarzanie równoległe Pojemność pamięci UT w bitach wzrośnie 3-krotnie (B-krotnie): 3 2 3 (max{0,4,1,5,3,7,4,8}) 3 2 3 4 96 la próbek wejściowych: x[0]=7, x[1]=2, x[2]=1 otrzymamy y=7+5 2 1 +4 2 2 =33 Wynik w jednym cyklu, czyli Wzrost szybkości 3-krotny! 61

Arytmetyka rozproszona Przetwarzanie równoległe Przykład: filtr 7-rzędu, próbki wejściowe 8-bitowe 62

Generator tablic A Na stronie: http://tomaszewicz.zpt.tele.pw.edu.pl/ Materiały > Programy > Program i opis programu Generator tablic UT 63

Przykład: filtr 7-rzędu Realizacja filtru F4 7-rzędu o współczynnikach c[n] ={-3, 0, 19, 32, 19, 0,-3} i próbkach wejściowych 8-bitowych ze znakiem. 64

IBRARY ieee; USE ieee.std_logic_1164.a; USE ieee.std_logic_arith.a; ENTITY case7s IS PORT ( table_in : IN ST_OGIC_VECTOR(6 OWNTO 0); EN case7s; table_out : OUT INTEGER RANGE -6 TO 70); ARCITECTURE Cs OF case7s IS BEGIN PROCESS (table_in) BEGIN... CASE table_in IS WEN "0000000" => table_out <= 0; WEN "0000001" => table_out <= -3; WEN "0000010" => table_out <= 0; WEN "0000011" => table_out <= -3; WEN "0000100" => table_out <= 19; WEN "0000101" => table_out <= 16; WEN "1111110" => table_out <= 67; WEN "1111111" => table_out <= 64; WEN OTERS => table_out <= 0; EN CASE; EN PROCESS; EN Cs; Realizacja filtru F4 w A V Tablica A 65

module case7s (table_in, table_out); input [6:0] table_in; output [7:0] table_out; reg [7:0] table_out; always @(table_in) begin end case (table_in) endcase endmodule 7'd0 7'd1 7'd2 7'd3 7'd4 7'd5.. 7'd126 7'd127 default : ; : table_out = 8'd0; : table_out = -8'd3; : table_out = 8'd0; : table_out = -8'd3; : table_out = 8'd19; : table_out = 8'd16; : table_out = 8'd67; : table_out = 8'd64; Realizacja filtru F4 w A Verilog Tablica A 66

Realizacja filtru F4 w A ARCITECTURE flex OF dapara IS [..] BEGIN PROCESS BEGIN WAIT UNTI clk = '1'; tap0 <= x_in; tap1 <= tap0; tap2 <= tap1; tap3 <= tap2; tap4 <= tap3; tap5 <= tap4; tap6 <= tap5; y <= s0 + 16*s1; -- adder tree p0 <= y0; p1 <= y1; p2 <= y2; p3 <= y3; --1st pipeline register p4 <= y4; p5 <= y5; p6 <= y6; p7 <= y7; r0 <= p0 + 2*p1; r1 <= p2 + 2*p3; -- 2nd pipeline register r2 <= p4 + 2*p5; r3 <= p6-2*p7; s0 <= r0 + 4*r1; s1 <= r2 + 4*r3; EN PROCESS; ENTITY dapara IS GENERIC ( : INTEGER := 7; -- filter lenght PORT (clk : IN ST_OGIC; EN dapara; --3rd pipeline register N : INTEGER := 8 -- input bit width ); x_in : IN ST_OGIC_VECTOR(N-1 OWNTO 0); y : OUT INTEGER RANGE -9722 TO 9658); 67

C FF f [Mz] t_clk [ns] 288 194 52,91 18,9 x0 <= (tap6(0) & tap5(0) & tap4(0) & tap3(0) & tap2(0) & tap1(0) & tap0(0)); x1 <= (tap6(1) & tap5(1) & tap4(1) & tap3(1) & tap2(1) & tap1(1) & tap0(1)); x2 <= (tap6(2) & tap5(2) & tap4(2) & tap3(2) & tap2(2) & tap1(2) & tap0(2)); x3 <= (tap6(3) & tap5(3) & tap4(3) & tap3(3) & tap2(3) & tap1(3) & tap0(3)); x4 <= (tap6(4) & tap5(4) & tap4(4) & tap3(4) & tap2(4) & tap1(4) & tap0(4)); x5 <= (tap6(5) & tap5(5) & tap4(5) & tap3(5) & tap2(5) & tap1(5) & tap0(5)); x6 <= (tap6(6) & tap5(6) & tap4(6) & tap3(6) & tap2(6) & tap1(6) & tap0(6)); x7 <= (tap6(7) & tap5(7) & tap4(7) & tap3(7) & tap2(7) & tap1(7) & tap0(7)); C_Table0: case7s C_Table1: case7s C_Table2: case7s C_Table3: case7s C_Table4: case7s C_Table5: case7s C_Table6: case7s C_Table7: case7s EN flex; PORT MAP(table_in => x0, table_out => y0); PORT MAP(table_in => x1, table_out => y1); PORT MAP(table_in => x2, table_out => y2); PORT MAP(table_in => x3, table_out => y3); PORT MAP(table_in => x4, table_out => y4); PORT MAP(table_in => x5, table_out => y5); PORT MAP(table_in => x6, table_out => y6); PORT MAP(table_in => x7, table_out => y7); 68

Realizacja filtru F4 w A Verilog module dapara(clk, x_in, y_out); parameter l=7; // filter lenght parameter n=8; // input bit width input clk; input [n-1:0] x_in; output reg [14:0] y_out; //-9722..9658 always@(posedge clk) begin tap0 <= x_in; tap1 <= tap0; tap2 <= tap1; tap3 <= tap2; tap4 <= tap3; tap5 <= tap4; tap6 <= tap5; // adder tree p0 <= {{7{y0[7]}},y0}; p1 <= {{7{y1[7]}},y1}; //1st pipeline register p2 <= {{7{y2[7]}},y2}; p3 <= {{7{y3[7]}},y3}; p4 <= {{7{y4[7]}},y4}; p5 <= {{7{y5[7]}},y5}; p6 <= {{7{y6[7]}},y6}; p7 <= {{7{y7[7]}},y7}; r0 <= p0 + (p1<<1); // 2nd pipeline register r1 <= p2 + (p3<<1); r2 <= p4 + (p5<<1); r3 <= p6 - (p7<<1); s0 <= r0 + (r1<<2);//3rd pipeline register s1 <= r2 + (r3<<2); y_out <= s0 + (s1<<4); //4th pipeline register end 69

Realizacja filtru F4 w A Verilog assign x0 = {tap6[0],tap5[0],tap4[0],tap3[0],tap2[0],tap1[0],tap0[0]}; assign x1 = {tap6[1],tap5[1],tap4[1],tap3[1],tap2[1],tap1[1],tap0[1]}; assign x2 = {tap6[2],tap5[2],tap4[2],tap3[2],tap2[2],tap1[2],tap0[2]}; assign x3 = {tap6[3],tap5[3],tap4[3],tap3[3],tap2[3],tap1[3],tap0[3]}; assign x4 = {tap6[4],tap5[4],tap4[4],tap3[4],tap2[4],tap1[4],tap0[4]}; assign x5 = {tap6[5],tap5[5],tap4[5],tap3[5],tap2[5],tap1[5],tap0[5]}; assign x6 = {tap6[6],tap5[6],tap4[6],tap3[6],tap2[6],tap1[6],tap0[6]}; assign x7 = {tap6[7],tap5[7],tap4[7],tap3[7],tap2[7],tap1[7],tap0[7]}; endmodule case7s C_Table0 (.table_in(x0),.table_out(y0)); case7s C_Table1 (.table_in(x1),.table_out(y1)); case7s C_Table2 (.table_in(x2),.table_out(y2)); case7s C_Table3 (.table_in(x3),.table_out(y3)); case7s C_Table4 (.table_in(x4),.table_out(y4)); case7s C_Table5 (.table_in(x5),.table_out(y5)); case7s C_Table6 (.table_in(x6),.table_out(y6)); case7s C_Table7 (.table_in(x7),.table_out(y7)); 70

Realizacja filtru F4 w postaci direct z symetrią i potokiem V BEGIN p1: PROCESS BEGIN WAIT UNTI clk = '1'; t0 <= tap(0) + tap(6); t1 <= tap(2) + tap(4); t2 <= tap(3); t3 <= 3 * t1; t4 <= 19 * t1; t5 <= 32 * t2; t6 <= -t3; t7 <= t4 + t5; y <= t6 + t7; FOR I IN 6 OWNTO 1 OOP tap(i) <= tap(i-1); EN OOP; tap(0) <= x; EN PROCESS; EN fir; C FF f [Mz] t_clk [ns] 254 156 24,51 40,8 71

Realizacja filtru F4 w postaci direct z symetrią i potokiem Verilog // FIR c[n] ={-3, 0, 19, 32, 19, 0,-3} module fir_direct(clk, x_in, y_out); parameter l=7; // filter lenght input clk; input [7:0] x_in; output [14:0] y_out; reg [14:0] y_out; reg [7:0] tap [l-1:0]; reg [14:0] t0,t1,t2,t3,t4,t5,t6,t7; integer i; C FF f [Mz] t_clk [ns] 265 149 22,68 always@(posedge clk) begin t0 <= {{7{tap[0][7]}},tap[0]} + {{7{tap[6][7]}},tap[6]}; t1 <= {{7{tap[2][7]}},tap[2]} + {{7{tap[4][7]}},tap[4]}; t2 <= {{7{tap[3][7]}},tap[3]}; t3 <= 3 * t0; t4 <= 19 * t1; t5 <= 32 * t2; t6 <= -t3; t7 <= t4 + t5; y_out <= t6 + t7; end endmodule for(i=1; i<=6; i=i+1) begin end tap[i] <= tap[i-1]; tap[0] <= x_in; 72

Realizacja filtru F4 Symulacja 73

Realizacja filtru F4 w A współczynniki symetryczne C FF f [Mz] t_clk [ns] 362 253 52,63 19,0 odatkowe sumatory w linii rejestrów z-1. odatkowa tablica A, ale mniej wejść /2 74

Realizacja filtru F4 w A współczynniki symetryczne Porównanie realizacji filtru F4 7-rzędu () i próbek 8-bitowych (k) dla A bez uwzględnienia (a) i z uwzględnieniem (b) symetryczności współczynników: tablice A (a) 8 tablic (k) o 7 wejściach () (b) 9 tablic (k+1) o 4 wejściach (/2) sumatory (b) dodatkowe sumatory w linii rejestrów z -1 (b) drzewo sumatorów ma dodatkową gałąź dla k+1 bitu 75

Realizacja filtru F8 w FPGA Zrealizować filtr F8 o współczynnikach: -6, 0, 33, 0, -116, 0, 490, 802, 490, 0, -116, 0, 33, 0, -6 W strukturze filtru szeregowego W strukturze filtru równoległego Z wykorzystaniem arytmetyki rozproszonej Z wykorzystaniem dekompozycji funkcjonalnej Filtr zrealizować w strukturach z wykorzystaniem bloków SP: Stratix EP1S10F484C5 CycloneII EP2C5T144C6 (mnożarki) Cyclone EP1C3T100C6 (brak bloków SP) Realizacja z wykorzystaniem systemu Quartus2 7.0 76

Mnożarki Cyclone II Mnożarki wykorzystywane w aplikacjach SP: filtr FIR, transformata FFT, transformata CT Mnożarka 18 18 może pracować jako dwie mnożarki 9 9 77

Mnożarki Cyclone II Jeżeli signa, signb = 1 to czynnik jest traktowany jako liczba ze znakiem (signed) 78

Mnożarki Cyclone II Sygnał signa kontroluje trybem pracy obydwa wejścia A, i signb obydwa wejścia B. 79

Blok SP Stratix Blok SP może być skonfigurowany jako: osiem mnożarek 9 9 cztery mnożarki 18 18 dwie mnożarki 36 36 Blok SP może także realizować funkcję dodawania lub akumulacji. 80

Blok SP Stratix: blok sumatora i akumulatora Wyjścia z mnożarek 81

Blok SP Stratix: tryby pracy 82

Przykład: Mnożenie liczb zespolonych Tryb pracy: Two- Multiplier Adder Mode (a + jb) (c + jd) = (a c b d) + j (a d + b c) 83

Realizacja filtru F8 szeregowego - Verilog Funkcja MAC z biblioteki systemu, parametry ustawione za pomocą Wizard Plug-In Manager // funkcja MAC mac f_mac(.aclr0(acc_clr),.clock0(clk),.dataa(dataa),.datab(datab),.result(acc)); always @(count) begin dataa = tap[count]; datab = c[count]; end 84

Realizacja filtru F8 szeregowego Verilog // glowny automat always @(posedge clk) begin : States parameter s0=0, s1=1, s2=2, s3=3; reg [3:0] state; integer i; case (state) s0 : begin // inicjacja state <= s1; c[0] <= -12'd6; c[1] <= 12'd0; c[2] <= 12'd33; c[3] <= 12'd0; c[4] <= -12'd116; c[5] <= 12'd0; c[6] <= 12'd490; c[7] <= 12'd802; c[8] <= 12'd490; c[9] <= 12'd0; c[10] <= -12'd116; c[11] <= 12'd0; c[12] <= 12'd33; c[13] <= 12'd0; c[14] <= -12'd6; for (i = 0; i <= l-1 ; i=i+1) tap[i] <= 8'd0; acc_clr = 1'b1; // zerowanie ACC end s1 : begin state <= s2; count <= 4'd0; tap[0] <= x_in; for (i = 1; i <= l-1 ; i=i+1) tap[i] <= tap[i-1]; acc_clr = 1'b0; end s2 : begin if (count == 14) state <= s3; else begin state <= s2; count <= count + 1'd1; end end s3 : begin acc_clr = 1'b1; //zerowanie akumulatora state <= s1; y <= acc; end default: ; endcase end 85

Funkcja MAC 86

Realizacja w układach fpga Realizacja funkcji MAC: A tylko w komórkach B z wykorzystaniem mnożarek C z wykorzystaniem bloków SP (mnożarki z funkcją sumowania i akumulacji) C A B 87

Realizacja w układach fpga Chip Zajętość A B C S CII C C 421 287 247 SP 0 2 4 f maks [Mz] 80,44 86,01 105,34 C 403 271 271 SP 0 2 2 f maks [Mz] 89,92 102,43 102,43 C 421 421 421 SP - - - f maks [Mz] 77,03 77,03 77,03 88

Realizacja filtru F8 równoległego Verilog module fir_par (clk, x_in, y); parameter l=15; //Filter length input clk; input [7:0] x_in; output [19:0] y; reg [19:0] y; Funkcje lpm_mult i padd są funkcjami bibliotecznymi wire [19:0] mult_c [l-1:0]; wire [7:0] dataa [l-1:0]; wire [10:0] datab [l-1:0]; wire [19:0] acc; wire [19:0] temp [2:0]; reg [7:0] tap [l-1:0]; reg [10:0] c [l-1:0]; genvar j; // mnozenie wspolczynnikow przez probki generate for (j = 0; j <= l-1; j=j+1) begin : mults assign dataa[j] = tap[j]; assign datab[j] = c[j]; lpm_mult mult_j(.dataa(dataa[j]),.datab(datab[j]),.result(mult_c[j])); defparam mult_j.lpm_widtha=8; defparam mult_j.lpm_widthb=11; defparam mult_j.lpm_representation="signe"; defparam mult_j.lpm_widthp=20; defparam mult_j.lpm_widths=1; end endgenerate // sumator rownolegly padd adder(.data0x(mult_c[0]),.data1x(mult_c[1]),.data2x(mult_c[2]),.data3x(mult_c[3]),.data4x(mult_c[4]),.data5x(mult_c[5]),.data6x(mult_c[6]),.data7x(mult_c[7]),.data8x(mult_c[8]),.data9x(mult_c[9]),.data10x(mult_c[10]),.data11x(mult_c[11]),.data12x(mult_c[12]),.data13x(mult_c[13]),.data14x(mult_c[14]),.result(acc) ); 89

Realizacja filtru F8 równoległego Verilog // glowny automat always @(posedge clk) begin : States parameter s0=0, s1=1; reg [3:0] state; integer i; case (state) s0 : begin //inicjacja state <= s1; c[0] <= -11'd6; c[1] <= 11'd0; c[2] <= 11'd33; c[3] <= 11'd0; c[4] <= -11'd116; c[5] <= 11'd0; c[6] <= 11'd490; c[7] <= 11'd802; c[8] <= 11'd490; c[9] <= 11'd0; c[10] <= -11'd116; c[11] <= 11'd0; c[12] <= 11'd33; c[13] <= 11'd0; c[14] <= -11'd6; for (i = 0; i <= l-1 ; i=i+1) tap[i] <= 8'd0; end s1 : begin state <= s1; tap[0] <= x_in; for (i = 1; i <= l-1 ; i=i+1) tap[i] <= tap[i-1]; y <= acc; end default: ; endcase end endmodule 90

Realizacja filtru F8 równoległego z Arytmetyką Rozproszoną Verilog module dapara(clk, x_in, y); parameter l=15; //Filter length input clk; input [7:0] x_in; output [19:0] y; reg [19:0] y; wire [l-1:0] t_in [7:0]; wire [11:0] t_out [7:0]; reg [11:0] p [7:0]; reg [13:0] r0, r1, r2; reg [12:0] r3; reg [15:0] s0, s1; reg [19:0] s; reg [7:0] tap [l-1:0]; integer i; always @(posedge clk) begin tap[0] <= x_in; for (i = 1; i <= l-1 ; i=i+1) tap[i] <= tap[i-1]; y <= {{4{s0[15]}},s0} + {s1,4'b0000}; end always @(*) begin for (i = 0; i <= 7; i=i+1) p[i] = t_out[i]; r0 = ({{2{p[0][11]}},p[0]}) + ({p[1][11],p[1],1'b0}); r1 = {{2{p[2][11]}},p[2]} + {p[3][11],p[3],1'b0}; r2 = {{2{p[4][11]}},p[4]} + {p[5][11],p[5],1'b0}; r3 = {p[6][11],p[6]} - {p[7],1'b0}; s0 = {{2{r0[13]}},r0} + {r1,2'b00}; s1 = {{2{r2[13]}},r2} + {r3[12],r3,2'b00}; end assign r0 = {p[0][11],p[0][11],p[0]} + {p[1][11],p[1],1'b0}; assign r1 = {p[2][11],p[2][11],p[2]} + {p[3][11],p[3],1'b0}; assign r2 = {p[4][11],p[4][11],p[4]} + {p[5][11],p[5],1'b0}; assign r3 = {p[6][11],p[6]} - {p[7],1'b0}; assign s0 = {r0[13],r0[13],r0} + {r1,2'b00}; assign s1 = {r2[13],r2[13],r2} + {r3[12],r3,2'b00}; genvar j; generate for (j = 0; j <= 7; j=j+1) begin: Aj assign t_in[j] = {tap[14][j],tap[13][j],tap[12][j],tap[11][j],tap[10][j],tap[9][j],tap[8][j],tap[ 7][j],tap[6][j],tap[5][j],tap[4][j],tap[3][j],tap[2][j],tap[1][j],tap[0][j]}; case15s Aj(.table_in(t_in[j]),.table_out(t_out[j])); end endgenerate endmodule 91

Realizacja filtru F8 równoległego z Arytmetyką Rozproszoną wer.2 Verilog module dapara(clk, x_in, y); parameter l=15; //Filter length input clk; input [7:0] x_in; output [19:0] y; reg [19:0] y; wire [l-1:0] t_in [7:0]; wire [11:0] t_out [7:0]; reg [11:0] p [7:0]; reg [13:0] r0, r1, r2; reg [12:0] r3; reg [15:0] s0, s1; reg [19:0] s; reg [7:0] tap [l-1:0]; integer i; always @(posedge clk) begin tap[0] <= x_in; for (i = 1; i <= l-1 ; i=i+1) tap[i] <= tap[i-1]; y <= s; end always @(*) begin for (i = 0; i <= 7; i=i+1) p[i] = t_out[i]; end Użycie funkcji bibliotecznej sumatora // sumator rownolegly padd adder(.data0x(p[0]),.data1x(p[1]),.data2x(p[2]),.data3x(p[3]),.data4x(p[4]),.data5x(p[5]),.data6x(p[6]),.data7x(p[7]),.result(s) ); genvar j; generate for (j = 0; j <= 7; j=j+1) begin: Aj assign t_in[j] = {tap[14][j],tap[13][j],tap[12][j],tap[11][j],tap[10][j],tap[9][j],tap[8][j],tap[ 7][j],tap[6][j],tap[5][j],tap[4][j],tap[3][j],tap[2][j],tap[1][j],tap[0][j]}; case15s Aj(.table_in(t_in[j]),.table_out(t_out[j])); end endgenerate endmodule 92

Realizacja filtru F8 równoległego z Arytmetyką Rozproszoną - tablica Tablica A bez dekompozycji module case15s(table_in, table_out); input [14:0] table_in; output [11:0] table_out; reg [11:0] table_out; always@(table_in) case (table_in) 15'b000000000000000: table_out = 12'd0; 15'b000000000000001: table_out = -12'd6; 15'b000000000000010: table_out = 12'd0; 15'b111111111111110: table_out = 12'd1610; 15'b111111111111111: table_out = 12'd1604; default : table_out = 12'bx; endcase endmodule Tablica A z dekompozycją module case15s(table_in, table_out); input [14:0] table_in; output [11:0] table_out; //reg [11:0] table_out; f8 b(.table_in(table_in),.table_out(table_out)); endmodule W pliku f8 znajduje się zdekomponowana tablica w postaci sieci tablic o wielkościach odpowiadających komórce logicznej fpga 93

Realizacja w układach fpga Chip Zajętość C E F S CII C C 247 402 1013 569 SP 4 30 0 0 f maks [Mz] 105,34 58,97 87,6 84,86 C 271 637 1014 569 SP 2 26 0 0 f maks [Mz] 102,43 76,49 84,11 82,61 C 421 2226 1013 569 SP - - - - f maks [Mz] 77,03 61,0 80,4 78,37 Realizacja: C szeregowa z wykorzystaniem bloków SP, równoległa z wykorzystaniem SP, E równoległa z arytmetyką rozproszoną, F równoległa ze zdekomponowaną tablicą A 94

Filtry w strukturach mieszanych Filtry można realizować także z wykorzystaniem wbudowanych bloków pamięci Realizacja tablicy A za pomocą dekompozycji funkcjonalnej dekompozycja na małe (komórki logiczne) i duże (pamięci) bloki 95

Filtry w strukturach mieszanych 96

Filtry w strukturach mieszanych Realizacja filtru ahp z dekompozycją: 2 pamięci ROM + 14C 97

Filtry w strukturach mieszanych ASIP - esign & Architectures for Signal and Image Processing Grenoble, France - November 27-29, 2007 98

Filtr IP core Realizacja filtru F8 z użyciem FIR Compiler: 99

Filtr IP core Realizacja filtru F8 z użyciem FIR Compiler: filtr F8 o współczynnikach: -6, 0, 33, 0, -116, 0, 490, 802, 490, 0, -116, 0, 33, 0, -6 100

Filtr testbench Realizacja filtru z użyciem testbench w środowisku ModelSim wady: długi czas symulacji 101