Koeffizient berechnen

[Mike (Gast)]

Hallo,

vielleicht könnt ihr mir ja weiterhelfen. Ich zerbreche mir nämlich 
schon seit Tagen den Kopf darüber wie ich den folgenden Koeffizienten 
effizient berechnen kann:

256 * a/(a+b)

a und b sind 32 Bit unsigned-Werte. Die 256 dient nur als 
Skalierungsfakor.

Eine 32 Bit Ganzzahl-Division mit dem ISE Divider-Core verschlingt doch 
tatsächlich 1766 Slices, 3312 FF's und 1345 LUT's, weshalb diese Lösung 
für mich wegfällt.

Ich überlege die ganze Zeit, ob es dafür einen tollen Trick gibt, z. B. 
mit Look-up-Tabellen. Wenn jemand ein Paper o. ä. kennt, welches sich 
dem Thema gewidmet hat, würde mich das auch interessieren.

Ein anderer Ansatz wäre, den Gleikomma-Dividierer-Core zu verwenden. Das 
mache ich aber nur, falls es keine bessere Lösung geben sollte.

Gruß,
Mike

[D. I. (Gast)]

http://www.lothar-miller.de/s9y/categories/24-Division

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

> Eine 32 Bit Ganzzahl-Division mit dem ISE Divider-Core verschlingt doch
> tatsächlich 1766 Slices, 3312 FF's und 1345 LUT's
Der kann offenbar mehr als unbedingt nötig ;-)
Ich habe mal meine Syntheseergebnisse für eine 32-bit Unsigned Division 
angeschaut, und folgendes erhalten:
Number of Slices           189
Number of Slice Flip Flops 138
Number of 4 input LUTs     358

[Mike (Gast)]

Mein erhöhter Ressourcen-Verbrauch lässt sich ganz einfach erklären: Ich 
brauche das Ergebnis nach einem Takt. Habe ich vergessen zu erwähnen. 
Wenn man deinen Algoritmus abrollen würde, käme sicherlich ein ähnlicher 
Verbruach raus.

[Mike (Gast)]

Meine obige Aussage ist nicht ganz richtig. Richtig müsste es heißen: 
Ich muss mit jedem Takt neue Operanden einlesen können. D. h. eine 
Pipeline-Verarbeitung wäre möglich, aber einen Pipeline-fähigen 
Divisions-Algorithmus habe ich leider noch nicht gesehen.

[Duke Scarring (Gast)]

@Mike:
Schnell oder klein, da muß man sich bei FPGAs entscheiden...

Duke

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

> Ich brauche das Ergebnis nach einem Takt.
> Ich muss mit jedem Takt neue Operanden einlesen können.
Das erklärt dann auch die vielen FFs beim Xilinx-Core. Dort ist offenbar 
auch eine Pipeline-Struktur zugange.

> Wenn man deinen Algoritmus abrollen würde, käme sicherlich ein ähnlicher
> Verbruach raus.
Richtig.

> Ich überlege die ganze Zeit, ob es dafür einen tollen Trick gibt, z. B.
> mit Look-up-Tabellen.
Deine LUTs wären zu groß, um sinnvoll in FPGAs implementiert zu werden 
:-/

[Andreas S. (andreas) (Admin)]

Kannst du Einschränkungen bei Genauigkeit oder Wertebereich machen? 
Ändert sich vielleicht einer der Parameter nur selten, o.ä.? Andernfalls 
wird es da keine andere Lösung geben als eine ganz normale 32 
Bit-Division.

Um die Funktion mal anschaulich zu machen:
http://www01.wolframalpha.com/input/?i=a%2F(a%2Bb)