Filtry cyfrowe o skończonej odpowiedzi impulsowej FIR - realizacje

Transkrypt

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

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 Realizacja filtrów w FPGA i SP vs MCU Źródło: 7

8 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

9 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

10 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

11 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, ,82 24, ,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

12 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

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,1294z 3 ( z 1 57z 2 33z 3 ) / z z 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 Filtr FIR programowalny symulacja Scilab 16

17 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 1 log G h[ k] 2 k0 log (9,5) 3, 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 (dla 4-bitów danych: -8 +7) 17

18 Przykład filtru FIR 4-rzędu realizacja V BEGIN p1: PROCESS BEGIN -- The coefficients are [ ]. WAIT UNTI clk = '1'; 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; EN PROCESS; EN fir; -- Registered input Realizacja: równoległa 18

19 Przykład filtru FIR 4-rzędu realizacja Verilog clk) begin //The coefficients are [ ]. /* 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 Operatory * i / dają gorszą realizację Realizacja: równoległa 19

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

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

22 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

23 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 [ ]. 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

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

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

26 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 [ ]. 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

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 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 [ ]. 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

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

30 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 ,82 24, ,48 54,1 ww. i symetria ,51 39,2 ww. i CS ,76 33,6 ww. i potok ,32 24,2 30

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 Realizacja: równoległa 31

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

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 33

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 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 Koszt sumatorów w MAG U.Meyer-Baese: SP with FPGAs 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); 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); Tylko dla liczb dodatnich Realizacja: równoległa 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 Realizacja: równoległa 41

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

43 Algorytm cub Na stronie: Parallel multiple constant multiplication (MCM) - Multiplier Block Generator Inne on-line generatory 43

44 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: /synth/acm1 -expensive -b 8 '3' '-25' '150' '256' - dotcode./dags/dot >&1 >./dags/mcm cat./dags/dot /dot.sh./dags/dag /usr/bin/convert -resize 539x539./dags/dag large.png./dags/dag png // Cost: 3 adds/subtracts 5 shifts 1 negations // epth: 3 44

45 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: /synth/acm1 -maxdepth 0 -expensive -aux -b 8 '3' '-25' '150' '256' -dotcode./dags/dot >&1 >./dags/mcm Solution infeasible with MAX_EPT=0. Increasing MAX_EPT=2. cat./dags/dot /dot.sh./dags/dag /usr/bin/convert -resize 411x411./dags/dag large.png./dags/dag png // Cost: 4 adds/subtracts 6 shifts 1 negations // epth: 2 45

46 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

47 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 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 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: ] [ 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: ] [ 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] 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 49 Kontynuując przekształcenie ]) [ 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 ]) [ ], [ ( 2 ] [ ] [ 2 n b B b b n b B b b n x n c f n x n c y

50 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

51 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

52 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

53 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] = = 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]) = = = = = = = = 8 Pojemność pamięci UT w bitach: 2 3 (max{0,4,1,5,3,7,4,8}) Krok b x b [2] x b [1] x b [0] f[b] 2 b + ACC(t 1) ACC(t)

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

55 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 ] [ Podstawiając do wzoru na sumę iloczynów: ]) [ ], [ ( 2 2 ]) [ ], [ ( n b B b b B B n x n c f n x n c f y

56 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]) = = = = = = = = 3 Krok b x b [2] x b [1] x b [0] f[b] 2 b + ACC(t 1) ACC(t) f[b] 2 b + ACC(t 1) ( )

57 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

58 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

59 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]) = = 3 x b [1] x b [0] f(c[1,0],x[1,0]) = = = = 5 Pojemność pamięci UT w bitach (2x mniej niż przed podzieleniem): 2 1 (max{0,3}) 2 2 (max{0,4,1,5}) 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)

60 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

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

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

63 Generator tablic A Na stronie: Materiały > Programy > Program i opis programu Generator tablic UT 63

64 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

65 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 " " => 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 65

66 module case7s (table_in, table_out); input [6:0] table_in; output [7:0] table_out; reg [7:0] table_out; 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

67 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 TO 9658); 67

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

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

70 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

71 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] ,51 40,8 71

72 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] ,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

73 Realizacja filtru F4 Symulacja 73

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

75 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

76 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

77 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

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

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

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

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

82 Blok SP Stratix: tryby pracy 82

83 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

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

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

86 Funkcja MAC 86

87 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

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

89 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

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

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

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

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

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

95 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

96 Filtry w strukturach mieszanych 96

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

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

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

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

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