[VHDL] elegant gerade Parity generieren

[zachso (Gast)]

Hallo!

ich gucke mir gerade den PCIlite-Core von opencores an, und dabei ist 
mir folgende codezeile aufgefallen:

pardat   <= d(0)  xor d(1)  xor d(2)  xor d(3)  xor d(4)  xor d(5)  xor d(6)  xor d(7)  xor d(8)  xor d(9)  xor d(10) xor d(11) xor 
d(12) xor d(13) xor d(14) xor d(15) xor d(16) xor d(17) xor d(18) xor d(19) xor d(20) xor d(21) xor d(22) xor d(23) xor d(24) xor 
d(25) xor d(26) xor d(27) xor d(28) xor d(29) xor d(30) xor d(31);

parcbe   <= cbe_i(0) xor cbe_i(1) xor cbe_i(2) xor cbe_i(3); 

par <= pardat xor parcbe;

hier wird eine gerade parity generiert aus dem vektor d(31 downto 0) und 
cbe(3 downto 0)

nun frage ich mich natuerlich ob das nicht um einiges eleganter geht 
irgendwie? das muss doch anders moeglich sein. leider faellt mir kein 
konstrukt ein was das bewerkstelligen koennte, kann mir vllt. einer von 
euch weiterhelfen?

danke
zachso

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

zachso schrieb:
> nun frage ich mich natuerlich ob das nicht um einiges eleganter geht
> irgendwie? das muss doch anders moeglich sein.
Sieh dir mal an, was der Synhtesizer draus macht. Ich würde sagen, dass 
da bei einer 4er LUT immer 4 Eingänge zsammengefasst werden, und dann 
immer 4 der Zwischenergebnisse wieder mit einer LUT. Schlussendlich 
bleiben also 3 ziemlich direkt verdrahtete Logikebenen.
Mit der 6er LUT vom Virtex6/Spartan6 sind es sogar nur 2 Logikebenen...

Das parcbe passt sogar in 1 4er-LUT und kann effizienter gar nicht 
dargestellt werden...

> par <= pardat xor parcbe;
Dafür wäre es allerdings u.U. besser, gleich alle beteiligten Signale in 
einem Term zu verknüpfen...
Also so:

par <=  d(0)  xor d(1)  xor d(2)  xor d(3)  xor d(4)  xor d(5)  xor d(6)  
        xor d(7)  xor d(8)  xor d(9)  xor d(10) xor d(11) xor d(12) xor d(13)
        xor d(14) xor d(15) xor d(16) xor d(17) xor d(18) xor d(19)
        xor d(20) xor d(21) xor d(22) xor d(23) xor d(24) xor d(25)
        xor d(26) xor d(27) xor d(28) xor d(29) xor d(30) xor d(31) 
        xor cbe_i(0) xor cbe_i(1) xor cbe_i(2) xor cbe_i(3);

Aber es kann auch gut sein, dass der Synthesizer das selber merkt und ie 
zusätzliche Logikebene rauslässt...

[Georg A. (Gast)]

Ich habe auch mal so einen PCI-Core geschrieben und bin damals (~2005) 
drauf gestossen, dass die schnell geschriebene Lösung mit einer 
for-Schleife+Index bei xst langsamer war, als die von Hand in 
4er-Gruppen gegliederte Variante. Seitdem habe ich es nicht mehr 
untersucht, evtl. ist xst ja doch intelligenter geworden...

[user (Gast)]

wie wäre es damit?

process(d)
  variable result : std_logic;
begin
  result := '0';
  for i in d'range loop
    result := result xor d(i);
  end for;
  par <= result;
end process;

[Hochpass (Gast)]

http://www.xilinx.com/itp/xilinx4/data/docs/cgd/x4.html#1000962

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Hochpass schrieb:
> http://www.xilinx.com/itp/xilinx4/data/docs/cgd/x4...
XOR_COLLAPSE
The default is YES.
--> XORs werden (schon seit der uralten Version 4) zusammengefasst.

Und siehe da: ein kleines Testprojekt aufgesetzt und ausprobiert...

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity XORing is
    Port ( d  : in  STD_LOGIC_VECTOR (31 downto 0);
           q0 : out  STD_LOGIC;
           q1 : out  STD_LOGIC;
           q2 : out  STD_LOGIC;
           q3 : out  STD_LOGIC);
end XORing;

architecture Behavioral of XORing is

function doXOR (din : std_logic_vector) return std_logic is
variable h : std_logic := '0';
begin
   h := '0';
   for i in din'range loop 
      h := h xor din(i);
   end loop;
   return h;
end doXOR;

begin

   q0 <= doXOR(d);

   q1 <=       d(0)  xor d(1)  xor d(2)  xor d(3)  xor d(4)  xor d(5)  xor d(6)  xor d(7)  
           xor d(8)  xor d(9)  xor d(10) xor d(11) xor d(12) xor d(13) xor d(14) xor d(15) 
           xor d(16) xor d(17) xor d(18) xor d(19) xor d(20) xor d(21) xor d(22) xor d(23)
           xor d(24) xor d(25) xor d(26) xor d(27) xor d(28) xor d(29) xor d(30) xor d(31); 

   process (d) 
   variable q : std_logic := '0';
   begin
      q := d(0);
      for i in 1 to 31 loop
         q := q xor d(i);
      end loop;
      q2 <= q;
   end process;

   process (d) 
   variable q : std_logic := '0';
   begin
      q := '0';
      for i in 0 to 31 loop
         q := q xor d(i);
      end loop;
      q3 <= q;
   end process;

end Behavioral;

Fazit: alle Ausgänge q0..3 bringen das selbe und werden einfach parallel 
geschaltet.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Schlags kaputt, Anhang vergessen...
Hier die Technologie-Schematic, die die 3 Logikebenen zeigt, und ebenso, 
dass alle Ausgänge parallel hängen.

[Hochpass (Gast)]

Jo so meinte ich das auch. Das macht das Tool selber. Bei der ISE weiß 
ich es, bei den anderen Tools gehe ich davon aus, dass es auch drin ist.

aber das xor_reduce hab ich auch schon mal benutzt:
http://www.vhdl.org/vhdlsynth/vhdl/reduce_pack.vhd

Es wird keinen Unterschied machen. Aber ich gebe zu dass ich es mir 
nicht bis aufs Gatter angeschaut habe, was die Tools draus machen.

[Georg A. (Gast)]

Schön, ich frag mich nur, warum das damals anders war. Evtl. hat auch 
die Restschaltung noch einen Einfluss darauf.