====== Tools ======
  * **JTAG** \\ Joint Test Action Group
  * **XSR** \\ Xilinx Synthesis Technology
  * **RTL** \\ Register Transfer Level

===== IDE =====
Projekt anlegen
  * **Family:** Spartan3E
  * **Device:** XC3S500E
  * **Package:** FG320
  * **Speed:** -4
  * **Preferred Language:** VHDL
===== Compilation =====
==== Files ====
  * **UCF** \\ User Constraint File
  * **NGC** \\ Native Generic Circuit: Netlist = Kombination aus ... (bei anderen Herstellern getrennt) (Technology Viewer: LUTs, carry logic, I/O buffers)
    * **EDIF**: logical design
    * **NCF**: constraints
  * **NGD** \\ Natice Generic Datatbase: Xilinx primitives
  * **NCD** \\ Native Circuit Description: FPGA components (FPGA Editor)
  * **NGR** (RTL Editor: Adders, multipliers, counters, AND gates, and OR gates)
  * **SDF** \\ Standard Delay Format: Delays bei post-map (Komponenten) und post-route (Komponenten + Leitungen) simulationen

==== Refinement process ====
%%=%% Verbesserungsprozess

  * synthesis (= logic synthesis)
    * VHDL => NGC (Netlist)
    * HDL Parsing: Syntax check
    * HDL Synthesis: Komponenten identifizieren (RAM, Arithmetic, ...), Finite State Machine (FSM) identifizieren
    * Low Level Optimization: Constraints beachten, Komponenten Identifizieren (RAM, Arithmetic, ...)
  * implementation
    * Translate
      * NGC (Netlist) + Constraints => NGD (Xilinx primitives)
    * Map
      * NGD (Xilinx primitives) => NCD (FPGA components)
    * Place and route
      * NCD => NCD
  * device configuration
    * NCD => Bitstream 

==== Validation process ====
Libs haben unterschiedliche Komponenten
  * UNISIM: implementation & functional simulation
  * SIMPRIM: timing simulation (kann nicht impementiert werden)

Phasen
  * RTL simulation
  * functional simulation
    * Behavioral simulation
  * timing simulation
    * post-translate simulation (unterschied zu Behavioral simulation bei RSFF im Forbidden state: keine oszilation)
    * post-map simulation
    * post-rote simulation

===== Optimierung =====
==== Speed ====
=== Kritischer Pfad ===
Größter delay zwischen zwei FFs
=== Durchsatz ===
Wie //viele// kommen //pro Zeit// druch

* Lösungsschritte
  - loop unrolling
  - Pipelining (Mehr Register auf Kritischen Pfad)
    * Register ausbalancieren (FFs gleichmäsig verteilen)
  * Latzen bleibt gleich

=== Latenz ===
//Zeit// die //ein Datum// benötigt um //komplett bearbeitet// zu werden.

  * Lösung
    * Parallelisierung
    * Logical short cuts
    * Pipelines entferenen (also deren FFs, loop unrolling bleibt)
=== timing ===
//CPU Tackt//

  * Pipelining (Mehr Register auf Kritischen Pfad)
  * Parallelisierung
  * Register ausbalancieren
==== Fläche ====
  * Kein unrolling
  * controll-based logic reuse
    * controll logic mit
      * Multiplexer
      * state machines
    * controll logic sollte kleiner sein als der gewinn
  * resource sharing
    * Komponenten näher an die wurzel bringen um sie (teilweise) von verschieden kompenenten nutze zu können
  * Hard macros verwenden
===== Simulation =====
  - Analysis
    * Syntax
    * Semantik
    * unit => library
  - Elaboration
    * Hierarchie/Baum aufbauen
    * ''component''s auflösen/instanziieren
    * ''component'' => Baum aus ''process'' & ''signal''
  - Execution
    - initialization phase
      - signal = default value
      - process.start()
    - Ende
      * Alle Prozesse ''wait''
      * Keine Signaländerungen
      * Timeout, gesetzt von user

  * functional simulatuion (synthesized)
  * timing simulation (implemented)

===== Testbench =====
  * top level module for simulation
  * Leere entity (da signale selbst erzeugt werden)
  * Nicht synthesierbar

<code vhdl>
library ieee;
use ieee.std_logic_1164.all;

entity testbench is
end testbench;

architecture tests of testbench is
    component testee
        port(...);
    end component;
    
    signal clk : std_logic;
begin
    instance1: testee
        port map(...);
    
    <stimuli>
end tests;
</code>

==== Stimuli ====
  * Prozess des testbench

<code vhdl>
clkGen : process
begin
    clk <= '1';
    wait for 10 ns;
    clk <= '0';
    wait for 10 ns;
end process;
</code>

===== User Constraint File =====
  * Nötig für Implementation
  * Semikolon am Ende
  * ''std_logic_vector sw(0)'' -> ''sw<0>''  

  * **INST** (instance): design components, macro cells, modules
  * **NET**: signals und ports von entities
  * **PIN**


^ Positionierung ^^^^^
^ NET  ^ INST ^ PIN ^ Example ^ Kommentar ^
|  X  |  X  |     | ''NET "sw<0>" LOC = A1 %%|%% DRIVE = 2 %%|%% FAST;''  | |
|  X  |  X  |     | ''INST "instanceName" LOC = SLICE_X2Y2;''  | |
|  X  |  X  |     | ''INST "instanceName" LOC = SLICE_X2Y2:SLICE_X3Y6;''  | |
|  X  |  X  |     | ''INST "instanceName" LOC = RAMB16_x0_y6;''  | |
^ Timing ^^^^^
^ NET  ^ INST ^ PIN ^ Example ^ Kommentar ^
|  X  |  X  |  X  | ''NET "reset" TIG;''  | Timing IGnore |
|  X  |  X  |  X  | ''INST "ff" TNM "ffs";''  | Timing NaMe: Element -> Gruppe |
|     |     |     | ''TIMEGRP "superGroup" = "subGroup1" "subGroup2";''  | Timing Group: Gruppen -> Gruppe |
|     |     |     | ''TIMESPEC "TS1" = FROM "groupA" TO "groupB" 5 ns;''  | Timing Specification: \\ Zeit zwischen Gruppen. \\ Muss mit "TS..." anfangen! |
^ Elektrisches ^^^^^
^ NET  ^ INST ^ PIN ^ Example ^ Kommentar ^
|  X  |  X  |     | ''NET "sw<0>" IOSTANDARD = lvTTL;''  | |
|  X  |  X  |     | ''NET "sw<0>" IOSTANDARD = lvCMOS12;''  | |
|  X  |  X  |     | ''NET "sw<0>" IOSTANDARD = lvCMOS15;''  | |
|  X  |  X  |     | ''NET "sw<0>" IOSTANDARD = lvCMOS18;''  | |
|  X  |  X  |     | ''NET "sw<0>" IOSTANDARD = lvCMOS25;''  | |
|  X  |  X  |     | ''NET "sw<0>" IOSTANDARD = lvCMOS33;''  | |
|  X  |  X  |     | ''NET "sw<0>" DRIVE = {2,4,6,8,12,16,24};''  | Default: 12mA|
|  X  |  X  |     | ''NET "sw<0>" FAST;''  | More Power & Noise  |
|  X  |  X  |     | ''NET "sw<0>" SLOW;''  | Flanken drosselung  |
|  X  |     |     | ''NET "sw<0>" PULLUP;''  | |
|  X  |     |     | ''NET "sw<0>" PULLDOWN;''  | |