OpenCores
URL https://opencores.org/ocsvn/raytrac/raytrac/trunk

Subversion Repositories raytrac

[/] [raytrac/] [branches/] [fp/] [dpc.vhd] - Blame information for rev 179

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 123 jguarin200
--! @file dpc.vhd
2 122 jguarin200
--! @brief Decodificador de operacion. 
3 128 jguarin200
--! @author Julián Andrés Guarín Reyes
4 122 jguarin200
--------------------------------------------------------------
5
-- RAYTRAC
6
-- Author Julian Andres Guarin
7 123 jguarin200
-- dpc.vhd
8 122 jguarin200
-- This file is part of raytrac.
9
-- 
10
--     raytrac is free software: you can redistribute it and/or modify
11
--     it under the terms of the GNU General Public License as published by
12
--     the Free Software Foundation, either version 3 of the License, or
13
--     (at your option) any later version.
14
-- 
15
--     raytrac is distributed in the hope that it will be useful,
16
--     but WITHOUT ANY WARRANTY; without even the implied warranty of
17
--     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18
--     GNU General Public License for more details.
19
-- 
20
--     You should have received a copy of the GNU General Public License
21
--     along with raytrac.  If not, see <http://www.gnu.org/licenses/>.
22
 
23
library ieee;
24
use ieee.std_logic_1164.all;
25 158 jguarin200
 
26 151 jguarin200
use work.arithpack.all;
27 134 jguarin200
 
28 158 jguarin200
 
29 123 jguarin200
entity dpc is
30 152 jguarin200
 
31 122 jguarin200
        port (
32 143 jguarin200
                clk,rst                                 : in    std_logic;
33 158 jguarin200
                paraminput                              : in    vectorblock12;                                                                  --! Vectores A,B,C,D
34
                prd32blko                               : in    vectorblock06;  --! Salidas de los 6 multiplicadores.
35
                add32blko                               : in    vectorblock04;  --! Salidas de los 4 sumadores.
36 152 jguarin200
                sqr32blko,inv32blko             : in    std_logic_vector (floatwidth-1 downto 0);                --! Salidas de la raiz cuadradas y el inversor.
37
                fifo32x23_q                             : in    std_logic_vector (03*floatwidth-1 downto 0);             --! Salida de la cola intermedia.
38
                fifo32x09_q                             : in    std_logic_vector (02*floatwidth-1 downto 0);     --! Salida de las colas de producto punto. 
39 127 jguarin200
                unary,crossprod,addsub  : in    std_logic;                                                                      --! Bit con el identificador del bloque AB vs CD e identificador del sub bloque (A/B) o (C/D). 
40 152 jguarin200
                sync_chain_0                    : in    std_logic;                                                                      --! Se&ntilde;al de dato valido que se va por toda la cadena de sincronizacion.
41
                eoi_int                                 : in    std_logic;                                                                      --! Se&ntilde;al de interrupci&oacute;n de final de instrucci&oacute;n.
42
                eoi_demuxed_int                 : out   std_logic_vector (3 downto 0);                           --! Se&ntilde;al de interrupci&oacute;n de final de instrucci&oacute;n pero esta vez va asociada a la instrucc&oacute;n UCA.
43
                sqr32blki,inv32blki             : out   std_logic_vector (floatwidth-1 downto 0);                --! Salidas de las 2 raices cuadradas y los 2 inversores.
44
                fifo32x26_d                             : out   std_logic_vector (03*floatwidth-1 downto 0);             --! Entrada a la cola intermedia para la normalizaci&oacute;n.
45
                fifo32x09_d                             : out   std_logic_vector (02*floatwidth-1 downto 0);             --! Entrada a las colas intermedias del producto punto.         
46 158 jguarin200
                prd32blki                               : out   vectorblock12;  --! Entrada de los 12 factores en el bloque de multiplicaci&oacute;n respectivamente.
47
                add32blki                               : out   vectorblock08;  --! Entrada de los 8 sumandos del bloque de 4 sumadores.  
48 149 jguarin200
                resw                                    : out   std_logic_vector (4 downto 0);                           --! Salidas de escritura y lectura en las colas de resultados.
49
                fifo32x09_w                             : out   std_logic;
50 143 jguarin200
                fifo32x23_w,fifo32x09_r : out   std_logic;
51
                fifo32x23_r                             : out   std_logic;
52 150 jguarin200
                resf_vector                             : in    std_logic_vector (3 downto 0);                           --! Entradas de la se&ntilde;al de full de las colas de resultados. 
53
                resf_event                              : out   std_logic;                                                                      --! Salida decodificada que indica que la cola de resultados de la operaci&oacute;n que est&aacute; en curso.
54 158 jguarin200
                resultoutput                    : out   vectorblock08 --! 8 salidas de resultados, pues lo m&aacute;ximo que podr&aacute; calcularse por cada clock son 2 vectores. 
55 122 jguarin200
        );
56 153 jguarin200
end entity;
57 122 jguarin200
 
58 123 jguarin200
architecture dpc_arch of dpc is
59 125 jguarin200
 
60
        constant qz : integer := 00;constant qy : integer := 01;constant qx : integer := 02;
61 123 jguarin200
        constant az : integer := 00;constant ay : integer := 01;constant ax : integer := 02;constant bz : integer := 03;constant by : integer := 04;constant bx : integer := 05;
62
        constant cz : integer := 06;constant cy : integer := 07;constant cx : integer := 08;constant dz : integer := 09;constant dy : integer := 10;constant dx : integer := 11;
63
        constant f0     : integer := 00;constant f1 : integer := 01;constant f2 : integer := 02;constant f3 : integer := 03;constant f4 : integer := 04;constant f5 : integer := 05;
64
        constant f6     : integer := 06;constant f7 : integer := 07;constant f8 : integer := 08;constant f9 : integer := 09;constant f10: integer := 10;constant f11: integer := 11;
65
        constant s0     : integer := 00;constant s1 : integer := 01;constant s2 : integer := 02;constant s3 : integer := 03;constant s4 : integer := 04;constant s5 : integer := 05;
66 127 jguarin200
        constant s6     : integer := 06;constant s7 : integer := 07;
67
        constant a0     : integer := 00;constant a1 : integer := 01;constant a2 : integer := 02;constant aa : integer := 03;
68 123 jguarin200
        constant p0     : integer := 00;constant p1 : integer := 01;constant p2 : integer := 02;constant p3 : integer := 03;constant p4 : integer := 04;constant p5 : integer := 05;
69 127 jguarin200
 
70 124 jguarin200
        constant dpfifoab : integer := 00;
71
        constant dpfifocd : integer := 01;
72
 
73 122 jguarin200
 
74
 
75 127 jguarin200
 
76 143 jguarin200
 
77 161 jguarin200
        signal sparaminput                                      : vectorblock12;
78
        --!TBXSTART:FACTORS_N_ADDENDS
79
        signal sfactor                                          : vectorblock12;
80
        signal ssumando                                         : vectorblock08;
81 167 jguarin200
        signal sdpfifo_q                                        : vectorblock02;
82 161 jguarin200
        --!TBXEND
83 163 jguarin200
 
84
 
85
        --!TBXSTART:ARITHMETIC_RESULTS
86 161 jguarin200
        signal sresult                                          : vectorblock08;
87 127 jguarin200
        signal sprd32blk                                        : vectorblock06;
88
        signal sadd32blk                                        : vectorblock04;
89 163 jguarin200
        signal ssqr32blk,sinv32blk                      : xfloat32;
90 171 jguarin200
        signal snormfifo_q,snormfifo_d          : vectorblock03;
91 163 jguarin200
        --!TBXEND
92
 
93 160 jguarin200
 
94
        --!TBXSTART:SYNC_CHAIN
95 171 jguarin200
        signal ssync_chain                                      : std_logic_vector(25 downto 1);
96 149 jguarin200
        signal sres567w,sres123w,sres2w         : std_logic;
97
        signal sres0w,sres4w                            : std_logic;
98 171 jguarin200
        --!TBXEND
99 163 jguarin200
 
100
        --! Entradas de la se&ntilde;al de full de las colas de resultados. 
101
        signal sres567f,sres123f                        : std_logic;
102 150 jguarin200
        signal sres24f,sres0f                           : std_logic;
103 143 jguarin200
 
104
 
105 140 jguarin200
 
106 151 jguarin200
 
107 123 jguarin200
begin
108 122 jguarin200
 
109 142 jguarin200
        --! Cadena de sincronizaci&oacute;n: 29 posiciones.
110 140 jguarin200
        sync_chain_proc:
111 163 jguarin200
        process(clk,rst,sync_chain_0)
112 140 jguarin200
        begin
113
                if rst=rstMasterValue then
114 171 jguarin200
                        ssync_chain(25 downto 1) <= (others => '0');
115 140 jguarin200
                elsif clk'event and clk='1' then
116 171 jguarin200
                        for i in 25 downto 2 loop
117 142 jguarin200
                                ssync_chain(i) <= ssync_chain(i-1);
118 140 jguarin200
                        end loop;
119 163 jguarin200
                        ssync_chain(1) <= sync_chain_0;
120 140 jguarin200
                end if;
121
        end process sync_chain_proc;
122 144 jguarin200
 
123 140 jguarin200
        --! Escritura en las colas de resultados y escritura/lectura en las colas intermedias mediante cadena de resultados.
124 143 jguarin200
        fifo32x09_w <= ssync_chain(5);
125
        fifo32x23_w <= ssync_chain(1);
126 171 jguarin200
        fifo32x09_r <= ssync_chain(12);
127
        fifo32x23_r <= ssync_chain(21);
128 163 jguarin200
 
129
 
130 149 jguarin200
        resw    <= sres567w&sres4w&sres123w&sres2w&sres0w;
131 140 jguarin200
        sync_chain_comb:
132 142 jguarin200
        process (ssync_chain,addsub,crossprod,unary)
133 140 jguarin200
        begin
134
                if unary='1' then
135 163 jguarin200
 
136
                        --!Desconectar los canales de Suma, Resta, Producto Punto y Producto Cruz
137
                        sres123w <= '0';
138
                        sres2w <= '0';
139
                        sres4w <= '0';
140
 
141 171 jguarin200
                        --! Producto Escalar, Normalizaci&oacute;n o Magnitud 
142 175 jguarin200
                        sres567w <= crossprod and ((ssync_chain(4) and addsub) or (ssync_chain(24) and not(addsub)));
143 171 jguarin200
                        sres0w <= ssync_chain(19) and not(addsub) and not(crossprod);
144 163 jguarin200
 
145
                elsif addsub='1' then
146
 
147
                        --! Desconectar los canales de Normalizaci&oacute;n, Producto Escalar, Producto Punto C.D y Magnitud    
148
                        sres567w <= '0';
149
                        sres0w <= '0';
150
                        sres4w <= '0';
151
 
152
 
153
                        --! Suma o Resta.
154 171 jguarin200
                        sres123w <= ssync_chain(7);
155
                        sres2w <= ssync_chain(7);
156 163 jguarin200
 
157 140 jguarin200
                else
158 163 jguarin200
 
159
                        --! Desconectar la escritura en los canales de Normalizaci&oacute;n, Producto Escalar, Suma, Resta y Magnitud.
160
                        sres567w <= '0';
161
                        sres0w <= '0';
162
 
163
                        --! Producto Punto o Cruz.
164 171 jguarin200
                        sres2w <= (ssync_chain(18) and not(crossprod)) or (ssync_chain(11) and crossprod);
165
                        sres4w <= ssync_chain(17) and not(crossprod);
166
                        sres123w <= ssync_chain(11) and crossprod;
167 163 jguarin200
 
168 140 jguarin200
                end if;
169
        end process sync_chain_comb;
170
 
171
 
172
        --! El siguiente c&oacute;digo sirve para conectar arreglos a se&ntilde;ales std_logic_1164, simplemente son abstracciones a nivel de c&oacute;digo y no representar&aacute; cambios en la s&iacute;ntesis.
173 158 jguarin200
        sparaminput     <= paraminput;
174
        prd32blki       <= sfactor;
175
        add32blki       <= ssumando;
176
        resultoutput<= sresult;
177
 
178
 
179 138 jguarin200
        stuff04:
180 171 jguarin200
        for i in aa downto a1 generate
181 158 jguarin200
                sadd32blk(i)  <= add32blko(i);
182 138 jguarin200
        end generate stuff04;
183
 
184
 
185 124 jguarin200
        stuff03:
186
        for i in 02 downto 0 generate
187 152 jguarin200
                snormfifo_q(i) <= fifo32x23_q(i*floatwidth+floatwidth-1 downto i*floatwidth);
188
                fifo32x26_d(i*floatwidth+floatwidth-1 downto i*floatwidth) <= snormfifo_d(i);
189 124 jguarin200
        end generate stuff03;
190
 
191 123 jguarin200
        stuff02:
192 127 jguarin200
        for i in 01 downto 0 generate
193 152 jguarin200
                sdpfifo_q(i)  <= fifo32x09_q(i*floatwidth+floatwidth-1 downto i*floatwidth);
194 123 jguarin200
        end generate stuff02;
195 140 jguarin200
 
196
        --! El siguiente c&oacute;digo sirve para conectar arreglos a se&ntilde;ales std_logic_1164, son abstracciones de c&oacute;digo tambi&eacute;n, sin embargo se realizan a trav&eacute;s de registros. 
197
        register_products_outputs:
198
        process (clk)
199
        begin
200
                if clk'event and clk='1' then
201 158 jguarin200
                        sprd32blk  <= prd32blko;
202 140 jguarin200
                end if;
203
        end process;
204
        --! Los productos del multiplicador 2 y 3, ya registrados dentro de dpc van a la cola intermedia del producto punto (fifo32x09_d)
205 148 jguarin200
        --! Los unicos resultados de sumandos que de nuevo entran al DataPathControl (observar la pesta&ntilde;a del documento de excel) 
206 171 jguarin200
        fifo32x09_d <= sprd32blk(p3)&sprd32blk(p2);
207 148 jguarin200
 
208 140 jguarin200
        register_adder0_and_inversor_output:
209
        process (clk)
210
        begin
211
                if clk'event and clk='1' then
212 158 jguarin200
                        sadd32blk(a0) <= add32blko(a0);
213 140 jguarin200
                        sinv32blk <= inv32blko;
214
                end if;
215
        end process;
216 122 jguarin200
 
217 127 jguarin200
 
218
 
219 140 jguarin200
 
220 144 jguarin200
        --! Raiz Cuadrada.
221 127 jguarin200
        ssqr32blk <= sqr32blko;
222
 
223 136 jguarin200
        --! Colas de salida de los distintos resultados;
224 127 jguarin200
        sresult(0) <= ssqr32blk;
225 171 jguarin200
        sresult(1) <= add32blko(a0);
226 127 jguarin200
        sresult(2) <= sadd32blk(a1);
227
        sresult(3) <= sadd32blk(a2);
228
        sresult(4) <= sadd32blk(aa);
229 171 jguarin200
        sresult(5) <= prd32blko(p3);
230
        sresult(6) <= prd32blko(p4);
231
        sresult(7) <= prd32blko(p5);
232 127 jguarin200
 
233
        --! Cola de normalizacion
234
        snormfifo_d(qx) <= sparaminput(ax);
235
        snormfifo_d(qy) <= sparaminput(ay);
236
        snormfifo_d(qz) <= sparaminput(az);
237
 
238
 
239
 
240 136 jguarin200
        --! La entrada al inversor SIEMPRE viene con la salida de la raiz cuadrada
241 171 jguarin200
        inv32blki <= ssqr32blk;
242 163 jguarin200
        --! La entrada de la ra&iacute;z cuadrada SIEMPRE viene con la salida del sumador 1.
243 136 jguarin200
        sqr32blki <= sadd32blk(a1);
244 127 jguarin200
 
245
 
246 136 jguarin200
 
247
        --! Conectar las entradas del sumador a, a la salida 
248
        ssumando(s6) <= sadd32blk(a2);
249
        ssumando(s7) <= sdpfifo_q(dpfifocd);
250
 
251 144 jguarin200
        --!El siguiente proceso conecta la se&ntilde;al de cola "casi llena", de la cola que corresponde al resultado de la operaci&oacute;n indicada por los bit UCA (Unary, Crossprod, Addsub).
252 179 jguarin200
        --!Adicionalmente codifca en formato one HOT la cola de la instruccion en la que se escriben los resultados de la ultima instrucci&oacute;n que haya finalizado.
253 150 jguarin200
        sres0f          <= resf_vector(0);
254
        sres123f        <= resf_vector(1);
255
        sres24f         <= resf_vector(2);
256
        sres567f        <= resf_vector(3);
257
        fullQ:process(sres0f,sres123f,sres24f,sres567f,unary,crossprod,addsub,eoi_int)
258 143 jguarin200
        begin
259
                if unary='0' then
260 179 jguarin200
 
261
                        if addsub='1' or crossprod='1' then
262
                                --! Suma o Resta o producto cruz, comparten la misma cola de resultados. 
263 147 jguarin200
                                eoi_demuxed_int <= "00"&eoi_int&'0';
264 150 jguarin200
                                resf_event <= sres123f;
265 179 jguarin200
                        else
266
                                --! Producto Punto utiliza como salida las colas 2 y 4
267 147 jguarin200
                                eoi_demuxed_int <= '0'&eoi_int&"00";
268 150 jguarin200
                                resf_event <= sres24f;
269 143 jguarin200
                        end if;
270 163 jguarin200
                elsif crossprod='1' then
271
 
272
                        --! Normalizaci&oacute;n o Producto Escalar
273 147 jguarin200
                        eoi_demuxed_int <= eoi_int&"000";
274 150 jguarin200
                        resf_event <= sres567f;
275 163 jguarin200
 
276
                elsif addsub='0' then
277
 
278
                         --! Magnitud
279 147 jguarin200
                        eoi_demuxed_int <= "000"&eoi_int;
280 150 jguarin200
                        resf_event <= sres0f;
281 163 jguarin200
 
282
                else
283
                        --! Se deber&iacute;a generar una excepci&oacute;n de se&ntilde;al invalida.
284
                        eoi_demuxed_int <= x"F";
285
                        resf_event <= '0';
286
 
287 143 jguarin200
                end if;
288
        end process;
289
 
290 144 jguarin200
        --! Decodificaci&oacute;n del Datapath.
291 142 jguarin200
        mul:process(unary,addsub,crossprod,sparaminput,sinv32blk,sprd32blk,sadd32blk,sdpfifo_q,snormfifo_q)
292 123 jguarin200
        begin
293 124 jguarin200
 
294 142 jguarin200
                sfactor(f4) <= sparaminput(az);
295 127 jguarin200
                if unary='1' then
296
                        --! Magnitud y normalizacion
297
                        sfactor(f0) <= sparaminput(ax);
298
                        sfactor(f1) <= sparaminput(ax);
299
                        sfactor(f2) <= sparaminput(ay);
300
                        sfactor(f3) <= sparaminput(ay);
301 142 jguarin200
 
302 127 jguarin200
                        sfactor(f5) <= sparaminput(az);
303 163 jguarin200
 
304
                        --!Multiplicaci&oacute;n escalar.
305 142 jguarin200
                        if crossprod='1' and addsub='1' then
306
                                sfactor(f6) <= sparaminput(cx);
307
                                sfactor(f7) <= sparaminput(dx);
308
                                sfactor(f8) <= sparaminput(cy);
309
                                sfactor(f9) <= sparaminput(dx);
310
                                sfactor(f10) <= sparaminput(cz);
311
                                sfactor(f11) <= sparaminput(dx);
312
                        else
313
                                sfactor(f6) <= snormfifo_q(ax);
314
                                sfactor(f7) <= sinv32blk;
315
                                sfactor(f8) <= snormfifo_q(ay);
316
                                sfactor(f9) <= sinv32blk;
317
                                sfactor(f10) <= snormfifo_q(az);
318
                                sfactor(f11) <= sinv32blk;
319
                        end if;
320
 
321
 
322
                elsif addsub='0' then
323
                        --! Solo productos punto o cruz
324
                        if crossprod='1' then
325
 
326
                                sfactor(f0) <= sparaminput(ay);
327
                                sfactor(f1) <= sparaminput(bz);
328
                                sfactor(f2) <= sparaminput(az);
329
                                sfactor(f3) <= sparaminput(by);
330
 
331
                                sfactor(f5) <= sparaminput(bx);
332
                                sfactor(f6) <= sparaminput(ax);
333
                                sfactor(f7) <= sparaminput(bz);
334
                                sfactor(f8) <= sparaminput(ax);
335
                                sfactor(f9) <= sparaminput(by);
336
                                sfactor(f10) <= sparaminput(ay);
337
                                sfactor(f11) <= sparaminput(bx);
338
 
339
                        else
340
 
341
                                sfactor(f0) <=  sparaminput(ax) ;
342
                                sfactor(f1) <=  sparaminput(bx) ;
343
                                sfactor(f2) <=  sparaminput(ay) ;
344
                                sfactor(f3) <=  sparaminput(by) ;
345
                                sfactor(f5) <=  sparaminput(bz) ;
346 163 jguarin200
 
347 142 jguarin200
                                sfactor(f6) <=  sparaminput(cx) ;
348
                                sfactor(f7) <=  sparaminput(dx) ;
349
                                sfactor(f8) <=  sparaminput(cy) ;
350
                                sfactor(f9) <=  sparaminput(dy) ;
351
                                sfactor(f10) <= sparaminput(cz) ;
352
                                sfactor(f11) <= sparaminput(dz) ;
353
                        end if;
354
 
355 127 jguarin200
                else
356
                        sfactor(f0) <=  sparaminput(ax) ;
357
                        sfactor(f1) <=  sparaminput(bx) ;
358
                        sfactor(f2) <=  sparaminput(ay) ;
359
                        sfactor(f3) <=  sparaminput(by) ;
360
                        sfactor(f5) <=  sparaminput(bz) ;
361
                        sfactor(f6) <=  sparaminput(cx) ;
362
                        sfactor(f7) <=  sparaminput(dx) ;
363
                        sfactor(f8) <=  sparaminput(cy) ;
364
                        sfactor(f9) <=  sparaminput(dx) ;
365
                        sfactor(f10) <= sparaminput(cz) ;
366
                        sfactor(f11) <= sparaminput(dx) ;
367 125 jguarin200
                end if;
368 127 jguarin200
 
369 136 jguarin200
 
370 127 jguarin200
                if addsub='1' then
371
                        ssumando(s0) <= sparaminput(ax);
372
                        ssumando(s1) <= sparaminput(bx);
373
                        ssumando(s2) <= sparaminput(ay);
374
                        ssumando(s3) <= sparaminput(by);
375
                        ssumando(s4) <= sparaminput(az);
376
                        ssumando(s5) <= sparaminput(bz);
377
                else
378
                        ssumando(s0) <= sprd32blk(p0);
379
                        ssumando(s1) <= sprd32blk(p1);
380 132 jguarin200
                        if crossprod='0' then
381
                                ssumando(s2) <= sadd32blk(a0);
382
                                ssumando(s3) <= sdpfifo_q(dpfifoab);
383 171 jguarin200
                        elsif unary='0' then
384 132 jguarin200
                                ssumando(s2) <= sprd32blk(p2);
385
                                ssumando(s3) <= sprd32blk(p3);
386 171 jguarin200
                        else
387
                                ssumando(s2) <= sadd32blk(a0);
388
                                ssumando(s3) <= sdpfifo_q(dpfifoab);
389
 
390 132 jguarin200
                        end if;
391 127 jguarin200
                        ssumando(s4) <= sprd32blk(p4);
392
                        ssumando(s5) <= sprd32blk(p5);
393
                end if;
394 123 jguarin200
        end process;
395
 
396
 
397 127 jguarin200
 
398 153 jguarin200
end architecture;

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.