Seminarski rad Bit Serijski Množač - apeg.ac.me · PDF fileSeminarski rad Blagojević Gojko 5 ... revizija i dorada tako da je stvorena cijela paleta algoritama koji množenje obavljaju

UNIVERZITET CRNE GORE ELEKTROTEHNIČKI FAKULTET-PODGORICA

AUTOMATIZOVANI DIZAJN ELEKTRONSKIH KOLA PROF. DR RADOVAN STOJANOVIĆ

Bit Serijski Množač

Seminarski rad

Blagojević Gojko 5/00 Jakšić Zoran 27/02

Bit-serial množač ADEK

2

UVOD

Množači igraju važnu ulogu u savremenoj obradi digitalnih signala i čine osnovne

gradivne komponente za velike digitalne aplikacije. Sa razvojem tehnologije sve više

istraživača nastoji da dizajnira množače koji će imati sledeće osobine:

Veliku brzinu,

Malu potrošnju,

Kompaktnu VLSI implementaciju

Pošto je teško kreirati jedno digitalno kolo koje će na sva tri

polja davadi izvanredne rezultete, pristupilo se pravljenju

kompromisa, što je za rezultat imalo pojavu čitavog spektra

algoritama za množenje. Glavni cilj ovog rada je

predstavljanje jednog od trenutno veoma atraktivnih

algoritama kada je riječ o implementaciji množača u FPGA

tehnologiji. Riječ je o „bit-serial“ množaču, koji po svojim

osobinama daje izvanredne rezultate kada je u pitanju

potrošnja i kompaktnost. Naravno, da bi se postigli tako dobri

rezultati kada su u pitanju ove dvije osobine VLSI kola,

morali su se praviti kompromisi po pitanju brzine. Iz tog

razloga, za ovakvo množenje je potreban značajan broj taktnih

impulsa u odnosu na konkurentnu paralelnu izvedbu množača

koja množenje obavlja u jednom taktu. U radu je

predstavljeno nekoliko varijanti „bit-serial“ množača, njihov

način implementacije u FPGA tehnologiji propraćen

odgovarajućim VHDL kodom. Takođe su dati uporedni

rezultati testova množača u „bit-serial“ i „parallel“ izvedbi.

VLSI (Very Large Scale Integration) – kola vrlo viskog stepena integracije

FPGA (Field Programmable Gate Array) - programabilni logički sklopovi velikog kapaciteta. Sastoje se od programabilnih ćelija okruženih programabilnim inter-konekcijama. Mogu implementirati skvencijalnu i kombinacionu logiku. Sadrže od 1K pa do 1M logičkig kapija i rade na taktovima i do 200MHz

VHDL je akronim za VHSIC (Very High Speed Integrated Circuit) Hardware Description Language. Pretstavlja internacionalni IEEE standardizovani jezik, visokog nivoa abstrakcije, za opis elektronskog hardvera.


3

Slika 1.— „Single-Cycle“ množač

1. MNOŽAČI U FPGA TEHNOLOGIJI

Algoritmi bazirani na paralelnoj izvedbi su tokom vremena doživljavali veliki broj

revizija i dorada tako da je stvorena cijela paleta algoritama koji množenje obavljaju na

ovaj način. Jedan od takvih algoritama je i „Single-Cycle“ algoritam (slika 1.) koji

operaciju množenja

obavlja u samo jednom

taktnom impulsu. Ovaj

algoritam osim što

rezerviše veliki broj

logičkih kola u čipu,

nije efikasan u FPGA

implementaciji jer

trasiranje podataka kod

FPGA čipova stvara

značajna propaga-ciona

kašnjenja. Samim tim, da bi se obezbijedio pravilan rad množača, potrebno je sniziti clock.

Kao rezultat svega toga imamo da množač, iako radi množenje samo u jednom taktu,

preopterećuje resurse čipa i uslovljava da cijelo FPGA kolo radi presporo.

Za razliku od paralelnog množenja, gdje se svi bitovi obrađuju istovremeno u

jednom taktnom impulsu, za množenje „bit-serial“ množačem (slika 5.) potrebno je oko

dva puta više taktnih impulsa od dužine ulaznih podataka. Na primjer, za množenje dva N-

bitna broja potrebno je najmanje 2N taktnih impulsa. Međutim ovakva implementacija

množača zazima N puta manje logičkih ćelija u samom FPGA čipu. Na taj način se vrši

ušteda na resursima i smanjuju se propagaciona kašnjenja, što daje mogućnost da se poveća

clock. Ako se uzmu u obzir osobine FPGA čipova, jasno je da je bolji izbor množač

zanovan na „bit-serial“ algoritmu, prije svega zbog uštede na resursima, koja apsolutno

opravdava realno sporiji rad.

Dalji tekst će biti posvećen „bit-serial“ množaču i njegovoj realizaciji u FPGA

tehnologiji


4

2. „BIT - SERIAL“ MNOŽAČ

U prethodnom tekstu je naznačeno da je za implementaciju „bit-serial“ množača

potrebna značajno manja logička struktura nego kod paralelnog množača. Razlog za to je

što se prilikom „bit-serial“ množenja u svakom taktnom impulsu koristi isti logički sklop

koji ima N puta manje logičkih elemenata nego u paralelnoj izvedbi. Na slici 1. nalazi se

šema jednog uprošćenog množača koji se bazira na „bit-serial“ arhitekturi. Riječ je o „bit-

serial by parallel“ množaču koji množi serijski sa paralelnim ulazom a rezultat daje

serijski.

Ovaj množač ima jedan paralelni i jedan serijski ulaz dok mu je izlaz očitava

serijski. Princip rada je sledeći. Ulaz koji se dovodi paralelno, množi se sa jednim bitom

ulaza koji se dovodi serijski i pomjeri za jedan bit udesno. Dobijeni rezultat se sabira sa

prethodnim rezultatom koji je dobijen na isti način. Ovo je takozvani „pomjeri-dodaj“

(shift-add) algoritam.

Množnje obavlja and kolo. Ukoliko paralelni ulaz ima N bita svaki njegov bit se

množi sa bitom serijskog ulaza. Rezultat sada treba sabrati sa prethodnim i u tu svrhu se

koristi sistem sastavljen od komponenti serijskog sabirača (serial adder). To kolo je

dobijeno rednim vezivanjem N serial-addera na taj način što je na jedan njegov ulaz

doveden izalaz prethodnog stepena. Isčitavanje se vrši sa bita najmanje tešine.


5

Slika 2.— serijski sabirač (serial_adder)

2.1 Struktura „bit-serial by parallel“ množača

Logički sklop „bit-serial by parallel“ množača je veoma prost. Bazira se na

osnovnim logičko-aritmetičkim komponentama kao što su sabirači, logičke kapije i

pomjerački registri. Osnovna gradivna ćelija ovakvog množača je serijski sabirač.

2.1.1 Serijski sabirač (serial_adder) To je u osnovi potpuni sabirač koji pamti stanja na carry izlazu i sabira ga u sledećem

clock-u sa podacima na ulazu. Sa šeme date na slici 2. vidi se da je osnovni memorijski

element D flip-flop koji sa full adder-om čini osnovnu strukturu serial adder-a.

Najprije je potrebno kreirati gradivne komponente koje ulaze u sastav ovog sabirača.


6

Slika 3.— D Flip-Flop

D flip-flop (D_f_f)

-----------------------D Flip-Flop---------------------- -------------------------------------------------------- Library ieee; Use ieee.std_logic_1164.all; -------------------------------------------------------- Entity D_f_f is Port (d, clk, clr : in std_logic ; q : out std_logic); End D_f_f; -------------------------------------------------------- Architecture D_f_f_behav of D_f_f is Begin Process(clk,clr) Begin if clr='1' then q<='0'; elsif clk'event and clk = '1' then q <= d ; End if ; End Process ; End D_f_f_behav; -------------------------------------------------------- Library ieee; Use ieee.std_logic_1164.all; -------------------------------------------------------- Package D_f_f_package is Component D_f_f Port (d, clk, clr : in std_logic ; q : out std_logic); End Component; End D_f_f_package; -------------------------------------------------------- --------------------------------------------------------


7

Slika 4.— Full_Adder (shematic file)

Potpuni sabirač (Full adder)

------------------------Fulladder----------------------- -------------------------------------------------------- Library ieee; Use ieee.std_logic_1164.all; ------------------------------------------------------- Entity Full_add is Port (a, b, cin, clk : in std_logic; sum, cout : out std_logic); End Full_add; ------------------------------------------------------- Architecture Full_add_behav of Full_add is Begin process(clk) Begin if clk'event and clk='1' Then sum <= (a xor b) xor cin ;

cout <= (a and b) or (cin and (a xor b)); end if; end process; End Full_add_behav; ------------------------------------------------------- Library ieee; Use ieee.std_logic_1164.all; ------------------------------------------------------- Package Full_add_package is Component Full_add Port( a,b,cin,clk : in std_logic; sum,cout : out std_logic); End Component; End Full_add_package; -------------------------------------------------------

-------------------------------------------------------

Pošto je izvršeno kreiranje osnovnih elemenata koji čine jedan serijski sabirač

pristupa se njihovom povezivanju u jednu funkcionalnu cjelinu. VHDL kod koji slijedi

pretstavlja jednu od realizacija serijskog sabirača koja prati šemu sa slike 2.


8

---------------------Bit-Serial-Adder------------------ ------------------------------------------------------- Library ieee; Use ieee.std_logic_1164.all; Library work; Use work.Full_add_package.all; Use work.D_f_f_package.all; ------------------------------------------------------- Entity Ser_add is Port(a, b, clk, rst, en : in std_logic; s : out std_logic); End Ser_add; ------------------------------------------------------- Architecture Ser_add_behav of Ser_add is Component Full_add Port( a, b, cin, clk :in std_logic; sum, cout :out std_logic); End Component; Component D_f_f Port( d, clk, clr :in std_logic; q :out std_logic); End Component; Signal s1, s2, s3, clktemp : std_logic; Begin clktemp<=clk And en;

Fa1: Full_add Port map(a=>a, b=>b, cin=>s1,sum=>s2, cout=>s3, clk=>clk); D1: D_f_f Port map(d=>s3, clk=>clktemp, clr=>rst, q=>s1); D2: D_f_f Port map(d=>s2, clk=>clktemp, clr=>rst, q=>s); End Ser_add_behav; ------------------------------------------------------- Library ieee; Use ieee.std_logic_1164.all; Library work; Use work.Full_add_package.all; Use work.D_f_f_package.all; ------------------------------------------------------- Package Ser_add_package is Component Ser_add Port( a,b,clk,rst,en : in std_logic; s : out std_logic); End Component; End Ser_add_package; ------------------------------------------------------- -------------------------------------------------------

Ovim smo kreirali osnovni gradivni element jednog bit „bit-serial by parallel“ množača

Uključivanje bibilioteka prethdno kreiranih

komponenti u novi projekat


9

Slika 5.— „bit-serial“ množač

2.2 Realizacija „bit-serial by parallel“ množača

Nakon kreiranja potrebnih komponenti, pristupa se i kreiranju samog množača.

Sledeći VHDL kod omogućava da se kreira „bit-serial by parallel“ množač koji može da

radi sa ulaznim podacima proizvoljne dužine. Riječ GENERIC u kodu nam omogućava

kreiranje množača za ulazne podatke bilo koje dužine.


10

--------------------Serial Multiplier------------------ ------------------------------------------------------- Library ieee; Use ieee.std_logic_1164.all; Library work; Use work.D_f_f_package.all; Use work.Full_add_package.all; Use work.Ser_add_package.all; Use work.Counter_package.all; ------------------------------------------------------- Entity Ser_mult is Generic(N : integer := 16); Port( y, clk, rst, en : In std_logic; x : In std_logic_vector (N-1 downto 0); Q : Out std_logic); End Ser_Mult; ------------------------------------------------------- Architecture Ser_mult_behav of Ser_mult is Component Ser_add Port(A, B, clk, rst,en : In std_logic; S : Out std_logic); End Component; Component Counter Generic(MaxVal : integer ); Port( Start_process,rst, Clk : In std_logic; Q : Buffer Integer Range 0 To MaxVal-1; End_process : Out std_logic); End Component; Signal pp : std_logic_vector (N Downto 0); Signal xy : std_logic_vector (N-1 Downto 0); Begin A : for I in xy'Range Generate Ser_add_i : Ser_add Port map(A => xy(I), B => pp(I+1), clk => clk, rst => rst, S => pp(I), en=>en); End Generate A; Q_generate : for I in xy'Range Generate xy(I) <= x(I) and y; End Generate Q_generate; pp(pp'LEFT) <= '0'; Q <= pp(pp'RIGHT); End Ser_mult_behav; ------------------------------------------------------- Library ieee; Use ieee.std_logic_1164.all; Library work; Use work.D_f_f_package.all; Use work.Full_add_package.all; Use work.Ser_add_package.all; ------------------------------------------------------- Package Ser_mult_package is Component Ser_mult Generic(N : integer); Port( y,clk, rst, en : In std_logic; x :In std_logic_vector (N-1 downto 0); Q : Out std_logic); End Component; End Ser_mult_package; ------------------------------------------------------- -------------------------------------------------------

Generic – daje mogućnost da isti kod koristimo za kreiranje množača za

ulazne podatke proizvoljne dužine


11

2.3 Rezultati simulacije

Quartus II kao programski paket razvijen od strane Altere, u okviru svog razvojnog

okruženja pruža mogućnost simuliranja rada kreiranih komponenti. Sve kreirane

komponente u ovom radu su prošle testiranje na Quartus-ovom simulatoru. Na slici 6 i 7. se

nalazi rezultat simulacije rada „bit-serial by parallel“ množača, kreiranog u prethodnom

poglavlju za 16-bitne i 8-bitne ulazne podatke.

Slik

a 6.

– R

ezul

tat s

imul

acije

za 8

-bitn

u va

rija

ntu

mno

žača

Slik

a 7.

– R

ezul

tat s

imul

acije

za 1

6-bi

tnu

vari

jant

u m

nožača


12

Slika 8.— brojač (shematic file)

3. VARIJANTE SERIJSKOG MNOŽAČA

Ako pažljivije pogledamo prethodnu realizaciju množača vidimo da je glavni

nedostatak nepostojanje sinhronizacionih signala za početak i kraj procesa množenja. Ti

signali su neophodni za sinhronizaciju samog množača sa ostalim digitalnim kolima koji

upućuju svoje zahtjeve ka njemu i očekuju rezultate množenja. Takodje, u FPGA kolima se

podaci prosleđuju i paralelno i serijski pa je potrebno da postoje množači koji mogu da

prihvataju i paralelne i serijske ulaze kao i da rezultate množenja daju u jednom od ova dva

obilika. Problem sinhronizacije se kod množača svodi na sinhronizaciju ulaznih i izlaznih

podataka iz množača.

Kolo koje igra značajnu ulogu u kontrolnoj logici sinhronizovanih množača je

brojač. Ovo kolo na ulazu dobija start_process signal i nakon određenog broja taktova

(MaxVal) generiše logičko „1“ na stop_process izlazu. Parametar MaxVal se zadaje u

VHDL kodu, ali postoji mogućnost i da se promijeni u samom „shematic file“ – u. (slika

8.)

Realizacija jednog takvog brojača, koji će biti korišćen u narednim primjerima data je

sledećimVHDL kodom.


13

-------------------------Counter------------------------ -------------------------------------------------------- Library Ieee; Use ieee.std_logic_1164.all; Use Ieee.std_logic_arith.all; -------------------------------------------------------- Entity Counter Is Generic (MaxVal : integer := 8); Port ( Start_process, rst, Clk : In std_logic; End_process : Out std_logic); End Counter; -------------------------------------------------------- Architecture Counter_Behav Of Counter Is Signal Q: integer range 0 To MaxVal; Begin Process (Clk, rst,Start_process, Q) Begin If rst = '1' Or Start_process='0' Then Q <= 0; End_process<='0'; Elsif rst='0' Then If Clk'event And Clk = '1' Then If Q = MaxVal-1 Then Q <= MaxVal-1; End_process<='1'; Else Q <= Q+1; End_process<='0'; End If; End If; End If; End Process; End Counter_Behav; -------------------------------------------------------- Library Ieee; Use ieee.std_logic_1164.all; Use Ieee.std_logic_arith.all; -------------------------------------------------------- Package Counter_package is Component Counter Generic(MaxVal : integer :=16 ); Port( Start_process,rst, Clk : In std_logic; End_process : Out std_logic); End Component; End Counter_package; -------------------------------------------------------- --------------------------------------------------------


14

Slika 9.— SPISPO Shift registar (shematic file)

Druga bitna komponenta koja je korišćena u narednim primerima je pomjerački

registar kod koga se podaci mogu upisivati i čitati i paralelno i serijski. Na koji način će se

podaci čitati i upisivati regulišu signali LoDa i SerEn. Ukoliko je na kontrolnom ulazu

LoDa logičko „1“ podaci se mogu upisivati paralelno, dok je za logičko „1“ na SerEn

ulazu omogućeno pomjeranje. Parametar „N“ definiše veličinu registra i može se menjati

direktno u VHDL kodu ili u shematic file-u.

Realizicaja ovakvog registra u VHDL-u je data sledećim kodom.

------------Serial Parallel Input And Output------------ -------------------------------------------------------- library IEEE; Use Ieee.std_logic_1164.all; Use Ieee.std_logic_arith.all; -------------------------------------------------------- Entity spispo Is Generic(N : Integer :=16); Port( Din : In std_logic_vector((N-1) Downto 0); Dout : Out std_logic_vector((N-1) Downto 0); Clk,LoDa,Rst,SerEn,SerIn : In Std_logic; SerOut : Out Std_logic ); End spispo; --------------------------------------------------------


15

-------------------------------------------------------- Architecture Spispo_Behav Of spispo Is Signal Qtemp: std_logic_vector((N-1) Downto 0):=(Others =>'X'); Begin Shift_Register_Process: Process(Clk,Rst) Begin If (Rst = '1') Then Qtemp <= (Others => '0');

Elsif (Clk'event And (Clk = '1') And (Clk'last_value = '0')) Then If (LoDa = '1') Then Qtemp <= Din; Elsif (SerEn = '1') Then Qtemp((N-1)) <= SerIn; Qtemp((N-2) Downto 0) <= Qtemp((N-1) Downto 1); End If; End If; End Process Shift_Register_Process; Dout <= Qtemp; SerOut <= Qtemp(0); End Spispo_Behav;

-------------------------------------------------------- Library ieee; Use ieee.std_logic_1164.all; Use Ieee.std_logic_arith.all; Package Spispo_package Is Component Spispo Generic(N : Integer ); Port( Din: In std_logic_vector((N-1) Downto 0); Dout: Out std_logic_vector((N-1) Downto 0); Clk,LoDa,Rst,SerEn,SerIn: In Std_logic; SerOut : Out Std_logic); End Component; End Spispo_package; -------------------------------------------------------- --------------------------------------------------------


16

Slika 10.— PPIPO množač

3.1 Parallel Input – Parallel Output (PPIPO) Množač

PPIPO množač pripada grupi sinhronizovanih serijskih množača koji imaju

paralelne ulaze i paralelni izlaz. Sinhronizacija je ostvarena tako što se start_process signal

(logičko“1“) šalje množaču u trenutku kad su signali dovedeni na ulaze množača. Nakon

dobijanja start_process, množač paralelni ulaz „X“ direktno vodi na kolo za množenje, a

ulaz „Y“ smješta u pomjerački registar. U trenutku kad je podatak učitan u registar startuje

se kolo za množenje i omogući se pomjeranje u samom registru tako da se paralelni ulaz

„Y“ serijski isčitava. U ovom slučaju je potrebno obezbijediti da se „X“ ulaz ne mijenja u

toku procesa množenja dok za „Y“ ulaz to nije od značaja. Rezultat iz kola za množenje se

serijski upisuje u pomjerački registar na izlazu. Kada se množenje završi kontrolna logika

množača generiše stop_process signal (logičko “1“) i tada je na paralelnom izlazu registra

moguće isčitati tačan rezultat množenja.

Sledeći VHDL kod pretstavlja realizaciju jednog PPIPO množača koji funkcioniše

po principu objašnjenom u prethodnom dijelu.


17

--Serijski mnozac Paralelni inputi i Paralelni Output--- --------------------ser_mult_PPIPO---------------------- Library ieee; Use ieee.std_logic_1164.all; Use Ieee.std_logic_arith.all; Library work; Use work.Full_add_package.all; Use work.Ser_add_package.all; Use work.spispo_package.all; Use work.Counter_package.all; --------------------------------------------------------

Entity ser_mult_PPIPO Is Generic (A: Integer :=4); Port(X,Y :In std_logic_vector(A-1 downto 0); clk, rst, start_process :In std_logic; end_process :Out std_logic; Rez :Out std_logic_vector(2*A-1 downto 0)); End ser_mult_PPIPO; -------------------------------------------------------- Architecture ser_mult_PPIPO_Behav Of ser_mult_PPIPO Is ---ser_mult Component Ser_mult Generic(N : integer); Port(y, clk, rst, en: In std_logic; X : In std_logic_vector (N-1 downto 0); Q : Out std_logic); End Component; ---spispo Component Spispo Generic(N : Integer ); Port( Din :In std_logic_vector((N-1) Downto 0); Dout :Out std_logic_vector((N-1) Downto 0); Clk, LoDa, Rst, SerEn, SerIn:In std_logic; SerOut : Out Std_logic); End Component; ---Counter Component Counter Generic(MaxVal : integer ); Port(rst, Clk, Start_process : In std_logic; End_process : Out std_logic); End Component; ---Deklaracija signala Signal ic1, ic2, ic3, ic4 : std_logic; Begin ---Povezivanje komponenti -------------------------------------------------------- ---- konverzija paralelnog Y ulaza u serijski(jedan ulaz –--u mnozac je serijski) Y_stor: Spispo Generic map(N=>A)

Port map(Din=>Y, clk=>clk, rst=>rst, SerIn=>'Z', LoDa=>not ic1, SerEn=>ic1 , SerOut=>ic2);


18

----konverzija serijskog izlaza u paralelni Rez_stor: Spispo Generic map(N=>2*A) Port map(Din=>(others=>'Z'), clk=>clk, rst=>rst, SerIn=>ic3, LoDa=>'0', SerEn=>not ic4 , Dout=>Rez); -----povezivanje serijskog mnozaca mult: Ser_mult Generic map(N=>A) Port map(clk=>clk, rst=>rst, en=>ic1, X=>X, Y=>ic2 and ic1, Q=>ic3); ----Counter za odredjivanje kada je Y_stor napunjen Count1: Counter Generic map(MaxVal=>2) Port map(rst=>rst,clk=>clk,Start_process=>Start_process, End_process=>ic1); ----Counter za odredjivanje stop_process Count2: Counter Generic map(MaxVal=>2*A+1) Port map (rst=>rst, clk=>clk, Start_process=>ic1, End_process=>ic4); end_process<=ic4; End ser_mult_PPIPO_Behav; -------------------------------------------------------- Library ieee; Use ieee.std_logic_1164.all; Use Ieee.std_logic_arith.all; Library work; Use work.Full_add_package.all; Use work.Ser_add_package.all; Use work.spispo_package.all; Use work.Counter_package.all; -------------------------------------------------------- Package ser_mult_PPIPO_Package Is Component ser_mult_PPIPO Generic (A: Integer :=8); Port(X,Y:In std_logic_vector(A-1 downto 0); clk, rst, start_process :In std_logic; end_process :Out std_logic; Rez:Out std_logic_vector(2*A-1 downto 0)); End Component; End ser_mult_PPIPO_package; --------------------------------------------------------


19

Slik

a 11

. – R

ezul

tat s

imul

acije

za 4

-bitn

u va

rija

ntu

PPIP

O m

nožača

Slik

a 12

. – R

ezul

tat s

imul

acije

za 4

-bitn

u va

rija

ntu

PPIP

O m

nožača


20

Slik

a 13

. – R

ezul

tat s

imul

acije

za 1

2-bi

tnu

vari

jant

u PP

IPO

mno

žača

Slik

a 14

. – R

ezul

tat s

imul

acije

za 1

6-bi

tnu

vari

jant

u PP

IPO

mno

žača


21

Slika 15.— PPISO množač

3.2 Parallel Input – Serial Output (PPISO) Množač

Drugi tip množača je PPISO množač. Kod njega je korišćena slična kontolna logika

kao i kod tipa PPIPO. Razlika je u tome što se signal iz kola za množenje vodi direktno na

izlaz množača pri čemu se stop_process signal (logičko “1“) generiše u trenutku kad se na

izlazu pojavi zadnji bit rezultata i traje sve dok se ne pojavi novi start_process. Grafički

prikaz ovoga kola dat je na slici koja sledi


22

----Serijski mnozac Paralelni inputi-serijski Output---- --------------------Ser_Mult_PPISO---------------------- Library ieee; Use ieee.std_logic_1164.all; Use Ieee.std_logic_arith.all; Library work; Use work.Full_add_package.all; Use work.Ser_add_package.all; Use work.spispo_package.all; Use work.Counter_package.all; --------------------------------------------------------

Entity Ser_Mult_PPISO Is Generic (A: Integer :=12); Port(X,Y :In std_logic_vector(A-1 downto 0); clk, rst, start_process :In std_logic; Rez, end_process :Out std_logic); End Ser_mult_PPISO; -------------------------------------------------------- Architecture Ser_Mult_PPISO_Behav Of Ser_Mult_PPISO Is ---ser_mult Component Ser_mult Generic(N : integer); Port( y, clk, rst, en : In std_logic; x: In std_logic_vector (N-1 downto 0); Q : Out std_logic); End Component; ---spispo Component Spispo Generic(N : Integer ); Port( Din :In std_logic_vector((N-1) Downto 0); Dout :Out std_logic_vector((N-1) Downto 0); Clk, LoDa, Rst, SerEn, SerIn:In Std_logic; SerOut : Out Std_logic); End Component; ---Counter Component Counter Generic(MaxVal : integer ); Port( rst, Clk, Start_process : In std_logic; End_process : Out std_logic); End Component; ---Deklaracija signala Signal ic1, ic2 : std_logic; Begin ---Povezivanje komponenti -------------------------------------------------------- -- konverzija paralelnog Y ulaza u serijski(jedan ulaz u --mnozac je serijski) Y_stor: Spispo Generic map(N=>A)

Port map(Din=>Y, clk=>clk, rst=>rst, SerIn=>'Z', LoDa=>not ic1, SerEn=>ic1 , SerOut=>ic2);


23

----povezivanje serijskog mnozaca mult: Ser_mult Generic map(N=>A) Port map(clk=>clk, rst=>rst, en=>ic1, X=>X, Y=>ic2 and ic1, Q=>Rez); ----Counter za odredjivanje kada je Y_stor napunjen Count1: Counter Generic map(MaxVal=>2) Port map (rst=>rst, clk=>clk, Start_process=>Start_process, End_process=>ic1); ----Counter za odredjivanje stop_process Count2: Counter Generic map(MaxVal=>2*A+1) Port map (rst=>rst, clk=>clk, Start_process=>ic1, End_process=>end_process); End Ser_Mult_PPISO_Behav; -------------------------------------------------------- Library ieee; Use ieee.std_logic_1164.all; Use Ieee.std_logic_arith.all; Library work; Use work.Full_add_package.all; Use work.Ser_add_package.all; Use work.spispo_package.all; Use work.Counter_package.all; -------------------------------------------------------- Package Ser_mult_PPISO_Package Is Component ser_mult_PPISO Generic (A: Integer :=8); Port(X,Y :In std_logic_vector(A-1 downto 0); clk, rst, start_process :In std_logic; Rez, end_process :Out std_logic); End Component; End Ser_mult_PPISO_package; --------------------------------------------------------


24

Slik

a 16

. – R

ezul

tat s

imul

acije

za 4

-bitn

u va

rija

ntu

PPIS

O m

nožača

Slik

a 17

. – R

ezul

tat s

imul

acije

za 8

-bitn

u va

rija

ntu

PPIS

O m

nožača


25

Slik

a 18

. – R

ezul

tat s

imul

acije

za 1

2-bi

tnu

vari

jant

u PP

ISO

mno

žača

Slik

a 19

. – R

ezul

tat s

imul

acije

za 1

6-bi

tnu

vari

jant

u PP

ISO

mno

žača


26

Slika 20.— SSISO množač

3.3 Serial Input – Serial Output (SSISO) Množač

Treći tip množača, za razliku od prethodna dva, ulazne signale prima u serijskom

obliku. Riječ je SSISO množaču koji na nailaskom start_process signala najprije „X“ i

„Y“ ulazne podatke smiješta u pomjeračke registre. Zatim prvi registar isčitava paralelno a

drugi serijski i takve izlaze iz registara vodi na kolo za množenje. Rezultat se daje serijski

pri čemu na kraj množenja ukazuje stop_process signal koji kontrolna logika množača

postavlja na logičko „1“.


27

---Serijski mnozac Paralelni inputi i serijski Output--- --------------------Ser_Mult_SSISO---------------------- Library ieee; Use ieee.std_logic_1164.all; Use Ieee.std_logic_arith.all; Library work; Use work.Full_add_package.all; Use work.Ser_add_package.all; Use work.spispo_package.all; Use work.Counter_package.all; -------------------------------------------------------- Entity Ser_Mult_SSISO Is Generic (A: Integer :=4); Port(X, Y, clk, rst, start_process :In std_logic; Rez, end_process :Out std_logic); End Ser_mult_SSISO; -------------------------------------------------------- Architecture Ser_Mult_SSISO_Behav Of Ser_Mult_SSISO Is ---ser_mult Component Ser_mult Generic(N : integer); Port( y, clk, rst, en : In std_logic; x: In std_logic_vector (N-1 downto 0); Q : Out std_logic); End Component; ---spispo Component Spispo Generic(N : Integer ); Port( Din : In std_logic_vector((N-1) Downto 0); Dout : Out std_logic_vector((N-1) Downto 0); Clk, LoDa, Rst, SerEn, SerIn:In Std_logic; SerOut: Out Std_logic); End Component; ---Counter Component Counter Generic(MaxVal : integer ); Port( rst, Clk, Start_process : In std_logic; End_process : Out std_logic); End Component; ---Deklaracija signala Signal ic1, ic2,ic3 : std_logic; Signal ic4 : std_logic_vector(A-1 Downto 0); Begin ---Povezivanje komponenti ----konverzija serijskog x ulaza u paralelni(jedan ulaz ---u mnozac je paralelni) X_stor: Spispo Generic map(N=>A) Port map(Din=>(others=>'Z'), clk=>clk, rst=>rst, SerIn=>X, LoDa=>'0',


28

SerEn=>start_process And(not ic1), dout=>ic4); ----serijski ulaz Y je potrebno zakasniti a bitova(da bi ---se napunio registar X_stor) Y_stor: Spispo Generic map(N=>A) Port map(Serin=>Y, clk=>clk, rst=>rst, Din=>(others=>'Z'), LoDa=>'0', SerEn=>start_process and (not ic2), SerOut=>ic3); -----povezivanje serijskog mnozaca mult: Ser_mult Generic map(N=>A) Port map(clk=>clk, rst=>rst, en=>ic1, X=>ic4, Y=>ic3 and ic1, Q=>Rez); ----Counter za odredjivanje kada je Y_stor napunjen Count1: Counter Generic map(MaxVal=>A) Port map ( rst=>rst, clk=>clk, Start_process=>Start_process, End_process=>ic1); ----Counter za zaustavljanje Y serijskog registra Count2: Counter Generic map(MaxVal=>A) Port map ( rst=>rst, clk=>clk, Start_process=>ic1, End_process=>ic2); ----Counter za odredjivanje stop_process Count3: Counter Generic map(MaxVal=>2*A+1) Port map (rst=>rst, clk=>clk, Start_process=>ic1, End_process=>end_process); End Ser_Mult_SSISO_Behav; -------------------------------------------------------- Library ieee; Use ieee.std_logic_1164.all; Use Ieee.std_logic_arith.all; Library work; Use work.Full_add_package.all; Use work.Ser_add_package.all; Use work.spispo_package.all; Use work.Counter_package.all; -------------------------------------------------------- Package Ser_mult_SSISO_Package Is Component ser_mult_SSISO Generic (A: Integer :=8); Port(X, Y, clk, rst, start_process:In std_logic; Rez, end_process :Out std_logic); End Component; End Ser_mult_SSISO_package; -------------------------------------------------------- --------------------------------------------------------


29

Slik

a 21

. – R

ezul

tat s

imul

acije

za 4

-bitn

u va

rija

ntu

SSIS

O m

nožača

Slik

a 22

. – R

ezul

tat s

imul

acije

za 8

-bitn

u va

rija

ntu

SSIS

O m

nožača


30

Slik

a 23

. – R

ezul

tat s

imul

acije

za 1

2-bi

tnu

vari

jant

u SS

ISO

mno

žača

Slik

a 24

. – R

ezul

tat s

imul

acije

za 1

6-bi

tnu

vari

jant

u SS

ISO

mno

žača


31

Slika 25.— SSIPO množač

3.4 Serial Input –Parallel Output (SSIPO) Množač

Četvrti tip množača predstavlja nadogradnju na SSISO množač jer rezultat

množenja najprije smješta u izlazni, a zatim generiše logičko „1“ na stop_process signalu,

nakon čega je moguće paralelno isčitati tačan rezultat.


32

--Serijski mnozac Serijski inputi i Paralelni Output---- --------------------Ser_Mult_SSIPO---------------------- Library ieee; Use ieee.std_logic_1164.all; Use Ieee.std_logic_arith.all; Library work; Use work.Full_add_package.all; Use work.Ser_add_package.all; Use work.spispo_package.all; Use work.Counter_package.all; -------------------------------------------------------- Entity Ser_Mult_SSIPO Is Generic (A: Integer :=12); Port(X, Y, clk, rst, start_process :In std_logic; end_process :Out std_logic; Rez Out std_logic_vector(2*A-1 downto 0)); End Ser_mult_SSIPO; -------------------------------------------------------- Architecture Ser_Mult_SSIPO_Behav Of Ser_Mult_SSIPO Is ---ser_mult Component Ser_mult Generic(N : integer); Port( y, clk, rst, en : In std_logic; x: In std_logic_vector (N-1 downto 0); Q : Out std_logic); End Component; ---spispo Component Spispo Generic(N : Integer ); Port( Din: In std_logic_vector((N-1) Downto 0); Dout:Out std_logic_vector((N-1) Downto 0); Clk, LoDa, Rst, SerEn, SerIn:In Std_logic; SerOut: Out Std_logic); End Component; ---Counter Component Counter Generic(MaxVal : integer ); Port( rst, Clk, Start_process : In std_logic Q : Buffer Integer Range 0 To MaxVal-1); End Component; ---Deklaracija signala Signal ic1, ic2,ic3,ic5,ic6 : std_logic; Signal ic4 : std_logic_vector(A-1 Downto 0); Begin ---Povezivanje komponenti --------------------------------------------------------

---- konverzija serijskog x ulaza u paralelni(jedan ulaz ----u mnozac je paralelni) X_stor: Spispo Generic map(N=>A) Port map(Din=>(others=>'Z'), clk=>clk, rst=>rst, SerIn=>X, LoDa=>'0', SerEn=>start_process And(not ic1) , dout=>ic4); ----serijski ulaz Y je potrebno zakasniti a bitova(da bi ----se napunio registar X_stor)


33

Y_stor: Spispo Generic map(N=>A)

Port map(Serin=>Y, clk=>clk, rst=>rst, Din=>(others=>'Z'), LoDa=>'0', SerEn=>start_process and (not ic2) , SerOut=>ic3); ----Konverzija serijskog izlaza u paralelni

Rez_stor: Spispo Generic map(N=>2*A) Port map(Serin=>ic5, clk=>clk, rst=>rst, Din=>(others=>'Z'), LoDa=>'0', SerEn=>not ic6 , Dout=>Rez); -----povezivanje serijskog mnozaca mult: Ser_mult Generic map(N=>A) Port map(clk=>clk, rst=>rst, en=>ic1, X=>ic4, Y=>ic3 and ic1, Q=>ic5); ----Counter za odredjivanje kada je Y_stor napunjen Count1: Counter Generic map(MaxVal=>A) Port map (rst=>rst, clk=>clk, Start_process=>Start_process, End_process=>ic1); ----Counter za zaustavljanje Y serijskog registra Count2: Counter Generic map(MaxVal=>A) Port map (rst=>rst, clk=>clk, Start_process=>ic1, End_process=>ic2); ----Counter za odredjivanje stop_process Count3: Counter Generic map(MaxVal=>2*A+1) Port map (rst=>rst, clk=>clk, Start_process=>ic1, End_process=>ic6); end_process<=ic6; End Ser_Mult_SSIPO_Behav; -------------------------------------------------------- Library ieee; Use ieee.std_logic_1164.all; Use Ieee.std_logic_arith.all; Library work; Use work.Full_add_package.all; Use work.Ser_add_package.all; Use work.spispo_package.all; Use work.Counter_package.all; -------------------------------------------------------- Package Ser_mult_SSIPO_Package Is Component ser_mult_SSIPO Generic (A: Integer :=8); Port(X, Y, clk, rst, start_process:In std_logic; end_process :Out std_logic; Rez:Out std_logic_vector(2*A-1 downto 0)); End Component; End Ser_mult_SSIPO_package; --------------------------------------------------------


34

Slik

a 26

. – R

ezul

tat s

imul

acije

za 4

-bitn

u va

rija

ntu

SSIP

O m

nožača

Slik

a 27

– R

ezul

tat s

imul

acije

za 8

-bitn

u va

rija

ntu

SSIP

O m

nožača


35

Slik

a 28

. – R

ezul

tat s

imul

acije

za 1

2-bi

tnu

vari

jant

u SS

IPO

mno

žača

Slik

a 29

. – R

ezul

tat s

imul

acije

za 1

6-bi

tnu

vari

jant

u SS

IPO

mno

žača


36

4. SERIAL vs PARALLEL

(završna riječ)

U prvom dijelu rada je bilo riječi o arhitekturama na kojima se baziraju množači.

Naglašeno je da postoje dvije osnovne arhitekture, paralelna i serijska. Množači u

paralelnoj izvedbi zauzimaju značajnu logičku strukturu, ali rezultat množenja je dostupan

već nakon jednog taktnog impulsa. Sa druge strane, množači bazirani na serijskoj

arhitekturi su vrlo štedljivi kada su u pitanju logički resursi u čipu ali je potrebno „potrošiti“

značajan broj taktova prije nego li se na izlazu množača pojavi rezultat! Na kojoj arhitekturi

bazirati rad množača koji se želi projektovati? Zavisi od tehnologije u okviru koje se vrši

implementacija, kao i od „debljine novčanika“ onoga koji je naručilac projekta. Krenimo

redom. Jasno je da nije moguće postići kompaktnost serijskog množača i brzinu paralelnog

u okviru jedne arhitekture. Iz tog razloga se moramo odlučiti za jednu od arhitektura i

praviti varijacije u okviru nje, a u cilju postizanja što boljih performansi. Pored toga bitno je

izabrati pogodnu tehnologiju za implementaciju takvog rješenja. Ranije u tekstu je

objašnjeno da propagaciona kašnjenja kod kola baziranih na FPGA tehnologiji ne

dozvoljavaju množačima u paralelnoj izvedbi da pokažu svoju punu efikasnost te je zbog

tog pogodnija „bit-serial“ arhitektura. Naravno, to nije i jedini razlog, jer ako se uzme u

obzir da je teorijski za realizovanje množenja dva N-bitna broja „bit-serial“ množačem

potrebno N puta manje logičkih kola jasno je da tada cijena igra odlučujuću ulogu.

Međutim kakav je stvarno odnos broja potrebnih logičkih ćelija za jednu i drugu izvedbu?

Upravo ovo poglavlje je posvećeno tome. Najbolji način da to saznamo je da na test

stavimo obije arhitekture i dozvolimo da one sebe postave na odgovarajuće mjesto. I tako

su se na testu našla četiri množača koja smo kreirali tokom rada kao predstavnici „bit-

serial“ arhitekture a nasuprot njima našao se lpm_mult. Ovaj množač pripada grupi

„Single-Cycle“ množača i njegov model se nalazi u Quartus-ovoj biblioteci megafunc.

Upravo su Quartus-ovi izvještaji koristili kao izvor podataka za ovaj test. A šta je

upoređivano? Prije svega broj logičkih kola koje ovi množači rezervišu u jednom FPGA

čipu, a zatim i vrijeme potrebno za izvršenje operacije množenja gledano kroz broj taktnih

impulsa. Testovi su urađeni za različite dužine podataka sa kojima množači operišu (4, 8,

12, 16 bita) i dobijeni grafik govori sam od sebe.


37

Slika 30.— Broj rezervisanih logičkih elemenata u funkciji dužine operanta za različite izvedbe množača

Tabela 1.— Rezervisani logički elementi pri različitim dužinama operanda za različite izvedbe množača

0

50

100

150

200

250

300

350

400

450

4 8 12 16Veličina operanada u bitima

PPISOPPIPOSSISOSSIPOLPM_mult

Vidimo da je za male dužine operanada paralelna izvedba u koraku sa „bit-serial“

izvedbom. Razlog za to je prije svega prisustvo pomjeračkih registara u „bit-serial“

množačima kao i postojanje kontrolne logike koja rezerviše određen broj logičkih kola.

Međutim sa porastom veličine operanda broj potrebnih kola kod „bit-serial“ množača se

mijenja gotovo linearno dok je za paralelnu varijantu ta zavisnost približno kvadratna

funkcija.

4 bita 8 bita 12 bita 16 bita

PPISO 28 54 74 96

PPIPO 36 70 98 128

SSISO 38 70 96 122

SSIPO 46 86 123 154

LPM_mult 34 136 274 450


38

Slika 31.— Broj potrebnih taktnih impulsa za dobijanje rezultata u funkciji dužine operanata za različite izvedbe množača

Tabela 2.— Broj potrebnih taktnih impulsa za dobijanje rezultata pri različitim dužinama operanda za različite izvedbe množača

0

5

10

15

20

25

30

35

40

45

50

4 8 12 16

PPISO

PPIPO

SSISO

SSIPO

LPM_mult

Što se tiče broja „utrošenih“ taktnih impulsa tu je paralelna izvedba u prednosti jer bez

obzira na veličinu operanata množenje traje jedan taktni impuls. Kod „bit-serial“ množenja

situacija je nešto drugačija. U principu potrebno je za množenje dva N – bitna broja

sačekati na rezultat 2N taktnih impulsa. U datim primjerima osim kola za množenje u

okviru množača se nalaze i pomjerački registri čije punjenje zahtjeva dodatno vrijeme

(jedan takt ako se pune paralelno odnosno onoliko taktova koliko je dimenzija registra ako

se pune serijski). Na grafiku se vidi da broj taktnih impulsa linearno zavisi od veličine

operanata za množače bazirane na serijskoj arhitekturi.

Zaključak izveden iz ovog testa upućuje ponovo na početak ovog poglavlja i

pitanje: „Kako ispravno odabrati arhitekturu množača za njegovu implementaciji u VLSI

kolo?“. To je prije svega stvar prakse, iskustva, informisanosti i poznavanja tehnologija, a

autorima ovog rada nikako nije bio cilj da favorizuju neku od arhitektura već da samo upute

budućeg čitaoca na osnovne karakteristike svake ponaosob.

4 bita 8 bita 12 bita 16 bita

PPISO 11 19 27 35

PPIPO 11 19 27 35

SSISO 13 25 37 49

SSIPO 13 25 37 49

LPM_mult 1 1 1 1


39

LITERATURA

Linkovi

www.altera.com

www.atmel.com

Literatura

Prof. Dr Radovan Stojanović, Skripta iz kursa ADEK, 2006

John B. Stephensen, Software-Defined Hardware For Software-Defined

Radios, KD60ZH.

N. Koblitz, Mathematics of Computation, November 1987

Surendranath Talla, Adaptive Explicitly Parallel Instruction Computing,

Decembar2000

Peter J. Ashenden, The VHDL Cookbook, July 1990

Documents

Seminarski rad Bit Serijski Množač - apeg.ac.me · PDF fileSeminarski rad Blagojević Gojko 5 ... revizija i dorada tako da je stvorena cijela paleta algoritama koji množenje obavljaju