Filtry cyfrowe o skończonej odpowiedzi impulsowej FIR

Transkrypt

1 Filtry cyfrowe o skończonej odpowiedzi impulsowej FIR 1

2 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

3 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

4 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

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

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

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 7

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 Koszt: -1 sumowań, mnoŝeń 8

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 9

10 Filtr FIR programowalny realizacja V -- This is a generic FIR filter generator -- It uses W1 signed bit data/coefficients bits IBRARY lpm; USE lpm.lpm_components.a; IBRARY ieee; USE ieee.std_logic_1164.a; USE ieee.std_logic_arith.a; USE ieee.std_logic_unsigned.a; moduł mnoŝenia potok 3 stopnie potok 1 stopień C FF f [Mz] t_clk [ns] ,82 24, ,35 31,9 ENTITY fir_prog IS GENERIC (W1 : integer := 9; -- Input bit width W2 : integer := 18; -- Multiplier bit width 2*W1 W3 : integer := 19; -- Adder width = W2+log2()-1 W4 : integer := 11; -- Output bit width : integer := 4; -- Filter length Mpipe : integer := 3); -- Pipeline steps of multiplier PORT ( clk : IN ST_OGIC; oad_x : IN ST_OGIC; x_in : IN ST_OGIC_VECTOR(W1-1 OWNTO 0); y_out : OUT ST_OGIC_VECTOR(W4-1 OWNTO 0)); EN fir_prog; 10

11 ARCITECTURE arch_fir OF fir_prog IS Filtr FIR programowalny BEGIN realizacja IF clk'event AN (clk = '1') TEN SUBTYPE N1BIT IS ST_OGIC_VECTOR(W1-1 OWNTO 0); SUBTYPE N2BIT IS ST_OGIC_VECTOR(W2-1 OWNTO 0); SOP: PROCESS (clk, load_x, a) -- Compute sum-of-products FOR I IN 0 TO -2 OOP -- Compute the transposed SUBTYPE N3BIT IS ST_OGIC_VECTOR(W3-1 OWNTO 0); a(i) <= (p(i)(w2-1) & p(i)) + a(i+1); -- filter adds TYPE ARRAY_N1BIT IS ARRAY (0 TO -1) OF N1BIT; EN OOP; TYPE ARRAY_N2BIT IS ARRAY (0 TO -1) OF N2BIT; a(-1) <= p(-1)(w2-1) & p(-1); -- First TAP has TYPE ARRAY_N3BIT IS ARRAY (0 TO -1) OF N3BIT; EN IF; -- only a register y <= a(0); SIGNA x : N1BIT; EN PROCESS SOP; SIGNA y : N3BIT; SIGNA c : ARRAY_N1BIT; -- Coefficient array -- Instantiate pipelined multiplier SIGNA p : ARRAY_N2BIT; -- Product array MulGen: FOR I IN 0 TO -1 GENERATE SIGNA a : ARRAY_N3BIT; -- Adder array Muls: lpm_mult -- Multiply p(i) = c(i) * x; GENERIC MAP ( PM_WITA => W1, PM_WITB => W1, BEGIN PM_PIPEINE => Mpipe, oad: PROCESS -- oad data or coefficient PM_REPRESENTATION => "SIGNE", BEGIN PM_WITP => W2, WAIT UNTI clk = '1'; PM_WITS => W2) IF (oad_x = '0') TEN PORT MAP ( clock => clk, dataa => x, c(-1) <= x_in; -- Store coefficient in register datab => c(i), result => p(i)); FOR I IN -2 OWNTO 0 OOP -- Coefficients shift one EN GENERATE; c(i) <= c(i+1); y_out <= y(w3-1 OWNTO W3-W4); EN OOP; EN arch_fir; ESE x <= x_in; -- Get one data sample at a time EN IF; EN PROCESS oad; 11

12 Filtr FIR programowalny realizacja Verilog // This is a generic FIR filter generator // It uses W1 signed bit data/coefficients bits 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 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 end else x <= x_in; end 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

13 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

14 Filtr FIR programowalny symulacja Współczynniki: G( z) = 0, ,8365z 1 + 0,2241z 2 0,1294 z 3 = ( z = z + 57z z z 2 3 ) / z 3 14

15 Filtr FIR programowalny symulacja Matlab Plik fir_1.m: [B] = [ ] 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 = in = out = Columns 1 through Columns 10 through >> 15

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 = ½ + ¼ = 11,11 2 ługość akumulatora wyznaczona jest sumą długości próbek wejściowych oraz bitów protekcji G G 1 log h[ k] = log2(9,5) k = 0 2 < 4 ZałoŜenie: projektowany system ma zaimplementowaną 8-bitow bitową architekturę arytmetyczną, dlatego próbki wejściowe powinny być ograniczone do wartości ±128/9,5 = ±13 16

17 Przykład filtru FIR 4-rzędu realizacja V PACKAGE eight_bit_int IS SUBTYPE BYTE IS INTEGER RANGE -128 TO 127; TYPE ARRAY_BYTE IS ARRAY (0 TO 3) OF BYTE; EN eight_bit_int; IBRARY work; USE work.eight_bit_int.a; IBRARY ieee; USE ieee.std_logic_1164.a; USE ieee.std_logic_arith.a; ENTITY fir_direct IS PORT (clk : IN ST_OGIC; x : IN BYTE; y : OUT BYTE); EN fir_direct; ARCITECTURE fir OF fir_direct IS -- Tapped delay line of bytes SIGNA tap : ARRAY_BYTE; BEGIN p1: PROCESS BEGIN WAIT UNTI clk = '1'; -- The coefficients are [ ]. y <= 2 * tap(1) + tap(1) + tap(1) / 2 + tap(1) / * 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; -- Input in register 0 EN PROCESS; EN fir; 17

18 Przykład filtru FIR 4-rzędu realizacja Verilog // irect FIR filter with 4 taps [ ] module fir_direct (clk, x_in, y_out); parameter n=8; parameter l=4; // filter lenght input clk; input [n-1:0] x_in; output [n-1:0] y_out; reg signed [n-1:0] tap [l-1:0]; reg signed [n-1:0] y_out; integer i; always@(posedge clk) begin. //The coefficients are [ ]. Operatory * i / dają gorszą realizację /* y_out <= 2 * tap[1] + tap[1] + tap[1] / 2 + tap[1] / * 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 18

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

20 Filtr FIR symetryczny Koszt: -1 sumowań, /2 mnoŝeń 20

21 Przykład filtru symetrycznego FIR 4- rzędu realizacja V PACKAGE eight_bit_int IS SUBTYPE BYTE IS INTEGER RANGE -128 TO 127; TYPE ARRAY_BYTE IS ARRAY (0 TO 3) OF BYTE; EN eight_bit_int; IBRARY work; USE work.eight_bit_int.a; IBRARY ieee; USE ieee.std_logic_1164.a; USE ieee.std_logic_arith.a; ENTITY fir_direct IS PORT (clk : IN ST_OGIC; x : IN BYTE; y : OUT BYTE); EN fir_direct; 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; ARCITECTURE fir OF fir_direct IS -- Tapped delay line of bytes SIGNA tap : ARRAY_BYTE; SIGNA t0, t1 : BYTE; 21

22 Przykład filtru symetrycznego FIR 4- rzędu realizacja Verilog // irect FIR filter with 4 taps [ ] //simmetric module fir_direct (clk, x_in, y_out); parameter n=8; parameter l=4; // filter lenght input clk; input [n-1:0] x_in; output [n-1:0] y_out; assign t0 = tap[0] + tap[3]; assign t1 = tap[1] + tap[2]; reg signed [n-1:0] tap [l-1:0]; reg signed [n-1:0] y_out; wire signed [n-1:0] t0, t1; integer i; always@(posedge clk) begin //The coefficients are [ ]. 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 22

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

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ę Zamień równieŝ sekwencję 1011 na ) 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: = = (2+1).( ) = = (4-0.25) 1 24

25 Przykład filtru symetrycznego FIR 4- rzędu o stałych współczynnikach CS PACKAGE eight_bit_int IS SUBTYPE BYTE IS INTEGER RANGE -128 TO 127; TYPE ARRAY_BYTE IS ARRAY (0 TO 3) OF BYTE; EN eight_bit_int; IBRARY work; USE work.eight_bit_int.a; IBRARY ieee; USE ieee.std_logic_1164.a; USE ieee.std_logic_arith.a; ENTITY fir_direct IS PORT (clk : IN ST_OGIC; x : IN BYTE; y : OUT BYTE); EN fir_direct; 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; ARCITECTURE fir OF fir_direct IS -- Tapped delay line of bytes SIGNA tap : ARRAY_BYTE; SIGNA t0, t1 : BYTE; 25

26 Przykład filtru symetrycznego FIR 4- rzędu o stałych współczynnikach CS // irect FIR filter with 4 taps [ ] //simmetric+csd module fir_direct (clk, x_in, y_out); parameter n=8; parameter l=4; // filter lenght input clk; input [n-1:0] x_in; output [n-1:0] y_out; reg signed [n-1:0] tap [l-1:0]; reg signed [n-1:0] y_out; wire signed [n-1:0] t0, t1; integer i; assign t0 = tap[0] + tap[3]; assign t1 = tap[1] + tap[2]; always@(posedge clk) begin //The coefficients are [ ]. 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 26

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

28 Przykład filtru FIR 4-rzędu z potokiem V PACKAGE eight_bit_int IS SUBTYPE BYTE IS INTEGER RANGE -128 TO 127; TYPE ARRAY_BYTE IS ARRAY (0 TO 3) OF BYTE; EN eight_bit_int; IBRARY work; USE work.eight_bit_int.a; IBRARY ieee; USE ieee.std_logic_1164.a; USE ieee.std_logic_arith.a; ENTITY fir_direct IS PORT (clk : IN ST_OGIC; x : IN BYTE; y : OUT BYTE); EN fir_direct; 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; ARCITECTURE fir OF fir_direct IS -- Tapped delay line of bytes SIGNA tap : ARRAY_BYTE; SIGNA t0, t1 : BYTE; 28

29 Przykład filtru FIR 4-rzędu z potokiem Verilog // irect FIR filter with 4 taps [ ] //simmetric+csd+pipelining module fir_direct (clk, x_in, y_out); parameter n=8; parameter l=4; // filter lenght input clk; input [n-1:0] x_in; output [n-1:0] y_out; always@(posedge clk) begin //The coefficients are [ ]. t0 <= tap[0] + tap[3]; t1 <= tap[1] + tap[2]; t2 <= (t1<<2) - (t1>>>2); t3 <= -t0; y_out <= t2 + t3; reg signed [n-1:0] tap [l-1:0]; reg signed [n-1:0] y_out; reg signed [n-1:0] t0, t1, t2, t3; integer i; for(i=1; i<=3; i=i+1) begin tap[i] <= tap[i-1]; end tap[0] <= x_in; end endmodule; 29

30 Symetryczny filtr FIR symulacja C FF f [Mz] t_clk [ns] ,32 24,2 30

31 Symetryczny filtr FIR porównanie realizacji realizacja FIR komórek przerzutników f [Mz] t_clk [ns] programowalny z potokiem ,82 24,5 o stałych ,48 54,1 współczynnikach ww. i symetria ,51 39,2 ww. i CS ,76 33,6 ww. i potok ,32 24,2 31

32 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 32

33 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). 33

34 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 34

35 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

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

37 Realizacja filtru FIR z wykorzystaniem RAG UŜycie algorytm RAG: Krok o realizacji Zrealizowane Opis 1 {3, 25, 150, 256} {} inicjacja 2 {3, 25, 150, 256} {} usunąć negacje 3 {3, 25, 150} {256} usunąć współczynniki 2 k 4 {3, 25, 75} {256} usunąć czynniki 2 k (150=2 75) 5 {25, 75} {256, 3} zrealizować współczynniki o koszcie jeden (3=2+1) 6 {75} {256, 3, 25} zrealizować pozostałe współczynniki (25=5 5=(4+1) (4+1)) 7 {} {256, 3, 25, 75} 75=5 15=5 (16 1) Koszt realizacji filtru wynosi 4 (zmniejszył się z 6). iczba poziomów w drzewie sumatorów zmniejszyła się z 3 do 2 (dla współczynnika 150). 37

38 Realizacja filtru FIR z wykorzystaniem RAG 38

39 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 = ta <= (" " & x_r & '0') + (" " & x_r); -- 5 = tb <= (" " & x_r & "00") + (" " & x_r); tc <= tb + (tb(15 OWNTO 0) & "00"); = 5 + 4*5 td <= (tb(13 OWNTO 0) & "0000") - tb; = 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; tap(3) <= tap(4); Tylko dla liczb dodatnich tap(4) <= tap(5) + (td (16 OWNTO 0) & '0'); tap(5) <= tap(6) + (" 00 " & x_r & " "); tap(6) <= tap(7) + (td(16 OWNTO 0) & '0'); tap(7) <= tap(8); tap(8) <= tap(9) - tc; tap(9) <= tap(10); tap(10) <= ta; -- 3 y <= tap(0); 39

40 Program RAG Na stronie: Materiały > Programy > Program i opis programu Wynik dla h[k]={ } 40

41 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 = assign tb = (x_r<<2) + x_r; // 5 = 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 41

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

43 Operacje mnoŝenia i dodawania MAC y = c, x = N 1 n= 0 c[ n] x[ n] Rejestr przesuwny = c[0] x[0] + c[1] x[1] + K+ c[ N Układ mnoŝący Sumator 1] x[ N 1] Akumulator X[N-1] X[1] X[0] C[N-1] C[1] C[0] + R 43

44 Arytmetyka rozproszona istributed Arithmetic - teoria JeŜeli załoŝymy, Ŝe filtr ma stałe współczynniki a x jest zmienną to x[n] moŝna zapisać: x[ n] = B 1 b= 0 x b [ n] 2 b gdzie x b [n] [0,1] i oznacza bit b w wektorze x[n] n-tej próbki Podstawiając powyŝszą sumę do równania y, otrzymamy: y = N 1 n= 0 c[ n] B 1 b= 0 x b [ n] 2 Przekształcając równanie: y = c[0]( x + c[1]( x + K + c[ N B 1 B 1 [1]2 1]( x [0]2 B 1 B 1 [ N B 1 + x + x B 2 1]2 b B 2 [1]2 B 1 [0]2 + B 2 x B 2 + K+ x B 2 [ N + K+ x 0 1]2 0 [1]2 B 2 [0]2 0 ) 0 ) + K+ x 0 [ N 1]2 0 ) 44

45 Arytmetyka rozproszona Teoria Kontynuując przekształcenie... y = ( c[0] x + ( c[0] x + K B 2 B 1 [0] + c[1] x [0] + c[1] x B 2 B 1 [1] + K+ c[ N [1] + K+ c[ N 1] x 1] x + ( c[0] x N B 1 B 2 [ N [ N 0 0[0] + c[1] x0[1] + K+ c[ N 1] x0[ 1]) 2 1])2 1])2 B 1 B 2 PowyŜszy wzór moŝna zapisać: y = B 1 b= 0 2 b N 1 n= 0 c[ n] x b [ n] = B 1 b= 0 2 b N 1 n= 0 f ( c[ n], x b [ n]) 45

46 Arytmetyka rozproszona Praktyka y = N 1 n= 0 c[ n] x[ n] Rejestr przesuwny Ukł. mnoŝący Akumulator X[N-1] X[1] X[0] C[N-1] C[1] C[0] + R 46

47 Arytmetyka rozproszona Praktyka y = B 1 b= 0 2 b N 1 n= 0 f ( c[ n], x b [ n]) Rejestr przesuwny ogika A Akumulator X B-1 [0] X 1 [0] X 0 [0] X B-1 [1] X 1 [1] X 0 [1] X B-1 [N-1] X 1 [N-1] X 0 [N-1] UT + R shift +/- 47

48 Arytmetyka rozproszona Wielkość pamięci UT ogika A UT Pamięć UT: N-bitów wejściowych (N rząd filtru), czyli na raz przetwarzamy N 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). 48

49 Arytmetyka rozproszona Zawartość pamięci UT ogika A UT Przykład: Filtr 3-rzędu o 3-bitowych współczynniki c[0]=2, c[1]=3, c[2]=1. x b [2] x b [1] x b [0] f(c[n],x[n]) x0+3x0+2x0 = 0 = x0+3x0+2x1 = 2 = x0+3x1+2x0 = 3 = Na wejściu pojawią się 3-bitowe próbki: x[0]=1=001 2, x[1]=3=011 2, x[2]=7=111 2, czyli y = c[0]x[0] + c[1]x[1] + c[2]x[2] = 2x1 + 3x3 + 1x7 = x0+3x1+2x1 = 5 = x1+3x0+2x0 = 1 = x1+3x0+2x1 = 3 = x1+3x1+2x0 = 4 = x1+3x1+2x1 = 6 = cykl t x t [2] x t [1] x t [0] f[t]+ ACC[t-1] =ACC[t] x = x = x =18 49

50 Arytmetyka rozproszona UŜycie akumulatora przesuwającego Realizując filtr z uŝyciem akumulatora przesuwającego otrzymamy dla poprzedniego przykładu następujące wyliczenia: cykl t x t [2] x t [1] x t [0] f[t]+ >>(ACC[t-1]) =ACC[t] x = x = x =18 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ć x2 B-1 ) i zawsze przesuwać akumulator w prawo o jeden bit. uŝo prostsza realizacja w sprzęcie. 50

51 Arytmetyka rozproszona Przetwarzanie równoległe MoŜliwe jest przetworzenie kilku bitów równolegle. JeŜeli dla kaŝdego bitu próbek x[n] podstawimy logikę A o takiej samej zawartości, to wówczas w wyniku sumy otrzymamy wartość wyjściową y w 1 cyklu zegara. Zysk w szybkości przetwarzania jest jednak okupiony dodatkowymi sumatorami, pamięciami UT i rejestrami (jeŝeli stworzymy strukturę potokową). 51

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

53 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. 53

54 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); table_out : OUT INTEGER RANGE -6 TO 70); EN case7s; ARCITECTURE Cs OF case7s IS BEGIN PROCESS (table_in) BEGIN CASE table_in IS WEN " " => table_out <= 0; WEN " " => table_out <= -3; WEN " " => table_out <= 0; WEN " " => table_out <= -3; WEN " " => table_out <= 19; WEN " " => table_out <= 16;... WEN " " => table_out <= 67; WEN " " => table_out <= 64; WEN OTERS => table_out <= 0; EN CASE; EN PROCESS; EN Cs; Realizacja filtru F4 w A V Tablica A 54

55 module case7s (table_in, table_out); input [6:0] table_in; output [7:0] table_out; reg [7:0] table_out; begin case (table_in) 7'd0 7'd1 7'd2 7'd3 7'd4 7'd5.. 7'd126 7'd127 default : ; endcase end endmodule : 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 55

56 Realizacja filtru F4 w A V IBRARY ieee; -- Using predefined packages USE ieee.std_logic_1164.a; USE ieee.std_logic_arith.a; PACKAGE da_package IS -- User defined components COMPONENT case7s PORT ( table_in : IN ST_OGIC_VECTOR(6 OWNTO 0); table_out : OUT INTEGER RANGE -6 TO 70); EN COMPONENT; EN da_package; ENTITY dapara IS > Interface IBRARY work; USE work.da_package.a; IBRARY ieee; USE ieee.std_logic_1164.a; USE ieee.std_logic_arith.a; GENERIC ( : INTEGER := 7; -- filter lenght N : INTEGER := 8 -- input bit width ); PORT (clk : IN ST_OGIC; x_in : IN ST_OGIC_VECTOR(N-1 OWNTO 0); y : OUT INTEGER RANGE TO 9658); EN dapara; 56

57 ARCITECTURE flex OF dapara IS SIGNA x0, x1, x2, Realizacja x3, x4, x5, x6, x7 : ST_OGIC_VECTOR(-1 filtru F4 OWNTO w A 0); SIGNA y0, y1, y2, y3, y4, y5, y6, y7 : integer RANGE -6 TO 70; SIGNA tap0, tap1, tap2, tap3, tap4, tap5, tap6 : ST_OGIC_VECTOR(7 OWNTO 0); SIGNA p0,p1,p2,p3,p4,p5,p6,p7 : integer RANGE -6 TO 70; SIGNA r0,r1,r2 : integer RANGE -18 TO 210; SIGNA r3 : integer RANGE -146 TO 82; SIGNA s0 : integer RANGE -90 TO 1050; SIGNA s1 : integer RANGE -602 TO 538; BEGIN PROCESS > A in behavioral style 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; --3rd pipeline register dr EN inŝ. Paweł PROCESS; Tomaszewicz 57

58 C FF f [Mz] t_clk [ns] ,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 PORT MAP(table_in => x0, table_out => y0); C_Table1: case7s PORT MAP(table_in => x1, table_out => y1); C_Table2: case7s PORT MAP(table_in => x2, table_out => y2); C_Table3: case7s PORT MAP(table_in => x3, table_out => y3); C_Table4: case7s PORT MAP(table_in => x4, table_out => y4); C_Table5: case7s PORT MAP(table_in => x5, table_out => y5); C_Table6: case7s PORT MAP(table_in => x6, table_out => y6); C_Table7: case7s PORT MAP(table_in => x7, table_out => y7); EN flex; 58

59 Realizacja filtru F4 w A Verilog //'include "case7s.v" 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 [14:0] y_out; // reg [14:0] y_out; // wire [l-1:0] x0, x1, x2, x3, x4, x5, x6, x7; reg [7:0] y0, y1, y2, y3, y4, y5, y6, y7; // reg [7:0] tap0, tap1, tap2, tap3, tap4, tap5, tap6; always@(posedge clk) begin tap0 <= x_in; tap1 <= tap0; tap2 <= tap1; tap3 <= tap2; tap4 <= tap3; tap5 <= tap4; tap6 <= tap5; reg [14:0] p0,p1,p2,p3,p4,p5,p6,p7; // reg [14:0] r0,r1,r2,r3; reg [14:0] s0,s1; 59

60 Realizacja filtru F4 w A Verilog end // 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 60

61 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)); 61

62 Realizacja filtru F4 w postaci direct z potokiem V PACKAGE eight_bit_int IS -- User defined types SUBTYPE BYTE IS INTEGER RANGE -128 TO 127; TYPE ARRAY_BYTE IS ARRAY (0 TO 6) OF BYTE; EN eight_bit_int; IBRARY work; USE work.eight_bit_int.a; IBRARY ieee; USE ieee.std_logic_1164.a; USE ieee.std_logic_arith.a; ENTITY fir_direct IS > Interface PORT (clk : IN ST_OGIC; x : IN BYTE; y : OUT INTEGER RANGE TO 9658); EN fir_direct; ARCITECTURE fir OF fir_direct IS SIGNA tap : ARRAY_BYTE; SIGNA t0, t1 : INTEGER RANGE -256 TO 254; SIGNA t2 : INTEGER RANGE -128 TO 127; SIGNA t3 : INTEGER RANGE -768 TO 762; SIGNA t4 : INTEGER RANGE TO 4826; SIGNA t5 : INTEGER RANGE TO 4064; SIGNA t6 : INTEGER RANGE -762 TO 768; SIGNA t7 : INTEGER RANGE TO 8890; 62

63 Realizacja filtru F4 w postaci direct z 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; dr inŝ. Paweł EN Tomaszewicz fir; C FF f [Mz] t_clk [ns] ,51 40,8 63

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

65 Realizacja filtru F4 Symulacja 65

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

67 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 67

68 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 Quartus 7.0 full 68

69 MnoŜarki Cyclone II MnoŜarki wykorzystywane w aplikacjach SP: filtr FIR, transformata FFT, transformata CT MnoŜarka moŝe pracować jako dwie mnoŝarki

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

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

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

73 Blok SP Stratix: blok sumatora i akumulatora Wyjścia z mnoŝarek 73

74 Blok SP Stratix: tryby pracy 74

75 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) 75

76 Realizacja filtru F8 szeregowego - Verilog module fir_ser (clk, x_in, y); parameter l=15; //Filter length input clk; input [7:0] x_in; output [19:0] y; reg [19:0] y; reg [19:0] mult_c; reg [7:0] dataa; reg [11:0] datab; reg [7:0] tap [l-1:0]; reg [11:0] c [l-1:0]; reg [3:0] count; reg [19:0] acc; reg acc_clr; 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)); begin dataa = tap[count]; datab = c[count]; end 76

77 Realizacja filtru F8 szeregowego Verilog // glowny automat 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 end state <= s2; count <= count + 1'd1; end s3 : begin acc_clr = 1'b1; //zerowanie akumulatora state <= s1; y <= acc; end default: ; endcase end 77

78 Funkcja MAC 78

79 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 79

80 Realizacja w układach fpga Chip Zajętość A B C C S SP f maks [Mz] 80,44 86,01 105,34 C CII SP f maks [Mz] 89,92 102,43 102,43 C C SP f maks [Mz] 77,03 77,03 77,03 80

81 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) ); 81

82 Realizacja filtru F8 równoległego Verilog // glowny automat 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 82

83 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; 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 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 83

84 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; clk) begin tap[0] <= x_in; for (i = 1; i <= l-1 ; i=i+1) tap[i] <= tap[i-1]; y <= s; end begin for (i = 0; i <= 7; i=i+1) p[i] = t_out[i]; end // 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) UŜycie funkcji bibliotecznej sumatora ); 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 84

85 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'b : table_out = 12'd0; 15'b : table_out = -12'd6; 15'b : table_out = 12'd0; 15'b : table_out = 12'd1610; 15'b : 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 85

86 Realizacja w układach fpga Chip Zajętość C E F S CII C C SP f maks [Mz] 105,34 58,97 87,6 84,86 C SP f maks [Mz] 102,43 76,49 84,11 82,61 C 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 86

87 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 87

88 Filtry w strukturach mieszanych 88

89 Filtry w strukturach mieszanych 89

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