Algorithmus in vhdl. Verbesserungen und Frage

[kleiens Licht (Gast)]

hallo,

Mir ist bei meinen vhdl Studien etwas langweilig geworden und ich möchte 
mich etwas damit auseinandersetzen, wie ich nun konkrete Berechnungen 
bzw Algorithmen angehe.
Ich habe dafür einfach mal eine entity für die Berechnung des ggt 
gemacht. Simuliert auch.
Nur Frage ich mich - (weil das Stichwort latency ja für mich seit Beginn 
eine Hirnzerrung nach sich zieht) - ob ich dort etwas grundsätzlich 
anders angehen könnte. Oder besser sollte.

ggt als eine Prozedur implementieren. Wie genau interagiert der Rest der 
Schaltung überhaupt mit einer Prozedur. Wenn die Berechnung gestartet 
wird, muss ja ein Großteil der Schaltung warten bis busy weggeht. Ist 
das in einer Prozedur zu erledigen?


Außerdem Frage ich mich langsam nach konkreten Anwendungen. Sprich ich 
würde mir mal eine Hardware kaufen und damit etwas realisieren. Habe nur 
noch keinerlei Inspiration. Und auch schwierigkeiten mir vorzustellen, 
wie ich mir Algorithmen und 'Berechnungen' in einer Hardware vorstellen 
kann und wie diese interagieren.

Den ganz brutalen Performance Zuwachs kann ich mir auch nicht vorstellen 
- der tritt auch nur zutage, wenn etwas "parallelisiert" werden kann. ok 
aber gebt ihr mir da mal ein Beispiel? Wenn ich eine 3d-2d Projektion 
hätte, die ich in einen Bildspeicher schreiben möchte und zur Anzeige 
bringe. Wo ist das parallelisierbar.
Geht schon EINIGES über die konkrete Frage zu meiner kleinen 
Beschreibung hinaus, aber ich sucher inzwischen fast krampfhaft nach 
einem motivierenden, doch für Anfänger beherrschbaren und zerlegbaren 
Aufgabe für die es sich lohnt, Hardware zu kaufen. (die auch nciht nach 
2 Wochen im Müll landet)


Wer kann möge bitte Rat geben. Im Bezug auf beide Fragen.


hier der code der mich so abschweifen ließ:

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity calc is
    Port ( clk : in  STD_LOGIC;
           val1 : in  STD_LOGIC_VECTOR (7 downto 0);
           val2 : in  STD_LOGIC_VECTOR (7 downto 0);
        go   : in  STD_LOGIC;
        busy : out STD_LOGIC;
           ggt : out  STD_LOGIC_VECTOR (7 downto 0));
end calc;

architecture Behavioral of calc is
type states is (idle, calc);
signal state : states := idle;

signal a : unsigned (7 downto 0);
signal b : unsigned (7 downto 0);
begin

  process begin
  wait until rising_edge(clk);
  
    case state is
      when idle =>
              a <= unsigned(val1); --speicher ich die IMMER in ff wenn idle ist, oder reicht ein sichern wenn go gefunden wird?
              b <= unsigned(val2);
              if( go = '1' ) then
                --a <= unsigned(val1); 
                --b <= unsigned(val2);
                state <= calc;
                ggt <= (others=>'0');--während berechnung läuft, alten Wert löschen Null anzeigen
                busy <= '1';            
              else
                busy <= '0';
              end if;      
      when calc =>
              if( a /= 0) then 
                if( to_integer(b) = 0 ) then --fertig, a ist der ggt
                  state <= idle;
                  busy <= '0';
                  ggt <= std_logic_vector(a);
                else
                  if ( a > b ) then  
                    a <= a - b;
                  else
                    b <= b - a;
                  end if;
                end if;
              else          --wenn a = 0 ist, kann man direkt wieder raus und b als ergebnis nehmen oder kann 
                state <= idle;  --das auch IN idle geprüft werden und gar nciht erst in calc gewechselt werden?
                busy <= '0';
                ggt <= std_logic_vector(b);
              end if;
      
    end case;

  end process;

end Behavioral;