www.mikrocontroller.net

Forum: FPGA, VHDL & Co. Hausgemachte Addition vs. + Operator


Autor: Mathias Hörtnagl (idiolatrie)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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

Autor: Rick Dangerus (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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

Autor: Mathias Hörtnagl (idiolatrie)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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!

Autor: Thomas Reinemann (Firma: abaxor engineering) (abaxor)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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

Autor: Mathias Hörtnagl (idiolatrie)
Datum:

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

Autor: Andreas Auer (Firma: Embedded Microtec) (andi) Flattr this
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [vhdl]VHDL-Code[/vhdl]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.