Forum: FPGA, VHDL & Co. Rechnen mit unsigned vs. signed und einer division

Marc K. schrieb:
> Mach ich das am besten mit den Werten als Zweierkomplement
Eher ja. Denn sonst hast du nur positive Werte und musst selber noch den 
Offset abziehen...

> Später muss ich das Ergebnis dividieren, so das der Quotient  immer
> zwischen -1 und 1 liegt.
Wie willst du denn diesen Zahlenbereich darstellen?

> oder hat da jemand eine andere Idee, weil mein Quotient ja nicht größer
> als 1 wird?!
Denk dir einfach das Komma vor das MSB.
Dann hast du eine Zahl von -1...+0.999, und das ganz ohne Rechnen...
:-o

ok vielen dank. Ich werde es mit dem Zweierkomplement machen :-)

Lothar Miller schrieb:
> Wie willst du denn diesen Zahlenbereich darstellen?

Das hab ich mich auch gefragt. Ich weiß noch nicht so recht wie ich das 
realisieren soll.


Lothar Miller schrieb:
> Denk dir einfach das Komma vor das MSB.
>
> Dann hast du eine Zahl von -1...+0.999, und das ganz ohne Rechnen...
>
> :-o

Ich muss die Divison aber durchführen, der Divisor ändert sich immer so 
das halt keine größere Zahl als 1 rauskommt. Mich interessiert 
eigentlich nur das vorzeichen und paar Nachkommastellen.

Marc K. schrieb:
> Ich muss die Divison aber durchführen,
Warum?

> keine größere Zahl als 1 rauskommt.
Nach wie vor die Frage: wie willst du mit Integerzahlen eine Zahl 
kleiner 1 darstellen?
Weiterhin meine Antwort: denk dir einfach ein "Null Komma" vor die 12 
Bit. Dann hat das führende Bit (links) die Wertigkeit 1/2, das nächste 
1/4, dann 1/8, 1/16, usw. Je weiter du nach rechts kommst, umso weniger 
ist ein Bit wert. Genau so, wie du es von gewöhnlichen Integerzahlen 
gewöhnt bist.

So wird das bei Signalprozessoren, die mit Festkommazahlen rechnen, auch 
gern gemacht. Und dafür gibt es massenweise Literatur.

Lothar Miller schrieb:
> Marc K. schrieb:
>
>> Ich muss die Divison aber durchführen,
>
> Warum?

Da sich mein Dividend und Divisor unabhängig ändert. Ich jedoch weiß das 
nur der bereich (-1 bis 1) rauskommen kann. Sonst ist ein fehler im AD 
Wert. Ich weiß auch das dies mit Integer nicht möglich ist...

ich werd mich erstmal einlesen und vermutlich löst sich das Problem. ich 
dachte nur vielleicht gehts auch ganz einfach :-)

vielen dank für die antwort :-)

ok danke. Ich bin gerade noch am umstrukturieren,  aber hab ich das 
jetzt richtig verstanden. Ich erweitere die Zähler und Nenner so

  Divisor <=  "000000000000" & std_logic_vector(Nenner);
   Dividend <= std_logic_vector(Zaehler) & "000000000000";

ich nutzte ein FPGA von Microsemi und ich habe dort bezüglich der 
division nachgefragt. Diese meinten man kann es einfach mit "/" 
implementieren. Wie es aussieht funktioniert es auch :-/

Marc K. schrieb:
> Diese meinten man kann es einfach mit "/" implementieren.
> Wie es aussieht funktioniert es auch :-/
Kann Altera auch.
Aber sieh mal nach, wie es mit dem Ressourcenverbrauch aussieht.
Was kostet dich eine 32/16 Division, die in 1 Takt fertig ist?

Lothar Miller schrieb:
> Marc K. schrieb:
>> Diese meinten man kann es einfach mit "/" implementieren.
>> Wie es aussieht funktioniert es auch :-/
> Kann Altera auch.
> Aber sieh mal nach, wie es mit dem Ressourcenverbrauch aussieht.
> Was kostet dich eine 32/16 Division, die in 1 Takt fertig ist?

Das sagt die synthese bei folgendem code:

1

library IEEE;

2

use IEEE.STD_LOGIC_1164.ALL;

3

use IEEE.NUMERIC_STD.ALL;

4

5

entity Div is

6

  port (

7

    div_out : OUT std_logic_vector (5 downto 0);

8

    clk  : IN std_logic;

9

    zahl_32 : IN std_logic_vector(5 downto 0);

10

    zahl_16 : IN std_logic_vector(5 downto 0)

11

   );

12

End Div;

13

14

architecture BEHAV of div is

15

16

signal ergebnis : unsigned (5 downto 0);

17

18

begin 

19

process (clk)

20

begin

21

if (rising_edge(clk)) then

22

ergebnis <=  unsigned(zahl_32) / unsigned(zahl_16);

23

end if;

24

end process;

25

26

div_out <= std_logic_vector(ergebnis);

27

28

end BEHAV;

Compile report:
===============

    CORE                       Used:    151  Total:  38400   (0.39%)
    IO (W/ clocks)             Used:     19  Total:    147   (12.93%)
    Differential IO            Used:      0  Total:     65   (0.00%)
    GLOBAL (Chip+Quadrant)     Used:      1  Total:     18   (5.56%)
    PLL                        Used:      0  Total:      2   (0.00%)
    RAM/FIFO                   Used:      0  Total:     60   (0.00%)
    Low Static ICC             Used:      0  Total:      1   (0.00%)
    FlashROM                   Used:      0  Total:      1   (0.00%)
    User JTAG                  Used:      0  Total:      1   (0.00%)

Wolltest du das wissen?

Marc K. schrieb:
> Wolltest du das wissen?
Jein...
Einen Divider für 6 Bit kann ich in ein BRAM packen...

Ich wollte das eigentlich für 32/16 Bits wissen:

1

    :

2

    zahl_32 : IN std_logic_vector(31 downto 0);

3

    zahl_16 : IN std_logic_vector(16 downto 0)

4

    :

Und auch: Wie schnell kannst du dieses Design takten?

Lothar Miller schrieb:
> Marc K. schrieb:
>> Wolltest du das wissen?
> Jein...
> Einen Divider für 6 Bit kann ich in ein BRAM packen...
>
> Ich wollte das eigentlich für 32/16 Bits wissen:
>

1

>     :

2

>     zahl_32 : IN std_logic_vector(31 downto 0);

3

>     zahl_16 : IN std_logic_vector(16 downto 0)

4

>     :

5

>

 CORE                       Used:   1799  Total:  38400   (4.68%)
    IO (W/ clocks)             Used:     81  Total:    147   (55.10%)
    Differential IO            Used:      0  Total:     65   (0.00%)

Lothar Miller schrieb:
> Marc K. schrieb:
>> Wolltest du das wissen?
> Jein...
> Einen Divider für 6 Bit kann ich in ein BRAM packen...
>
> Ich wollte das eigentlich für 32/16 Bits wissen:
>>     :
>     zahl_32 : IN std_logic_vector(31 downto 0);
>     zahl_16 : IN std_logic_vector(16 downto 0)
>     :
>



 CORE                       Used:   1799  Total:  38400   (4.68%)
    IO (W/ clocks)             Used:     81  Total:    147   (55.10%)
    Differential IO            Used:      0  Total:     65   (0.00%)






> Und auch: Wie schnell kannst du dieses Design takten?

Wo seh ich das?

Marc K. schrieb:
>   zahl_32 : IN std_logic_vector(5 downto 0);
>   zahl_16 : IN std_logic_vector(5 downto 0)
>     CORE                    Used:    151  Total:  38400   (0.39%)

Marc K. schrieb:
>     zahl_32 : IN std_logic_vector(31 downto 0);
>     zahl_16 : IN std_logic_vector(15 downto 0)
>  CORE                       Used:   1799  Total:  38400   (4.68%)
Da wird tatsächlich ein kombinatorischer Divider gebaut.

>> Und auch: Wie schnell kannst du dieses Design takten?
> Wo seh ich das?
Das ist eine wichtige Zahl, die solltest du mit einem Blick erkennen 
können. Such mal im Synthese- oder Implementation-Report nach MHz.

>>> Und auch: Wie schnell kannst du dieses Design takten?
>> Wo seh ich das?
> Das ist eine wichtige Zahl, die solltest du mit einem Blick erkennen
> können. Such mal im Synthese- oder Implementation-Report nach MHz.




Alles was ich mit MHz im Report gefunden habe.

1

Clock Summary

2

**************

3

4

Start      Requested     Requested     Clock      Clock          

5

Clock      Frequency     Period        Type       Group          

6

-----------------------------------------------------------------

7

System     1.0 MHz       1000.000      system     system_clkgroup

8

=================================================================

9

10

11

12

13

Performance Summary 

14

*******************

15

16

17

Worst slack in design: NA

18

19

                   Requested     Estimated     Requested     Estimated               Clock        Clock              

20

Starting Clock     Frequency     Frequency     Period        Period        Slack     Type         Group              

21

---------------------------------------------------------------------------------------------------------------------

22

top|clk            100.0 MHz     NA            10.000        NA            NA        inferred     Inferred_clkgroup_0

23

=====================================================================================================================

24

25

26

##### START OF TIMING REPORT #####[

27

# Timing Report written on Thu Sep 06 16:08:47 2012

28

#

29

30

31

32

Requested Frequency:    100.0 MHz

33

Wire load mode:         top

34

Paths requested:        5

35

Constraint File(s):    

36

@N: MT320 |Timing report estimates place and route data. Please look at the place and route timing report for final timing.

37

38

@N: MT322 |Clock constraints cover only FF-to-FF paths associated with the clock.

Bei Actel FPGAs würde ich da nicht zuviel erwarten bezüglich 
Taktfrequenz. Deren Architecktur ist nicht auf solche Rechenschaltungen 
optimiert. Ich kann es hier ja auch mal fix bauen und nachprüfen, haben 
die Toolchain auch am Start.

Also Synplify Pro 9.0.2A2 kann diese Division nicht synthetisieren. Er 
möchte gern nur durch 2^n teilen.

T. M. schrieb:
> Also Synplify Pro 9.0.2A2 kann diese Division nicht synthetisieren. Er
> möchte gern nur durch 2^n teilen.

Ich nutzte Synplify Pro AE F-2012.03MSP1. Da gehts.

Spartanist schrieb:
> Lothar Miller schrieb:
>> Da wird tatsächlich ein kombinatorischer Divider gebaut.
> Klaro und wenn man dem genug FF-stages hinten dran packt, kann die
> Synthese ihn per register retiming auch auf das jeweils benötigte Tempo
> bringen.
Das ist aber immer langsamer als ein nicht aufgeteilter Pfad und dazu 
ein Multicycle Constraint, weil ja für jedes FF noch die Setup-Zeit 
dazukommt...

Es ist aber nicht so, dass eine mit "register retiming" beschleunigte 
Logik automatisch pipelinefähig wäre...