Hausgemachte Addition vs. + Operator

[Mathias H. (idiolatrie)]

Hi, Leute!

Gibt es eigentlich VHDL Code vom + Operator für Additionen. Ich versuche 
nähmlich gerade diese nachzubauen, allerdings komme ich auf weit größere 
Zeiten (30ns) die selbe mit + dauert nur 8ns!!!
Ich arbeite mit ISE 10.1 Webpack für einen Spartan 3E.

1-bit Addierer mit dedicated MUX und XOR

entity add is
    Port ( A : in  STD_LOGIC;
           B : in  STD_LOGIC;
           CIN : in  STD_LOGIC;
           COUT : out  STD_LOGIC;
           Y : out  STD_LOGIC);
end add;

architecture Behavioral of add is
  signal HAS : std_logic;
begin
  HAS <= A xor B;

  xor_cy : XORCY
    port map (
    LI => HAS,
    CI => CIN,
          O  => Y
       );

  mux_cy : MUXCY
    port map (
    S  => HAS,
    DI => A,
    CI => CIN,
    O  => COUT
        );
end Behavioral;



32-bit Addierer

entity add32 is
    Port ( A : in  STD_LOGIC_VECTOR (31 downto 0);
           B : in  STD_LOGIC_VECTOR (31 downto 0);
           CIN : in  STD_LOGIC;
           Y : out  STD_LOGIC_VECTOR (31 downto 0);
           COUT : out  STD_LOGIC);
end add32;

architecture Behavioral of add32 is
  component add is
    Port ( A : in  STD_LOGIC;
           B : in  STD_LOGIC;
           CIN : in  STD_LOGIC;
           COUT : out  STD_LOGIC;
           Y : out  STD_LOGIC);
  end component;

  signal C : std_logic_vector (32 downto 0);
  signal S : std_logic_vector (31 downto 0);
begin
  C(0) <= CIN;

  gen:
  for i in 0 to 31 generate
  begin
    add : add
      port map(A(i), B(i), C(i), S(i), C(i+1));
  end generate;

  y <= S;
  COUT <= C(32);
end Behavioral;

Die Simulation brachte in puncto Platz:
+ Operator: 16 Slices, 32 LUT's
mein Addierer: 32 Slices!!!, 32 LUT's

Ein 4bit Modell meines Addierers hingegen verwendet gleichviele Slices 
und LUTS wird aber schlechter platziert (2ns Unterschied).

Ist es überhaupt möglich die Implementierung gleich schnell zu machen?


Grüße

Mathias

[Rick Dangerus (Gast)]

Hast Du Dir mal im RTL-Viewer angeschaut, was XST wirklich draus baut?
Aber wer will den heutzutage die Addition noch per Hand zusammenbauen?

Rick

[Mathias H. (idiolatrie)]

RTL-Viewer kannte ich gar nicht. Das macht die Sache natürlich 
einfacher.
Ich mache das, für meine Bachelor-Arbeit. Bin beim überlegen, ob ich auf 
viele Features von VHDL verzichte und alles "manuell" verdrahte. Wäre 
natürlich super wenn ich dabei auch eine ähnliche Performance erreiche.

Thx für den Tipp!

[Thomas R. (Firma: abaxor engineering) (abaxor)]

Du hast einen Ripple carry adder gebaut. Hier wird der Übertrag pro Bit 
berechnet und läuft durch ein Bit nach dem anderen. Das dauert 
entsprechend lange. Besser ist ein Carry look-ahead adder, bei dem wird 
der Übertrag für mehrere Stellen gleichzeitig berechnet. Die Thematik 
heißt Computer-Arithmetik, sieh dir mal in Wikipedia 
http://en.wikipedia.org/wiki/Adder_(electronics) an, folgendes Buch kann 
ich dir auch empfehlen:
Koren, Israel: Computer Arithmetic Algorithms; Prentic Hall; Englewood 
Cliffs; 1993

Tom

[Mathias H. (idiolatrie)]

Andere Frage: Kann man den Zeitangaben die im Sysnthesereport stehen 
vertrauen? Oder: Welchen Zeitangaben kann ich wirklich vertrauen?

[Andreas A. (Firma: Embedded Microtec) (andi)]

BTW, wenn du in VHDL deinen Addierer aus den logischen Grundfunktionen 
baust, dann wird Xilinx ISE die logischen Funktionen in die Look-up 
Table genauso reinschreiben und dadurch verlierst du die Vorteile, dass 
das Webpack die dedizierte Carry Chain im FPGA nutzen kann (denke ich 
jetzt mal).

Addierer selbst zu bauen hat für Spezialfälle durchaus noch Sinn! Z.B. 
für Crypto-Sachen. Da hat man zum Teil Addierer, die über mehrere 100 
Bit (oder sogar 2048 Bit für RSA-2048) lang sind. Interessant sind da 
dann Carry-Save Adder. Die bestehen im Grunde aus lauter 1 Bit 
Full-Adder, wobei das Carry nicht an den nächsten Adder gegeben wird. 
D.h. du erkaufst dir die konstante Durchlaufszeit (egal wie lang der 
Addierer ist) durch den doppelten Speicherbedarf, weil du den Summen 
Teil und den Carry Teil speicherst. Genaueres darüber gibts auch im 
Wiki.

Bezüglich der Zeiten im Webpack... also die dürften relativ genau sein, 
da ja die Architektur des FPGAs genau bekannt ist. Für ein sauberes und 
schnelles Design versuch die Pfade so kurz wie möglich zu halten. 
Außerdem solltest du Steuersignale immer in Registern speichern, um 
Glitches und Race Conditions zu vermeiden!

mfg
Andreas