Filtry cyfrowe o skończonej odpowiedzi impulsowej FIR

Filtry cyfrowe o skończonej odpowiedzi impulsowej FIR 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

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

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

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

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] 794 592 40,82 24,5 746 264 31,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

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

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

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,1294 z 3 = (124 + 214z = 124 256 + 214 256 1 z + 57z 1 + 2 57 256 33z z 2 3 ) / 256 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

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

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 [-1 3.75 3.75-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; -- Input in register 0 EN PROCESS; EN fir; 17

Przykład filtru FIR 4-rzędu realizacja Verilog // irect FIR filter with 4 taps [-1 3.75 3.75-1] 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 [-1 3.75 3.75-1]. Operatory * i / dają gorszą realizację /* 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 18

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

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

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

Przykład filtru symetrycznego FIR 4- rzędu realizacja Verilog // irect FIR filter with 4 taps [-1 3.75 3.75-1] //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 [-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 22

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 23

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 24

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

Przykład filtru symetrycznego FIR 4- rzędu o stałych współczynnikach CS // irect FIR filter with 4 taps [-1 3.75 3.75-1] //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 [-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 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 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

Przykład filtru FIR 4-rzędu z potokiem Verilog // irect FIR filter with 4 taps [-1 3.75 3.75-1] //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 [-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; 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

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

Symetryczny filtr FIR porównanie realizacji realizacja FIR komórek przerzutników f [Mz] t_clk [ns] programowalny z potokiem 794 592 40,82 24,5 o stałych 142 40 18,48 54,1 współczynnikach 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 31

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

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

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

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

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

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 Tylko dla liczb dodatnich 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); 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 41

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

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

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

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

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

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

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

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]) 0 0 0 1x0+3x0+2x0 = 0 = 000 2 0 0 1 1x0+3x0+2x1 = 2 = 010 2 0 1 0 1x0+3x1+2x0 = 3 = 011 2 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 = 18. 0 1 1 1x0+3x1+2x1 = 5 = 101 2 1 0 0 1x1+3x0+2x0 = 1 = 001 2 1 0 1 1x1+3x0+2x1 = 3 = 011 2 1 1 0 1x1+3x1+2x0 = 4 = 100 2 1 1 1 1x1+3x1+2x1 = 6 = 110 2 cykl t x t [2] x t [1] x t [0] f[t]+ ACC[t-1] =ACC[t] 0 1 1 1 6x2 0 + 0 =6 1 1 1 0 4x2 1 + 6 =14 2 1 0 0 1x2 2 + 14 =18 49

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] 0 1 1 1 6x2 2 + 0 =24 1 1 1 0 4x2 2 + 12 =28 2 1 0 0 1x2 2 + 14 =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

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

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

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

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 "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 54

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

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 -9722 TO 9658); EN dapara; 56

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

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

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; //-9722..9658 reg [14:0] y_out; //-9722..9658 wire [l-1:0] x0, x1, x2, x3, x4, x5, x6, x7; reg [7:0] y0, y1, y2, y3, y4, y5, y6, y7; //-6..70 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; //-6..70 reg [14:0] r0,r1,r2,r3; reg [14:0] s0,s1; 59

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

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

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 -9722 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 -4864 TO 4826; SIGNA t5 : INTEGER RANGE -4096 TO 4064; SIGNA t6 : INTEGER RANGE -762 TO 768; SIGNA t7 : INTEGER RANGE -8960 TO 8890; 62

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] 254 156 24,51 40,8 63

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] 265 149 22,68 endmodule tap[i] <= tap[i-1]; end tap[0] <= x_in; end 64

Realizacja filtru F4 Symulacja 65

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 66

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

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

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 69

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

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

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

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

Blok SP Stratix: tryby pracy 74

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

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)); always @(count) begin dataa = tap[count]; datab = c[count]; end 76

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

Funkcja MAC 78

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

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

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

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 82

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 83

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

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 85

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 86

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

Filtry w strukturach mieszanych 88

Filtry w strukturach mieszanych 89

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