SpinalHDL ist eine quelloffene, in Scala eingebettete Hardwarebeschreibungssprache von Charles Papon (Projektstart um 2015). Anders als die ereignisgetriebenen Klassiker VHDL und Verilog fokussiert SpinalHDL auf effiziente Hardware-Beschreibung: Konstrukte wie Clock Domains, Streams und State Machines sind fest eingebaut. Die Designs werden in synthetisierbares Verilog oder VHDL übersetzt und sind damit kompatibel zu gängigen EDA-Tools.

Grundlagen

Ein Design besteht aus einer Klasse, die von Component erbt. Mit SpinalVerilog wird daraus Verilog erzeugt:

import spinal.core._

case class Zaehler(max: Int) extends Component {
  val io = new Bundle {
    val enable = in Bool()
    val wert   = out UInt(8 bits)
  }

  val reg = Reg(UInt(8 bits)) init (0)
  when(io.enable) {
    reg := reg + 1
    when(reg === max) { reg := 0 }
  }
  io.wert := reg
}

object Main extends App {
  SpinalVerilog(Zaehler(255))
}

Wichtige Konstrukte

• Component, Bundle, in/out – Modul- und Portdefinition
• Reg, RegNext, RegInit – Register mit Initialwert und Taktverzögerung
• ClockDomain – getrennte Takt-/Reset-Domänen; when/switch – Bedingungen und Zustandsautomaten
• Stream, Flow – Handshake-basierte Verbindungen (valid/ready) für Pipelines und Busse
• SpinalVerilog, SpinalVhdl – Codegeneratoren

Einsatz

Das bekannteste SpinalHDL-Projekt ist VexRiscv, ein parametrisierbarer 32-Bit-RISC-V-Prozessor. Weil die Beschreibungssprache auf Scala aufbaut, lassen sich Busse (z. B. AXI) als wiederverwendbare Abstraktionen definieren und in einer Zeile instanziieren. Damit steht SpinalHDL in direkter Konkurrenz zu Chisel, der zweiten großen Scala-basierten Hardware-Konstruktionssprache.

Verwandte Grundlagen: Scala-Befehle, Verilog-Befehle, Chisel-Befehle, SystemC-Befehle (System-Level-Modellierung).

SystemC ist keine eigene Programmiersprache, sondern eine C++-Klassenbibliothek und Simulationsumgebung für die Modellierung von Hardware und eingebetteten Systemen. Sie ist als IEEE-Standard 1666 genormt (2005, 2011, 2023) und wird von der Accellera Systems Initiative gepflegt. Mit SystemC beschreiben Entwickler Prozessoren, Speicher, Busse und ganze System-on-Chip-Designs auf einer höheren Abstraktionsebene als mit klassischen Hardwarebeschreibungssprachen wie VHDL oder Verilog.

Grundlagen

Ein SystemC-Modell besteht aus Modulen (SC_MODULE), die über Ports und Signale miteinander verbunden werden. Der Einstiegspunkt ist die Funktion sc_main, die Simulation startet man mit sc_start():

#include "systemc.h"

SC_MODULE(Zaehler) {
  sc_in<bool> clk;
  sc_out<unsigned> wert;
  sc_uint<8> reg;

  void tick() { reg = reg + 1; wert.write(reg); }

  SC_CTOR(Zaehler) {
    SC_METHOD(tick);
    sensitive << clk.pos();
  }
};

int sc_main(int argc, char* argv[]) {
  sc_clock clk("clk", 10, SC_NS);
  sc_signal<unsigned> w;
  Zaehler z("z");
  z.clk(clk); z.wert(w);
  sc_start(100, SC_NS);
  return 0;
}

Wichtige Konstrukte

• SC_METHOD – ereignisgesteuerter Prozess ohne eigenen Stack (schnell, aber zustandslos)
• SC_THREAD / SC_CTHREAD – Thread-Prozesse mit eigenem Stack; CTHREAD für taktsynchrone Abläufe
• sc_signal, sc_in, sc_out, sc_inout – Verbindungselemente und Ports
• sc_clock, sc_time – Takt- und Zeitmodellierung
• sc_uint, sc_bv – Bitvektoren und Ganzzahltypen fester Breite

Transaction Level Modeling (TLM)

Der TLM-2.0-Standard ergänzt SystemC um eine abstrakte Transaktionsmodellierung: Kommunikationspartner tauschen Transaktionen (Generic Payload) über Sockets aus, ohne Signale im Detail zu modellieren. Dadurch laufen Simulationen von virtuellen Prototypen um Größenordnungen schneller als RTL-Simulationen.

Verwandte Grundlagen: C/C++-Befehle, VHDL-Befehle, Chisel-Befehle (Hardware-Konstruktionssprache), SpinalHDL-Befehle.

Chisel (Constructing Hardware In a Scala Embedded Language) ist eine Hardware-Konstruktionssprache, die als DSL in Scala eingebettet ist. Sie wurde ab 2012 an der UC Berkeley entwickelt (u. a. von Jonathan Bachrach) und wird heute von der Chips Alliance gepflegt. Chisel erzeugt aus Scala-Code synthesetaugliches Verilog – die Beschreibung bleibt parametrisierbar, weil sie die volle Ausdruckskraft von Scala nutzt.

Grundlagen

Ein Chisel-Modul ist eine Scala-Klasse, die von Module erbt. Ein- und Ausgänge werden mit IO und Bundle beschrieben, Register mit Reg, Kombinatorik mit Wire und Mux:

import chisel3._

class Zaehler(max: Int) extends Module {
  val io = IO(new Bundle {
    val enable = Input(Bool())
    val wert   = Output(UInt(8.W))
  })

  val reg = RegInit(0.U(8.W))
  when(io.enable) {
    reg := Mux(reg === max.U, 0.U, reg + 1.U)
  }
  io.wert := reg
}

Wichtige Konstrukte

• Reg, RegInit, RegNext – Register mit optionalem Initialwert beziehungsweise Taktverzögerung
• Wire – kombinatorische Verbindung; Mux(cond, a, b) – Auswahl
• Bundle, Vec – strukturierte Bündel und Felder; when/elsewhen/otherwise – Bedingungen
• Bool(), UInt, SInt, FixedPoint – Datentypen mit fester Bitbreite
• Module, BlackBox – Modul- und Fremdsprachen-Anbindung

FIRRTL und Ökosystem

Chisel kompiliert zuerst nach FIRRTL (Flexible Intermediate Representation for RTL), einer Zwischenrepräsentation, die Optimierungen und die Verilog-Generierung ermöglicht. Das bekannteste Chisel-Projekt ist der Rocket Chip Generator, auf dem die RISC-V-Referenzprozessoren aufbauen. Auch SystemVerilog-Strukturen lassen sich über Chisel abstrahieren.

Verwandte Grundlagen: Scala-Befehle, Verilog-Befehle, SpinalHDL-Befehle (zweite Scala-basierte HDL), SystemC-Befehle (C++-basiertes System-Level-Modeling).

XSD (XML Schema Definition) ist die vom W3C standardisierte Schemasprache, mit der Struktur und Datentypen von XML-Dokumenten beschrieben werden. Die Empfehlung erschien 2001 in Version 1.0, 2012 folgte XSD 1.1; eine kompakte Alternative ist die RELAX-NG-Schemasprache.

Grundstruktur eines Schemas

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="buch" type="xs:string"/>
</xs:schema>

Einfache und komplexe Typen

• xs:simpleType — einfache Typen mit Restriktionen (xs:restriction), z.B. Muster, Längen, Wertebereiche
• xs:complexType — Elemente mit Kindelementen und Attributen
• xs:sequence — geordnete Kindelemente; xs:choice — Auswahl; xs:all — beliebige Reihenfolge
• xs:attribute — Attribute mit Typ und use="required"
• Eingebaute Datentypen: xs:string, xs:int, xs:decimal, xs:date, xs:boolean

<xs:complexType name="buchTyp">
  <xs:sequence>
    <xs:element name="titel" type="xs:string"/>
    <xs:element name="preis" type="xs:decimal"/>
  </xs:sequence>
  <xs:attribute name="id" type="xs:int" use="required"/>
</xs:complexType>

Validierung und Werkzeuge

Ein XML-Dokument wird gegen das Schema validiert — xmllint (libxml2) kann mit --schema prüfen, in Java ist der JAXP-Validator der Standardweg. XSD 1.1 brachte Assertions (xs:assert) und die Typalternative xs:alternative.

Verwandte Grundlagen: XPath-Befehle (Pfadabfragen auf validierten XML-Daten), XQuery-Befehle (typisierte Abfragen), XSLT/XSL-Befehle (Transformationen), XML.