 Das ist den zweiten. Wir haben noch schon mal einen. Opa, Entschuldigung. Hier ist Charles Papin, Main Developer. Der Hauptentwickler hinter der Spinal HDL, eine Hardware-Beschreibungssprache. Er arbeitet die ganze Zeit, oder full time, auf diesem Programm. Und jetzt hätte mir gerne einen Applaus. Dankeschön. Jetzt will ich euch zuerst ein bisschen sagen, warum VDL und VDL nicht so gut sind. Dann werde ich euch vorstellen, die kleine Special Header Introduction und dann werden wir euch ein paar Beispiele zeigen. Und wir werden euch zeigen, warum wir beispielen. So wie ich gesagt habe, dieser Tag ist nur über Hardware. Wir werden keine virtuellen Maschinen, keine Simulierungen nicht. Das ist the real thing, down where the machine runs. VDL und Varylog waren ursprünglich entworfen für Simulierungen und für Verbosbeschreibungen. Und später wurden sie für die ausentwickelt, was wir jetzt verwenden, als Hardware-Sprache. Um Hardware zu beschreiben, musst du auf Simulizierungsprogramme beschreiben. Aus einer VDL macht das nicht sehr viel Sinn, weil du musst funktionelles Programmieren verwenden. Wir könnten über objektorientierte Hardware-Beschreibungssprache sprechen. Das ist ziemlich sinnvoll. In manchen Bereichen ist ziemlich powerful, aber es reicht eben auch noch. Die Varylog-Dokumente sind immer sehr verbos, oder meistens mehr verbos. Da gibt es kein Interface, das gibt ja einfach aus, was es hat. Und da gibt es auch ein paar andere Dinge, die nicht so gefallen. Und du kannst keine Abstraktionslevels variieren. Du kriegst deinen Abstraction-Layer, und du musst alles mit der Hand zusammenhängen. Du musst jedes Gate einzumdefinieren. Es könnte schlimm, aber es könnte eigentlich auch besser sein. Da gibt es vor HDL 2008 und es vor Varylog. Die helfen uns aber auch nicht weiter, weil sie haben dieselben Paradigmen. Du musst immer noch eine Immaginierungskonzept, also ein Abstraktionskonzept verwenden. Die bringen keine Meterhardware-Beschreibungsmöglichkeiten mit. Die Supports könnten sehr, sehr schlecht sein. Es gibt ja viele interessante Möglichkeiten, aber je nachdem, welche Variablen dort sind, die du beschreibst, du kommst nicht weiter, du bist in einem Substance-Mitten drinnen. Da gibt es auch ein sehr, sehr interessantes Feature mit der Interface-Simulierung. Aber das ist auch nicht zu das gelbe von mir. Was machen wir jetzt? Wir nehmen einfach vor HDL und Varylog als Nettlist-Sprache, auf einem höheren Level als Sprache, und bringen herein die Span-HDL, das ist ein Projekt, das ich im Dezember 2014 begonnen habe. Es fokussiert ausschließlich auf der STHL-Beschreibung. Wir kompromisse, dass ich die beste Sprache, die vorhanden war. Anfangszeit ist es kompatibel mit existieren Tools. Wir werden die Leute niederzubringen, auf ein komplett neues Tool umzusteigen. Es macht als Output ein Nettlist. Man kann auch Legacy-IPs integrieren, also Blackboxes, die man da einfügen kann. So ähnlich wie man C-Header-Files hinzufügen kann. Und das Abtragsionslevel ist eigentlich das Gleiche wie VHDL und Varylog. Aber auf Spinal-HDL oben drauf kann man weitere Abtragsionslevel definieren. Also das ist halt die mächtige Seite hier. Also es gibt ein Flow, also man definiert eine Beschreibung in den Scala-Files, dann generiert man daraus die Nettliste. In Varylog oder VHDL-IPs tut man dazu, die man verwenden will und man kann die gleichen Simulations- und Synthese-Tools dann verwenden wie vorher. Aufgrund der Nettliste. Also fangen wir mal mit ein paar Beispielen an. Spinal-HDL macht keinen Overhead im RTL, also man will keine Gates verlieren. Man kann einen beliebigen C-Algorithmus schreiben, der in RTL übersetzt wird, aber es ist nicht das. Es ist mehr ein RTL-Ansatz, also man definiert Register, so ein bisschen wie vorher und Gates, wie vorher. Und alle Komponenten in der Hierarchie und alle Namen, die man definiert, sind in dieser RTL. Das heißt man kann die Simulation wie vorher machen, mit dem Signal verläufen und so weiter. Also Spinal-HDL ist nicht wirklich eine Sprache, es ist eine sogenannte interne DSL. Spinal-HDL ist im Prinzip einfach Scala, also es ist eine Scala-Bibliothek. Scala ist eine General Purpose Sprache und Spinal-HDL ist darin implementiert und es ist ein bisschen komisch, wenn man eine Sprache in eine andere verwendet. Aber das ist für mich das beste Feature von Spinal-HDL. Also machen wir ein Beispiel. Also ein ganz einfaches Beispiel hier. Man hat hier ein paar Bedingungen, um ein Merks oder ein Counter zu treiben. Und der HDL, wenn man das machen will, muss man drei verschiedene Prozesse schreiben. Weil es ist ein event-driven Paradigma und also das muss man so machen. Es ist sehr langsam, es ist sehr verbos. Man hat hier dreimal die gleiche Bedingung. Und in Spinal-HDL sieht das equivalent so aus. Also man definiert zwar Signale, das ist schon mal anders. Also hier kann zum Beispiel sagen, mein Signal ist einfach ein Buhl. Wenn man das Register hier will, sagt man, ich will REC von diesem Typ, also unsignierte 4-Bit. Es ist nicht wie FowerDialog oder Verilog, wo Signale Register bekommen werden, weil man sie im Prozess zuweist, sondern sehr explizit bei der Definition schon hier. Diese grundlegende Fakt ändert schon ganz viel. Also zum Beispiel heißt man, all diesen Dingen hier kann man im Gleichen, if ein Wert zuweisen. Also es ist ein zufälliges Beispiel, aber es passiert oft in der State Machine. Also man hat ein Counter, eine sequenzielle Struktur und es hat einfach schlimm den Codequalität, wenn das in FowerDial machen muss. Das sind 28 Zeilen und beim anderen Beispiel und jetzt das gleiche in Spinal-HDL sind 9 Zeilen. Also es ist gut. Noch ein Beispiel. Also stelle ich vor, ihr habt ein RGB-Farb-Input und ihr wollt den Grauwert berechnen. Also man multipliziert jeweils mit einem konstanten Koeffizienten. Also ich habe dreimal das gleiche Muster her. Man hat die Signale unsigniert und vorzeichenlos. Und am Ausgang hat man den Output eines Registers. Also man hat das ganze dreimal, wenn ich schlau sein will in FowerDial, kann man diese Baugruppe als Komponente definieren, damit man nicht dreimal das gleiche schrieben muss. Also ja, Komponenten zu schreiben ist sehr verbos, ist langweilig. Und man könnte Funktionen verwenden in FowerDial, in Spinal-HDL. Also man definiert hier den RGB-Wert, dann definiert man hier eine Funktion. Die nimmt diesen vorzeichenlosen Wert und eine Konstante. Und das gibt zurück die Outputs dieses Flip Flops. Also man hat diese Zwischenregister hier, die sind jeweils 8-Bits. Hier macht man die Floating Point Berechnung. Und wir verwenden diese Funktion hier nochmal. In Veriloc hat man Funktionen, Tasks und so weiter. Aber man kann die nicht in beliebiger Hardware instanzieren. Also man ist immer noch fest auf einem Syntax, das nur eine nicht sehr perifäre Art des Ausdrucks ist. Das zweite Beispiel. Du hast deinen Handshake-Bus mit Farbe und du möchtest es queuen. Und da hast du die Master-Vitration und den Slave hinten dran. Und die Pilot. Wie sie hier sind. Ich habe zwei Instanzen von Tidbits auf einen auf Sync und ihr wollt eine Queue inserieren. Wenn du das in Farbe L tun wirst, musst du sehr erfahrtes Zeug schreiben. Du musst alle Signale redefinieren, jedes Einzelnen auf einer Checkliste, zweimal. Dann musst du den Pfeiffer definieren, es ist Farb. Du musst die Vektoren singularisieren. Die haben hier nur drei Elemente, aber ich habe einmal in einer Firma geabneten, wo wir 20 Signale haben, die wir alle mapen müssen in einen Restriktor. Das wird ihr sehr mühsam. Hier machen wir das in Spaniel. Ein Handshake-Bus ist einfach das Stream. Ein Stream ist ein Handshake-Bus, der einen zufälligen Detail betragen kann. Hier ist das RGB mit Parametrisierung. Ich kann Source und Sync definieren. Das steht hier da rechts unten. Dieser Parametrisierung, das definiere ich dann einen Pfeiffer drüber. Einen Streampfeiffer, der diesgab und das tatata tragen wird. Und du musst keine Pizzignale einzeln mehr. Du kannst direkt zugreifen auf den IO vom Pfeiffer zu. Beim Sagen in dem Pfeiffer antwortest du über Pop-Dispo anzuzapfen. Ich will meinen Source-System hier sagen. Ich will es verbinden, indem ich voll synchronisiere, mit Direktverbindung in die Signale Richtung zum Pfeiffer IO Pop-Port. Ich den die Pfeiffer IO Pop-Ports verzeihung. Von 29 Line-of-Code bin ich jetzt plötzlich auf sieben Line-of-Codes. Das könnte man immer noch verbessern, aber es ist schon deutlich besser. Du hast einen RGB-Data-Listiktor, der kommt ... ... mit der Parametrisierung in der Konstruktion, dann extendet zu das Bandel. Das ist die Noten des Tatata-Beschränkungen in der Hardware. Da kannst du Elemente definieren. Das ist eine ganz normale Syntax. Hier definierst du den Stream als Konzept. In Spinal HDL ist immer noch eine Kästglas, immer noch die Abstaktionsparameter. Welche Art von Daten? Nimm dein Bandel im Dataslave hinauf. Du kannst den Stream abgreifen, kannst ihn als Master definieren oder als Slave. Und dann definierst du die einzelnen Werte heraus aus dem Signalwert, dann die Pilot. Dann implementierst du die Master Funktion, indem du definierst, wie man das als Master oder als Slave Komponente setzt. Also du heißt das Output, die Werte und den Pilot. Und dann kannst du mit dieser Syntax dadlos arbeiten. Und jetzt kommt der lustige Teil. Habe ich hier gesagt, dass eine Scalar Bibliothek ... Du kannst da jetzt Funktionen dazufügen. Ah, du könntest die Cominter, also die ... die Datenverbindungen definieren den Strom. Du könntest eine Funktion hinein inserieren. Wenn wir den auf unserem Stream rufen, connecte diesen Stream, den du jetzt ranrufst, auf dem POP Board, und leg es auf diesen POP Board von diesem POP Board. Und das plötzlich bewegst du, wo du alles behandelst, wo halt einfach nur zwei Scars kommen. Und das ist immer dasselbe. Ich will den Output dann connecte einfach. Und die Abstraktion ist einfach deutlich höher. Und ich komme von diesem ... Ich kode so wie meine Drähte aus schon, hinten aus der Rere, sozusagen, als eine einfache Sprache, wie ich das abstrahiere. Da gibt es andere, viel lustige Sachen, die man mit dem POP Board schalten kann. Zum Beispiel ... Ja, man gibt eine beliebige Hardware, man hat ein Stream von Farben, und man will eine Projektion machen. Also, wenn die schwarz sind, will man das feststellen. Und man will Pipelining-Stufen haben, aus Performance gründen, um das weiterzugeben, noch an andere Konnektoren. Wenn man das machen will, in VHDL ist es ja sehr langweilig. Und Spinal HDL sind das Zweizeilen. Also, ich habe ein Stream von RGB-Farben. Ich nenne es Source. Und dann nehme ich die Source, und ich will die Transaktion werfen, wenn die Source payload schwarz ist. Und dann füge ich die Pipeline schwarz, und dann nenne ich das ganze Sync. Also, dieses ganze Zeug hier ist eigentlich automatisch abgeleitet von dieser Zeile hier. Also, ich definiere die IsBlack-Funktion noch, und das ist das hier. Also, Code sieht aus wie Machi, aber es ist einfach alles ganz simpel eigentlich. Also, wenn man jetzt die Throw-When-Funktion anschaut, dann sieht man was, das ist der purest RTL. Also, es geht nicht darum, irgendwie was Magisches hinzuzufügen, dass die Struktur entsteht, sondern man kann immer einfach da reinschauen, wie das gebaut ist mit regulär RTL. Also, es macht eine Instanz eines Streams vom gleichen Datentyp. Und dann befand man den Stream-Dist zum Return-Strom. Also, das heißt, es inferiert dann der Gate. Und ich füge hier noch spezielle Bedingungen hinzu. Also, wenn ich Transaktionen zurückgeben will, dann mach ich valid, punkt, valid gleich false, und mit dem ready noch true. Also, das ist immer noch reguläres RTL. Also, jetzt wechsel ich das Thema Sicherheit zuerst. Also, wenn man RTL macht, ist es sehr einfach, verbotenes Zeug zu bauen. Also, zum Beispiel Loops oder man vergisst, den Latch hinzuzufügen. In Spinal HDL werden diese korrupten Dinge automatisch detektiert. Also, zum Beispiel der Loop von Spinal HDL-Compiler definiert. Oder hier wird gemerkt, dass das Resultat nicht zugewiesen ist. Das heißt, wenn man erfolgreich mit Spinal HDL das output RTL generiert, hat man viel mehr Zuversicht, dass RTL keine Box hat im Vergleich zu Handgeschrieben. Also, weil RTL einem so viele Boxen schon findet. Also, grundsätzlich Absraktion, machen wir hier ein einfaches Beispiel. Also, hier machen wir ein einfaches Beispiel für etwas, das absahiert werden könnte. Also, man macht ein Verbindungsmodul mit einem Timeout drin, um irgendwas zu überprüfen. Also, ich kann jetzt sagen, ich mache ein Timeout, das Timeout heißt. Das nimmt jetzt 1000 Zyklen. Und wenn der Timeout tickt, dann möchte ich es löschen. Aber es ist ein Hardware. Also, ihr seht hier, wir benutzen eine Funktion, um auf die Hardware zuzugreifen. Also, es setzt diesen Counter auf 0. Und davon wird dann informiert. Also, wenn wir hier einen Counter haben wollen, der von 0 bis 9 zählen kann, dann machen wir Counter 10. Dann kann ich sagen, ich will den löschen, ich will incrementieren, ich will den Wert erhalten oder den nächsten Wert. Ich will wissen, ob er dann überläuft oder ich will schauen, wann er 5 ist. Also, diese Dinge kann man so mehr oder weniger haben mit Powerdale oder Valleylog, mit Komponenten. Also, ich weiß ja, wie langweilig Komponenten sind, um zu benutzen. Aber hier, man kann einfach sagen, ich will die und dann kann man verwenden, was man will. Und diese Abstraktionen sind auf Spinal HDL aufgebaut. Also, man kann da natürlich selbst definieren, was ein Timeout ist oder all diese Dinge. Funktionale Programmierung. Also, das ist etwas groß, ist der Moment. Und wir verwenden hier nur ein Stückchen davon. Also, zum Beispiel, wenn man diese Hardware hier erhalten will. Also, ein Array von Adressen. Überprüfe ich, welche Adressen ich hier habe. Und ich will wissen, ob eine davon true ist. Dann definiere ich hier Adressen. Ein Vektor von diesem Typen, viermal. Dann definiere ich den Key. Und ich nehme die Adressen. Und ich will ein neues Area stellen da draus. Also, wir benutzen das Konzept Mapping. Und ich nehme die Übersetzungsfunktion da. Also, ich will diese Elemente einzeln umwandeln in das nächste Array. Oder man könnte stattdessen Reduce verwenden. Also, ich nehme das Array. Und ich will es reduzieren auf dieses einzelne Element mit dieser Reduktionsfunktion. Also, es wird dann ein paar Weisen zwischen den Elementen verwendet, um das zu reduzieren. Also, das sind so die Dinge, die man verwenden kann in Spinal HDL. Also, das ist ein lustiges Ding hier. Also, man braucht Spinal HDL auch, wenn man so eine Sorte Programmierung machen will. Jetzt mal, wenn man es verwendet, gibt es im RAM ein Modell der Hardware. Also, man kann diesen Graph anschauen und eine Idee zu haben, von was modelliert wird. Also, zum Beispiel, hat man diese Werte hier an B, die irgendwie zusammengefügt werden. Also, A geht hier durch eine Berechnungspipeline. Ich weiß die Latents davon nicht. Und wenn das Resultat von A rauskommt, muss ich B dazu zählen, im gleichen Moment natürlich. Also, ich muss das Signal B um die gleiche Verzögerung hinzufügen, wie das Signal A hat. In Verilog, wie werde ich das machen? Das gibt es dann nicht. Also, das muss ich selber ausrechnen. Oder ich muss eine Simulation laufen lassen, um die Waveform anzuschauen. Das ist natürlich nicht so schübsch, weil wenn die Pipeline Latents sich verändert, dann stimmt es wieder nicht mehr. Dann muss ich das wieder anpassen, dann muss ich dran denken und so weiter. Aber in Spinal HDL kann ich einfach die Netteliste fragen. Gehe mir einfach die Latents zwischen hier und da. Und das macht diese Latents ja alles Funktion. Also, hier dieser ganze Pipeline. Und dann kann ich hier eine Instanz machen eines Delays mit genau dem richtigen Delay. Das macht das Design viel mehr elastisch, weil ich kann das eine hier verändern, ohne mich um die Delaydauer zu kümmern. Also, das ist mehr so, was ich mit Meta-Hardware-Beschreibung meine. Also, hört auf RTL mit Signalen und so selbst zu schreiben. Stellt euch vor, ihr wollt dieses State Machine hier implementieren mit diesen drei Zuständen, A, B und C, mit dieser Bedingung hier. Also, wenn ich da reinkomme, setze ich ein Counter auf 0. In jedem Zyklus inklementiere das. Und wenn ich da rauskomme, setze Result auf True. Um das zu machen in Spinal HDL kann ich das da hier machen. Das ist auch eine State Machine. Und das ist ja auf Spinal HDL drauf implementiert. Das ist nicht eine fixe Komponent von Spinal HDL. Das sieht so aus. Also, ich will eine State Machine, dann habe ich hier die States A, B und C. Dann A ist mein Startzustand. Dann sage ich hier, wenn ich beim State B eintrete, will ich den Counter auf 0 setzen. Wenn B aktiv ist, will ich den Counter hier, hier will es implementieren in jedem Zyklus. Und wenn es 4 ist, dann gehe ich zu State C. Und bei Exit will ich den Result auf True setzen. Also, es ist einfach, um euch zu zeigen, dass Spinal HDL nicht ein fixes Syntax ist. Das kann man selber erweitern. Man kann eigene Abstraktion definieren. Also, das könnte sehr nützlich sein. Ein letztes Beispiel. Wir wollen einen einfachen Timer mit einem kleinen Input, einem Limit, wenn der Timer aus ist oder voll ist. Ein Output wird, wenn dir sagt, wenn der Timer voll ist. Und dann einen Output für den laufenden Value vom Timer. Der Spinal HDL muss mit ein bisschen Paratmisierung den Spinal HDL definieren. Also, durch die Klassenkomponente setze, definiere ich den IO dieser Komponente in einem neuen Data Set. Zyk ist der Input-Bull, der Clear ist der Unten-Limit in breiten Bits. Dann kriegst du das, dann bist du krieglich. Und jetzt wirst du es mapen. Wenn du etwas bestehendes, von einem Memory-Zugriff, möchtest du den IO-Limit setzen über den Timer. Da definierst du, wie viele External-Ticks deinen Timer zum Überlaufen bringen oder zum Beenden bringen. Du wirst wahrscheinlich ... Hier ist eine andere Lösung, die wir verwenden. Die Objektor hentiertes Programmieren verwendet. Da gibt es ein Werkzeug, das heißt Basel-Factory. Das ist ein absacktes Tool, das ist ein absackter Zugriff. Es definiert seine definierten Funktionen, die dir erlauben, die dir das Mapping ... Das definieren das Mappingserlauben und die Register, die du Ihnen schreibst. Es ist ein zufälliges, und wir nehmen das und bauen unseren Timer nicht. In unserem Bestandteil des Timers steht es für eine neue Funktion dazu. Ich will jetzt treiben, diese Treiberkomponente aus dem Memory-Busser aus der Slave-Factory auf einer equivalenten Basisadresse, und wir können entweder eine Liste von Signalen, die das definieren, die das diesen Tick auslösen können, die gerade Signal Positionen abgeben. Dann kann man sagen, ich will meinen Bit-Kontroller, der den Iod-Limit dieses Timers heben kann, als Treiber. Das heißt, hier sagst du, das Iod-Limit ist ein Register von der Pistolec-Factory, und das kannst du dabei zero akzessieren, also zugreifen, und das kannst du reediten. Du kannst die Kontrolle davon übernehmen, du kannst es treiben und verändern. Also du wirst den Clear Flag des Timers wenn du denkst, der Bus-Adresse ist zu versteckt. Diese abstrakte Register-Mapping-Beschreibung erlaubt dir, dass dir die Bus-Timings wuscht werden. Ganz egal, du musst nicht wissen, wann die Timings einzulaufen und Axis, du musst auch nicht wissen können, ob der Bus funktioniert oder wann er liefert. Das ist sehr interessant, weil diese Funktion ist abstrakt. Ich kann sie mit einem beliebigen Bus, und ich muss nicht irgendwelche eigene, fix definierte Mappings einrichten bebußt, weil das ist eine eine Funktionsfunktion. Du bist ein großer Timer mit allen wirklichen Varianten mit dieser Paratomissierung, kannst du eine Signale drüber definieren. Ich will 16-Bits, ich will eine mit 32-Bits, mit einem Timer B und wieder 16-Bits, dann will ich eine kleine Bislay Factory erstellen, die man das dort mapen wird, auf die Hardware, und dann kannst du sagen, ich nehme meinen Timer C, und mit dem Seimer C will ich mit dem Bus Controller bei dieser Adresse den Timer C antreiben, und da werde ich eine Liste von Signalen, die es zum Überlaufen bringen, und die könnten es klieren. Bei diesen Listen nebeneinander. Es ist eigentlich ganz kurz. Es ist ausdrücklich. Du definierst, du heißt das, ich will das, ich will das, ich will das, und es muss nichts mit den Variablen herum spielen, die Funktion macht das einfach für dich. Es ist sehr flexibel, du kannst es editieren, du kannst auch eine Pack einbauen, aber du kannst wenig Bugs einbauen, du kannst der Timing, du musst dich nicht kümmern, Hardware-Adressen musst du dich nicht kümmern. Das ist ein Projekt, das ist ein Bandsick, ein Makro-Controller mit einer Wurst, GPS5. Also Multiplikation, Division und so weiter, mit einem Tape, um das zu debugging mit Breakpoints, und solche Dinge montieren Controller, es gibt On-Chip-Ram, dann gibt es hier einen AXI zu dieser Crossbar, dann gibt es hier eine Böcke zu Peripherie, GPIO, Timer, New Art Controller und VGA Controller, und es gibt hier ein paar interessante Dinge, eine Implementation von diesem Design ist. Also da wir APB-Color, zum Beispiel um dieses Teil hier zu instanzieren, diese macht man 5 Pipelines, also über diese Dinge habe ich vorhin schon gesprochen. Also zum Beispiel um diesen hier zu instanzieren und diese ganzen Verknüpfungen hier, muss ich einfach das Map-Beacon definieren, hier in dieser Abitrierung. Also sage hier den IPB-Tree-Color, dann das APB-Bridge-IO-APB, der hier da, und dann gebe ich hier eine Liste der Slaves. Also der Contra-IO-APB wird in dieser Adresse mit diesem Memory Range gemappt. Ein weiteres Beispiel ist, wie dieses Ding hier gemacht wird. Also AXI 4 Crossbar, der all diese Dinge hier miteinander verknüpft. Da benutzen wir ein Builder Pattern Form, also hier mit dem Key kann ich sagen, ich will ein AXI 4 Crossbar Factory und dann pass ich da ein Datenmodell ein, um zu beschreiben, was ich genau will. Und wenn ich jetzt das Datenmodell eingefügt habe, dann sage ich hier am Ende, da baue ich selbst. Also zum Beispiel in diesem Tool hier, ich nehme eine Liste von Slaves dann gegen, zum Beispiel halt RAM, SDRAM, die APB-Bridge, und dann sage ich, es gibt zum Beispiel ein VGA Controller, der soll auf den SDRAM zugreifen können, auf das SDRAM IO-AXI. Also es ist fast so einfach, wie wir auf Things oder QC-Things zuverwenden, aber es ist ohne ein grafisches Interface zu verwenden. So, noch was zu Scala? Also Scala ist wahrscheinlich eine sehr gute Sprache. Wenn ihr was ausprobieren wollt, dann gibt es Scala Ideas, die euch helfen können. Also ich habe da zum Beispiel Syntax Highlighting, Refactoring, Code-Navigation, Plug-in, Schnittstelle, Plug-in für IMAX und zu Spinal HDL. Also es ist komplett Open Source. Ihr könnt die Dokumentation online finden hier. Es gibt ein paar Projekte, die ihr fertig sind, die ihr verwenden könnt. Also wenn ihr was ausprobieren wollt, dann geht hierhin. Dann gibt es ein paar Kommunikationskanäle, wenn ihr Fragen habt, also zum Beispiel ein Guitar Chat oder Github Issues, wenn ihr irgendwie der Compiler was Komisches macht, also kann passieren, aber es ist eigentlich solites Software unterdessen. Also sonst, hier ist noch meine E-Mail-Adresse. Herzlichen Dank. Danke sehr. Es ist uns ein bisschen Zeit übergeliebt für Frage und Antwort. Wenn ihr geht, ist das in Ordnung, nehmt ein Mist mit und geht bitte leise. Wenn ihr eine Frage stellen wollt, bitte stellt euch die Mikrofonen auf. Danke für ihren Talk. Ich habe mich gerade gefragt, wir haben eine wirklich hochgradige Hardware-Beschreibung. Wie schaut das mit dem Deep-In-Gang aus? Wenn da was schief geht, müssen wir den VHDL-Code anschauen und dann muss sich der Wetter umbegehen beim Deep-In-Gang. Also zum Beispiel, ich kann da ein Beispiel machen. Und zum Beispiel hier, wenn wir ein Problem haben in dieser Funktion hier, zum Beispiel das Mapping funktioniert nicht oder so, in VHDL haben wir nicht mehr noch die Komponenten, die man behalten muss. Zum Beispiel hier behalten wir diese Namen oder hier hat man eine Logik, die man verwendet, die ist dann hier definiert. Wenn man zum Beispiel ein Signal definiert, dann ist das da. Also der Name wird aber behalten, weil diese Funktion gibt einen Array zurück. Also es ist nicht so schwer. Also ja, man behält immer noch den Namen und es ist ein Fakt, dass wenn man hier diese Abstraktion verwendet, also zum Beispiel passt die Pipeline-Stages an oder so, die Funktionen wurden schon durch jemand anderen verifiziert. Also man muss es nicht jedes Mal selber neu schreiben, was man kann schreiben, was man denkt und dann funktioniert es direkt schon. Also weil man eben einen abstrakten Weg hat, um die Hardware zu definieren. Also die Beschreibung ist einfacher. Und manchmal ist es ziemlich unglaublich, also wenn man VHDL und Varylog schreibt, dann funktioniert es beim ersten Mal nicht immer. Und hier passiert es manchmal, aber es ist noch überraschend, dass eigentlich hier oft funktioniert. Also ihr könnt ja mal ein Beispiel euch anschauen in VHDL, also VHDL ist nicht scheiße guter VHDL-Code. Also wenn man gute Signalnamen hat, wenn man finden, was man sucht, oder einen One-Stampend verwendet und das antreibt, ist es nicht ein Chaos, aber normalerweise muss man das VHDL hier nicht anschauen. Also es sollte ja reichen. Dankeschön. Eine Frage hier vorne. Schöner Vortrag. Haben Sie je gehört von System Level Design Languages, System C oder Spec C? Weil die machen einen ähnlichen Approach auf das Problem, um den wir den Abstaktionslevel anheben. Hab Sie je gehört von den? Ja, ich habe davon gehört, dass von System C und ja, Spec C auch. Nein, Spec C kenne ich nicht. Aber System C, ja, ich weiß, dass man viele Features verwenden kann, die man will, für Simulation von Dingen, für synthetisierbaren Code weiß ich nicht, ob man die ganzen wahnsinnigen Features verwenden kann. Aber ich bin auch nicht kein Experte, also ich will jetzt keine Scheiße erzählen. Also, ja, wenn man zu C kommt, muss man halt ein synthetisierbares Subset verwenden und dann ist es natürlich nicht so mächtig. Aber ja, vielleicht stimmt das nicht, was ich hier sage. Nein, das stimmt schon. Aber es ist ähnlich mit VHDL. Du kannst es verwenden, indem du simulierst. Das macht immer noch Sensitivitilist und diese Sorte von Dingen. Aber du musst keine Empfindlichkeitslisten verwenden. Du kannst auch Tabels für die ganze Kommunikation verwenden. Du kannst auch Busse einführen. Sehr ähnlich im Approach. Der mir gut gefällt. Entweder man einfach die Abstaktionslevel anhebt, damit man sich darunter synthetisieren muss. Kann man es mit Schüssel vergleichen, dass auch scalable ist? Ja, grundsätzlich, also ich habe Schüssel verwendet, bevor ich Spinaladial angefangen habe. Ich bin davon weggekommen, weil ich hatte schlechte Gefühle zu gewissen Dingen. Also, ich meine, ich will scheiß Schüssel nicht fertig machen, aber es hat einfach Features, die da nicht gut funktionieren, wie zum Beispiel, man kann nicht Multi-Club-Domain-Support verwenden. Also eigentlich schon, aber nicht wirklich. Man ist immer noch gezwungen, Synchronous Reset zu verwenden, dass Active High ist, diese Sorte von Dingen. Also Schüssel, die Idee hinter Schüssel, fokussiert auf Tools, die nicht Programme von allen lösen wollen. Also sie gehen dahin, wo sie brauchen. Sie sagen einfach, okay, wir brauchen das, das ist für uns genug. Und bei Spinaladial geht es mir wirklich darum, also ich habe eine Seite meiner Dokumentation, die Spinal und HTL und Schüssel vergleicht. Da gibt es einen Haufen kleine Details, die, wenn man das in Schüssel verwenden will, dann macht es das komplett kaputt. Also man kann das da nicht produktiv verwenden. Oder meinst du, die Synthese? Oder hast du eine Frage zur Synthese? Ich wollte es nur erwähnen. Aber wenn wir von den unterschiedlichen sprechen, wenn wir sollten wir nicht Schüssel verwenden, um diese, verwenden statt weiter, dort fixen statt es zu forken. Ja, ich wollte das forken, um, ja, rauszufinden. Also Spinaladial war zuerst nur, ich wollte rausfinden, wie das geht und dann Schüssel fixen. Aber, also ich habe auch ein paar Patches geschrieben und ein paar Pull Requests gemacht und ja, es gab keine Interaktion mit dem Team, kein Feedback, also keine Ahnung, wie der ein Development-Prozess ist. Ich habe es probiert, aber da war nichts zu machen. Ich glaube, ich kenne alle das Konzept mit dem IP-Course. Habt ihr sich einen Review-Prozess vorgedacht, die diese Library-Signal handelt und wie könnte man das einrichten? Ich will ja den Code nicht jedes Mal re-write, also will ich ihn wieder verwenden. Und wie kann ich sicherstellen, dass es dann guter Code ist? Also grundsätzlich, ja, das ist die nächste Ankündigung, was sich in Spinaladial einbauen fällt. Das ist wirklich etwas Wichtiges und Kompliziertes. Also wenn man was gemacht hat in Delivery auf Spinaladial, dann muss man nicht Features entfernen, die man schon hinzugefügt hat. Also was jetzt schon dokumentiert ist in meiner Dooku, kann so verstanden werden, dass das sicher ist. Also das ist das Zeug, dass wenn man Strings so verwendet, wie es in der Dooku steht, dann kann man davon ausgehen, dass das weiterhin funktionieren wird. Aber es gibt dann noch was zu tun, mit zusätzlichen Bibliotheken in Spinaladial. Also das ist ein Weg, die Feature-Entwicklung weiter anzuschauen. Also bis jetzt habe ich mich auf Core Spinaladial fokussiert. Kann man die mit clocklose Logic kreieren? Clockless Logic? Clockless Logic, dass du keine fixe Uhr hast. Das ist nur ein Hardware-Handshake. Ja, zum Beispiel die Complete Logic, also ohne Flip Flops. Ja, okay. Ich wollte Sie auch noch mein weiteres Tool. Kannst du mit Ihren Unterschiede klären zwischen deinem System und Pluspec, das auf Haskell basiert und wird sehr stark aufgenommen von der MIT. Und 8246-Kartons. Also ich habe von diesem Projekt gehört, aber ich weiß nicht wirklich Bescheid darüber. Ja, ich kann da nicht wirklich was zu sagen. All right, any other questions? Now is your chance? Do you have any questions from the internet? Nope. All right, if anything comes to your mind, please find a speaker afterwards and before you leave, please take the trash out with you. With that, let's give a round of applause to Schall. Thank you.