FPGA Praktikum WS2000/ Woche: BlockRAM CoreGen CPU Informationen Aufgaben

Noch keine Platine zDeshalb: zMehr graue Theorie statt bunter, blinkender Lämpchen. zSorry

Block RAMs

Verteilte Speicher (Wiederholung) zJede LUT kann als 16x1 RAM verwendet werden z=> 4700 kleine Speicher über den ganzen Chip verteilt zDual Port bei doppeltem Platzbedarf zIdeal für kleine FIFOs, Stacks, Register-Files, etc. zZusammenschalten zu tieferen RAMs kostet zusätzlichen Platz und Zeit RAM MUX A(3 downto 0) A(4) A(5)

BlockRAMs (Neu) zZusätzlich gibt es 14 BlockRAMs in unserem FPGA mit je 4kBit zZwei völlig unabhängige Ports ysogar getrennte CLK zBusbreite für jeden Port unabhängig wählbar: y4096x1 y2048x2 y1024x4 y512x8 y256x16

BlockRAM - Signale zPort A und Port B haben mindestens die folgenden Signale: yCLK- Takteingang yADD - Adresseingang yDO- Datenausgang zOptional yDI- Dateneingang yWE- Write Enable yEN- Enable der Ausgangsregister yRST- Reset der Ausgangsregister

BlockRAM - Lesen zWenn an einem vor der steigenden Taktflanke eine Addresse anliegt, und EN=‘1‘ ist, so erscheinen 4ns nach der Taktflanke gültige Daten an den Ausgängen. zDas RAM läßt sich also beim Lesen wie ein DFF verwenden, bloß daß nicht die Eingangsdaten an den Ausgängen erscheinen, sondern die an der entsprechenden Addresse gespeicherten Daten.

BlockRAM - Schreiben zWenn an einem Port vor der steigenden Taktflanke eine Addresse anliegt und WE=‘1‘ ist und gültige Daten an DI liegen, so werde diese Daten an die entsprechende Addresse geschrieben.

BlockRAM - Verwendung zEs gibt fertige BlockRAM Entities, die sich in VHDL verwenden lassen. zSie haben alle zuvor gezeigten Ports, und müssen entsprechend deklariert und instanziert werden. zEin Beispiel dafür setze ich auf die Tips und Tricks Seite zBei den Single-Port Varianten fehlt der Buchstabe A bzw. B hinter den Portnamen.

BlockRAM - Verwendung zWenn die Standardelemente nicht ausreichen, oder wenn man den Anfangsinhalt des RAMs vorgeben möchte, muß man sich mit dem CORE Generator selber ein RAM erstellen.

Core Generator zIn der Liste gibt es Distributed RAMs und Block RAMs zKontrolliert vorher, ob in „Project->Project Options“ Spartan2 als Familie und VHDL als Design Entry eingestellt ist.

Core Generator Block RAMs zIn den Optionen des BlockRAM CORE Generators kann man einiges einstellen: zDen Namen der Entity zOb man einen oder zwei Ports haben möchte zWelche Steuersignale für jeden Port gewünscht sind zDie Busbreite für jeden Port zOb der Takt auf steigende oder fallende Flanke reagiert zDer Knopf „Datasheet“ zeigt eine detaillierte Beschreibung des Cores.

Core Generator Block RAMs zEin Klick auf „Generate“ generiert diverse Dateien im Projektverzeichnis. zUnter anderem eine.VHO Datei, die Beispiele für Deklaration und Instanzierung der Entity in VHDL enthällt. Dies kann man einfach in seinen VHDL Text kopieren.

Core Generator COE Datei zDas RAM kann mit beliebigen Werten vorinitialisiert werden. zDazu ist eine.COE Datei erforderlich, die mit dem Knopf „Load Init File“ aktiviert wird. zNach Änderung der COE Datei muß das RAM neu generiert werden. zDer RAM-Inhalt wird nur in der Timingsimulation berücksichtigt, nicht in der funktionalen Simulation zEin Beispiel für eine COE Datei findet Ihr in den CPU Dateien von letzter Woche

Die Praktikums CPU

Instruction Set Architechture zDie CPU hat 16 Register mit je 16-Bit zRegister R0 enthält immer den Wert 0x0000 zBeim Reset werden alle Register mit 0x0000 initialisiert zDrei Operanden Architektur: zDie Meisten Befehle haben die Form Rc <= Ra op Rb zFast alle Befehle werden in einem Taktzyklus ausgeführt. zAlle Befehlsworte sind 16-Bit lang

ALU Befehle zBefehlswort: 0xxxaaaabbbbcccc zDabei ist xxx der Steuercode „operation“ für die ALU z000:Rc <= Ra + Rb z001:Rc <= Ra - Rb z010:Rc <= Ra & ~Rb z011:Rc <= Ra | Rb z100:Rc <= Ra / 2 zDiese Befehle benötigen einen Taktzyklus

Load Immediate zLaden von Konstanten (oberes und unteres byte) z1000iiiiiiiicccc zRc <= iiiiiiii z1001iiiiiiiicccc zRc <= iiiiiiii << 8 zDiese Befehle benötigen einen Taktzyklus

Load/Store zSpeichern eines Registers im Hauptspeicher (Store) z1101aaaabbbb---- zmem[a] <= Rb zDieser Befehl braucht einen Taktzyklus zLaden eines Registers aus dem Hauptspeicher (Load) z1100aaaa----cccc zRc <= mem[a] zDieser Befehl braucht zwei Taktzyklen

Sprungbefehle zVerzweigung abhängig von einer Bedingung und speichern des Programmzählers für einen eventuellen Rücksprung. z1010aaaabbbbcccc zif (Ra < 0) { goto Rb; Rc <= PC } z1011aaaabbbbcccc zif (Ra >= 0) { goto Rb; Rc <= PC } zDelayed Branches: zDer Befehl hinter einem Sprung Befehl wird immer ausgeführt, auch wenn gesprungen wird

Emulierte Befehle zDa sich R0 nie ändert, kann man weitere Befehle emulieren: zUnbedingter Sprung ohne laden des PC z bbbb0000 zif (R0 >= 0) { goto Rb; R0 <= PC } entspricht zgoto Rb zRegister-Register-Move z0000aaaa0000cccc zRc <= Ra + R0 entpricht zRc <= Ra

Beispiel: Das Programm vom letzten mal 8011 : R1 <= : R2 <= 7 8fff : R15 <= : R3 <= R1 + R3; R3 <= R : R4 <= R3 - R2 ; R4 <= R3 - 7 A4f0 : if (R4 < 0) { goto R15;} 0000 : R0 <= R0 + R0; NOP B000 : goto R : NOP z9 Taktzyklen pro Iteration, 72 Taktzyklen insgesamt

Beispiel: Verbessert 8011 : R1 <= : R4 <= : R3 <= 4 8fff : R15 <= : R4 <= R4 - R1; R4-- B430 : if (R4 >= 0) { goto R3} 0000 : R0 <= R0 + R0; NOP B0F0 : goto R : NOP z3Taktzyklen pro Iteration, 30 Taktzyklen insgesamt

Beispiel: Nutzung des Delay Slots 8011 : R1 <= : R4 <= : R3 <= 4 8fff : R15 <= 256 B430 : if (R4 >= 0) { goto R3} 1414 : R4 <= R4 - R1; R4 <= R4 - 1 B0F0 : goto R : NOP z2 Taktzyklen pro Iteration, 22 Taktzyklen insgesamt

Der Prozessor in VHDL

PCU Eure PCU wird verwendet um einen instruction_pointer hochzuzählen. program_counter: PCU -- program counter unit port map( jump_target=> b_data, stop=> pc_stop, jump=> pc_jump, clk=> clk, pc=> instruction_pointer);

instruction RAM Port B eines BlockRAMs liefern dann im nächsten Takt ein Befehlswort ram: DPRAM port map ( addra => a_data(9 downto 0), dia=>b_data, doa=>ram_read_data, wea=>ram_write, clka=>clk, addrb =>instruction_pointer(9 downto 0) dob=>instruction, clkb=>clk);

instruction RAM Port A kann mit den LOAD/STORE Befehlen gelesen und geschrieben werden ram: DPRAM port map ( addra => a_data(9 downto 0), dia=>b_data, doa=>ram_read_data, wea=>ram_write, clka=>clk, addrb =>instruction_pointer(9 downto 0) dob=>instruction, clkb=>clk);

Befehlswort Das Befehlswort wird in seine Einzelteile zerlegt opcode <= instruction(15 downto 12); operand_a <= instruction(11 downto 8); operand_b <= instruction( 7 downto 4); operand_c <= instruction( 3 downto 0);

Register File zDie meisten Befehle lesen zwei Operanden aus den Registern und schreiben einen zurück zDual-Ported-RAMs können pro Takt nur einen Wert lesen und einen schreiben. zDeshalb: zZwei DPRAMs die gemeinsam geschrieben aber getrennt gelesen werden. zDer Inhalt der beiden RAMs ist immer gleich.

Register File registers_a: dpram1616 port map ( A=> operand_c,CLK=> clk, D=> reg_write_data,WE=> reg_write, DPRA=> operand_a,DPO=> a_data, SPO=> open); registers_b: dpram1616 port map ( A=> operand_c,CLK=> clk, D=> reg_write_data,WE=> reg_write, DPRA=> operand_b,DPO=> b_data, SPO=> open);

Register File Die Daten aus dem Register File werden durch die ALU geschickt ALU: ALU16 port map ( in_a=> a_data, in_b=> b_data, operation=> opcode(2 downto 0), result => alu_result);

Result Mux Was ins Zielregister geschrieben wird hängt vom opcode ab: reg_write_data <= alu_result when (opcode(3) = '0') else " " & operand_a & operand_b when opcode="1000" else operand_a & operand_b &" " when opcode="1001" else instruction_pointer when opcode(3 downto 1) = "101" else ram_read_data when opcode = "1100" else " ";

Sprungsteuerung  Wir schreiben immer ein Ergebnis in ein Register, es sei den es handelt sich um R0: reg_write <= '0' when operand_c="0000" else '1'; zIn den Hauptspeicher wird bei Store Befehlen geschrieben ram_write <= '1' when opcode = "1101" else '0'; zGesprungen wird, wenn die Sprungbedingungen erfüllt sind pc_jump <= '1‘ when (opcode = "1010" and a_data(15)='1') else '1‘ when (opcode = "1011" and a_data(15)='0') else '0';

Load Wait State zDer Hauptspeicher liefert erst nach einer Taktflanke gültige Daten, also müssen wir einen Takt warten. pc_stop <= '1' when (opcode = "1100" and second_load_cycle='0') else '0'; process (clk) begin-- this is the only flip-flop in the top level. if rising_edge(clk) then if (opcode = "1100" and second_load_cycle <= '0') then econd_load_cycle <= '1'; else second_load_cycle <= '0'; end if; end process;

Aufgaben 4. Woche

Aufgabe 4.1 zDie Ausgabe des PC ist relativ sinnlos. zStattdessen soll es ein beschreibbares I/O Register geben zÄndert den VHDL Text so, daß der Hauptspeicher bei Store Befehlen nur dann beschrieben wird, wenn es sich um eine positive Adresse handelt. zBei negativen Adressen soll stattdessen ein 16 Bit Register beschrieben werden, dessen Inhalt am Ausgang sichtbar wird.

Aufgabe 4.2 zSchreibt ein Programm, daß nacheinander die ersten 100 Quadratzahlen in das Ausgaberegister schreibt. zTip: x 2 -(x-1) 2 = 2x-1 zDas Programm soll die Werte tatsächlich ausrechnen, ich will keine Wertetabelle mit 100 Einträgen sehen ;-) zSchickt mir das Programm in folgendem Format: zaddresse : Befehl Binär : Befehl Hex : Pseudocode 0: : 01a3 : R3 <= R10 + R10

Aufgabe 4.3 zÄndert das.COE des Hauptspeichers dpram so, daß es euer Programm enthält. zGeneriert das neue RAM,. Achtet darauf, daß alle Einstellungen stimmen zSchickt mir die.MIF und die.VHO Dateien die dabei entstehen

Aufgabe 4.4 zSynthetisiert und implementiert das neue design zWie groß ist es? zWas ist die maximale Taktfrequenz? zÜberprüft per Timingsimulation euer Programm zNach wieviel Taktzyklen wird der Wert 100 ausgegeben?