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.
Bit-serial množač ADEK
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
Bit-serial množač ADEK
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.
Bit-serial množač ADEK
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.
Bit-serial množač ADEK
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; -------------------------------------------------------- --------------------------------------------------------
Bit-serial množač ADEK
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.
Bit-serial množač ADEK
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
Bit-serial množač ADEK
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.
Bit-serial množač ADEK
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
Bit-serial množač ADEK
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
Bit-serial množač ADEK
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.
Bit-serial množač ADEK
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; -------------------------------------------------------- --------------------------------------------------------
Bit-serial množač ADEK
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; --------------------------------------------------------
Bit-serial množač ADEK
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; -------------------------------------------------------- --------------------------------------------------------
Bit-serial množač ADEK
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.
Bit-serial množač ADEK
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);
Bit-serial množač ADEK
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; --------------------------------------------------------
Bit-serial množač ADEK
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
Bit-serial množač ADEK
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
Bit-serial množač ADEK
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
Bit-serial množač ADEK
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);
Bit-serial množač ADEK
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; --------------------------------------------------------
Bit-serial množač ADEK
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
Bit-serial množač ADEK
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
Bit-serial množač ADEK
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“.
Bit-serial množač ADEK
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',
Bit-serial množač ADEK
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; -------------------------------------------------------- --------------------------------------------------------
Bit-serial množač ADEK
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
Bit-serial množač ADEK
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
Bit-serial množač ADEK
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.
Bit-serial množač ADEK
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)
Bit-serial množač ADEK
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; --------------------------------------------------------
Bit-serial množač ADEK
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
Bit-serial množač ADEK
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
Bit-serial množač ADEK
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.
Bit-serial množač ADEK
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
Bit-serial množač ADEK
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
Bit-serial množač ADEK
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