Quasi ROM 2 Varianten ; welche braucht weniger Ressourcen ?

[FPGA-Fragender (Gast)]

Hallo zusammen,

ich hab mal eine Frage bzgl. dem Ressourcenverbrauch:

Ich hab im Sparan 400 noch distributed Ram frei aber nur noch wenig LUT 
und FF.

1. Variante ( bisher soll optimiert werden )

a_8_Bit_wert1 usw. sind konstante 8 bit Wert und ändern sich nicht

die 4 Bytes Data_1 usw. werden zyklisch 0 bis 7 immer wieder für eine 
Berechnung als Multiplikanten gebraucht.

Pseudo Code:

if Addr_Counter = 0 then
    Data_1 = a_8_Bit_wert1
    Data_2 = a_8_Bit_wert2
    Data_3 = a_8_Bit_wert3
    Data_4 = a_8_Bit_wert4

elseif Addr_Counter = 1 then
    Data_1 = a_8_Bit_wert5
    Data_2 = a_8_Bit_wert6
    Data_3 = a_8_Bit_wert7
    Data_4 = a_8_Bit_wert8

elseif Addr_Counter = 2 then
    Data_1 = a_8_Bit_wert9
    Data_2 = a_8_Bit_wert10
    Data_3 = a_8_Bit_wert11
    Data_4 = a_8_Bit_wert12

usw...

elseif Addr_Counter = 7 then
    Data_1 = a_8_Bit_wert29
    Data_2 = a_8_Bit_wert30
    Data_3 = a_8_Bit_wert31
    Data_4 = a_8_Bit_wert32
end if


2. Variante:
=============

Realisierung als Codierter Zähler, welcher 8 Zustände kennt und 32 Bit 
Breit ist.

If Reset = 1 then

  Data_32_Bit = a_8_Bit_w1 & a_8_Bit_w2 & a_8_Bit_w3 & 8_Bit_w4

elseif clk = steigende flanke und counter_enable = 1 then

  if Data_32_Bit = a_8_Bit_w1 & a_8_Bit_w2 & a_8_Bit_w3 & 8_Bit_w4 then

     Data_32_Bit =  a_8_Bit_w5 & a_8_Bit_w6 & a_8_Bit_w7 & 8_Bit_w8

  elsif Data_32_Bit =  a_8_Bit_w5 & a_8_Bit_w6 & a_8_Bit_w7 & 8_Bit_w8 
then

     Data_32_Bit =  a_8_Bit_w9 & a_8_Bit_w10 & a_8_Bit_w11 & 8_Bit_w12

     usw.

alle 8 Zustände und Folgeschritte definieren.


3. Variante:
=============

Definition als Distributed Ram bzw. ROM und einen 3 Bit Zähler der von 0 
bis 7 am Adresseingang durchläuft.


Ich hab nun grundsätzliche Fragen:

1. Erkennt die Optimierungs Mimik des Compiler dass es sich bei der 
Variante 1 letzlich um ein ROM handelt und bestelt "intern" eine 
Platzsparende Lösung ?

2. Kann man den Platzbedarf bei Variante 1 als ca. 4  8  8 Bits d.h. 
256 FFs ansetzen ? Und durch Einsatz von Distributed RAM / ROM genau 
diese Anzahl FF einsparen oder verstehe ich das falsch ?

3. Kann man bei Variante 2 den Platzbedarf als ca. 4 * 8= 32 FF ansetzen 
plus entsprechende AND, OR, XOR Logik ? Wie geht die AND, OR Logik in 
die Platzbedarfsrechnung ein ?

4. Kann man sagen, dass bei noch verfügbarem distributed ROM die 3. 
Variante auf jeden Fall die Ressourcensparendste ist . ca. 3 FF + AND OR 
Logik ?


Ich hoffe Ihr könnt mir helfen.
Gruß vom FPGA-Fragenden

[Falk (Gast)]

@FPGA-Fragender

>Ich hab im Sparan 400 noch distributed Ram frei aber nur noch wenig LUT
>und FF.

Das ist ein Widerspruch. Distributed RAM IST LUTs, wobei beim Spartan3 
technologisch bedingt nur die Hälfte der LUTs als distributed RAM 
verwendet werden kann.


>1. Erkennt die Optimierungs Mimik des Compiler dass es sich bei der
>Variante 1 letzlich um ein ROM handelt und bestelt "intern" eine
>Platzsparende Lösung ?

Wahrscheinlich schon, das sollte dir der Compiler bei der Synthese 
sagen.

>2. Kann man den Platzbedarf bei Variante 1 als ca. 4  8  8 Bits d.h.
>256 FFs ansetzen ?

???
Das ist ein ganz normaler Dekoder. Die FlipFlops werden nur für den 
Zähler gebraucht (3 Stück).
Nix mit 256 FlipFlops.

> Und durch Einsatz von Distributed RAM / ROM genau
>diese Anzahl FF einsparen oder verstehe ich das falsch ?

Ich fürchte du verstehst was falsch.

>3. Kann man bei Variante 2 den Platzbedarf als ca. 4 * 8= 32 FF ansetzen

Ja.

>plus entsprechende AND, OR, XOR Logik ? Wie geht die AND, OR Logik in
>die Platzbedarfsrechnung ein ?

Kommt darauf an wie weit der Compiler das optimieren kann (hängt auch 
ein wenig von den Werten a_8_Bit_wert1 etc. ab). Das wird dann in LUTs 
gemapped.

>4. Kann man sagen, dass bei noch verfügbarem distributed ROM die 3.
>Variante auf jeden Fall die Ressourcensparendste ist . ca. 3 FF + AND OR
>Logik ?

Deine 1. und 3. Variante sind praktisch identisch, und wenn der Compiler 
nicht stolpert kommt am Ende das gleiche raus.

MFG
Falk

[na (Gast)]

In VHDL erkennt ISE z.B. eine constant, gefüllt mit deinen Werten, auf 
deren Index du mit der Adresse zugreifst, als ROM.