Student: Eric Schoch
Supervisor: Ramon Wirsch
Time period: 04/24/2023 - 07/24/2023

Am Fachgebiet Rechnersysteme werden Hardware-Beschleuniger für verschiedene Prozessorarchitekturen entwickelt. Hierzu sollen reguläre Programme ohne jegliche Anpassungen an den Hardware-Beschleuniger zur Laufzeit analysiert und partiell mit diesem ausgeführt werden können.

Eines der Teilsysteme für diese Hardware-Beschleunigung ist das RV-CGRA SoC, dass unter anderem einen Taiga/CVA5 RISC-V Prozessor enthält. Dabei handelt es sich um ein Embedded-System das bisher hauptsächlich ohne Betriebsystem oder mit dem Echtzeitbetriebssystem Zephyr betrieben wurde. Viele für die Hardwarebeschleunigung interessante Benchmarks benötigen Zugriff auf Dateien, so dass sie zum Beispiel eine Video-Datei wie auf einem Linux-System öffnen können. Diese sind deshalb bisher nicht ohne aufwendige Code-Änderungen für jeden Benchmark ausführbar.

Ziel dieser Arbeit ist die Erweiterung des existierenden Systems um eine Möglichkeit, Dateien identisch oder sehr ähnlich zur libc aus C-Code verarbeiten zu können. Eine vorherige Arbeit hat gezeigt, dass die Anbindung der existierende Systeme via LAN-Anschluss an einen Host-PC samt einer Software auf dem Host-PC am vielversprechendsten ist. Die genaue Verteilung der Aufgaben zwischen Host-PC und Embedded-System kann selbst gewählt werden.

Student: Daniel Diener
Supervisor: Dennis Wolf
Time period: 10/18/2018 - 09/30/2019

Ein Coarse Grained Reconfigurable Array (CGRAs) ist eine Rechnenarchitektur, die Hardwarebeschleuniger eingesetzt wird. Einzelne Rechenzellen verarbeiten entsprechend eines im voraus definierten Operationsplans (Scheduling) Daten massiv parallel. Die individuelle Auslegung eines CGRAs (u.a. der Selektion an Operationen der einzelnen Rechenzellen, deren Anzahl und Verbindung untereinander) ist generisch und im Einzelfall entscheidend für die Laufzeit einzelner Applikationen.

Entsprechend mehrerer Beispielapplikationen kann die Komposition eines CGRAs für eine Anwendungsdomäne optimiert werden. Die Erzeugung einer optimalen Komposition ist dabei aufgrund der Komplexität nicht mehr möglich. In solchen Fällen werden heuristische Optimierungsverfahren genutzt. Für diese Verfahren, liegen zwei der drei relevanten Qualitätsmaße in der möglichen Taktfrequenz und den benötigten Ressourcen einer CGRA Instanz. Da ein Syntheselauf zu deren Bestimmung im Stundenbereich liegen kann, muss eine Schätzung genutzt werden.

Im Rahmen dieser Arbeit soll ein (in Java) geschriebenes Framework zu einem neuronalen Netzwerk entstehen. Das Netz soll genutzt werden, um die maximale Taktfrequenz und den Ressourcenverbrauch einer Komposition auf einem FPGA zu schätzen. Es gilt ein generisches Netzwerk zu implementieren und ein geeignetes Rahmenwerk zur automatisierten Erstellung und Nutzung eines Netzes zu entwerfen. Dabei können bestehende Methoden und Klassen des jetzigen Frameworks wiederverwendet werden. Fokus im Bereich der Forschung liegt in der Repräsentation der CGRAs an dem Eingang des Netztes.

Student: Marius Ball
Supervisor: Ramon Wirsch
Time period: 04/12/2021 - 10/11/2021

Am Fachgebiet Rechnersysteme werden Hardwarebeschleuniger für verschiedene Prozessoren entwickelt. Hierzu sollen reguläre Programme ohne jegliche Anpassungen an den Hardwarebeschleuniger zur Laufzeit analysiert und partiell mit dem Hardwarebeschleuniger ausgeführt werden können.

Um diverse Anwendungen und Benchmarks ausführen zu können, muss das Betriebsystem, mit dem diese Anwendungen kommunizieren, emuliert werden. Dies passiert idealerweise auf Ebene der Kernel-Calls, um unabhängig von etwaigen LibC-Implementierungen zu sein. Falls nicht möglich können aber auch LibC-Funktionsaufrufe abgefangen und emuliert werden, was bisher der Fall ist. Hierbei müssen aber meist ganze Klassen von Funktionen möglichst vollständigt abgefangen werden können, da sie sich meist internen Zustand teilen, der von der von abgefangen Aufrufen nicht gepflegt wird.

Da bereits zwei verschiedene Simulatoren (RISC-V, IBM-Z) entwickelt werden, sollte die Betriebsystem-Emulation so architektur-agnostisch wie möglich sein, um für beide Simulatoren gleichzeitig zu funktionieren.

Ziel dieser Arbeit ist es daher fehlende Funktionalität möglichst architektur-agnostisch in die Simulatoren nachzurüsten.

Student: Nora Simon
Supervisor: Ramon Wirsch
Time period: 01/20/2022 - 05/18/2022

Am Fachgebiet Rechnersysteme werden Hardwarebeschleuniger für eine Reihe von Architekturen entwickelt. Hierzu sollen reguläre Programme zur Laufzeit analysiert und partiell mit dem Hardwarebeschleuniger ausgeführt werden können, ohne dass sie vorher dafür angepasst werden müssen.

Bei einer dieser Architekturen handelt es sich um RISC-V. Hierfür existiert bereits ein Demo-System bestehend aus dem Taiga RISC-V Prozessor und einem CGRA, allerdings mangelt es dem Taiga Prozessor noch an nativer Unterstützung von Fließkommazahlen in Form des RV32IMF Befehlssatzes . Diese soll im Rahmen dieser Arbeit nachgerüstet werden, um entsprechende Benchmarks in Hardware/auf FPGAs ausführen zu können.

Entsprechend der bereits durchgeführten Analyse soll FloPoCo 5 als Grundlage für die Fließkommaoperatoren genutzt werden. Eine möglichst identische Implementierung mit gleichen Operationen und Latenzen für CGRA und Taiga hat große Vorteile für die Vergleichbarkeit, weshalb eine zukünftige Portierung der Fließkommaoperatoren für den CGRA berücksichtigt werden soll.

Student: Pascal Rehfinger
Supervisor: Ramon Wirsch
Time period: 09/05/2019 - 04/01/2020

Am Fachgebiet Rechnersysteme wird ein Hardwarebeschleuniger für IBM-Z Prozessoren entwickelt. Hierzu sollen reguläre Programme ohne jegliche Anpassungen an den Hardwarebeschleuniger zur Laufzeit analysiert und partiell mit dem Hardwarebeschleuniger ausgeführt werden können.

Um die Analyse und Synthese für den Beschleuniger zu evaluieren, soll im Rahmen dieser Arbeit ein Simulator geschaffen werden, der sowohl den Z-Befehlssatz als auch den Beschleuniger simulieren kann. Dieser Simulator soll als Plattform für die weitere Entwicklung dienen und muss somit für die Z-Architektur kompilierte Binärdateien laden können. Da der Simulator hauptsächlich rechenlastige Benchmarks ausführen können soll, mit denen die Hardwarebeschleunigung in anderen Arbeiten evaluiert werden kann, muss nur eine rudimentäre Schnittstelle zu einem Betriebsystem implementiert werden.

Es existiert bereits ein modulares, in Java/Kotlin implementiertes Framework, dass den Hardwarebeschleuniger und eine andere Prozessor-Architektur simulieren kann, welches als Grundlage verwendet werden kann.

Student: Leon Mayrhofer
Supervisor: Dennis Wolf
Time period: 07/01/2019 - 07/31/2020

Ein Coarse Grained Reconfigurable Array (CGRA) ist ein Hardwarebeschleuniger, in dem einzelne Rechenzellen entsprechend eines im voraus definierten Operationsplans (Scheduling) Daten massiv parallel verarbeiten.

Eines unserer Forschungsthemen ist die Heterogenität von CGRAs. Um dies möglich zu machen, wurde ein Framework realisiert, mit dem beliebig heterogene und irreguläre CGRA modelliert wernde können. Dieses Modell ist auch die Grundlage für das Scheduling und dient als Input um Verilog Code zu erzeugen. Da die jetzige Modellierung nicht flexibel genug ist und Änderungen an der Mikroarchitektur vorgenommen wurden wird das gesamte Framework umgebaut. Basierend auf der Erfahrung der letzten Jahre wurde beschlossen ein generisches Ressourcen basiertes Modell umzusetzen. Der Kern des CGRAs wurde bereits weitgehend realisiert. Nun fehlen noch die Systemspezifischen Komponenten zur Integration des CGRAs. Das Konzept sieht ein Interface mit generischen Schnittstellen vor, das für die Nutzung des CGRA in verschiedene Systeme den eigentlich Kern des CGRAs zunächst kapselt. Dadurch müssen nur noch Systemspezifische Kommunikationsmodule generiert werden, die die generischen Schnittstellen des Interfaces nutzen.

Ziel dieser Arbeit ist eben ein solches Interface und die nötigen Kommunikationsmodule zu realisieren. Dies betrifft sowohl die Modellierung in Software, als auch die Erzeugung der resultierenden Hardwarebeschreibung. Dabei sollen innerhalb des Wrappers Live-In und Live-Out Mechanismen zusammengefasst werden, die die Anforderungen aller Systeme bedient werden können. Es sollen für die beiden bestehenden Systeme die nötigen Kommunikationsschnittstellen modularisiert werden und an die Mechanismen des Interfaces angeschlossen werden. Der Verlauf der Arbeit folgt den typischen Schritten der Analyse, des Entwurfs, der Implementierung und abschließend dem Testen. Die Arbeit soll in Abstimmung mit mehreren Entwicklern des Systems laufen.

Student: Julian Veit
Supervisor: Ramon Wirsch
Time period: 04/11/2022 - 09/26/2022

Am Fachgebiet Rechnersysteme werden Hardwarebeschleuniger für eine Reihe von Architekturen entwickelt, unter anderem für RISC-V und IBM Z-Architekturen. Hierzu sollen reguläre Programme ohne jegliche Anpassungen an den Hardwarebeschleuniger zur Laufzeit analysiert und partiell mit dem Hardwarebeschleuniger ausgeführt werden können.

Um Code-Abschnitte als Kandidaten für Hardware-Beschleunigung zu identifizieren, wird üblicherweise nach Schleifen gesucht in denen ein erheblicher Anteil der Rechenzeit verbracht wird. Anschließend können diese, auch Hot-Spots genannten Schleifen, weiter auf Eignung für die Hardware-Beschleunigung untersucht werden.

Ziel dieser Arbeit ist es insbesondere einen Loop-Profiler für die RISC-V Architektur zu entwerfen. Dieser soll in den Taiga RISC-V Prozessor integriert werden, wo er zur Laufzeit Schleifen finden und Iterationen sowie Aufruf-Häufigkeit analysieren soll. Die so gewonnen Daten sollen vom Prozessor selbst abrufbar sein und die Grundlage bilden für die weitere Auswahl von Schleifen für die Beschleunigung mittels unseres Hardware-Beschleunigers.

Student: Ivan Rubinskii
Supervisor: Tajas Ruschke
Time period: 12/03/2018 - 05/03/2019

Am Fachgebiet Rechnersysteme wird momentan an einer CGRA-Architektur geforscht, die zur Beschleunigung des Programmablaufs verwendet werden soll.

Damit ein Programmteil auf das CGRA abgebildet werden kann, muss ein Scheduler die Problemgraphen auf die Zielhardware abbilden. Dabei müssen verschiedene Abhängigkeiten berücksichtigt werden, um den korrekten Programmablauf zu gewährleisten. Eine besondere Herausforderung besteht in der Berücksichtigung der Datenlokalität und der Verbindungseinschränkungen. Wenn keine direkte Verbindung zwischen Quelle und Senke eines Datums besteht, ist eine Weiterleitung nötig. Dabei muss auch beachtet werden, dass eine Ressource bereits mit einer anderen Operation beschäftigt sein kann und deshalb ein vermeintlich längerer Pfad dennoch schneller zum Ziel führt.

Ziel dieser Arbeit ist das Design und die Implementierung eines Routingverfahrens, das einen geeigneten Pfad für die Weiterleitung der Werte produziert.

Student: Nico Rieckhoff
Supervisor: Ramon Wirsch
Time period: 05/02/2022 - 09/05/2022

Am Fachgebiet Rechnersysteme werden eine Reihe von Architekturen mitteles Coarse-Grained Reconfigurable Arrays (CGRAs) beschleunigt. Hierbei sollen reguläre Programme zur Laufzeit analysiert und partiell mit dem Hardwarebeschleuniger ausgeführt werden können, ohne dass sie vorher dafür angepasst werden müssen.

Eines dieser Zielsysteme ist der RISC-V Prozessor Taiga, der für die Benutzung auf FPGAs entworfen wurde. Er wurde bereits Cache-Kohärent mit dem CGRA zu einem Demonstationssystem kombiniert. Und ist mit vorbereiteten CGRA-Kerneln laufwendig. Es existierenden auch bereits Code um das nachträgliche Überschreiben von Instruktionen im Speicher durchzuführen, das benötigt wird um zur Laufzeit entdeckte Kernel anzuwenden.

Da der Beschleunigungsprozess ("Synthese") letztendlich vollständig nebenläufig auf dem Taiga Prozessor laufen soll, möglichst nebenläufig und unabhängig vom jeweiligen Nutzerprogramm, wird eine mit allen Bestandteilen des Systems abgestimmte Softwareumgebung für die Ausführung auf dem Taiga Prozessor benötigt. Diese Umgebung muss, ähnlich zu Echtzeitbetriebsystemen die Rechenzeit des Systems auf die Beschleunigung und das eigentliche Nutzprogramm verteilen. Weiterhin muss dabei die Beschleunigung mit dem Nutzprogramm synchronisiert werden, weil dazu zur Laufzeit in das originale Programm, durch Umschreiben des Codes ("Patchen"), eingegriffen werden muss. Die Umgebung soll auch den CGRA, die vorhandenen Kernel und den noch in der Entwicklung befindlichen Loop-Profiler managen. Um das Beschleunigen von möglichst vielen und verschiedenen Nutzprogrammen möglichst einfach zu machen, soll vom Nutzer keine aufwendige Integration in das Nutzprogramm erforderlich sein. Im Idealfall kann diese Umgebung deshalb in den bereits vorhanden Bootloader integriert werden, so dass gar keine gesonderte Anpassung des Nutzerprogramms erforderlich ist.

Student: Katharina Schultheis
Supervisor: Ramon Wirsch
Time period: 06/21/2021 - 11/22/2021

Am Fachgebiet Rechnersysteme werden Hardwarebeschleuniger für eine Reihe von Architekturen entwickelt. Hierzu sollen reguläre Programme zur Laufzeit analysiert und partiell mit dem Hardwarebeschleuniger ausgeführt werden können, ohne dass sie vorher dafür angepasst werden müssen.

Eine erste Fassung dieses Verfahrens läuft bereits, bei der der Assembler-Code in einen Kontrollflussgraphen (CFG) eingelesen wird und mithilfe einer Sammlung von Optimierungspasses für den Hardwarebeschleuniger optimiert wird. Hierbei muss der Hardwarebeschleuniger allerdings immer wieder auf den Stack des Host-Systems zugreifen, da der ursprüngliche Compiler hier zum Beispiel Funktionsargumente übergibt, oder Variablen, die nicht mehr in Register gepasst haben platziert hat.

Diese Stackzugriffe stellen einen Flaschenhals dar und sollen in dieser Arbeit so weit wie möglich durch Register-Zugriffe erstetzt werden.

Hierzu sollen Stack-Zugriffe analysiert werden, um notwendigerweise indirekte Zugriffe, wie auf Arrays, die auf dem Stack liegen, von Zugriffen auf skalare Werte zu unterscheiden. Anschließend sollen mindestens die skalaren Stack-Zugriffe durch Register-Zugriffe ersetzt werden. Manche Array-Zugriffe könnten eventuell in Kombination mit Loop-Unrolling ebenfalls eliminiert werden.

Student: Ann-Kathrin Werner
Supervisor: Dennis Wolf
Time period: 11/01/2019 - 03/01/2021

Ein Coarse Grained Reconfigurable Array (CGRA) ist ein Hardwarebeschleuniger, in dem einzelne Rechenzellen entsprechend eines im voraus definierten Operationsplans (Scheduling) Daten massiv parallel verarbeiten.

Eines unserer Forschungsthemen ist die Heterogenität von CGRAs. Um dies möglich zu machen, wurde ein Framework realisiert, mit dem beliebig heterogene und irreguläre CGRA modelliert werden können. Dieses Modell ist auch die Grundlage für das Scheduling und dient als Input um Verilog Code zu erzeugen. Da die jetzige Modellierung nicht flexibel genug ist und Änderungen an der Mikroarchitektur vorgenommen wurden, wird nun basierend auf der Erfahrung der letzten Jahre ein generisches, Ressourcen basiertes Modell umgesetzt. Der Kern des CGRAs und eine generische Schnittstelle wurden realisiert. Nun fehlen noch die Systemspezifischen Komponenten zur Integration des CGRAs in Amidar. Amidar ist ein am Lehrstuhl Rechnersystem entwickelter adaptiver Prozessor. Hierfür sollen Kommunikationsmodule automatisiert generiert werden, die die generischen Schnittstellen des CGRA Kerns bedient. Außerdem soll die Cache-Anbindung überarbeitet werden.

In dieser Arbeit soll die Systemintegration in Amidar durchgeführt werden und automatisierte Tests des CGRAs implementiert werden. Die Integration des alten CGRAs in Amidar kann hierfür als Vorlage genutzt werden. Zu Beginn soll manuell ein exemplarisches CGRA in Verilog umgesetzt und für eine simple Anwendung simuliert werden. Danach folgt die Integration in das Framework, so dass die Generierung der Kommunikationsschnittstellen für beliebige CGRAs automatisiert geschieht. Der Fokus der Arbeit soll abschließend ein Tool sein, das für gegebenen Java Applikationen, automatisierte Tests durchführt und die korrekte Funktionsweise des CGRAs inkl. der Kommunikationsschnittstellen prüft.

Student: Lukas Pajak
Supervisor: Ramon Wirsch
Time period: 04/14/2023 - 07/24/2023

Am Fachgebiet Rechnersysteme werden Hardware-Beschleuniger für verschiedene Prozessorarchitekturen entwickelt. Hierzu sollen reguläre Programme ohne jegliche Anpassungen an den Hardware-Beschleuniger zur Laufzeit analysiert und partiell mit diesem ausgeführt werden können.

Eine Form dieser Beschleuniger ist das CGRA, das sich insbesondere durch seine Parallelität mit vielen gleichzeitig arbeitenden Recheneinheiten auszeichnet. Die Recheneinheiten arbeiten aber nicht unabhängig voneinander, sondern müssen regelmäßig, taktgenau Daten zwischeneinander austauschen. Das Debuggen von Programmen, sogenannten Kerneln, für diese Hardwarebeschleuniger ist dementsprechend schwer.

Im Rahmen dieser Arbeit soll ein grafisches Tool entwickelt werden, um die Kernel für das CGRA nachzuvollziehen. Es soll möglich sein, jeden einzelnen Zeitschritt des Kernels detailliert, grafisch darzustellen und die exakten Tätigkeiten jeder einzelnen Einheit zu erkennen und sich schrittweise durch die Zeitschritte zu bewegen.

Die CGRA-Programme werden automatisch von einem Scheduler erzeugt. Deshalb soll die grafische Darstellung auch Informationen des Schedulers über die Erstellung des Programms nutzen können. So können Nutzer besser nachvollziehen, warum zum Beispiel eine bestimmte Operation nur auf einer bestimmten Einheit ausgeführt werden kann oder warum der Beschleuniger auf spezifische Daten warten muss. Auf der Suche nach Fehlern können so schneller unerwartete Scheduling-Entscheidungen identifiziert werden.

Es existiert bereits ein taktgenauer Simulator des CGRAs, der genutzt werden kann, um auch echte Werte aus der Simulation in die Darstellung zu integrieren. So könnte das Tool bis hin zu einem vollständigem Debugger für den CGRA ausgebaut werden.

Student: Simon Gütthoff
Supervisor: Dennis Wolf
Time period: 04/03/2017 - 01/01/2018

Ein Coarse Grained Reconfigurable Array (CGRA) ist eine Schaltung, die zumeist als Hardwarebeschleuniger eingesetzt wird. Einzelne Rechenzellen verarbeiten entsprechend eines im voraus definierten Operationsplans (Scheduling) Daten massiv parallel. Die Selektion an Operationen der einzelnen Rechenzellen, sowie deren Anzahl und Verbindung untereinander sind generisch und im Einzelfall entscheidend für die Laufzeit einzelner Applikationen.

Entsprechend mehrerer Beispielapplikationen kann ein CGRA für eine Anwendungsdomäne optimiert werden. Die Erzeugung einer optimalen CGRA Komposition ist dabei aufgrund der Komplexität nicht mehr möglich. In solchen Fällen werden heuristische Optimierungsverfahren genutzt. In diesem Fall finden sich zwei der drei relevanten Kosten in der möglichen Taktfrequenz und den benötigten Ressourcen einer CGRA Instanz. Da ein Syntheselauf allerdings im Stundenbereich liegen kann, muss eine Schätzung genutzt werden.

Im Rahmen dieser Arbeit soll ein Bibliotheks- basierter Schätzer entworfen werden, der die maximale Taktfrequenz und den Ressourcenverbrauch für eine Komposition auf einem FPGA bestimmt. Das Erstellen der Bibliothek für einzelne FPGA Typen soll im Laufe der Arbeit automatisiert werden.

Student: Julian Käuser
Supervisor: Dennis Wolf
Time period: 12/20/2016 - 02/20/2017

Coarse Grained Reconfigurable Arrays (CGRA) sind Schaltungen, die zumeist als Hardware-Beschleuniger eingesetzt werden. Einzelne Rechenzellen verarbeiten entsprechend eines im voraus definierten Operationsplans (Scheduling) Daten massiv parallel. Das Operationssprektrum der einzelnen Rechenzellen sowie die Verbindung untereinander sind generisch und im Einzelfall entscheidend für die Laufzeit einzelner Applikationen.

In dem Projekt "Ultrasynth" soll entsprechend mehrerer Beispielapplikationen aus einer Anwendungsdomäne ein CGRA für diese Domäne automatisiert erstellt und implementiert werden. Die Erzeugung einer optimalen CGRA Komposition (beispielsweise die Anzahl an Rechenzellen und deren Operationsspektrum) ist dabei aufgrund der Komplexität nicht mehr möglich. In solchen Fällen werden Heuristiken genutzt, die darauf setzen ein nicht optimales aber ausreichend gutes Ergebnis zu liefern.

In dieser Arbeit sollen zunächst Charakteristika/Attribute aus exemplarischen Beispielanwendungen extrahiert werden. Darauf basierend soll mit einem konstruktiven Verfahren ein passendes CGRA modelliert werden.

Student: Marcel Heinlein
Supervisor: Dennis Wolf
Time period: 12/20/2016 - 03/20/2017

CGRAs sind konfigurierbare Logik-Bausteine, die besonders geeignet sind, um rechenintensive Programmteile zu realisieren. Das Fachgebiet Rechnersysteme forscht seit geraumer Zeit auf diesem Gebiet. Nun sollen CGRAs auch in beliebige Rechnersysteme integriert werden.

Problematisch bei fast allen CGRAs, die nicht direkt in einen Prozessor integriert sind, ist der vergleichsweise hohe Aufwand den Konfigurationsspeicher zu beschreiben. Um die Ausführungsdauer dieses Vorgangs zu reduzieren und die Kommunikation mit dem zugehörigen Prozessor zu gewährleisten ist eine AXI-Slave Schnitstelle auf Seiten des CGRAs vorgesehen.

Im Rahmen dieser Arbeit soll diese AXI-Slave Schnittstelle entworfen werden, die die Kommunikationsschnittstelle zu einem Prozessor bildet und alle eingehenden Daten und Adressen entsprechend einer generischen CGRA Architektur passend aufarbeitet.

Student: Felix Retsch
Supervisor: Dennis Wolf
Time period: 02/14/2017 - 02/14/2017

Coarse Grained Reconfigurable Arrays (CGRA) sind Schaltungen, die zumeist als Hardwarebeschleuniger eingesetzt werden. Einzelne Rechenzellen verarbeiten entsprechend eines im voraus definierten Operationsplans (Scheduling) Daten massiv parallel. Das Operationsspektrum der einzelnen Rechenzellen, sowie die Verbindung untereinander, sind generisch und im Einzelfall entscheidend für die Laufzeit einzelner Applikationen.

In dem Projekt "UltraSynth" soll entsprechend mehrerer Beispielapplikationen ein CGRA für die entsprechende Anwendungsdomäne automatisiert erstellt und implementiert werden. Die Erzeugung einer optimalen CGRA Komposition (bzgl. der Anzahl an Rechenzellen und deren Operationsspektrums) ist dabei aufgrund der Komplexität nicht mehr möglich. In solchen Fällen werden Heuristiken genutzt, die darauf setzen, ein nicht zwingend optimales aber ausreichend gutes Ergebnis zu liefern. Für das vorliegende Optimierungsproblem kann die Heuristik "Simluated Annealing" genutzt werden.

Im Rahmen dieser Arbeit soll eine Version des Simulated Annealing implementiert werden. Dieses soll zur Findung einer möglichst guten Komposition für einen bestimmten Anwendungsbereich genutzt werden. Der Anwendungsbereich wird durch gegebene Applikationen definiert. Herausforderungen bestehen in der grundlegenden Parametrisierung des Algorithmus' sowie der Superposition oder Aggregation der Applikationen. In einem weiteren Schritt soll untersucht werden, ob entsprechend der Applikationen eine automatische Parametrisierung des Algorithmus' die Qualität gehoben und die Laufzeit gesenkt werden kann.

Student: Florian Prott
Supervisor: Boris Dreyer
Time period: 05/01/2015 - 06/12/2016

Für die Korrektheit von sicherheitskritischen eingebetteten Systemen ist es nicht nur wichtig, dass Programme korrekte Ergebnisse berechnen, sondern dass sie diese auch rechtzeitig liefern. Um dies sicherzustellen, muss die Worst Case Execution Time (WCET) des Programms bestimmt werden. Die WCET eines Programms setzt sich aus der WCET von einzelnen Basic Blocks (BB) zusammen. Ein BB ist eine nicht verzweigende Sequenz von Instruktionen. Ein Programm besteht daher aus hunderttausenden von BBs, die aus nur wenigen Instruktionen bestehen können.

Für jeden BB wird eine Statistik über dessen Ausführungszeit erstellt. Aufgrund der großen Anzahl an BBs und den Timing-Anforderungen, sollen diese Statistiken in Reduced Latency DDR (RLDRAM) geführt werden.

Ziel dieser Arbeit ist das Design und die Implementierung eines RLDRAM-Controllers zur dynamischen Programmanalyse. Diese Hardwarekomponente soll auf einem bestehenden RLDRAM-Controller aufsetzen und diesen um vier unabhängige Lese- und Schreibports erweitern. Anschließend soll einer dieser Ports an den SpartanMC angebunden werden, um auf den Speicher auch per Software Zugriff zu erlangen.

Student: Nico Eberlein
Supervisor: Boris Dreyer
Time period: 02/01/2015 - 04/30/2015

Für die Korrektheit von sicherheitskritischen eingebetteten Systemen ist es nicht nur wichtig, dass Programme korrekte Ergebnisse berechnen, sondern dass sie diese auch rechtzeitig liefern. Um dies sicherzustellen, muss die Worst Case Execution Time (WCET) des Programms bestimmt werden. Die WCET eines Programms setzt sich aus der WCET von einzelnen Basic Blocks (BB) zusammen. Ein BB ist eine nicht verzweigende Sequenz von Instruktionen. Ein Programm besteht daher aus hunderttausenden von BBs.

Mittels dynamischer Programmanalyse kann die WCET und weitere Zeiten eines Programms gemessen werden. Hierbei wird die Ausführungszeit eines jeden einzelnen BBs gemessen und eine Statistik geführt. Diese Statistik enthält für jeden BB die WCET, die Average Case Execution Time (ACET) und die Best Case Execution Time (BCET). Anschließend können durch entsprechende Kombination der BB-Statistiken anhand des Programmablaufplans Rückschlüsse auf die Ausführungszeit des Programms gezogen werden.

Da ein Programm aus hunderttausenden von BBs besteht, kann die Statistik aufgrund ihrer Größe nicht im BRAM oder distributed RAM eines FPGAs gehalten werden, sondern muss in externen RAM ausgelagert werden.

Das Ziel dieser Arbeit ist das Design und die Implementierung eines Hardware-Statistik-Moduls für die dynamische Programmanalyse. Neben einer Schnittstelle, über die das Modul die erhobene Statisik nach einer Programmanalyse einem weiteren Modul zur Verfügung stellt, muss das Hardware-Statistik-Modul eine Schnittstelle bereitstellen, über das es während der dynamischen Programmanalyse, die IDs der BBs und deren jeweils gemessen Ausführungszeiten entgegennehmen kann.

Student: Hu Yue
Supervisor: Boris Dreyer
Time period: 10/20/2015 - 01/20/2016

Für die Korrektheit von sicherheitskritischen eingebetteten Systemen ist es nicht nur wichtig, dass Programme korrekte Ergebnisse berechnen, sondern dass sie diese auch rechtzeitig liefern. Um dies sicherzustellen, muss die Worst Case Execution Time (WCET) des Programms bestimmt werden. Die WCET eines Programms setzt sich aus der WCET von einzelnen Basic Blocks (BB) zusammen. Ein BB ist eine nicht verzweigende Sequenz von Instruktionen. Ein Programm besteht daher aus hunderttausenden von BBs, die aus nur wenigen Instruktionen bestehen können.

Mittels dynamischer Programmanalyse kann die WCET und weitere Zeiten eines Programms gemessen werden. Hierbei wird die Ausführungszeit eines jeden einzelnen BBs gemessen und eine Statistik geführt. Ein Modul, welches diese Messungen durchführt ist bereits vorhanden.

Ziel dieser Arbeit ist der Entwurf und die Implementierung eines Statistik-Moduls, das die WCET, Average Case Execution Time (ACET) und die Best Case Execution Time (BCET) eines jeden BBs bestimmt. Wird dem Modul signalisiert, dass laufende Programmanalyse beendet ist, so soll die Statistik per USB auf auf einen Host-Computer übertragen werden. Die Übertragung soll auf Basis des SpartanMC geschehen, welcher USB-Kommunikation unterstützt.

Student: Steffen Grimm
Supervisor: Philip Gottschling
Time period: 11/01/2015 - 04/30/2016

Um einen für eine bestimmte Aufgabe spezialisierten Datenpfad zu erstellen wird ein vorliegender Datenflussgraph in Hardware umgesetzt. Der Datenpfad erfüllt dann genau die vom Nutzer gewünschte Funktion. Um eine andere Funktion zu realisieren wird eine neuer Datenpfad erstellt. Das Erstellen des Datenpfades (Syntheseprozess) benötigt allerdings viel Zeit. Effizienter ist es daher, einen Datenpfad zu erstellen, der bereits mehrere Funktionen realisieren kann und nur noch konfiguriert werden muss.

Diese Arbeit befasst sich mit der Überlagerung von Datenflussgraphen bzw. mit der Erweiterung eines bestehenden Datenpfades. Damit würden zunächst zwei oder mehrere Datenflussgraphen überlagert und erst danach ein Datenpfad erstellt, der dadurch mindestens alle gewünschten Funktionen bereitstellt. Dazu müssen Kommpatibilitätsgraphen (zwischen Datenflussgraph und bestehendem Datenpfad) erstellt und danach die größtmögliche Kompatibilität gefunden werden.

Student: Jakob Wenzel
Supervisor: Prof. Dr. Christian Hochberger / extern
Time period: 10/15/2013 - 01/14/2014

• 32 Eingangskanäle, single ended
• wahlweise interner oder externer Takt
• 2 Clock-Eingänge
• programmierbarer Clock, Abtastung der Eingänge mit bis zu 1 GHz
• programmierbare Filterung der Eingangssignale
• Ringpuffer in internen Block-RAMs sowie in externem DDR3-Speicher
• einfache Trigger-Bedingungen / einfacher Trigger-Sequenzer

Student: Stefan Knipp
Supervisor: Boris Dreyer
Time period: 02/01/2015 - 06/30/2015

Für die Korrektheit von sicherheitskritischen eingebetteten Systemen ist es nicht nur wichtig, dass Programme korrekte Ergebnisse berechnen, sondern, dass sie diese auch rechtzeitig liefern. Um dies sicherzustellen, muss die Worst Case Execution Time (WCET) des Programms bestimmt werden. Die WCET eines Programms setzt sich aus der WCET von einzelnen Basic Blocks (BB) zusammen. Ein BB ist eine nicht verzweigende Sequenz von Instruktionen. Ein Programm besteht daher aus hunderttausenden von BBs.

Mittels dynamischer Programmanalyse kann die WCET und weitere Zeiten eines Programms gemessen werden. Hierbei wird die Ausführungszeit eines jeden BBs gemessen und eine Statistik geführt. Diese Statistik enthält für jeden BB die WCET, die Average Case Execution Time (ACET) und die Best Case Execution Time (BCET). Anschließend kann durch entsprechende Kombination der BB-Statistiken anhand des Programmablaufplans Rückschlüsse auf die Ausführungszeit des Programms gezogen werden.

Die Zerlegung eines Programms in BBs geschieht bereits automatisiert. Hierbei entsteht ein XML-Dokument mit Informationen über die einzelnen BBs des Programms, wie die Adressen der ersten und letzten Instruktionen. Darüber hinaus werden die BBs zu einem Flussgraph angeordnet, so dass sich mögliche Programmabläufe bestimmen lassen.

Ziel dieser Arbeit ist das Design und die Implementierung eines Software-Tools, das bestehende XML-Dokumente aufbereitet und eines Hardware-Moduls, welches unter Zuhilfenahme dieser aufbereiteten Informationen, die Ausführungszeit einzelner BBs misst.

Eine nachfolgende Arbeit wird auf diese Zeiten zurückgreifen und Statistiken über die Ausführungszeiten der einzelnen BBs erstellen.

Student: Tobias Schladt
Supervisor: Philip Gottschling
Time period: 04/15/2015 - 09/09/2015

Am Fachgebiet Rechnersysteme (und an der Professur Mikrorechner der TU Dresden) wird ein SoC-Kit rund um den SpartanMC Soft-Core entwickelt. Dieser ist ein speziell für die Verwendung in FPGAs entwickelter CPU-Core. Aufgrund dieser Zielplattform nutzt der SpartanMC eine Befehls- und Datenbreite von 18 Bit, welche die Strukturen aktueller FPGAs optimal ausnutzt.

Inzwischen setzt die Xilinx Plattform bei fast allen IP-Komponenten auf AXI (Advanced eXtensible Interface Bus) als Peripheriebus. Der Bus verwendet zum Lesen und Schreiben einen Handshake und bietet die Möglichkeit von Burst-Transfers für schnelle Datenübertragungen. Um die Anbindung solcher vorgefertigter Module an die SpartanMC-Architektur zu vereinfachen, soll daher im Rahmen einer Bachelorarbeit ein AXI-Bus-Master implementiert werden. Dieser soll dann auch Einzug in die bestehende Entwicklungsumgebung für den SpartanMC erhalten.

Student: Ludwig Meysel
Supervisor: Philip Gottschling
Time period: 12/01/2016 - 02/28/2017

Ein Teilaspekt der Generierung von schnell rekonfigurierbaren Datenpfaden umfasst die automatische Überlagerung und anschließende Synthese von Datenflussgraphen. Damit wird erreicht, dass verschiedene Aufgaben in einem konfigurierbaren Verilog-Modul implementiert werden können. Um möglichst effiziente Module zu entwerfen, lassen sich definierte Strukturen innerhalb eines Datenflussgraphen zu atomaren Operationen zusammenfassen.

Viele der theoretisch möglichen Strukturen treten in echten Beispielen nur sehr selten oder sogar gar nicht auf. Um keine unnötige Arbeit in deren Optimierung zu investieren, sind Kenntnisse über die Gemeinsamkeiten von Datenflussgraphen und häufig auftretende Teilstrukturen hilfreich.

Student: Karsten Müller
Supervisor: Lukas Jung
Time period: 11/02/2015 - 04/04/2016

Student: Patrick Appenheimer
Supervisor: Lukas Jung
Time period: 06/27/2016 - 11/26/2016

Coarse Grained Reconfigurable Arrays (CGRAs) werden in AMIDAR-Prozessoren als Hardware Beschleuniger verwendet. Eine hohe Beschleunigung wird dabei erreicht, wenn das CGRA über mehrere DMA-Schnittstellen verfügt, über welche auf den Speicher zugegriffen werden kann. Dabei verfügt jede Schnittstelle über einen eigenen Cache.

Im Zuge dieser Arbeit soll ein Verfahren entwickelt werden, welches Cache-Kohärenz sicherstellt. Dies kann zum einen mit Hilfe von bekannten Kohärenz-Protokollen erreicht werden. Darüber hinaus muss untersucht werden, ob durch geeignete Programmierung des CGRAs sichergestellt werden kann, dass Inkonsistenzen in den Caches gar nicht oder nur selten auftreten.

Student: Frederik Lührs
Supervisor: Changgong Li
Time period: 10/01/2014 - 02/28/2015

Student: Hendrik Schöffmann
Supervisor: Lukas Jung
Time period: 01/01/2016 - 04/01/2016

Die Hardware Synthese ist ein wichtiges Werkzeug in AMIDAR zur automatischen Generierung von Hardware Beschleunigern zur Laufzeit. Der Synthese-Algorithmus kann dabei über Zahlreiche Parameter an die aktuelle Anwendung angepasst werden. Zur Zeit werden empirisch gefundene Werte verwendet, welche im Mittel zu guten Ergebnissen führen.

Im Zuge dieser Arbeit soll ein Verfahren entwickelt werden, welches es erlaubt mit Hilfe von Mustererkennung die optimalen Parameterwerte für eine gegebene Anwendung zu finden.

Da der Synthese-Algorithmus permanent weiterentwickelt wird, soll das Verfahren leicht anpassbar und wiederholbar sein.

Student: Michael Meister
Supervisor: Lukas Jung
Time period: 09/15/2017 - 12/15/2017

Am Fachgebiet Rechnersysteme wird momentan ein Java-Prozessor auf Basis des AMIDAR-Modells (www.amidar.de) implementiert, welches es dem Prozessor erlaubt, zur Laufzeit einer Applikation auf deren spezifische Anforderungen zu reagieren. In diesem Modell werden Instruktionen in eine Komposition von sogenannten Tokens zerlegt, die dann an einzelne Funktionseinheiten verteilt werden. Die Funktionseinheiten koordinieren ihre Arbeit über die Daten, die sie produzieren oder konsumieren.

Um Java-Code auf diesem Prozessor ausführen zu können, müssen die Quelldateien zunächst kompiliert werden. Die dadurch erzeugten class-Dateien enthalten Java Bytecode und müssen anschließend mit Hilfe des AXT-Converters in ein Amidar-Excutable (AXT) umgewandelt werden. Eine AXT-Datei enthält dabei immer den Bytecode aller benötigten Java Klassen (leicht modifiziert) sowie benötigte Konstanten.

Derzeit wird sowohl vom Prozessor als auch vom AXT-Converter nur Java Version 1.4 unterstützt. Im Zuge dieser Arbeit soll zunächst untersucht werden, worin die Unterschiede zwischen Java Version 1.4 sowie der aktuellen Version 8 auf Klassen-Ebene bestehen. Anschließend sollen Prozessor und AXT-Converter erweitert werden, sodass Java Version 8 unterstützt wird
Zusätzlich dazu müssen zugehörige API Klassen sowie der AMIDAR-Simulator ebenfalls erweitert werden.

Student: Yannik Böttcher
Supervisor: Alexander Schwarz
Time period: 10/29/2018 - 03/29/2019

Derzeit wird am Fachgebiet Rechnersysteme an AMIDAR-Prozessoren geforscht, die aus mehreren unabhängigen Funktionseinheiten aufgebaut sind und verschiedene Möglichkeiten der Rekonfiguration bereitstellen. Bisher lag der Fokus auf Ausführung von Java Bytecode, jedoch eignet sich das Grundprinzip für verschiedenste Instruktionssätze.

Nun wird die Idee verfolgt, einen speziell auf das AMIDAR-Konzept zugeschnittenen Instruktionssatz zu entwickeln, der einige Gedanken von Datenflussarchitekturen aufgreift. Für diesen Instruktionssatz wurde bereits ein Simulator implementiert, der jedoch nur einen Thread ausführen kann.

In dieser Arbeit soll zunächst ein Mechanismus für Kontextwechsel entwickelt und in den Simulator integriert werden. Anschließend ist ein Simulationsmodell für einen Thread Scheduler zu entwerfen. Hierfür kann sich am Verhalten der bereits existierenden Hardware-Implementierung orientiert werden. Abschließend soll die Funktionalität mit einem einfachen Programm, das mehrere Threads nutzt, getestet werden.

Student: Lars Stein
Supervisor: Dennis Wolf
Time period: 05/22/2017 - 08/21/2017

Am Fachgebiet Rechnersysteme wurde das Modell eines adaptiven Prozessors entwickelt (AMIDAR). Dieses Modell erlaubt es zur Laufzeit auf spezifische Anforderungen einer Applikation zu reagieren. Dazu zählt die Erkennung von rechenintensiven und wiederkehrenden Schleifen und deren Abbildung auf ein Coarse Grained Reconfigruable Array (CGRA). Ein CGRA ist ein Set aus Rechenzellen, die Instruktionssequenzen massiv parallel verarbeiten können. 2015 wurde hierfür eine generische CGRA Architektur implementiert. Mittels eines Generators können beliebige CGRA Instanzen in Verilog erzeugt werden, ohne dabei den Verilog Code manuell anpassen zu müssen. Die Architektur beherrscht zum jetzigen Zeitpunkt Arithmetik und Kontrollflussoperationen auf Basis von Festkommadarstellung. Um ohne Einschränkung relevante Code-Sequenzen abbilden zu können, ist es allerdings notwendig auch Gleitkommaberechnungen durchführen zu können.

Daher soll im Rahmen dieser Arbeit das CGRA um Gleitkommaoperationen und Datentypkonvertierungen erweitert werden. Dabei gilt es im ersten Schritt auch eine strategisch sinnvolle Auswahl an Implementierungen zu treffen. Neben der generischen Implementierung soll sich die Arbeit auf ausführliche Tests und die Verifikation durch Eigenschaftsnachweise (Property Checking) mit System Verilog Assertions konzentrieren.

Student: Ralf Kundel
Supervisor: Lukas Jung
Time period: 04/23/2015 - 08/14/2015

Student: Christian Rose
Supervisor: Changgong Li
Time period: 08/05/2013 - 01/06/2014

Student: Benedikt Heumüller
Supervisor: Changgong Li
Time period: 06/10/2013 - 09/09/2013

Student: Marek Völker
Supervisor: Changgong Li
Time period: 12/01/2015 - 05/01/2016

• Garbage Collection Algorithmus auf Basis des vorhandenen Prozessormodells entwerfen
• Schnittstellen zu den betroffenen Funktionseinheiten definieren
• Algorithmus implementieren und testen

Student: Sven Himer
Supervisor: Changgong Li
Time period: 06/01/2015 - 11/01/2015

Student: Adrian Weber
Supervisor: Lukas Jung
Time period: 11/25/2016 - 04/24/2017

Am Fachgebiet Rechnersysteme wird momentan ein Java-Prozessor auf Basis des AMIDAR-Modells (www.amidar.de) implementiert, welches es dem Prozessor erlaubt, zur Laufzeit einer Applikation auf deren spezifische Anforderungen zu reagieren.

Es ist möglich Programmteile, die häufig ausgeführt werden, automatisch auf einen rekonfigurierbaren Baustein (Coarse Grained Reconfigurable Array, kurz CGRA) abzubilden, und somit zu beschleunigen. Dieser Vorgang wird als Hardware Synthese bezeichnet.

Um herauszufinden, welche Programmteile häufig ausgeführt werden, kann beispielsweise der Quellcode vor der Ausführung analysiert werden. Dies führt aber meist nicht zu verlässlichen Ergebnissen, da der Ablauf eines Programms oftmals von den Eingabedaten abhängt und daher erst zur Laufzeit festgelegt wird.
Deshalb soll im Prozessor ein Profiler implementiert werden, der die Ausführung eines Programms im laufenden Betrieb analysiert und ein Profil erstellt, aus dem ersichtlich ist, welche Schleifen im Programm besonders oft ausgeführt werden (nähere Infos hier).

Da Programme, die auf dem AMIDAR-Prozessor ausgeführt werden, Zugang zu diesen Daten haben müssen, muss der Profiler auch als Peripherie-Gerät in den Prozessor eingebunden werden.

Student: Sven Himer
Supervisor: Changgong Li
Time period: 04/20/2015 - 11/20/2015

Am Fachgebiet Rechnersysteme wird momentan ein Java-Prozessor auf Basis des AMIDAR-Modells (www.amidar.de) implementiert, welches es dem Prozessor erlaubt, zur Laufzeit einer Applikation auf deren spezifische Anforderungen zu reagieren. In diesem Modell werden Instruktionen in eine Komposition von so genannten Tokens zerlegt, die dann an einzelne Funktionseinheiten verteilt werden. Die Funktionseinheiten koordinieren ihre Arbeit über die Daten, die sie produzieren oder konsumieren.

Ziel dieser Arbeit ist die Implementierung eines Ray-Tracers (Raytracing) mit Videoausgabe auf dem AMIDAR-Prozessor. Softwaremäßig soll dieser in Java 1.4 realisiert werden.

Damit sich die transformierten Bilder über einen DVI-Anschluss auf einem Bildschirm zeigen lassen, müssen verschiedene Peripherie-Module für den Wishbone-Bus realisiert werden (inkl. passender Java-API) implementiert werden. Schließlich muss ein existierender Ray-Tracer an diese Schnittstellen angepasst werden

Student: Sven Ströher
Supervisor: Lukas Jung
Time period: 04/03/2015 - 11/03/2015

Student: Maximilian Heer
Supervisor: Alexander Schwarz
Time period: 05/11/2020 - 10/10/2020

Derzeit wird am Fachgebiet Rechnersysteme ein Java-Prozessor auf Basis des AMIDAR-Modells implementiert, der aus mehreren unabhängigen Funktionseinheiten (FUs) besteht und verschiedene Möglichkeiten der dynamischen Anpassung an die Software bereitstellt. Der Prozessor führt bisher Java Bytecode in fast unveränderter Form in Hardware aus. Allerdings ist Java Bytecode nicht für die Ausführung in Hardware konzipiert, weshalb das Potenzial des AMIDAR-Modells damit nur schwer voll auszuschöpfen ist.

Ein vielversprechender Ansatz für eine neue Instruction Set Architecture, die speziell auf das AMIDAR-Konzept zugschnitten ist, greift Ideen von Datenflussmaschinen auf. Der Ansatz erlaubt es, Datenübertragungen zwischen Operationen direkt in den Instruktionen zu definieren. Es wurde bereits ein Prozessor mit dieser neuen ISA auf einem FPGA implementiert. Dieser kann bisher allerdings nur den Hauptthread eines Java-Programms ausführen. Darüber hinaus existiert ein Simulator für die ISA, der Programme mit beliebig vielen Threads entsprechend der Java-Spezifikation ausführen kann.

In dieser Arbeit soll die Hardware-Implementierung des Prozessors um die Fähigkeit ergänzt werden, Programme mit mehreren Threads auszuführen. Diese Fähigkeit soll durch zwei Komponenten realisiert werden. Zum einen ist eine Erweiterung der Token Machine notwendig. Diese spezielle FU verteilt die Operationen und die Zielinformationen der Operationsergebnisse an alle anderen FUs. Zum anderen ist eine Thread-Scheduler-FU notwendig, die Synchronisationsmechanismen für Threads bereitstellt und entscheidet, wann welcher Thread auszuführen ist.

Student: Jakob Karg
Supervisor: Changgong Li
Time period: 03/01/2016 - 08/01/2016

• Implementierung eines Newton-Raphson-Dividierers für die beiden ALUs
• Beschleunigung der IALU durch neue Implementierung der vorhandenen Pipeline
• Erweiterung der FALU um eine Pipeline

Student: Philipp Müller
Supervisor: Alexander Schwarz
Time period: 07/23/2018 - 02/14/2019

Derzeit wird am Fachgebiet Rechnersysteme an AMIDAR-Prozessoren geforscht, die aus mehreren unabhängigen Funktionseinheiten aufgebaut sind und verschiedene Möglichkeiten der Rekonfiguration bereitstellen. Bisher lag der Fokus auf Ausführung von Java Bytecode, jedoch eignet sich das Grundprinzip für verschiedenste Instruktionssätze. Zudem werden bisher Tags für die Zuordnung der Daten zu den Operationen der Funktionseinheiten benutzt. Über diese Zuordnung erfolgt die Synchronisation zwischen den Funktionseinheiten.

Zurzeit wird die Idee verfolgt, einen speziell auf das AMIDAR-Konzept zugeschnittenen Instruktionssatz zu entwickeln, der einige Gedanken von Datenflussarchitekturen aufgreift. Ein neuer Instruktionssatz eröffnet die Möglichkeit, andere Mechanismen zu verwenden, um die Daten den Operationen der Funktionseinheiten zuzuordnen. Hierzu gibt es bereits zwei Ideen.

In dieser Arbeit soll die Anwendbarkeit der Mechanismen untersucht werden. Hierzu sollen aus Java-Methoden generierte Graphen hinsichtlich bestimmter Muster analysiert werden, die eine solche Synchronisation überhaupt nötig machen. Darüber hinaus sollen offene Fragen zu den Mechanismen durch weitergehende Analyse der Graphen geklärt werden.

Student: Sebastian Kleemann
Supervisor: Alexander Schwarz
Time period: 11/02/2020 - 04/01/2021

Derzeit wird am Fachgebiet Rechnersysteme an AMIDAR-Prozessoren geforscht, die aus mehreren unabhängigen Funktionseinheiten (FUs) aufgebaut sind und verschiedene Möglichkeiten der Rekonfiguration bereitstellen. Bisher lag der Fokus auf Ausführung von Java Bytecode, jedoch eignet sich das Grundprinzip für verschiedenste Instruktionssätze.

Nun wird die Idee verfolgt, eine speziell auf das AMIDAR-Konzept zugeschnittene Instruction Set Architecture (ISA) zu entwickeln, die einige Gedanken von Datenflussarchitekturen aufgreift. Für diesen Instruktionssatz wurde bereits ein funktionierender Prozessor auf einem FPGA implementiert.

Speziell für die FU, die den Java-Heap implementiert, bieten sich noch einige Verbesserungsmöglichkeiten, die im Rahmen dieser Arbeit umgesetzt werden sollen. Primär ist dies die Unterstützung echter Byte- und Short-Arrays, die derzeit noch durch Integer-Arrays realisiert sind.

Student: Evrard Simo
Supervisor: Lukas Jung
Time period: 05/01/2018 - 07/31/2018

Am Fachgebiet Rechnersysteme wird momentan ein Java-Prozessor auf Basis des AMIDAR-Modells (www.amidar.de) implementiert, welches es dem Prozessor erlaubt, zur Laufzeit einer Applikation auf deren spezifische Anforderungen zu reagieren.

Es ist möglich Programmteile, die häufig ausgeführt werden, automatisch auf einen rekonfigurierbaren Baustein (Coarse Grained Reconfigurable Array, kurz CGRA) abzubilden, und somit zu beschleunigen. Dieser Vorgang wird als Hardware Synthese bezeichnet.

An der Universität of Wisconsin-Madison wird an einem ähnlichen Projekt namens DySER (Dynamically Specialized Execution Resources) geforscht. Ziel dieser Bachelorarbeit ist es, die Hardware Synthese mit DySER hinsichtlich Funktionsweise und Leistungsfähigkeit zu vergleichen.

Interessante Aspekte sind unter anderen welche Code-Teile auf Hardware abgebildet werden können, wie Kontrollfluss umgesetzt wird oder wie die Kommunikation zwischen Beschleuniger und Prozessor umgesetzt ist.

Student: Jonathan Strobl
Supervisor: Jakob Wenzel
Time period: 04/30/2019 - 10/28/2019

Am Fachgebiet Rechnersysteme wird ein SoC-Kit rund um den SpartanMC Soft-Core entwickelt. Dieser ist ein speziell für die Verwendung in FPGAs entwickelter CPU-Core. Aufgrund dieser Zielplattform nutzt der SpartanMC eine Befehls- und Datenbreite von 18 Bit, welche die Strukturen aktueller FPGAs optimal ausnutzt.

Der SpartanMC-Prozessor verfügt über 3 Pipelinestufen und einen entprechend simplen RISC-Befehlssatz. Diverse Bypasses der Pipelinestufen liegen auf dem kritischen Pfad und limitieren somit die maximal mögliche Taktgeschwindigkeit des Prozessors.

Ziel dieser Arbeit ist die Entfernung bzw. Beschleunigung dieses Pfades. In Folge dessen wird es dazu kommen, dass bei bestimmten Instruktionssequenzen Wartetakte eingefügt werden müssen. Die bestehende Hazard Detection Unit des Prozessors ist dahingehend zu erweitern, dass sie die nicht mehr möglichen Fälle erkennt und Stalls einfügt.

Außerdem soll der Compiler angepasst werden, sodass er von der neu eingefügten Limitation des Prozessors weiß. Durch die dann bessere Instruktionsreihenfolge sollte sich die Anzahl der Straftakte reduzieren.

Student: Ho Thanh Tu Nguyen
Supervisor: Kris Heid
Time period: 11/13/2017 - 04/13/2018

Am Fachgebiet Rechnersysteme wird ein SoC-Kit rund um den SpartanMC Soft-Core entwickelt. Dieser ist ein speziell für die Verwendung in FPGAs entwickelter CPU-Core. Aufgrund dieser Zielplattform nutzt der SpartanMC eine Befehls- und Datenbreite von 18 Bit, welche die Strukturen aktueller FPGAs optimal ausnutzt.

Momentan wird daran gearbeitet hoch parallele Multiprozessor System-On-Chips (MPSoC) zu erstellen. Hierfür wird µStreams (ein eigens entwickeltes Parallelisierungs-Tool) genutzt. µStreams nimmt ein gewöhnliches sequenzielles Programm entgegen und parallelisiert dieses automatisch. Das erzeugte Many-Core System kommuniziert und synchronisiert sich über 1 zu 1, 1 zu N, N zu 1 Verbindungen, einen Router für Networks-On-Chip (NoC) und einen geteilten Speicher. Das resultierende MPSoC System ist dann eine Verarbeitungspipeline, ähnlich aktueller Prozessorpipelines, nur grob granularer arbeitend.

Je nach MPSoC Konfiguration werden auf dem FPGA unterschiedliche maximale Frequenzen erreicht, abhängig von Anzahl an Prozessoren, Periperie und Speicher. Die maximal erreichbare Frequenz gibt bei der Entscheidung zwischen mehreren realisierbaren MPSoC Konfigurationen möglicherweise den Ausschlag für oder gegen eine bestimmte Konfiguration. Leider ist momentan die Evaluation der maximalen Frequenz erst relativ weit am Ende des Design Prozesses möglich und geschieht erst nach einer Entscheidung für eine bestimmte Konfiguration. Dies ist für den Nutzer enorm Zeitaufwendig und verlangsamt die Findung einer optimalen Lösung.

Ziel dieser Arbeit soll es sein, eine Schätzfunktion für die maximal mögliche Frequenz einer gegebenen Konfiguration zu erstellen. Um herauszufinden welche Faktoren wie stark die Frequenz beeinflussen, sollen in dieser Arbeit verschiedene Konfigurationen systematisch gebaut und synthetisiert werden. Anschließend sollen die Erkenntnisse in einer Funktion in Form eine Java-Klasse bereitgestellt werden.

Student: Kacper Wiecek
Supervisor: Jakob Wenzel
Time period: 10/15/2019 - 03/16/2020

Am Fachgebiet Rechnersysteme wird ein SoC-Kit rund um den SpartanMC Soft-Core entwickelt. Dieser ist ein speziell für die Verwendung in FPGAs entwickelter CPU-Core. Aufgrund dieser Zielplattform nutzt der SpartanMC eine Befehls- und Datenbreite von 18 Bit, welche die Strukturen aktueller FPGAs optimal ausnutzt.

Der Befehlssatz des SpartanMC-Prozessors wurde eigens dafür entwickelt, allerdings verfügt er über mehrere auf bestimmte Anwendungen spezialisierte Befehle und wurde auch maßgeblich für das manuelle Schreiben von Assembler-Code optimiert.

Da mittlerweile hauptsächlich ein moderner, optimierender Compiler (GCC) eingesetzt wird, sind einige Befehle redundant geworden, während manche der spezialisierteren Befehle ungenutzt bleiben.

In dieser Arbeit soll analysiert werden, welche Befehle aktuell vom GCC nicht verwendet werden. Wenn es mit vertretbarem Aufwand möglich ist, soll die Machine Description des Compilers so angepasst werden, dass er diese Befehle verwendet. Wenn nicht möglich, sollen sie aus dem Prozessor entfernt werden.

Im Anschluss soll auch die Kodierung der Befehle optimiert werden, sodass der Decoder kleiner wird.

Student: Isabelle Bacher
Supervisor: Philip Gottschling
Time period: 09/04/2017 - 01/19/2018

Oftmals benötigt man einen Kommunikationskanal zwischen einem Host-PC und dem am Fachgebiet Rechnersysteme entwickelten SpartanMC Softcore. Zur schnellen Datenübertragung eignet sich ein USB 3.0 Interface, da es Datenraten bis zu 5Gbit/s unterstützt. Derzeit steht allerdings nur eine USB 1.1 Schnittstelle zur Verfügung, deren Datenrate mit 12Mbit/s deutlich geringer ausfällt. Im Rahmen dieser Bachelorarbeit soll ein Peripherie-Modul weiterentwickelt werden, die über ein FTDI USB 3.0 Modul mit einem PC Daten austauschen kann. Mit diesem Modul lassen sich im FT245-Modus 32 Bit breite Worte bei einer maximalen Frequenz von 100Mhz übertragen.

Student: Thorsten Melbaum
Supervisor: Jakob Wenzel
Time period: 06/20/2017 - 09/20/2017

Das SpartanMC SoC-Kit ist eine Werkzeugkette und ein Satz von Soft- und Hardware-Komponenten, die Anwendern erlauben, ein anwendungsspezifisches SoC zu konstruieren, ohne selbst Spezialist für FPGAs zu sein. Um nicht für jede Änderung der Systemkonfiguration ein komplett neues System synthetisieren zu müssen, wurde RapidSoC erstellt. Dieses Werkzeug erlaubt es, vorab Module des SoC-Kit in partielle FPGA-Konfigurationen zu verwandeln. Bei Verwendung müssen diese dann nur noch zusammengefügt werden. Bei der Modulgenerierung werden Platzierungs-Constraints verwendet, um kompakte, rechteckige Module zu erzeugen.

Die Erstellung der Platzierungs-Constraints ist noch nicht automatisiert. Bisher können Benutzer aus einem Satz von fertigen Constraints auswählen, oder sie selbst erzeugen. Ziel dieser Arbeit ist die Automatisierung dieses Schritts. Nach dem Technologie-Mapping wird von den Hersteller-Tools eine Statistik über die Ressourcenverwendung des Moduls erzeugt. Aus dieser Statistik sollen passende Constraints erzeugt werden. Dabei müssen selten vorkommende Ressourcen wie Block-RAMS oder DSP-Blöcke speziell berücksichtigt werden.

Bei der Modul-Synthese wird jeder Port des Moduls an ein FPGA-Pin angeschlossen. Die Auswahl dieser Pins erfolgt bisher zufällig. Im Rahmen dieser Arbeit soll dafür ein besserer Ansatz gefunden werden.

Student: Maximilian Flaig
Supervisor: Kris Heid
Time period: 07/01/2014 - 09/30/2014

Student: Melanie Braun
Supervisor: Kris Heid
Time period: 02/22/2016 - 07/22/2016

Student: Andre Miebes
Supervisor: Kris Heid
Time period: 10/18/2016 - 03/18/2017

Am Fachgebiet Rechnersysteme (und an der Professur Mikrorechner der TU Dresden) wird ein SoC-Kit rund um den SpartanMC Soft-Core entwickelt. Dieser ist ein speziell für die Verwendung in FPGAs entwickelter CPU-Core. Aufgrund dieser Zielplattform nutzt der SpartanMC eine Befehls- und Datenbreite von 18 Bit, welche die Strukturen aktueller FPGAs optimal ausnutzt.

Zur Kommunikation mehrerer Prozessorkerne untereinander wurden bereits spezielle Schaltungen in SpartanMC integriert, welche eine 1-1 oder 1-N bzw. N-1 Kommunikation ermöglichen. Bei der Kommunikation der Kerne untereinander ist eine entsprechend hohe Bandbreite und niedrige Latenz essenziell. Alle bisherigen Implementierungen benötigen jedoch den Prozessor, um Daten von dem Hauptspeicher in den Peripherieadressbereich zu kopieren. Die Kommunikation erreicht hierbei einen akzeptablen Durchsatz, jedoch ist der Prozessor ausschließlich mit dem Kopieren beschäftigt und kann seinen eigentlichen Zweck (die Berechnung der Daten) nicht verfolgen.

Ziel dieser Arbeit ist daher eine Variante der Prozessorkommunikation zu entwickeln, welche über DMA arbeitet, um den Prozessor zu entlasten. Anstelle einzelner Datenwerte müsste der Prozessor lediglich die Startadresse der Daten übergeben, das stupide Kopieren würde die Peripherie erledigen.

Student: Markus Noll
Supervisor: Kris Heid
Time period: 12/01/2014 - 04/01/2015

Student: Joris Beringer
Supervisor: Kris Heid
Time period: 10/01/2015 - 03/01/2016

Student: Jan Frenzel
Supervisor: Siegmar Schöne
Time period: 05/09/2012 - 08/09/2012

Student: Laurenz Kamp
Supervisor: Kris Heid
Time period: 08/01/2016 - 11/01/2016

Student: Maximilian Sexauer
Supervisor: Ramon Wirsch
Time period: 04/19/2021 - 09/20/2021

Am Fachgebiet Rechnersysteme wird das SoC-Kit SpartanMC verwendet. Hierbei handelt es sich um ein speziell auf eingebettete Anwendungen auf FPGAs optimiertes System-On-Chip. Die Architektur des Prozessors weicht an einigen Stellen von herkömmlichen Prinzipien ab um die FPGA-Hardware optimal auszulasten. Aufgrund dieser Anpassungen funktionieren aber Features wie Debugging mit GDB nur beschränkt. Dies soll in dieser Arbeit verbessert werden.

Bei dem SpartanMC-Prozessor handelt es sich um eine 18-Bit Architektur. Da dies eine nicht übliche Breite ist, müssen die für SpartanMC relevanten 18-Bit in unterschiedlichen Formaten in vielfache von Bytes gepackt werden, meist 32-Bit. Dies sorgt allerdings für einen Unterschied in den Addressen, die vom Compiler und Debugger angenommen werden, im Vergleich zu den Addressen die auf dem Prozessor Anwendung finden. Da der Debugger aus dem laufenden System explizite Speicherbereiche ausliest, führen diese Unterschiede dazu, dass die falschen Addressen vom Debugger ausgelesen oder geschrieben werden.

Um dieses Problem zu beheben, muss an entsprechenden Stellen im Ablauf eine Address-Übersetzung stattfinden. Mögliche Stellen dafür sind im Compiler, der Debugging-Informationen in Form des DWARF2 Formats erzeugt, die die Addressen beschreiben sollen. Der Prozessor kann ebenfalls zur Laufzeit Addressen umrechnen und so dem Debugger ein unterstütztes, passendes Address-Layout vorspielen. Eine weitere Möglichkeit, die bisher noch nicht genutzt wird, ist ein Nachbearbeiten der DWARF2 Infos. Dies ist sinnvoll, weil der Compiler sehr komplex und nicht auf die Format-Änderungen ausgelegt ist. Der Prozessor hingegen hat als engebettetes Gerät nicht Zugriff auf alle nötigen Informationen, um alle Addressen korrekt umrechnen zu können.

Ziel dieser Arbeit ist es durch Nachbearbeiten der DWARF2 Debugging-Infos noch fehlende Debugging-Möglichkeiten umzusetzen. Hierbei soll insbesondere ermöglicht werden lokale Variablen, die sich allerdings auf dem Stack und nicht in Registern befinden, mit dem Debugger auslesen und bearbeiten zu können.

Student: Alexander Weisel
Supervisor: Changgong Li
Time period: 07/29/2013 - 10/28/2013

Student: Ramon Wirsch
Supervisor: Kris Heid
Time period: 10/13/2014 - 03/13/2015

Student: Rainer Wahler
Supervisor: Prof. Dr. Christian Hochberger
Time period: 02/15/2013 - 05/24/2013

Student: Carsten Heinz
Supervisor: Kris Heid
Time period: 02/16/2015 - 05/04/2015

Student: Lukas Schild
Supervisor: Kris Heid
Time period: 05/01/2017 - 02/01/2018

Am Fachgebiet Rechnersysteme wird ein SoC-Kit rund um den SpartanMC Soft-Core entwickelt. Dieser ist ein speziell für die Verwendung in FPGAs entwickelter CPU-Core. Aufgrund dieser Zielplattform nutzt der SpartanMC eine Befehls- und Datenbreite von 18 Bit, welche die Strukturen aktueller FPGAs optimal ausnutzt. Ein in direkter Konkurrenz mit dem SpartanMC stehender SoC ist der Microblaze von Xilinx.

Um den Microblaze zu verwenden, muss der Nutzer die Konfiguration im Xilinx eigenen Konfigurationstool: Xilinx Platform Studio (XPS) manuell zusammenstellen. Um den SpartanMC konfigurieren und instantiieren zu können wurde jConfig entwickelt. jConfig bietet dem Nutzer generell die Möglichkeit beliebige Hardware zu instantiieren. Außerdem bietet es sehr gute Unterstützung um Komponenten aus einer sehr einfachen XML Beschreibung zu importieren. Über individuelle Skripte werden die Komponenten mit sehr wenig manuellem Aufwand konfiguriert und verkabelt. Der Nutzer muss im Gegensatz zum XPS kaum noch tätig werden. In jConfig befindet sich bereits sehr viele Peripheriekomponenten für SpartanMC.

Seit kurzem ist nun auch der Microblaze in jConfig instantiierbar. Allerdings steht und fällt die Verwendbarkeit eines SoC mit den verfügbaren Peripheriekomponenten und für Microblaze sind bisher erst UART und FSL Interconnects verfügbar. Daher sollen in dieser Arbeit mehr Peripheriekomponenten für den Microblaze über jConfig zugänglich gemacht werden. Hierzu müssen die Komponenten aus XPS ausgelesen und über eine Instantiierung in einem passenden Verilog Wrapper in jConfig verfügbar gemacht werden. Um die gewünschte automatisierte Konfiguration zu erreichen, müssen außerdem die Peripheriekomponenten um individuelle Skripte ergänzt werden. Anschließend sollten die Komponenten getestet werden. Bei den zu portierenden Komponenten handelt es sich um populäre Protokolle für Mikrocontroller wie: SPI, I2C, USB und AXI-Stream Interconnect für Multi-Core Systeme.

Student: Heiko Schüßler
Supervisor: Jakob Wenzel
Time period: 06/22/2018 - 11/22/2018

Am Fachgebiet Rechnersysteme wird ein SoC-Kit rund um den SpartanMC Soft-Core entwickelt. Dieser ist ein speziell für die Verwendung in FPGAs entwickelter CPU-Core. Aufgrund dieser Zielplattform nutzt der SpartanMC eine Befehls- und Datenbreite von 18 Bit, welche die Strukturen aktueller FPGAs optimal ausnutzt.

Der in den SpartanMC integrierte Debugging-Support nutzt zur Kommunikation mit dem Host-PC bisher eine UART-Schnittstelle. Auch für printf-Ausgaben wird eine UART-Schnittstelle benötigt. In Multicore-Systemen ist dieser Umstand problematisch: Jeder Core benötigt eine eigene UART-Verbindung, es existiert aber nur eine einzige Verbindung zum Host.

Ziel dieser Arbeit ist es, diese Situation zu verbessern. Es soll eine Kommunikationsstruktur erstellt werden, die es erlaubt, eine große Anzahl interner Ports mit dem Host-PC zu verbinden. Statt per UART soll dies aber per JTAG erfolgen, da diese Verbindung mit einem höheren Takt arbeiten kann.

Auf Host-PC-Seite müssen die zu einem Port zusammengeführten Daten wieder getrennt werden. Dabei muss eine eindeutige Zuordnung der Daten zu den Ports möglich sein. Hierzu soll ein Linux-Programm erstellt werden, das die Daten auf Pseudo-Geräte aufteilt. Dadurch ist der Zugriff von jedem Programm, das normale serielle Schnittstellen verwenden kann, möglich.

Student: Gregor Koch
Supervisor: Prof. Dr. Christian Hochberger
Time period: 12/02/2013 - 02/28/2014

• Task-Verwaltung mit Prioritäten
• Semaphore als Synchronisationsmechanismus
• Einfache Speicherverwaltung

Student: Uzay Yavuz
Supervisor: Ramon Wirsch
Time period: 10/31/2018 - 02/27/2019

Am Fachgebiet Rechnersysteme wird ein SoC-Kit rund um den SpartanMC Soft-Core entwickelt. Dieser ist ein speziell für die Verwendung in FPGAs entwickelter CPU-Core. Aufgrund dieser Zielplattform nutzt der SpartanMC eine Befehls- und Datenbreite von 18 Bit, welche die Strukturen aktueller FPGAs optimal ausnutzt.

Die Firmware / Daten der Prozessoren liegen meist in BlockRAMs des FPGAs. Da es sich bei BlockRAMs nur um kleine Speicherblöcke mit festen Größen handelt, müssen diese kombiniert und die Daten aufgeteilt werden, um ausreichende Mengen an Speicher zu erhalten. Momentan werden nur 2 im voraus festgelegte Varianten zur Aufteilung der Daten unterstützt.

Eine geschicktere Aufteilung der Daten könnte insbesondere bei hohem Speicherbedarf die möglichen Taktfrequenzen und damit die Geschwindigkeit des Prozessors steigern.

Weiterhin kann das am Fachgebiet entwickelte grafische Konfigurationstool angepasst werden, um die Optimierung der Aufteilung zu automatisieren oder den Benutzer auf mögliche bessere Alternativen hinzuweisen.

Student: Patrick Hentschel
Supervisor: Prof. Dr. Christian Hochberger
Time period: 11/18/2013 - 02/17/2014

Student: Felix Sterzelmaier
Supervisor: Kris Heid
Time period: 10/19/2015 - 03/21/2016

Am Fachgebiet Rechnersysteme (und an der Professur Mikrorechner der TU Dresden) wird ein SoC-Kit rund um den SpartanMC Soft-Core entwickelt. Dieser ist ein speziell für die Verwendung in FPGAs entwickelter CPU-Core. Aufgrund dieser Zielplattform nutzt der SpartanMC eine Befehls- und Datenbreite von 18 Bit, welche die Strukturen aktueller FPGAs optimal ausnutzt.

Es besteht bereits die Möglichkeit mehrere SpartanMC Kerne auf einem FPGA unter zu bringen und diese über einfache send und receive Funktionen kommunizieren zu lassen. Eine solche Kommunikation ist momentan allerdings nur möglich, wenn zwischen beiden Kernen eine direkte Verbindung besteht. Ziel der Arbeit ist die Unterstützung von Nachrichtenrouting. Mit Hilfe von Routing sollen alle Kerne unabhängig von der zugrunde liegenden Vernetzung miteinander Kommunizieren können.

In einer vorangegangenen Arbeit wurde bereits mit der Implementierung eines circuit switching Routers begonnen, welcher weiterentwickelt werden soll.

Student: Mohammadmehdi Peiro
Supervisor: Kris Heid
Time period: 07/01/2016 - 12/01/2016

Am Fachgebiet Rechnersysteme wird ein SoC-Kit rund um den SpartanMC Soft-Core entwickelt. Dieser ist ein speziell für die Verwendung in FPGAs entwickelter CPU-Core. Aufgrund dieser Zielplattform nutzt der SpartanMC eine Befehls- und Datenbreite von 18 Bit, welche die Strukturen aktueller FPGAs optimal ausnutzt.

Ein Hauptaugenmerk bei der Weiterentwicklung des SpartanMC Toolkits liegt aktuell auf der Erweiterung der Multi-Core Fähigkeit des SpartanMC. Um die erstellten Multi-Core Systeme zu testen, fehlt allerdings momentan noch eine gewisse Bandbreite an guten Anwedungen. Die Parsec Benchmark Suite beherbergt eine Reihe von Anwendungen, die speziell auf Multithreading ausgelegt sind.

Ziel dieser Arbeit soll daher die Portierung von Parsec Benchmarks auf SpartanMC sein. Viele Anwendungen sind bereits als C-Sourcecode in Parsec enthalten und müssen nur auf die vergleichsweise eingeschränkte SpartanMC Plattform angepasst werden. So hat der SpartanMC beispielsweise kein Dateisystem aus dem Eingabedaten gelesen werden können. Die Eingabedaten müssen dann entweder komplett als Array in Datenspeicher abgelegt werden oder per USB zur Laufzeit übertragen werden.

Idealerweise sollte während der Arbeit noch die Parallelisierbarkeit der Anwendungen, mit Hilfe des von uns entwickelten parallelisierenden Compilers, getestet und evaluiert werden

Student: Lukas Boland
Supervisor: Kris Heid
Time period: 04/07/2015 - 09/07/2015

Student: Andreas Ring
Supervisor: Kris Heid
Time period: 01/01/2014 - 03/31/2014

Student: Nourhan El-Hamawy
Supervisor: Kris Heid
Time period: 03/29/2016 - 08/30/2016

Student: Johannes Klöhn
Supervisor: Jakob Wenzel
Time period: 04/11/2018 - 09/11/2018

Am Fachgebiet Rechnersysteme wird ein SoC-Kit rund um den SpartanMC Soft-Core entwickelt. Dieser ist ein speziell für die Verwendung in FPGAs entwickelter CPU-Core. Aufgrund dieser Zielplattform nutzt der SpartanMC eine Befehls- und Datenbreite von 18 Bit, welche die Strukturen aktueller FPGAs optimal ausnutzt.

Als Programm- und Datenspeicher werden die Block-RAMs des FPGAs verwendet. Da diese gerade bei Many-Core-Systemen stark limitiert sind, ist es ratsam, einem Kern nicht mehr Block-RAMs zuzuteilen, als auch benötigt werden. Diese Anzahl genau zu ermitteln ist schwierig, da sich beispielsweise die Größe des Stack über die Laufzeit des Programms ändert. Ziel dieser Arbeit ist daher eine statische Analyse der Größe des benötigten Speichers eines Programms.

Die Größe von Programmcode und Daten sind statisch bekannt. Herausforderung dieser Arbeit ist hingegen die Bestimmung der maximalen Stackgröße. Bei der Kompilierung kann GCC optional die Stackgrößen aller Funktionen in eine separate Datei ausgeben. Die Größen sind dabei nur die der Funktionen selber und enthalten nicht die der von ihnen aufgerufenen Funktionen.

Aus dem fertig gelinkten Programm oder aus den dazugehörigen Debug-Infos soll anschließend rekonstruiert werden, welche Funktionen aus einer Funktion heraus aufgerufen werden. Zusammen mit dem Speicherbedarf der einzelnen Funktionen lässt sich dann eine Worst-Case-Stackgröße ermitteln.

Student: Marcel Jourdan
Supervisor: Changgong Li
Time period: 10/23/2013 - 01/22/2014

Student: Tobias Averhage
Supervisor: Jakob Wenzel
Time period: 02/20/2017 - 07/20/2017

Das SpartanMC SoC-Kit ist eine Werkzeugkette und ein Satz von Soft- und Hardware-Komponenten, die Anwendern erlauben, ein anwendungsspezifisches SoC zu konstruieren, ohne selbst Spezialist für FPGAs zu sein. Um nicht für jede Änderung der Systemkonfiguration ein komplett neues System synthetisieren zu müssen, wurde RapidSoC erstellt. Dieses Werkzeug erlaubt es, vorab Module des SoC-Kit in partielle FPGA-Konfigurationen zu verwandeln. Bei Verwendung müssen diese dann nur noch zusammengefügt werden. Bei der Modulgenerierung werden Platzierungs-Constraints verwendet, um kompakte, rechteckige Module zu erzeugen.

Diese Platzierungs-Constraints legen auch das Verhältnis von Höhe zu Breite der Module fest. Für verschiedene Kombinationen von Modulen können jedoch unterschiedliche Seitenverhältnisse sinnvoll sein. Ziel dieser Arbeit ist daher die Unterstützung verschiedener Versionen der Module. Da die Auswahl der zu verwendenden Version erst bei der Platzierung getroffen wird, müssen Informationen über die verwendeten Ressourcen schon vorher verfügbar sein, ohne jedoch das komplette Modul laden zu müssen. Daher soll ein Dateiformats zur Speicherung der fertigen Module entwickelt werden.

Student: Dominik Lorych
Supervisor: Kris Heid
Time period: 04/25/2017 - 09/25/2017

Am Fachgebiet Rechnersysteme wird ein SoC-Kit rund um den SpartanMC Soft-Core entwickelt. Dieser ist ein speziell für die Verwendung in FPGAs entwickelter CPU-Core. Aufgrund dieser Zielplattform nutzt der SpartanMC eine Befehls- und Datenbreite von 18 Bit, welche die Strukturen aktueller FPGAs optimal ausnutzt.

Momentan wird daran gearbeitet hoch parallele Multiprozessor System-On-Chips (MPSoC) zu erstellen. Hierfür wird µStreams (ein eigens entwickeltes Parallelisierungs-Tool) genutzt. µStreams nimmt ein gewöhnliches sequenzielles Programm entgegen und parallelisiert dies automatisch. Das erzeugte Many-Core System kommuniziert und synchronisiert sich über 1 zu 1, 1 zu N, N zu 1 Verbindungen, einen Router für Networks-On-Chip (NoC) und einen geteilten Speicher. Das resultierende MPSoC System ist dann eine Verarbeitungspipeline, ähnlich aktueller Prozessorpipelines, nur grob granularer arbeitend.

µStreams ist derzeit in der Lage mehrere Anweisungen, Schleifen oder komplette Funktionen auf einen Task abzubilden. Eine Analyse förderte jedoch zutage, dass einzelne Schleifen oft eine erhebliche Ausführungszeit besitzen, was zum kritischen Schritt in der MPSoC Verarbeitungspipeline werden kann. µStreams besitzt momentan noch keine Automatismen, um diese Schleifen aufzubrechen und noch weiter zu parallelisieren.

Daher soll in dieser Arbeit in µStreams Loop Tiling eingebaut werden. Hierdurch soll beispielsweise eine Schleife, welche zehn Durchläufe besitzt in zwei Schleifen zu je fünf Durchläufen transformiert werden. µStreams ist jetzt in der Lage beide Schleifen auf je einen Task zu packen und somit die Schleifen mit ca. doppelt so hohem Durchsatz auszuführen. Schleifen mit sehr vielen Durchläufen sind somit fast beliebig parallelisierbar.

Die Komplexität beim Loop Tiling liegt allerdings darin, die Grenzen einer Schleife (Start/Abbruchbedingung/Schrittweite) korrekt zu analysieren, um eine Aufteilung in gleich große Teile zu gewährleisten.

Student: Jonas Diegelmann
Supervisor: Kris Heid
Time period: 11/06/2017 - 04/06/2018

Am Fachgebiet Rechnersysteme wird ein SoC-Kit rund um den SpartanMC Soft-Core entwickelt. Dieser ist ein speziell für die Verwendung in FPGAs entwickelter CPU-Core. Aufgrund dieser Zielplattform nutzt der SpartanMC eine Befehls- und Datenbreite von 18 Bit, welche die Strukturen aktueller FPGAs optimal ausnutzt.

Momentan wird daran gearbeitet hoch parallele Multiprozessor System-On-Chips (MPSoC) zu erstellen. Hierfür wird µStreams (ein eigens entwickeltes Parallelisierungs-Tool) genutzt. µStreams nimmt ein gewöhnliches sequenzielles Programm entgegen und parallelisiert dies automatisch. Das erzeugte Many-Core System kommuniziert und synchronisiert sich über 1 zu 1, 1 zu N, N zu 1 Verbindungen, einen Router für Networks-On-Chip (NoC) und einen geteilten Speicher. Das resultierende MPSoC System ist dann eine Verarbeitungspipeline, ähnlich aktueller Prozessorpipelines, nur grob granularer arbeitend.

µStreams ist mit AutoStreams mittlerweile in der Lage, anhand eines Performance-Profils ein Programm in eine (beliebige) Anzahl an Threads aufzuteilen. Hierbei wird lediglich eine Pipeline mit 1:1 Verbindungen aufgebaut. Dies ist die einfachste Variante einer Aufteilung. µStreams besitzt allerdings momentan weitaus mehr ungenutzte Parallelsierungsmechnismen:

• Scheifen (welche möglicherweise die kritische Pipelinestufe bilden) weiter aufteilen, um Aufteilungspunkte besser platzieren zu können und eine ausgewogene Pipeline zu bekommen.
• Bei einer Entscheidung zwischen mehreren möglichen Aufteilungen, den geschätzten Ressourcenverbrauch auf dem FPGA bzw. die maximal mögliche Frequenz mit einzubeziehen.
• Nutzung des replicate Konstrunkts aus µStreams, um kritische Pipelinestufen quasi Superskalar aufzubauen und damit zu entlasten.

Ziel dieser Arbeit soll es daher sein, die bisher ungenutzten Parallelisierungsmechnismen zu integrieren, um das volle Potential von µStreams auszunutzen und optimal zu unterstützen.

Student: Jonas Schoenen
Supervisor: Tobias Schladt
Time period: 04/11/2022 - 09/12/2022

In FPGAs werden zur Speicherung der Konfigurationsdaten SRAM-Speicherzellen verwendet. Diese stellen einen flüchtigen Speicher dar, verlieren also bei Unterbrechung der Spannungsversorgung ihre Information. Deswegen wird an Non-Volatile (NV)-FPGAs geforscht, die nicht-flüchtigen Konfigurationsspeicher besitzen. Eine Möglichkeit, diese zu implementieren, stellen Speicherzellen auf Memristor-Basis dar.

Memristoren sind passive Bauelemente, deren Widerstandswert von der Vorgeschichte des hindurchgeflossenen Stromes abhängt. Aufgrund der additiven Fertigung von Memristor-basierten Speichern ist davon auszugehen, dass ein gewisser Anteil der Speicherzellen fehlerbehaftet ist. Eine einzige defekte Speicherzelle mit undefiniertem Zustand führt dazu, dass klassische Look-up-Tables (LUTs) nur noch zur Hälfte nutzbar sind. Beim Entwurf von Logik-Elementen für NV-FPGAs müssen potentielle Fehler und ihre Auswirkungen also im Sinne einer besseren Fehlertoleranz berücksichtigt werden.

Ziel dieser Arbeit ist es, eine neue Architektur für die Logik-Elemente von NV-FPGAs zu entwerfen und diese auf ihre Fehlertoleranz hin zu evaluieren.

Student: Stefan Reichel
Supervisor: Tobias Schwarz
Time period: 11/02/2023 - 01/25/2024

In FPGAs werden zur Speicherung der Konfigurationsdaten SRAM-Speicherzellen verwendet. Diese stellen einen flüchtigen Speicher dar, verlieren also bei Unterbrechung der Spannungsversorgung ihre Information. Deswegen wird an Non-Volatile (NV)-FPGAs geforscht, die nicht-flüchtigen Konfigurationsspeicher besitzen. Eine Möglichkeit, diese zu implementieren, stellen Speicherzellen aus Memristoren dar.

Memristoren sind passive Bauelemente, deren Widerstandswert von der Vorgeschichte des hindurchgeflossenen Stromes abhängt. Aufgrund der additiven Fertigung von Memristor-basierten Speichern ist davon auszugehen, dass ein gewisser Anteil der Speicherzellen defektbehaftet ist. Diese potentiellen Defekte müssen in Architekturentwurf für NV-FPGAs berücksichtigt werden.

Ziel dieser Arbeit ist es, eine alternative Architektur für die Switchbox-Elemente im Routing-Netzwerk von FPGAs zu entwickeln. Gegenüber der traditionellen Architektur soll diese eine verbesserte Toleranz gegenüber defekten Zellen des Konfigurationsspeichers aufweisen.

Student: Lukas Freiberger
Supervisor: Tobias Schladt
Time period: 11/15/2021 - 02/07/2022

In FPGAs werden zur Speicherung der Konfigurationsdaten SRAM-Speicherzellen verwendet. Diese stellen einen flüchtigen Speicher dar, verlieren also bei Unterbrechung der Spannungsversorgung ihre Information. Deswegen wird an Non-Volatile (NV)-FPGAs geforscht, die nicht-flüchtigen Konfigurationsspeicher besitzen. Eine Möglichkeit, diese zu implementieren, stellen Speicherzellen auf Memristor-Basis dar.

Memristoren sind passive Bauelemente, deren Widerstandswert von der Vorgeschichte des hindurchgeflossenen Stromes abhängt. Aufgrund der additiven Fertigung von Memristor-basierten Speichern ist davon auszugehen, dass ein gewisser Anteil der Speicherzellen fehlerbehaftet ist. Diese potentiellen Fehler müssen bei der Logiksynthese für NV-FPGAs beachtet werden.

Ziel dieser Arbeit ist es, fehlerbehaftete Routing-Elemente in den Logiksynthese-Prozess des Tools "Versatile Place and Route" (VPR), das Teil der Toolchain "Verilog-to-Routing" (VTR) ist, zu integrieren. Anschließend soll die Auswirkung der Fehler auf das Routing evaluiert werden.

Student: Tobias Steinbach
Supervisor: Tobias Schladt
Time period: 10/01/2021 - 12/27/2021

In FPGAs werden zur Speicherung der Konfigurationsdaten SRAM-Speicherzellen verwendet. Diese stellen einen flüchtigen Speicher dar, verlieren also bei Unterbrechung der Spannungsversorgung ihre Information. Deswegen wird an Non-Volatile (NV)-FPGAs geforscht, die nicht-flüchtigen Konfigurationsspeicher besitzen. Eine Möglichkeit, diese zu implementieren, stellen Speicherzellen auf Memristor-Basis dar.

Memristoren sind passive Bauelemente, deren Widerstandswert von der Vorgeschichte des hindurchgeflossenen Stromes abhängt. Aufgrund fehlender Erfahrungen mit der Integration von Memristor-basierten Speichern ist davon auszugehen, dass ein gewisser Anteil der Speicherzellen fehlerbehaftet ist. Diese potentiellen Fehler müssen bei der Logiksynthese für NV-FPGAs beachtet werden.

Ziel dieser Arbeit ist es, fehlerbehaftete Look-Up-Tables (LUTs) in den Logiksynthese-Prozess des Tools "Versatile Place and Route" (VPR), das Teil der Toolchain "Verilog-to-Routing" (VTR) ist, zu integrieren.

Student: Mohamed Saleh
Supervisor: Tobias Schwarz
Time period: 04/18/2023 - 09/19/2023

Am Fachgebiet Rechnersysteme wird ein Verfahren zur Abbildung digitaler Entwürfe auf FPGA-Technologie entwickelt, das Binary Decision Diagrams (BDDs) als Zwischendarstellung nutzt. Ein entscheidender Faktor für die Laufzeit des Verfahrens ist die Performanz der BDD-Erzeugung. Aktuell wird eine in Kotlin geschriebene Bibliothek verwendet, die aus in BLIF beschriebenen Entwürfen BDDs generiert. Diese weist für Funktionen mit vielen Variablen eine sehr große Laufzeit auf, was die Abbildung von komplexen Entwürfen erschwert oder verhindert.

Das Ziel dieser Bachelorarbeit ist die Optimierung der BDD-Bibliothek, sodass diese auch aus komplexen Entwürfen BDDs generieren kann. Für die Bearbeitung sind Vorkenntnisse in Kotlin sowie sehr gute Programmierkenntnisse gute Voraussetzungen.

Student: Niklas Mertens
Supervisor: Johanna Rohde
Time period: 10/30/2020 - 01/29/2021

Ein Forschungsprojekt am Fachgebiet Rechnersysteme der TU Darmstadt befasst sich mit der automatischen Erzeugung von Hardwarebeschleunigern. Das entwickelte GCC-Plugin (PIRANHA) führt dazu eine statische Programmanalyse des Programmcodes durch und wählt eigenständig die Schleifen aus, die voraussichtlich die größte Ausführungszeit benötigen. Anschließend wird deren Funktionalität mit Hilfe einer High Level Synthese (HLS) als Hardwarebeschleuniger implementiert.

Der verfolgte Ansatz ist unabhängig vom Prozessor, an welchen die Beschleuniger angeschlossen werden. Gegenwärtig steht dafür unter anderem der MicroBlaze von Xilinx zur Verfügung.

Derzeit unterstützt PIRANHA nur Integer-Rechnung, obwohl der MicroBlaze an sich auch Floating Point Operationen verarbeiten kann. Dies hat zur Folge, dass potentielle Kernel, welche mit Floats arbeiten, nicht beschleunigt werden können.

Ziel dieser Bachelorarbeit ist es, den Floating Point Support in das PIRANHA HLS Plugin zu implementieren. Dafür ist die Operatorbibliothek sowohl Hardware- als auch Softwareseitig zu erweitern. Passende Implementierung von Floating Point Operationen stehen am FG Rechnersysteme zur Verfügung.

Student: Mehmet Can Kivanc
Supervisor: Jonas Gehrunger
Time period: 04/24/2023 - 09/25/2023

Es gibt zahlreiche Formate, um Zahlen mit Nachkommastellen darzustellen. Am häufigsten sind dabei Fließkommazahlen nach der IEEE 754 Norm anzutreffen. Diese Darstellung hat allerdings mehrere Nachteile, die die alternative Darstellung Posit interessant machen. Posits können etwa bei gleicher Breite einen größeren Wertebereich und eine bessere Präzision abbilden. Vorhandene Hardware-Implementationen wie z.B. PACoGen benötigen bisher im Vergleich allerdings fast die doppelte Fläche.

Daher soll in dieser Arbeit die vorhandene Hardware-Implementation PACoGen angepasst werden, um nur diskrete Regime-Breiten zu unterstützen. Dies reduziert die Komplexität der erzeugten Hardware und damit die benötigte Fläche, schränkt aber auch den Wertebereich ein. Dieser Trade-Off soll genauer untersucht werden.

Student: Felix Hübner
Supervisor: Boris Dreyer
Time period: 09/15/2015 - 12/15/2015

Das Fachgebiet Rechnersysteme bietet seit dem Sommersemester 2014 das Digitaltechnische Praktikum wieder an. Während des Digitaltechnischen Praktikums setzen sich Studenten mit dem MP3-Verfahren zum Kodieren und Dekodieren von Audio-Signalen intensiv auseinander und implementieren einen Teil der Dekodierungslogik. Zur effizienten Verarbeitung der MP3-Frames innerhalb des FPGAs geschieht diese mittels Festkommaarithmetik. Dies führt zu Rundungsfehlern mit entsprechender Auswirkung auf die Klangqualität.

Ziel dieser Arbeit ist die Implementierung eines MP3-Players zur Untersuchung der Korrelation zwischen Klangqualität und unterschiedlich präzisen Festkommadarstellungen. Hierzu soll der Player in C implementiert und die Genauigkeit der Festkommadarstellung parametrierbar gewählt werden können.

Student: Katja Münch
Supervisor: Tobias Schladt
Time period: 07/29/2019 - 10/28/2019

Das Ziel der Synthetischen Biologie ist es, biochemische Systeme von Grund auf neu zu entwickeln. Dabei spielen neben biologischen und chemischen Verfahren Methoden aus den Ingenieurswissenschaften und der Informationstechnik eine entscheidende Rolle. So wird unter anderem daran geforscht, digitale Schaltungen auf Basis genetischer Mechanismen in biologischen Zellen zu implementieren.

Für die Logiksynthese kommen dabei bisher vor allem Verfahren zum Einsatz, die nicht an die Rahmenbedingungen genetischer Schaltkreise angepasst sind. So ist die Bibliothek zur Verfügung stehender Logikgatter stark eingeschränkt und es kommt zu biochemischen Wechselwirkungen zwischen einzelnen Bausteinen. Ein Ansatz zur Lösung dieses Problems ist es, alle Implementierungen einer kombinatorischen Funktion aufzuzählen und die gefundenen Gatterschaltungen später zu bewerten.

Für die Erzeugung von Implementierungsvarianten wird aktuell ein boolesches Matching-Verfahren in Verbindung mit einer Bibliothek aus "Supergates" verwendet. Diese stellen (Teil-)Schaltungen dar, die aus Kombinationen der zur Verfügung stehenden primitiven Gatter generiert werden. Dabei verfügen die erzeugten Supergates nicht über internes Fanout, Logik wird also innerhalb eines Supergates nicht wiederverwendet. Das Ziel dieser Arbeit ist die Implementierung eines Verfahrens zur Optimierung der Supergate-Bibliothek, sodass Teile der Schaltungen wenn möglich wiederverwendet werden.

Student: Daniel Stein
Supervisor: Ramon Wirsch
Time period: 10/13/2022 - 04/12/2023

Am Fachgebiet Rechnersysteme werden Hardware-Beschleuniger unter anderem für einen RISC-V Prozessor entwickelt. Hierzu sollen reguläre Programme ohne jegliche Anpassungen an den Hardware-Beschleuniger zur Laufzeit analysiert und partiell mit diesem ausgeführt werden können.

Es existiert bereits ein FPGA-basiertes SoC inklusive des Beschleunigers. Bei der Entwicklung hat sich aber ein Flaschenhals an den Speicherschnittstellen des Beschleunigers herausgestellt. Um Fehlerfreiheit bei Cache-/Speicherzugriffen zu garantieren, dürfen Zugriffe zur Zeit nicht parallel ausgeführt werden.

Im Rahmen dieser Arbeit soll sowohl der Scheduler, als auch die Hardware um Möglichkeiten für eine neue Synchronisierung ergänzt werden. Der Scheduler soll Speicheroperationen gesondert betrachten und Wege bereitstellen, wie ihm potentielle Konflikte, Überlappungen oder auch garantierte Konfliktfreiheit zwischen Speicherzugriffen mitgeteilt werden können. Der Scheduler muss dann die Zugriffe so auf die verschiedenen Speicherzugriffseinheiten und Caches verteilen, dass Konflikte ausgeschlossen werden können. Für den Fall, dass es nicht möglich ist Konflikte statisch auszuschließen, soll der Scheduler granulare "Speicherbarrieren" einsetzen, die warten, bis die potentiell in Konflikt stehenden Transaktionen vollständig abgeschlossen wurden.

Für die Umsetzung dieser Barrieren muss die Hardware erweitert werden. Eine bedingte Umsetzung, bei der zur Laufzeit auf Konflikte getestet wird, um die Anzahl an Stalls zur Vermeidung von Konflikten zu reduzieren, könnte gerwinnbringend sein.

Weiterhin sollen bei diesen Änderungen auch verwandte Probleme gelöst werden. Cache-Prefetch Operationen brauchen nur geschedulet werden, wenn sie in den Schedule passen ohne diesen signifikant zu verlängern. Die Adressberechnung, bestehend aus Basisadresse und Offset findet aktuell als Teil des Speicherzugriffes statt und liegt auf dem kritischen Pfad. Gerade weil die finale Addresse aber eventuell für Überlackungschecks zur Laufzeit benötigt werden, macht es unter Umständen Sinn, diese Berechnung als getrennte Operation auszulagern, dies hängt aber von der Umsetzung der bedingten Speicherbarrieren ab.

Student: Daniel Trigo
Supervisor: Dennis Wolf
Time period: 10/01/2019 - 03/31/2020

Ein Coarse Grained Reconfigurable Array (CGRAs) ist Schaltung, die als Hardwarebeschleuniger eingesetzt wird. Einzelne Rechenzellen verarbeiten entsprechend eines im voraus definierten Operationsplans (Scheduling) Daten massiv parallel. Die individuelle Komposition eines CGRAs (Selektion an Operationen der einzelnen Rechenzellen, deren Anzahl und Verbindung untereinander etc.) kann entsprechend mehrerer Beispielapplikationen für eine Anwendungsdomäne optimiert werden. Da die Erzeugung einer optimalen Komposition dabei aufgrund der Komplexität nicht mehr möglich ist, werden heuristische Optimierungsverfahren genutzt

Am Fachgebiet Rechnersysteme wird an solchen Optimierungsverfahren geforscht. Um die Herausforderungen der Optimierungen besser zu verstehen und optimierte CGRAs gegeneinander evaluieren zu können, müssen diese quantitativ verglichen werden. Im Rahmen dieser Arbeit soll ein Tool umgesetzt werden, das CGRAs (z.B. auf Graphenbasis) vergleichen kann. Dabei soll bei einem Vergleich der Fokus auf verschiedene Eigenschaften gelegt werden können (z.B. Parallelität oder Operationsverteilung).

Student: Mario Wetzel
Supervisor: Tajas Ruschke
Time period: 11/04/2019 - 06/04/2020

Student: Felix Hübner
Supervisor: Ramon Wirsch
Time period: 10/19/2020 - 04/19/2021

Am Fachgebiet Rechnersysteme werden Hardwarebeschleuniger für eine Reihe von Architekturen entwickelt, unter anderem für die RISC-V Architektur. Hierzu sollen reguläre Programme zur Laufzeit analysiert und partiell mit dem Hardwarebeschleuniger ausgeführt werden können, ohne dass sie hierzu vorher angepasst werden müssen.

Um diese Verfahren zu testen und zu demonstrieren, soll ein vollständiges, lauffähiges System bestehend aus einem RISC-V Prozessor und unserem CGRA-Hardwarebeschleuniger auf einem FPGA gebaut werden. Dafür soll eine für FPGAs geeignete existierende RISC-V Implementierung ausgewählt werden.

Für ein lauffähiges System muss insbesondere der Beschleuniger cache-kohärenten Speicherzugriff auf den RAM erhalten, sowie als Peripherie an den Prozessor angebunden werden. Dies umfasst auch die Auswahl geeigneter Methoden zu Anbindung, sowie das Schreiben von Treibern, die Hardware spezifische Eigenheiten möglichst abstrahieren.

Student: Simon Vetter
Supervisor: Ramon Wirsch
Time period: 07/05/2021 - 01/03/2022

Am Fachgebiet Rechnersysteme werden eine Reihe von Architekturen mitteles Coarse-Grained Reconfigurable Arrays (CGRAs) beschleunigt. Hierbei sollen reguläre Programme zur Laufzeit analysiert und partiell mit dem Hardwarebeschleuniger ausgeführt werden können, ohne dass sie vorher dafür angepasst werden müssen.

Es existiert bereits ein Demonstator auf FPGA-Basis für das CGRA zusammen mit einem RISC-V Prozessor. Allerdings ist die Cache- und Speicher-Anbindung des CGRAs noch nicht ausgereift oder optimiert. Auch fehlt die Unterstützung von Prefetching von Speicherinhalten für das CGRA, so dass regelmäßig gestalled wird, weil sich Speicherinhalte noch nicht in den Caches befinden.

Ein Vorläufer des aktuellen CGRAs hatte bereits Prefetching-Support in Kombination mit dem AMIDAR-Prozessor. Durch den Wechsel der Host-Architektur hin zu RISC-V und einer grundlegenden Aktualisierung des CGRAs ist diese Funktionalität verloren gegangen und soll jetzt nachgerüstet werden.

Student: Jonas Diegelmann
Supervisor: Ramon Wirsch
Time period: 06/21/2021 - 12/20/2021

Am Fachgebiet Rechnersysteme werden eine Reihe von Architekturen mittels Coarse-Grained Reconfigurable Arrays (CGRAs) beschleunigt. Hierbei sollen reguläre Programme zur Laufzeit analysiert und partiell mit dem Hardwarebeschleuniger ausgeführt werden können, ohne dass sie vorher dafür angepasst werden müssen.

Das CGRA wurde ursprünglich für auf Java Bytecode basierende Architekturen entwickelt. Leider hat sich die aktuelle Umsetzung der Bedingungslogik (CBOX) für native Befehlssätze wie RISC-V als Flaschenhals herausgestellt. Limitierend sind hier unter anderem, wie viele Bedingungen effizient gleichzeitig ausgeliefert werden können. Außerdem können nur strikt geschachtelte Bedingungen auf der CBOX umgesetzt werden. Komplexere boolesche Logik muss im Kontrollflussgraphen (CFG) explizit umgeschrieben werden, um auf andere, breitere Einheiten (PEs) ausgelagert zu werden.

Der Scheduler enthält aktuell noch Sonderbehandlungen für die CBOX, die bei einem Neuentwurf vermieden werden könnten. Weiterhin werden bestimmte Features der Hardware zur Verkürzung von kritischen Pfaden vom aktuellen Scheduler noch nicht unterstützt.

Im Rahmen dieser Arbeit soll die Bedingungslogik des CGRAs neu entworfen werden. Sie soll dabei modularer und besser auf die Struktur von konventionellen Befehlssätzen und die Struktur der vorhanden CFGs angepasst werden.

Student: Marcel Heinlein
Supervisor: Ramon Wirsch
Time period: 10/31/2019 - 05/01/2020

Am Fachgebiet Rechnersysteme werden Hardwarebeschleuniger für eine Reihe von Architekturen entwickelt, unter anderem für RISC-V, IBM Z und auf Java-Bytecode-basierende Architekturen. Hierzu sollen reguläre Programme ohne jegliche Anpassungen an den Hardwarebeschleuniger zur Laufzeit analysiert und partiell mit dem Hardwarebeschleuniger ausgeführt werden können.

Die Synthesetools des Hardwarebeschleunigers benötigen zur Zeit Kontroll- und Datenflussgraphen (CDFGs) als Eingabedaten. Diese wurden bisher für jede Prozessorarchitektur speziell erstellt und bedeuten einen hohen Portierungsaufwand zum Unterstützen neuer Architekturen.

Um einfacher andere Architekturen zu unterstützen, sollen in Zukunft Quell-Architektur-unabhängige Kontrollflussgraphen (CFGs) als Eingabedaten verwendet werden. Diese Graphen können dann, unabhängig von der ursprünglichen Prozessorarchitektur großteilig mit üblichen Compiler-Methoden optimiert werden und anschließend zu CDFGs für den Hardwarebeschleuniger transformiert werden.

Ziel dieser Arbeit ist es eine Vorgehensweise für diese Optimierungen und Konvertierungen zu entwickeln und zu implementieren die insbesondere mit den 3 vorhandenen Quell-Architekturen umgehen kann und möglichst optimale Ergebnisse liefert.

Student: Johannes Klöhn
Supervisor: Ramon Wirsch
Time period: 11/09/2020 - 05/17/2021

Am Fachgebiet Rechnersysteme werden Hardwarebeschleuniger für eine Reihe von Architekturen entwickelt. Hierzu sollen reguläre Programme zur Laufzeit analysiert und partiell mit dem Hardwarebeschleuniger ausgeführt werden können, ohne dass sie vorher dafür angepasst werden müssen.

Eine erste Fassung dieses Verfahrens läuft bereits. Assemblercode wird dabei zur Laufzeit in einen Kontrollflussgraphen (CFG) eingelesen und mithilfe einer Sammlung von Optimierungspasses für den Hardwarebeschleuniger optimiert. Zurzeit werden allerdings noch alle Schreibzugriffe auf den Speicher in der originalen Reihenfolge ausgeführt und limitieren somit die möglichen Optimierungen. Dies ist nötig, da eine andere Reihenfolge potentiell zu falschen Ergebnissen kommen kann, wenn manche Speicherzugriffe überlappen.

Als Teil dieser Arbeit soll eine Points-To Analyse entwickelt werden, die auf Basis der existierenden CFGs versucht Überlappungen in Speicherzugriffen zu identifizieren. Diese Analyse soll möglichst unabhängig vom zugrunde liegenden Assembler-Befehlssatz sein, so dass sie auf den verschiedenen unterstützten Architekturen funktioniert und auch in der Lage sein, ähnliche Informationen zu verwenden, wie sie normalerweise vom Compiler bereitgestellt werden.

Die gewonnenen Informationen sollen anschließend genutzt werden, um die Reihenfolge von Speicherzugriffen zu lockern. Weiterhin kann in Fällen in denen Aliasing nicht ausgeschlossen werden kann, Spekulative Ausführung angewendet werden. Hier wird erst während der Ausführung eines Codeabschnittes auf Überlappung getestet und dann nur die dazu passende Variante des Abschnittes ausgeführt.

Student: Lars Stein
Supervisor: Dennis Wolf
Time period: 03/02/2020 - 08/30/2020

Ein Coarse Grained Reconfigurable Array (CGRA) ist ein Hardwarebeschleuniger, in dem einzelne Rechenzellen entsprechend eines im voraus definierten Operationsplans (Scheduling) Daten massiv parallel verarbeiten.

Eines unserer Forschungsthemen ist die Heterogenität von CGRAs. Um dies möglich zu machen, wurde ein Framework realisiert, mit dem beliebig heterogene und irreguläre CGRA modelliert werden können. Dieses Modell ist auch die Grundlage für das Scheduling und dient als Input um Verilog Code zu erzeugen.

Da die jetzige Modellierung nicht flexibel genug ist und Änderungen an der Mikroarchitektur vorgenommen wurden wird das gesamte Framework neu implementiert. Basierend auf der Erfahrung der letzten Jahre wurde beschlossen ein generisches Ressourcen basiertes Modell umzusetzen. Dabei soll auch untersucht werden, wie sich verschiedene Datenpfadbreiten auf die Performance des CGRA auswirken.

Die Arbeit besteht aus zwei Teilen. Zum einen soll das Framework angepasst werden, so dass Datenpfadbreite parametrisierbar ist. Somit müssen Funktionen des Ressourcen Models angepasst werden und die automatisierte Generierung von Verilog vervollständigt werden. Zum anderen soll neben funktionalen Tests vor allem eine detaillierte Evaluation durchgeführt werden.

Student: Julian Käuser
Supervisor: Tajas Ruschke
Time period: 05/02/2019 - 11/04/2019

Student: Sebastian Kleemann
Supervisor: Ramon Wirsch
Time period: 11/21/2022 - 05/22/2023

Am Fachgebiet Rechnersysteme werden Coarse Grained Reconfigurable Array Beschleuniger unter anderem für einen RISC-V Prozessor entwickelt. Hierzu sollen reguläre Programme ohne jegliche Anpassungen an den Hardware-Beschleuniger zur Laufzeit analysiert und partiell mit diesem ausgeführt werden können.

Der Prozessor verfügt bereits über eine Fließkommaimplementierung auf Basis von optimierten FloPoCo-Operatoren. Das CGRA beherrscht auch bereits Fließkommazahlen, allerdings mit einer im Fließkommaformat konfigurierbaren, aber für aktuelle Zwecke ineffizienten Fließkommaimplementierung. Für eine bessere Vergleichbarkeit zwischen CGRA und Prozessor, um so besser eine Beschleunigung mittels CGRA aufgrund von Parallelisierung nachzuweisen, soll der CGRA an den Prozessor angeglichen werden.

Hierzu muss das FloPoCo-Framework um noch fehlende Funktionalität erweitert werden. Alle Single-Precision Fließkommaoperationen auf dem CGRA sollen dann durch FloPoCo-Varianten ersetzt werden. Für eine optimale Nutzung mit FloPoCo sollen die Registerfiles des CGRAs, wie beim Prozessor verbreitert werden. Zusammen mit der Inbetriebnahme von gepipelinten Registerfiles sollten sich so die meisten Flaschenhälse des CGRAs gelöst werden und das CGRA deutlich höhere Frequenzen erreichen.

Student: Christoph Spang
Supervisor: Dennis Wolf
Time period: 11/19/2018 - 05/18/2019

Ein Coarse Grained Reconfigurable Array (CGRA) ist ein Hardwarebeschleuniger, in dem einzelne Rechenzellen entsprechend eines im voraus definierten Operationsplans (Scheduling) Daten massiv parallel verarbeiten. Die individuelle Auslegung eines CGRAs (u.a. die Selektion der Operationen der einzelnen Rechenzellen, deren Anzahl und Verbindung untereinander) ist generisch und im Einzelfall entscheidend für die Laufzeit einzelner Applikationen.

Entsprechend mehrerer Beispielapplikationen kann die Komposition eines CGRAs für eine Anwendungsdomäne optimiert werden. Die Erzeugung einer nachweislich optimalen Komposition ist dabei aufgrund der Komplexität nicht mehr möglich. In solchen Fällen werden heuristische Optimierungsverfahren genutzt. Für diese Verfahren liegen zwei der drei relevanten Qualitätsmaße in der möglichen Taktfrequenz und den benötigten Ressourcen einer CGRA Instanz. Da ein Syntheselauf zu deren Bestimmung im Stundenbereich liegen kann, muss eine Schätzung genutzt werden.

Im Rahmen dieser Arbeit soll ein Verfahren implementiert werden, das automatisch den längsten Pfad beliebiger CGRAs schätzt. Wird der längste Pfad richtig bestimmt, kann mit diesen Informationen die Genauigkeit bereits bestehender Schätzfunktionen des längsten Pfades verbessert werden.

Student: Laleh Janipour
Supervisor: Tajas Ruschke
Time period: 08/16/2016 - 02/16/2017

Am Fachgebiet Rechnersysteme wird momentan an einer CGRA-Architektur geforscht, die zur Beschleunigung des Programmablaufs verwendet werden soll.

Damit ein Programmteil auf das CGRA abgebildet werden kann, muss ein Scheduler die Problemgraphen auf die Ziel-Hardware abbilden. Dabei müssen verschiedene Abhängigkeiten berücksichtigt werden, um den korrekten Programmablauf zu gewährleisten. Die Erstellung der Problemgraphen geschieht bisher aus Java Bytecode. Zur Demonstration und zum Test weiterer Benchmarks ist eine Generierung von Graphen aus C-Code wünschenswert.

Ziel dieser Arbeit ist das Design und die Implementierung eines Graphgenerators, welcher Kontroll- und Datenflussinformationen sowie die ausgeführten Operationen in das am Fachgebiet verwendete Graphformat überführt. Dabei sollen auch einfache Schleifen übergreifende Abhängigkeiten berücksichtigt werden.

Student: Hengxin Zhou
Supervisor: Tajas Ruschke
Time period: 05/16/2016 - 11/15/2016

Student: Lukas Jäger
Supervisor: Dennis Wolf
Time period: 04/07/2016 - 10/07/2016

Coarse Grained Reconfigurable Arrays (CGRA) sind Schaltungen, die zumeist als Hardwarebeschleuniger eingesetzt werden. Einzelne Rechenzellen verarbeiten entsprechend eines im voraus definierten Operationsplans (Scheduling) Daten massiv parallel. Das Operationssprektrum der einzelnen Rechenzellen sowie die Verbindung untereinander sind generisch und im Einzelfall entscheidend für die Laufzeit einzelner Applikationen.

In dem Projekt "UltraSynth" soll entsprechend mehrerer Beispielapplikationen ein CGRA für die entsprechende Anwendungsdomäne automatisiert erstellt und implementiert werden. Die Erzeugung einer optimalen CGRA Komposition (bzgl. Anzahl an Rechenzellen und deren Operationsspektrum) ist dabei aufgrund der Komplexität nicht mehr möglich. In solchen Fällen werden Heuristiken genutzt, die darauf setzen ein nicht optimales aber ausreichend gutes Ergebnis zu liefern. Für das vorliegende Optimierungsproblem kann eine Heuristik der evolutionären Algorithmen (EA) genutzt werden. Dazu ist eine Schätzung der benötigten Resourcen und des maximalen Taktes auf einem FPGA notwendig, da diese weitere Kostenfunktionen eines EA darstellen - neben der Laufzeit eines Programmes auf der Komposition. Dies soll außerdem sicher stellen, dass unnötige Synthese- und Implementierungsvoränge minimiert oder gar vermieden werden können.

Diese Arbeit ist in mehrere Schritte unterteilt. Zuerst soll aufbauend auf exemplarischen Implementierungen ein Schätzer des Resourcenverbrauchs und der maximalen Taktfrequenz realisiert werden. Mit Hilfe der insgesamt 3 Kostenfunktionen soll dann ein passender evolutionärer Algorithmus umgesetzt werden. Im besten Fall soll zuletzt eine Senkung der Laufzeit erreicht werden, indem anhand der gegebenen Applikationen Parameter der Heuristik automatisch kalibriert werden.

Student: Sebastian Focke
Supervisor: Tajas Ruschke
Time period: 02/06/2017 - 08/07/2017

Student: David Winter
Supervisor: Tajas Ruschke
Time period: 12/19/2016 - 06/19/2017

Am Fachgebiet Rechnersysteme wird momentan an einer CGRA-Architektur geforscht, die zur Beschleunigung des Programmablaufs verwendet werden soll.

Ziel dieser Arbeit ist das Design und die Implementierung eines Scheduling-Verfahrens, welches das Problem durch einen iterativen Ansatz löst. Dabei sollen Erkenntnisse aus vorhergehenden Scheduling-Läufen in die nächste Iteration einfließen.

Student: Aljoscha Mazur
Supervisor: Dennis Wolf
Time period: 11/01/2018 - 05/31/2019

Ein Coarse Grained Reconfigurable Array (CGRA) ist ein Hardwarebeschleuniger, in dem einzelne Rechenzellen entsprechend eines im voraus definierten Operationsplans (Scheduling) Daten massiv parallel verarbeiten. Auf Hardwareebene ist für die Performance des CGRAs neben der strukturellen Auslegung der Rechenzellen, vor allem die genutzte Operatorbibliothek entscheidend. Diese ist das Herzstück zur Generierung der ALUs aller Rechenzellen in Verilog.

Der Generator sieht vor, dass jede Operation als eigenständiges Modul instantiiert wird. Dies hat Vorteile bei der Parallelisierung von Anwendungen, benötigt aber unverhältnismäßig viel Ressourcen. Operationen wie Addition und Subtraktion oder Division und Modulo können zusammengeführt werden und reduzieren folglich die benötigten Hardware-Ressourcen auf fast die Hälfte. Außerdem soll die Operation MAC implementiert werden.

Ziel dieser Arbeit ist Optimierung der Bibliothek durch das Zusammenführen von Operationen. Dabei gilt es, sinnvolle Zusammenführung zu finden, diese umzusetzen und in das Backend ein zu pflegen. Abschließend soll eine ausführliche Evaluation durchgeführt werden.

Student: Ashkan Ashooripour Moghadam
Supervisor: Dennis Wolf
Time period: 10/10/2016 - 04/09/2017

Ein Coarse Grained Reconfigurable Array (CGRA) ist eine Schaltung, die zumeist als Hardwarebeschleuniger eingesetzt werden. Einzelne Rechenzellen verarbeiten entsprechend eines im voraus definierten Operationsplans (Scheduling) Daten massiv parallel. Das Operationsspektrum der einzelnen Rechenzellen sowie die Verbindung untereinander sind generisch und im Einzelfall entscheidend für die Laufzeit einzelner Applikationen.

In dem Projekt "UltraSynth" soll entsprechend mehrerer Beispielapplikationen ein CGRA für die entsprechende Anwendungsdomäne automatisiert erstellt und implementiert werden. Die Erzeugung einer optimalen CGRA Komposition (bzgl. der Anzahl an Rechenzellen und deren Operationsspektrums) ist dabei aufgrund der Komplexität nicht mehr möglich. In solchen Fällen werden Heuristiken genutzt, die darauf setzen ein nicht zwingend optimales aber ausreichend gutes Ergebnis zu liefern. Diese Heuristiken benötigen mindestens eine Kostenfunktionen. In diesem Fall finden sich zwei der drei relevanten Kosten in der möglichen Taktfrequenz und den benötigten Ressourcen einer CGRA Instanz. Da ein Synthesevorgang einer CGRA Beschreibung im Minuten- oder Stundenbereich liegen kann, wurde ein neuronales Netz entwickelt, das beide Kosten schätzt. Dieses Erstellen und Anlernen des Netzes wurde bereits automatisiert

Im Rahmen dieser Arbeit soll in Kooperation mit dem Fachgebiet "Regelungsmethoden und Robotik" das neuronale Netz überarbeitet werden. Dabei gilt es nicht nur die Ergebnisqualität zu verbessern, sondern auch den Automatismus zur Erstellung eines Netzes in seiner Anwendbarkeit auf ganze Technologiefamilien zu erweitern. Ein möglicher Ansatz ist der Einsatz eines evolutionären Algorithmus' zur Findung einer gut geeigneten Topologie des Netzes.

Student: Abhishek Sirsikar
Supervisor: Tajas Ruschke
Time period: 09/30/2017 - 04/09/2018

Am Fachgebiet Rechnersysteme wird momentan an einer CGRA-Architektur geforscht, die zur Beschleunigung des Programmablaufs verwendet werden soll.

Ziel dieser Arbeit ist das Design und die Implementierung eines Scheduler-Verfahrens, welches den Graphen in umgekehrter Reihenfolge bearbeitet und dabei alle Einschränkungen berücksichtigt.

Student: Philip Gottschling
Supervisor: Prof. Dr.-Ing. Christian Hochberger
Time period: 06/16/2014 - 12/15/2014

Moderne Mikrocontroller können über Trace-Schnittstellen wie z.B. Nexus enorme Datenmengen an externe Beobachter weitergeben. Neben Instruktions- und partiell auch Daten-Traces stehen dabei auch abstraktere Informationen, wie z.B. Ownership (welcher Prozess wird gerade ausgeführt) oder sogar anwendungsgetriebene Nachrichten zur Verfügung.

Im Rahmen dieser Master-Arbeit soll ein Werkzeug entstehen, welches die Überprüfung solcher Nachrichten vereinfacht. Dazu soll eine formale Sprache zur Beschreibung einer Finite State Machine entworfen werden. Diese Beschreibung gliedert sich in einen strukturellen Teil und eine Beschreibung des Verhaltens.

Student: Thomas Ballenthin
Supervisor: Boris Dreyer
Time period: 10/15/2015 - 03/15/2016

Für die Korrektheit von sicherheitskritischen eingebetteten Systemen ist es nicht nur wichtig, dass Programme korrekte Ergebnisse berechnen, sondern dass sie diese auch rechtzeitig liefern. Um dies sicherzustellen, muss die Worst Case Execution Time (WCET) des Programms bestimmt werden. Die WCET eines Programms setzt sich aus der WCET von einzelnen Basic Blocks (BB) zusammen. Ein BB ist eine nicht verzweigende Sequenz von Instruktionen. Ein Programm besteht daher aus hunderttausenden von BBs, die aus nur wenigen Instruktionen bestehen können.

Mittels dynamischer Programmanalyse kann die WCET und weitere Zeiten eines Programms gemessen werden. Hierbei wird die Ausführungszeit eines jeden einzelnen BBs gemessen und eine Statistik geführt. Ein Modul, welches diese Messungen durchführt ist bereits vorhanden.

Ziel dieser Arbeit ist der Entwurf und die Implementierung eines Statistik-Moduls, basierend auf einem Histogramm. Hierzu erhält das Modul die gemessenen Ausführungszeiten der BBs und aktualisiert daraufhin entsprechend das Histogramm.

Student: Ammar Obaid
Supervisor: Prof. Christian Hochberger/extern
Time period: 02/15/2013 - 08/14/2013

• Implementation of a tool for code instrumentation. The tool can either work on source or on object level. It should be developed on the basis of existing tools.
• Application of this tool to generate instrumentation that uses the ITM (Instrumentation Trace Macrocell) of Cortex M3 processors to compute the code coverage of an application
• Application of the tool to generate a different instrumentation that does not require the ITM, but rather uses regular code trace features on a Cortex R4
• Evaluation of the overhead of both methods. For this purpose sample applications have to be implemented on both platforms. These sample applications should span the range from completely control flow dominated code to completely computation dominated code.

Student: Frédéric Peignet
Supervisor: Prof. Dr. Christian Hochberger
Time period: 02/11/2013 - 08/09/2013

• Inbetriebnahme der Trace-/Debug-Einheit im QorIQ P4080 Prozessor
• Implementierung einer Aurora-Schnittstelle in einem FPGA, um Trace-Daten entgegen nehmen zu können
• Erweiterung der Nexus-Implementierung, um empfangene Trace-Daten auswerten zu können

Student: Raphael Nißl
Supervisor: Philip Gottschling
Time period: 09/01/2016 - 02/28/2017

Ein Teilaspekt des CONIRAS-Projekts umfasst die automatische Überlagerung und anschließende Synthese von Datenflussgraphen. Damit wird erreicht, dass verschiedene Aufgaben in einem konfigurierbaren Verilog-Modul implementiert werden können. Um danach ein bestimmtes Problem auf die bereits synthetisierte Hardware abbilden zu können, muss entsprechend der korrekte Pfad durch den überlagerten Datenflussgraph gefunden werden. Damit reduziert sich die Wartezeit beim Wechsel zwischen Aufgaben oder einzelnen Werten innerhalb einer Aufgabe von Minuten (Syntheseprozess) auf Sekundenbruchteile.

In der derzeitigen Implementierung der Superposition lassen sich mindestens alle Ausgangsprobleme auf die kombinierten Hardware abbilden. Durch die Überlagerung und abschließendes Postprocessing wird der Raum abbildbarer Probleme allerdings noch deutlich erweitert. Nicht immer ist die Möglichkeit der Abbildung eines einzelnen Problems ohne weiteres zu erkennen. Mit Hilfe von neutralen Elementen wie 0 bei Addition/Subtraktion oder 1 bei Multiplikationen lassen sich beispielsweise Operationen "abschalten", ohne dass diese Möglichkeit explizit synthetisiert wurde. Auch die Assoziativität von Operationen kann die Abbildbarkeit eines Datenflussgraphen beeinflussen.

Student: Philipp Käsgen
Supervisor: Philip Gottschling
Time period: 04/01/2016 - 09/30/2016

Im Bereich der High-Level-Synthese wird oft ein bestehender Daten- und Kontrollflussgraph in einen Datenpfad übersetzt. Die anschließende Hardware-Synthese für ein FPGA kann dabei je nach Problemgröße bis zu einigen Stunden dauern. Ändert man die Funktion oder nur einen Wert innerhalb des Datenflussgraphen, muss die Synthese erneut durchgeführt werden. Bei sich häufig ändernden Funktionen, ist dieses Vorgehen so nicht praktikabel. Wesentlich effizienter ist es daher, aus der Superposition mehrerer Ausgangs-Datenflussgraphen einen überlagerten Datenflussgraph zu erstellen, der je nach Konfiguration alle gewünschten Funktionalitäten implementiert. Zur Superposition werden Kompatibilitätsgraphen erzeugt, aus denen sich mit Hilfe von maximalen Cliquen der größte gemeinsame Teil zweier Datenflussgraphen ermitteln lässt.

Das Cliquenproblem ist schon lange bekannt und Gegenstand vieler Forschungsarbeiten aus dem Bereich der Mathematik. Derzeit wird das Problem mit Hilfe eines Algorithmus von Bron und Kerbosch gelöst, der allerdings eine exponentielle Komplexität aufweist. Zwar existieren Heuristiken, die das Problem in polynomieller Zeit lösen, diese können allerdings die Struktur von Kompatibilitätsgraphen nicht ausnutzen. Ziel dieser Arbeit ist es daher, ein Verfahren zu entwickeln und zu implementieren, dass die größte maximale Clique in einem automatisch generierten Kompatibilitätsgraphen findet.

Student: Felix Retsch
Supervisor: Alexander Schwarz
Time period: 09/02/2019 - 03/01/2020

Derzeit wird am Fachgebiet Rechnersysteme ein Java-Prozessor auf Basis des AMIDAR-Modells implementiert, der aus mehreren unabhängigen Funktionseinheiten (FUs) besteht und verschiedene Möglichkeiten der dynamischen Anpassung an die Software bereitstellt. Der Prozessor führt bisher Java Bytecode in fast unveränderter Form in Hardware aus. Allerdings ist Java Bytecode nicht für die Ausführung in Hardware konzipiert, weshalb das Potenzial des AMIDAR-Modells damit nur schwer voll auszuschöpfen ist.

Im Rahmen dieser Arbeit soll nun ein Token Generator in (System)Verilog implementiert werden, der binär codierte NISA-Instruktionen decodiert und entsprechende Tokens an die FUs schickt. Dies ist der erste Baustein einer Hardware Implementierung für die neu entwickelte ISA.

Student: Alan Tanfer
Supervisor: Changgong Li
Time period: 01/01/2014 - 06/30/2014

• Multi-Master Fähigkeit des Protokolls und aller Infrastruktur-Komponenten
• Unterstützung von Burst-Übertragungen
• Möglichst "faire" Buszuteilung
• Dynamische Regulierung der Busbelastung durch Anhalten/Fortsetzen der Kommunikation zwischen zwei bestimmten Funktionseinheiten
• Unterstützung der Parametrierung der Anzahl und Bandbreite der einzusetzenden Busse
• Optionale Unterstützung der Fehlererkennung und Re-Transportierung der entsprechenden Daten

Student: Tajas Ruschke
Supervisor: Lukas Jung
Time period: 05/20/2015 - 11/20/2015

Student: Dennis Wolf
Supervisor: Lukas Jung
Time period: 05/26/2015 - 11/26/2015

Student: Christian Rose
Supervisor: Changgong Li
Time period: 05/01/2015 - 11/01/2015

Student: Marcel Jourdan
Supervisor: Changgong Li
Time period: 03/01/2016 - 09/01/2016

Am Fachgebiet Rechnersysteme wird momentan ein Java-Prozessor auf Basis des AMIDAR-Modells (www.amidar.de) implementiert, welches es dem Prozessor erlaubt, zur Laufzeit einer Applikation auf deren spezifische Anforderungen zu reagieren. In diesem Modell werden Instruktionen in eine Komposition von so genannten Tokens zerlegt, die dann an einzelne Funktionseinheiten verteilt werden. Die Funktionseinheiten koordinieren ihre Arbeit über die Daten, die sie produzieren oder konsumieren.

Der aktuelle Object-Heap des Prozessors erlaubt nur den Anschluss einfacher, kleiner Peripheriekomponente mit separaten Registern (z.B. UART). So eine Peripherie lässt sich dann in einer Java-Anwendung als normales Objekt deklarieren und verwalten, wobei deren Register auf primitive Datenfelder des Objektes abgebildet werden können. Aber ein kompliziertes Gerät wie der Ethernet-Controller besitzt typischerweise große Datenstrukturen (z.B. FIFO), die nicht mehr als primitives Feld umsetzbar sind. Idealerweise sollen solche Datenstrukturen als Java-Array definiert und genutzt werden, um die nahtlose Verbindung externer Geräte mit dem AMIDAR-Prozessor auf der Java-Ebene grundsätzlich zu ermöglichen.

Ziel dieser Arbeit soll es sein, das bisherige Peripheriemodell von AMIDAR um den DMA-Anschluss zu erweitern. Über diesen Anschluss soll der Austausch großer Datenmengen zwischen einer Peripherie und dem Heap schnell und transparent stattfinden können. Auf Basis des erweiterten Modells soll exemplarisch ein DMA-fähiger Ethernet-Controller sowie ein praxisnaher Benchmark realisiert werden.

Student: Jan Andresen
Supervisor: Changgong Li
Time period: 11/01/2015 - 05/01/2016

Student: Syed Abdul Majid Ali
Supervisor: Dennis Wolf
Time period: 04/01/2016 - 09/30/2016

Am Fachgebiet Rechnersysteme wurde das Modell eines adaptiven Prozessors entwickelt (AMIDAR). Dieses Modell erlaubt es zur Laufzeit auf spezifische Anforderungen einer Applikation zu reagieren. Dazu zählt die Erkennung von rechenintensiven und wiederkehrenden Schleifen und deren Abbildung auf einem Coarse Grained Reconfigruable Array (CGRA). CGRAs sind Arrays aus Rechenzellen, die Instruktionssequenzen massiv parallel verarbeiten können. 2015 wurde hierfür eine generische CGRA Architektur implementiert. Mittels eines Generators können beliebige CGRA Instanzen in Verilog erzeugt werden, ohne dabei den Verilog Code manuell anpassen zu müssen. Die Architektur beherrscht zum jetzigen Zeitpunkt Arithmetik und Kontrollflussoperationen auf Basis von Festkommadarstellung. Um ohne Einschränkung Kernels abbilden zu können, ist es allerdings notwendig auch Gleitkommaberechnungen durchführen zu können.

Student: Alexander Weisel
Supervisor: Changgong Li
Time period: 04/25/2016 - 10/25/2016

Am Fachgebiet Rechnersysteme wird momentan ein Java-Prozessor auf Basis des AMIDAR-Modells implementiert, welches es dem Prozessor erlaubt, zur Laufzeit einer Applikation auf deren spezifische Anforderungen zu reagieren. Bisher besteht noch keine Möglichkeit, mehrere Instanzen des Prozessors auf verschiedenen FPGAs laufen und miteinander kommunizieren zu lassen. Außerdem wurde ein spezielles kompaktes Format (AXT) für Anwendungen des Prozessors entworfen, wobei das Konzept Class-Object bisher aber noch nicht implementiert ist.

Ziel dieser Arbeit ist die Implementierung von Remote Method Invocation (RMI) für den oben genannten Java-Prozessor. Zunächst soll ein generischer Mechanismus zur dynamischen Erzeugung von Class-Object entwickelt werden. Dieser soll allgemein gehalten und auch für die Initialisierung von Peripherien eingesetzt werden. Dabei soll der aktuelle Bootloader sowie die Startup-Phase angepasst werden.

Im nächsten Schritt soll das vollständige Reflection API auf den Java-Prozessor portiert werden, damit jede Methode des ursprünglichen Objekts über ein dazu gehörendes Class-Objekt aufgerufen werden kann. Anschließend soll der in Java eingebettete Mechanismus zur Serialisierung/Deserialisierung von Objekten realisiert werden.

Auf Basis der obigen zwei Schritte soll RMI zunächst für ein einfaches Client-Server-System realisiert werden, welches aus einem AMIDAR-System (Client) und einem PC (Server) besteht. Dabei soll eine vollständige AXT-Datei auf der AMIDAR Seite vorher geladen werden. Mithilfe von RMI soll der Client in der Lage sein, Methoden auf dem Server auszuführen.

Student: Christian Rose
Supervisor: Changgong Li
Time period: 05/01/2015 - 11/01/2015

Student: Christian Illy
Supervisor: Changgong Li
Time period: 05/01/2015 - 11/01/2015

Am Fachgebiet Rechnersysteme wird an adaptiven Prozessorstrukturen geforscht. Die Familie der AMIDAR Prozessoren basiert dabei auf einem Modell, welches an der Professur Mikrorechner der TU Dresden entwickelt wurde. Dieses Modell erlaubt es dem Prozessor zur Laufzeit einer Applikation auf deren spezifische Anforderungen zu reagieren. Hierzu zählen sowohl die Anpassung von Busstrukturen, als auch die Anpassung von bestehenden und die Synthese von neuen Funktionseinheiten.

Im Rahmen dieser Arbeit soll ein generischer Stack-Speicher auf AMIDAR-Basis für einen Java-Prozessor in Verilog realisiert werden. Aus diesem sollen dann spezielle Stack-Module leicht abgeleitet werden können, wie z.B. Method-Stack und Operand-Stack, welche alle vom Java-Bytecode, bzw. vom AMIDAR-Modell definierten Stack-Operationen unterstützen müssen.

Student: Christian Illy
Supervisor: Changgong Li
Time period: 05/01/2015 - 11/01/2015

Am Fachgebiet Rechnersysteme wird momentan ein Java-Prozessor auf Basis des AMIDAR-Modells (www.amidar.de) implementiert, welches es dem Prozessor erlaubt, zur Laufzeit einer Applikation auf deren spezifische Anforderungen zu reagieren. In diesem Modell werden Instruktionen in eine Komposition von so genannten Tokens zerlegt, die dann an einzelne Funktionseinheiten verteilt werden. Die Funktionseinheiten koordinieren ihre Arbeit über die Daten, die sie produzieren oder konsumieren.

Ziel dieser Arbeit ist die Implementierung der Thread-Verwaltung in diesem AMIDAR-Prozessor. Zunächst soll ein Mechanismus zur Ausführung nativer Methoden entwickelt werden. Dieser soll allgemein gehalten und nicht speziell auf die Anforderungen der Thread-Verwaltung zugeschnitten sein.

In einem zweiten Schritt soll die Konzeption der zur Verwaltung von Threads notwendigen Strukturen erfolgen. Ein zentraler Bestandteil dieses Schrittes ist der Entwurf einer effektiven Verwaltung der Methodenstacks, Operandenstacks und der lokalen Variablen der einzelnen parallel ausgeführten Threads. Weiterhin wird ein Scheduler und damit verbunden eine Warteschlange benötigt.

Ein weiteres essentielles Ziel dieser Arbeit ist der Entwurf eines effizienten Mechanismus zur Realisierung verschiedener Synchronisationskonzepte. Diese können sowohl auf Monitoren, Semaphoren oder Mutexen beruhen. Die verschiedenen Varianten sind in Bezug auf ihre Realiserbarkeit im AMIDAR-Prozessor zu untersuchen. Die Entscheidung für eine spezielle Variante ist zu begründen.

Student: Alexander Schwarz
Supervisor: Changgong Li
Time period: 10/01/2015 - 03/31/2016

FPGAs sind in den letzten Jahren kontinuierlich günstiger geworden und haben mittlerweile ein Preisniveau erreicht, welches es erlaubt, diese Bausteine ganz regulär für die Implementierung von System-on-Chip (SoC) zu verwenden. Aber aufgrund ständig steigender Größe und Komplexität von SoCs sind diese immer schwieriger zu debuggen und zu testen. Damit das Debugging eines komplexen, FPGA basierten Systems leichter vorgenommen werden kann, stellen die meisten FPGA-Hersteller spezielle Interfaces bereit, welche das Auslesen eines kompletten Designs aus einem FPGA als Bitstream in Echtzeit erlauben.

Am Fachgebiet Rechnersysteme wird momentan ein Java-Prozessor auf Basis des AMIDAR-Modells (www.amidar.de) implementiert, welches es dem Prozessor erlaubt, zur Laufzeit einer Applikation auf deren spezifische Anforderungen zu reagieren. Im Laufe des Projekts wird das Debugging des Prozessors durch Hinzufügen unterschiedlicher Funktionseinheiten immer komplizierter, wobei eine Post-Synthesis-Simulation schon nicht mehr ausreicht.

Ziel dieser Arbeit ist die Entwicklung einer Debug Perspektive in Eclipse, welche ein Bitstream von einem Xilinx-FPGA analysieren und anschießend die aktuellen Zustände einzelner Funktionseinheiten textuell oder graphisch darstellen kann. Hierfür soll auch ein Break-Point Mechanismus entworfen werden, welcher ermöglicht, ein SoC an einer bestimmten Programmstelle anzuhalten und dann das ganze Design über einen JTAG-Port auszulesen.

Wünschenswert ist außerdem, dass das entstehende Tool auch auf andere SoC Architekturen übertragen werden kann (z.B. SpartanMC).

Student: Hendrik Schöffmann
Supervisor: Alexander Schwarz
Time period: 09/03/2018 - 03/02/2019

Derzeit wird am Fachgebiet Rechnersysteme ein Java-Prozessor auf Basis des AMIDAR-Modells implementiert, der aus mehreren unabhängigen Funktionseinheiten (FUs) besteht und verschiedene Möglichkeiten der dynamischen Anpassung an die Software bereitstellt. Zu diesen Möglichkeiten zählt insbesondere das integrierte Coarse Grained Reconfigurable Array (CGRA) als automatisch genutzter Hardwarebeschleuniger. Der Prozessor führt bisher Java Bytecode in fast unveränderter Form in Hardware aus. Allerdings ist Java Bytecode nicht für die Ausführung in Hardware konzipiert, weshalb das Potenzial des AMIDAR-Modells damit nur schwer voll auszuschöpfen ist.

Ein vielversprechender Ansatz für eine neue Instruction Set Architecture (ISA), die speziell auf das AMIDAR-Konzept zugschnitten ist, greift Ideen von Datenflussmaschinen auf. Der Ansatz erlaubt es, Datenübertragungen zwischen Operationen direkt in den Instruktionen zu definieren. Um das CGRA weiter nutzen zu können, ist daher eine Anpassung des Syntheseverfahrens an die neue ISA notwendig.

Im Rahmen dieser Arbeit soll ein Graphgenerator entwickelt werden, der als Eingabe Code der neuen ISA nutzt. Die erzeugten Graphen dienen als Eingabe für den vorhandenen CGRA Scheduler. Dadurch kann die Hardware-Synthese auch mit der neuen ISA genutzt werden.

Student: Taimoor Naveed
Supervisor: Tajas Ruschke
Time period: 04/04/2016 - 10/04/2016

Am Fachgebiet Rechnersysteme wird momentan ein Java-Prozessor auf Basis des AMIDAR-Modells implementiert, dem ein CGRA (coarse grained reconfigurable array) für die dynamische Beschleunigung des Programmablaufs zur Verfügung steht.

Damit ein Programmteil auf das CGRA abgebildet werden kann, müssen Kontroll- und Datenflussabhängigkeiten aus dem Java Bytecode extrahiert und in ein Graphformat übersetzt werden. Dieses wird dann von einem Scheduler verwendet, um daraus die Konfiguration des CGRAs zu bestimmen.

Ziel dieser Arbeit ist die Implementierung eines neuen Graphgenerators, der zusätzlich auch schleifenübergreifende Abhängigkeiten (loop carried dependencies) aus dem Bytecode extrahieren kann. Zusätzlich müssen innere Schleifen erkannt werden. Für die Repräsentation des Graphen müssen die bestehenden Klassen um die neuen Informationen erweitert werden.

Student: Ramon Wirsch
Supervisor: Alexander Schwarz
Time period: 04/24/2017 - 10/23/2017

Derzeit wird am Fachgebiet Rechnersysteme an AMIDAR-Prozessoren geforscht, die aus mehreren unabhängigen Funktionseinheiten aufgebaut sind und verschiedene Möglichkeiten der Rekonfiguration bereitstellen. Bisher lag der Fokus auf Ausführung von Java Bytecode, jedoch eignet sich das Grundprinzip für verschiedenste Instruktionssätze.

Es besteht die Idee, einen speziell auf das AMIDAR-Konzept zugeschnittenen Instruktionssatz zu entwickeln, der einige Gedanken von Datenflussarchitekturen aufgreift. Grundlegende Merkmale dieses neuen Instruktionssatzes sind bereits erarbeitet worden.

Aufgabe ist es, einen Simulator zu entwickeln, der Programme bestehend aus diesen Instruktionen ausführen kann. Mit Hilfe des Simulators soll die Anwendbarkeit des Instruktionssatzes verifiziert werden. Hierbei kann auf einen Assembler zurück gegriffen werden, um Programme zu erzeugen.

Student: Daniel Versick
Supervisor: Dipl. Inf. Stephan Gatzka
Time period: 06/01/2003 - 12/31/2003

Student: Adrian Weber
Supervisor: Alexander Schwarz
Time period: 04/01/2019 - 09/30/2019

Derzeit wird am Fachgebiet Rechnersysteme an AMIDAR-Prozessoren geforscht, die aus mehreren unabhängigen Funktionseinheiten aufgebaut sind und verschiedene Möglichkeiten der Rekonfiguration bereitstellen. Bisher lag der Fokus auf Ausführung von Java Bytecode, jedoch eignet sich das Grundprinzip für verschiedenste Instruktionssätze.

Nun wird die Idee verfolgt, eine speziell auf das AMIDAR-Konzept zugeschnittene Instruction Set Architecture (ISA) zu entwickeln, die einige Gedanken von Datenflussarchitekturen aufgreift. Für diesen Instruktionssatz wurde bereits ein Code Converter entwickelt, der Code ausgehend von Java Class Files erzeugt. Dieser kann anschließend in einer Simulation ausgeführt werden.

Eine besondere Herausforderung bei der neuen ISA ist das Scheduling der Instruktionen, da die Reihenfolge der Instruktionen einigen Einschränkungen unterliegt, damit sie ausführbar ist. Hierbei gilt es unter anderem, Deadlocks zu beseitigen. Derzeit funktioniert der Scheduling-Algorithmus unter bestimmten Voraussetzungen gut. Bei komplexem Code und unter engen Einschränkungen liefert er jedoch schlechte Ergebnisse oder scheitert ganz. Daher soll im Rahmen dieser Arbeit ein verbesserter Algorithmus implementiert werden.

Student: Jan Weber
Supervisor: Kris Heid
Time period: 04/05/2015 - 10/05/2015

Student: Muhammad Naveed Baig
Supervisor: Kris Heid
Time period: 03/01/2015 - 09/01/2015

Student: Gregor Koch
Supervisor: Kris Heid
Time period: 10/07/2015 - 04/07/2016

Am Fachgebiet Rechnersysteme (und an der Professur Mikrorechner der TU Dresden) wird ein SoC-Kit rund um den SpartanMC Soft-Core entwickelt. Dieser ist ein speziell für die Verwendung in FPGAs entwickelter CPU-Core. Aufgrund dieser Zielplattform nutzt der SpartanMC eine Befehls- und Datenbreite von 18 Bit, welche die Strukturen aktueller FPGAs optimal ausnutzt.

Es besteht bereits die Möglichkeit mehrere SpartanMC Kerne auf einem FPGA unter zu bringen und diese über sogenannte Core Connectoren kommunizieren zu lassen. Dabei hat jeder Kern des Systems seine eigene Firmware. Bei Multicore Anwendungen kann es jedoch sein, dass mehrere Kerne prinzipiell die selbe Firmware benötigen. Da der Speicherplatz bei vielen Prozessorkernen durchaus zur kritischen Ressource werden kann, ist es naheliegend einen globalen Firmwarespeicher für alle Kerne zu verwenden.

Ziel dieser Arbeit soll sein den SpartanMC Kern zu modifizieren, um Stalls zu unterstützen, welche hierfür benötigt werden. Ein zweiter Teil der Arbeit soll sich damit beschäftigen ein Memory Modul zu entwerfen und es mit einem Arbiter auszustatten, welcher den Zugriff auf den Speicher festlegt und jeden Kern mit einem Instruction Cache auszustatten.

Student: Sebastian Herber
Supervisor: Kris Heid
Time period: 08/01/2016 - 02/01/2017

Am Fachgebiet Rechnersysteme (und an der Professur Mikrorechner der TU Dresden) wird ein SoC-Kit rund um den SpartanMC Soft-Core entwickelt. Dieser ist ein speziell für die Verwendung in FPGAs entwickelter CPU-Core. Aufgrund dieser Zielplattform nutzt der SpartanMC eine Befehls- und Datenbreite von 18 Bit, welche die Strukturen aktueller FPGAs optimal ausnutzt.

Der kritische Punkt, um die Leistungsfähigkeit von Manycore SoC Systemen zu steigern, ist momentan die Software. Durch die klassische iterative Denkweise beim Programmieren ist es relativ schwer die Software sinnvoll auf mehrere Rechenkerne aufzuteilen. In einer laufenden Arbeit wird versucht dieses Problem über Annotationen der Programmierer im Sourcecode zu umgehen und einzelne Aufgabenblöcke auf verschiedene Kerne aufzuteilen. Hierbei ist die Verwendung von globalen Variablen besonders kritisch. Allerdings müssten hierfür die Variablen zwischen allen Kernen synchronisiert werden. Dies wirft u.A. das Problem auf, was passiert, wenn bspw. eine globale Variable von zwei Kernen gleichzeitig beschrieben werden soll. Um ein aufwändiges Konfliktmanagement und die Synchronisation zu umgehen, soll ein Memory Kern existieren, von welchem alle anderen Kerne ihre globalen Variablen beziehen und welche nur dort geschrieben werden dürfen.

Ziel der Arbeit ist daher in dem Source to Source Compiler Cetus einen Tranformation-Pass zu integrieren, welcher die Nutzung globaler Variablen in den einzelnen vom Nutzer definierten Task-Abschnitten erkennt. Anschließend müssen die globalen Variablen durch getter und setter Funktionen ersetzt werden. Die reale Implementierung des hinter den getter und setter liegenden Speichers soll in Form einer spezialisierten Peripherie-Komponente in die einzelnen Kerne eingeblendet werden. Anschließend soll eine abstrakte SoC Konfiguration ausgegeben werden, welche später zu einem lauffähigen System transformiert werden soll.

Student: Steven Leduc
Supervisor: Kris Heid
Time period: 10/01/2015 - 04/01/2016

Am Fachgebiet Rechnersysteme (und an der Professur Mikrorechner der TU Dresden) wird ein SoC-Kit rund um den SpartanMC Soft-Core entwickelt. Dieser ist ein speziell für die Verwendung in FPGAs entwickelter CPU-Core. Aufgrund dieser Zielplattform nutzt der SpartanMC eine Befehls- und Datenbreite von 18 Bit, welche die Strukturen aktueller FPGAs optimal ausnutzt.

Ein Hauptaugenmerk bei der Weiterentwicklung des SpartanMC Toolkits liegt aktuell auf der Erweiterung der Multi-Core Fähigkeit des SpartanMC. Ziel ist es, Anwendungen für den SpartanMC zu finden, welche sich gut parallelisieren lassen. Eine Firewall ist potenziell eine solche Anwendung, die eine parallele Abarbeitung Paketen erlaubt.

Ziel dieser Arbeit soll es sein, eine eigene kleine Firewall App auf Basis des SpartanMC zu entwickeln oder eine Open Source Implementierung wie bspw. pfsense oder ipfire auf SpartanMC zu portieren. Der Fokus soll hierbei auf einer sinnvollen Aufteilung der Anwendung liegen, sodass zwischen den Prozessoren eine Art Pipeline entsteht. So wäre es denkbar, dass der erste Prozessor Pakete über die erste Ethernet Schnittstelle entgegen nimmt, diese an den ersten Kern weiterleitet, welcher einen Port Filter implementiert. Auf dem zweiten Kern findet eine IP-Adressen Filterung statt. Wurde das Paket bisher nicht verworfen, wird es an den letzten Kern weitergeleitet, der das Paket auf der Ausgangs Ethernet-Schnittstelle ausgibt.

Student: Fabio Mayoral
Supervisor: Rico Backasch
Time period: 02/01/2011 - 07/31/2011

Student: Sheheryar Zahoor Qazi
Supervisor: Prof. Dr. Christian Hochberger
Time period: 05/01/2014 - 09/30/2014

Student: Jakob Wenzel
Supervisor: Christian Hochberger
Time period: 10/01/2015 - 03/31/2016

Das SpartanMC SoC-Kit ist eine Werkzeugkette und ein Satz von Soft- und Hardware-Komponenten, die dem Anwender erlauben, ein anwendungsspezifisches SoC zu konstruieren, ohne selbst Spezialist für FPGAs zu sein.

Bisher verwendet das SpartanMC SoC-Kit die Hersteller-Werkzeuge, um die FPGA-Konfiguration zu berechnen. Dies kann im Einzelfall leicht 15 Minuten und mehr benötigen.

Im Rahmen dieser Arbeit soll nach Möglichkeiten gesucht werden, mit Hilfe der RapidSmith Tools ein SoC erheblich schneller fertig zu stellen, als dies bisher möglich ist.

Student: Lucas Gaia de Castro
Supervisor: Tobias Schladt
Time period: 03/30/2022 - 09/28/2022

In FPGAs werden zur Speicherung der Konfigurationsdaten SRAM-Speicherzellen verwendet. Diese stellen einen flüchtigen Speicher dar, verlieren also bei Unterbrechung der Spannungsversorgung ihre Information. Deswegen wird an Non-Volatile (NV)-FPGAs geforscht, die nicht-flüchtigen Konfigurationsspeicher besitzen. Eine Möglichkeit, diese zu implementieren, stellen Speicherzellen auf Memristor-Basis dar.

Memristoren sind passive Bauelemente, deren Widerstandswert von der Vorgeschichte des hindurchgeflossenen Stromes abhängt. Aufgrund der additiven Fertigung von Memristor-basierten Speichern ist davon auszugehen, dass ein gewisser Anteil der Speicherzellen fehlerbehaftet ist. Durch die mehrstufigen Pass-Transistor-Schaltungen, die in der Routing-Architektur von FPGAs eingesetzt werden, wirken sich Speicherzellenfehler auf große Teile des Routing-Netzes aus. Beim Entwurf einer Routing-Architketur für NV-FPGAs müssen potentielle Fehler und ihre Auswirkungen also berücksichtigt werden.

Ziel dieser Arbeit ist es, eine neue Architektur für die Routing-Elemente von NV-FPGAs zu entwerfen und diese auf ihre Fehlertoleranz hin zu evaluieren.

Student: Christoph Flothow
Supervisor: Tobias Schwarz
Time period: 05/10/2023 - 11/08/2023

Am Fachgebiet Rechnersysteme wird zur Logiksynthese für Field Programmable Gate Arrays (FPGAs) geforscht. Einen Schwerpunkt bildet dabei das Technology Mapping, bei dem eine Boolesche Beschreibung der gewünschten Funktionalität auf Elemente der Zieltechnologie abgebildet wird. Den Kern des Technology Mappings für FPGAs bildet die Abbildung auf Lookup-Tables (LUTs). Im Rahmen eines Projektseminars am Fachgebiet wurde ein Mapper für LUTs entwickelt, der als Zwischendarstellung Binary Decision Diagrams (BDDs) verwendet. Mit Hilfe von Modifikationen der BDDs werden in diesem Verfahren die Eingabefunktionen dekomponiert und eine Zuordnung der Booleschen Variablen auf LUTs vorgenommen.

Im Rahmen dieser Arbeit soll das vorhandene Verfahren dahingehend erweitert werden, dass es mit beliebig strukturierten Eingabefunktionen funktioniert. Dazu sollen bekannte Probleme des Verfahrens analysiert und gelöst werden, sowie neue Strategien implementiert werden, um eine gesteigerte Lösungsqualität zu erreichen.

Student: Blandine Rivière
Supervisor: Johanna Rohde
Time period: 04/03/2018 - 10/02/2018

Ein Forschungsprojekt am Fachgebiet Rechnersysteme der TU Darmstadt befasst sich mit der Entwicklung des PIRANHA GCC Plugins zur automatischen Erzeugung von Hardwarebeschleunigern. Das Plugin führt dazu eine statische Programmanalyse des Programmcodes durch und wählt eigenständig die Schleifen aus, die voraussichtlich die größte Ausführungszeit benötigen. Anschließend wird deren Funktionalität mit Hilfe einer High Level Synthese als Hardwarebeschleuniger implementiert. Der Zugriff der Beschleuniger auf den Datenspeicher kann wahlweise direkt oder über ein Cachesystem erfolgen.

Der verfolgte Ansatz ist unabhängig vom Prozessor, an welchen die Beschleuniger als Peripheriekomponente angeschlossen werden. Gegenwärtig steht dafür vor allem der SpartanMC des gleichnamigen SoC-Kits zur Verfügung.

Der MicroBlaze ist ein 32-Bit RISC Softcore Prozessor entwickelt von Xilinx. Er bietet zahlreiche Konfigurationsmöglichkeiten wie z.B. die Anzahl der Pipelinestufen, zusätzliche arithmetische Einheiten und optionale Caches für Daten und Instruktionen.

Ziel dieser Arbeit ist es, die von PIRANHA unterstützten Prozessoren um den MicroBlaze von Xilinx zu erweitern. Dabei ist insbesondere auch das vorhandene Cachesystem an den MicroBlaze anzupassen.

Student: David Volz
Supervisor: Johanna Rohde
Time period: 11/06/2020 - 05/05/2021

Ein Forschungsprojekt am Fachgebiet Rechnersysteme der TU Darmstadt befasst sich mit der automatischen Erzeugung von Hardware-Beschleunigern. Das entwickelte GCC-Plugin führt dazu eine statische Programmanalyse des Programmcodes durch und wählt eigenständig die Schleifen aus, die voraussichtlich die größte Ausführungszeit benötigen. Anschließend wird deren Funktionalität mit Hilfe einer High Level Synthese (HLS) als Hardwarebeschleuniger implementiert.

Den Flaschenhals stellen dabei die Speicherzugriffe dar. Über ein Cache-System können zwar mehrere Speicherzugriffe gleichzeitig ausgeführt werden, dennoch kommt es bei Cache-Misses und dem anschließenden Laden aus dem Hauptspeicher zu langen Wartezeiten.

Die Anzahl an Cache-Misses kann durch Prefetching reduziert werden. Dabei werden zukünftige Speicheradressen antizipiert und während des Leerlaufs des Caches spekulativ geladen. Der Erfolg von Prefetching hängt maßgeblich davon ab, wie genau Speicheradressen vorhergesagt werden können. Ein Vorteil des High Level Synthese Tools besteht darin, dass die Speicherzugriffe der Hardware Beschleuniger bereits zur Compilezeit ausführlich analysiert werden. Die dabei gewonnenen Informationen könnten zum Prefetching verwendet werden.

Ziel dieser Arbeit ist es, eine Prefetch Engine für den Level-2 Cache des vorhandenen Cache-Systems zu implementieren und zu integrieren. Des Weiteren, sollen die generierten Hardware Beschleuniger gezielt um Prefetch-Instruktionen erweitert werden, welche an die Prefetch Egnine übergeben werden.

Voraussetzung für diese Masterarbeit ist der Level-2 Cache. Dieser kann im Vorfeld als Projektseminars implementiert werden.

Student: André Miebes
Supervisor: Johanna Rohde
Time period: 09/04/2019 - 03/03/2020

Ein Forschungsprojekt am Fachgebiet Rechnersysteme der TU Darmstadt befasst sich mit der automatischen Erzeugung von Hardware-Beschleunigern. Das entwickelte GCC-Plugin führt dazu eine statische Programmanalyse des Programmcodes durch und wählt eigenständig die Schleifen aus, die voraussichtlich die größte Ausführungszeit benötigen. Anschließend wird deren Funktionalität mit Hilfe einer High Level Synthese (HLS) als Hardwarebeschleuniger implementiert.

Die Performanz der Beschleuniger wird maßgeblich durch die Speicherzugriffe limitiert. Um diese zu beschleunigen, wurde ein Multicachesystem entwickelt, welches den Beschleunigern mehrere parallele Speicherports zur Verfügung stellt.

Derzeit werden die Speicherzugriffe erst zeitlich gescheduled und anschließend auf die Speicherports gemapped. Dabei entsteht eine erhöhte Anzahl geteilter Cache-Lines, welche die Ausführung verzögern. Wie in diesem Paper gezeigt wurde, ist es deswegen sinnvoll, die Speicherzugriffe zu Beginn zu klassifizieren und gegebenenfalls noch vor dem Schedulen auf die Ports zu verteilen. Diese Technik wird Access Classification and Distribution (ACD) genannt.

Aufgabe dieser Masterarbeit ist es, ACD in das PIRANHA Plugin zu integrieren und dadurch die Anzahl der Leertakte, die durch geteilten Cache-Lines entstehen, zu verringern. Anschließend ist der ACD Algorithmus selbst zu optimieren, indem untersucht wird, welche Kriterien für die Klassifizierung verwendet werden sollen und wie das Verhältnis von exklusiven Cache-Lines zu parallel ausführbaren Instruktionen verbessert werden kann.

Student: Benedikt Heumüller
Supervisor: Johanna Rohde
Time period: 01/16/2019 - 07/15/2019

Ein Forschungsprojekt am Fachgebiet Rechnersysteme der TU Darmstadt befasst sich mit der automatischen Erzeugung von Hardware-Beschleunigern. Dabei kann der Zugriff der Beschleuniger auf den Datenspeicher wahlweise direkt oder über ein Cachesystem erfolgen.

Der verfolgte Ansatz ist unabhängig vom Prozessor, an welchen die Beschleuniger als Peripheriekomponente angeschlossen werden. Gegenwärtig steht dafür der SpartanMC des gleichnamigen SoC-Kits und der MicroBlaze von Xilinx zur Verfügung.

Der MicroBlaze ist ein 32-Bit RISC Softcore Prozessor. Er bietet zahlreiche Konfigurationsmöglichkeiten wie z.B. die Anzahl der Pipelinestufen, zusätzliche arithmetische Einheiten und optionale Caches für Daten und Instruktionen.

Derzeit ist das Cachesystem der Beschleuniger nur unzureichend mit dem MicroBlaze kompatibel. Grund dafür ist, dass das Cachesystem über die AXI Coherence Extension (ACE) an den Kohärenzbus des MicroBlaze eigenen Cache angeschlossen ist. Dies hat jedoch den Nachteil, dass nicht alle Funktionen des Cachesystems unterstützt werden und es zu zusätzlichen Verzögerungen beim Lesen und Schreiben kommt.

Ziel dieser Arbeit ist es, die Performanz des vorhandenen Cachesystems zu optimieren und dieses als Datenspeicher an den Local Memory Bus (LMB) des MicroBlaze anzuschließen.

Student: Jonas Gehrunger
Supervisor: Johanna Rohde
Time period: 11/09/2020 - 05/10/2021

Ein Forschungsprojekt am Fachgebiet Rechnersysteme der TU Darmstadt befasst sich mit der automatischen Erzeugung von Hardware-Beschleunigern. Das entwickelte GCC-Plugin führt dazu eine statische Programmanalyse des Programmcodes durch und wählt eigenständig die Schleifen aus, die voraussichtlich die größte Ausführungszeit benötigen. Anschließend wird deren Funktionalität mit Hilfe einer High Level Synthese (HLS) als Hardwarebeschleuniger implementiert.

Eine Herausforderung besteht darin, die Abhängigkeiten von Lese- und Schreibzugriffen auf den Speicher zu bestimmen. Um die Semantik des Programms nicht zu verändern, müssen diese im konservativsten Fall im Beschleuniger in der gleichen Reihenfolge ausgeführt werden, wie in der Software beschrieben. Dies limitiert jedoch die Anzahl an parallel ausführbaren Instruktionen und stellt einen Flaschenhals dar.

Der GCC ermöglicht es, Speicherzugriffe umfassend zu charakterisieren. Diese Informationen werden derzeit dazu verwendet, möglichst viele Speicherzugriffe zur Compilezeit voneinander zu entkoppeln. Dies ist jedoch häufig nicht möglich, da es durch das Pointer-Aliasing dazu kommen kann, dass man über verschiedene Pointer auf den gleichen Speicher zugreift. Deswegen soll die Compilezeit-Analyse um eine Laufzeitanalyse erweitert werden. Dabei wird zur Compilezeit ein Satz an Bedingungen formuliert, deren Evaluation zur Laufzeit bestimmt, ob zwei Speicherzugriffe immer unabhängig voneinander sind. Bei einem positiven Ergebnis, kann dann ein optimierter Beschleuniger ausgeführt werden.

Aufgabe der Masterarbeit ist es, das Plugin so zu erweitern, dass möglichst viele Speicherzugriffe zur Laufzeit entkoppelt werden können. Dabei sollen insbesondere die Informationen zu Zugriffsmuster, Anzahl der Schleifeniterationen und Arraygröße herangezogen werden.

Die genauen Hintergründe zur Compilezeit-Analyse werden in diesem Paper beschrieben

Student: Tim Burkert
Supervisor: Changgong Li
Time period: 04/16/2018 - 10/15/2018

Coarse Grained Reconfigurable Arrays (CGRA) sind Schaltungen, die zumeist als Hardwarebeschleuniger eingesetzt werden. Einzelne Rechenzellen verarbeiten entsprechend eines im voraus definierten Operationsplans (Scheduling) Daten massiv parallel.

Problematisch bei fast allen CGRAs, die nicht direkt in einen Prozessor integriert sind, ist der vergleichsweise hohe Aufwand auf Daten der Anwendung zuzugreifen oder den Konfigurationsspeicher zu beschreiben. Um die Ausführungsdauer dieses Vorgangs zu reduzieren und die Kommunikation mit dem zugehörigen Prozessor zu gewährleisten ist eine PCIe-Schnittstelle auf Seiten des Host vorgesehen.

Im Rahmen dieser Arbeit soll ein vorhandenes CGRA mit einer PCIe-Schnittstelle versehen werden, welche die Kommunikationsschnittstelle zwischen Host und CGRA bildet und alle eingehenden Daten und Adressen entsprechend einer generischen CGRA Architektur passend aufarbeitet, bzw. die vom CGRA benötigten Daten in System konformer Weise aus dem Speicher des Host holt.

Student: Marek Völker
Supervisor: Changgong Li
Time period: 05/01/2018 - 10/31/2018

Coarse Grained Reconfigurable Arrays (CGRA) sind Schaltungen, die zumeist als Hardwarebeschleuniger eingesetzt werden. Einzelne Rechenzellen verarbeiten entsprechend eines im voraus definierten Operationsplans (Scheduling) Daten massiv parallel.

Ziel der Arbeit ist die Anpassung der bestehenden CGRA-Architektur an machine-learning Anwendungen. Bei diesen Anwendungen genügen häufig Festkommadarstellungen mit 32 oder 16 Bit Genauigkeit für die Berechnung. Daher ist es erforderlich entsprechende Rechenwerke bereitzustellen und gegebenenfalls zwei 16-bit Operationen zu einer kombinierten Operation zusammenzufassen. Je nach Ausgangsproblem kann es nötig werden swap-Operationen bereitzustellen.

Student: Uzay Yavuz
Supervisor: Jonas Gehrunger
Time period: 11/15/2021 - 05/16/2022

Am Fachgebiet Rechnersysteme wird im Rahmen des (EES)²-Projektes die Hardware-Beschleunigung der Schaltungssimulation von Memristoren mithilfe der Software SPICE untersucht. Dabei werden Modelle der Schaltungselemente in einem Hardwarebeschleuniger parallelisiert ausgewertet. Da ein großer Teil der verbleibenden Simulationszeit auf die Lösung des linearen Gleichungssystems der Schaltung entfällt, soll dies ebenfalls in Hardware erfolgen.

Die Struktur der von SPICE erzeugten Schaltungsmatrizen ist sehr dünnbesetzt (sparse), wofür es spezialisierte Solver gibt. Einer davon ist das KLU Verfahren. Dieses soll für ein FPGA-System implementiert werden, wobei die Implementation parametrisierbar in Bezug auf Datentyp und zugewiesenen Ressourcen erfolgen soll.

Um eine einfache Skalier- und Parametrisierbarkeit zu ermöglichen, soll die Implementation dabei in der Hardware-Beschreibungssprache Chisel entwickelt werden.

Student: David Scheunert
Supervisor: Jonas Gehrunger
Time period: 05/02/2023 - 10/30/2023

Im Bereich der Entwicklung von Steuergeräten und eingebetteten Systemen hat sich seit einigen Jahren die Methodik "Hardware-in-the-loop" etabliert. Dabei wird ein Steuergerät nicht mit dem realen System verbunden, welches es kontrollieren soll, sondern mit einer Simulation dieses Systems. Diese Methodik lässt sich auch auf komplexe Regelungssysteme im wissenschaftlichen Bereich übertragen. So ist es denkbar, die Strahlregelung eines Cyclotrons nicht am realen Cyclotron auszutesten und zu entwickeln, sondern stattdessen ein Modell eines Strahls zu rechnen und somit die Strahlreaktion auf die Regelungseingriffe nur zu simulieren.

Am Fachgebiet Rechnersysteme wird seit mehreren Jahren an Coarse Grained Reconfigurable Arrays (CGRA) als Rechenbeschleuniger geforscht. Dabei wurde in einem vorhergehenden Projekt auch schon ein physikalisches Modell in einem industriellen Umfeld in Echtzeit simuliert. CGRAs haben also bereits bewiesen, dass sie für den Einsatz in Echtzeitsystemen gut geeignet sind. Es bietet sich daher an, die Strahlsimulation ebenfalls mithilfe von CGRAs zu realisieren.

Im Rahmen dieser Arbeit soll ein CGRA basierter Strahlsimulator entworfen, anhand mehrerer Anwendungsfälle verifiziert und in der GSI an einem realen Strahlregelungssystem getestet werden.

Student: Jian Liu
Supervisor: Jonas Gehrunger
Time period: 12/09/2021 - 06/09/2022

Am Fachgebiet Rechnersysteme wird im Rahmen des (EES)²-Projektes die hardwarebeschleunigte Schaltungssimulation von Memristoren mithilfe der Software SPICE untersucht. Dabei werden Modelle der Schaltungselemente in einem Hardwarebeschleuniger parallelisiert ausgewertet und das entstandene Gleichungssystem gelöst. Ein Weg, die Effizenz der Simulation weiter zu erhöhen, besteht in der Verwendung von Zahlendarstellungen und Berechnungen mit reduzierter Genauigkeit.

Um die Auswirkung von Änderungen an der Genauigkeit abzuschätzen, soll die Open-Source Software ngspice um eine Instrumentierung erweitert werden, die eine einstellbare Veränderung der Genauigkeit von Berechnungen erlaubt. Dafür sollen zunächst während laufender Simulationen der auftretende Dynamikbereich überwacht werden.

Anschließend sollen innerhalb der Berechnungen Werte mit minimalem und maximalem Betrag erzwungen sowie eine Quantisierung durchgeführt werden, um reduzierte Genauigkeit zu simulieren. Mit diesen Änderungen soll das Verhalten der Simulation analysiert werden, etwa in Bezug auf den Spannungsverlauf und das Konvergenzverhalten.

Student: Nora Simon
Supervisor: Ramon Wirsch
Time period: 02/12/2021 - 06/01/2021

Am Fachgebiet Rechnersysteme werden Hardwarebeschleuniger für eine Reihe von Architekturen entwickelt, unter anderem für die RISC-V Architektur. Hierzu sollen reguläre Programme zur Laufzeit analysiert und partiell mit dem Hardwarebeschleuniger ausgeführt werden können, ohne dass sie vorher dafür angepasst werden müssen.

Um den Gewinn der Laufzeitbeschleunigung praktisch testen und zeigen zu können, wird aktuell ein auf FPGAs lauffähiges System samt Beschleuniger entwickelt. Mit Taiga wurde bereits ein spezifischer RISC-V Prozessor ausgewählt, der zum aktuellen Zeitpunkt allerdings noch nicht über Fließkomma-Recheneinheiten verfügt. Diese sollen zu einem späteren Zeitpunkt nachgerüstet werden.

Um die Beschleunigung mit unserer Technik untersuchen und nachweisen zu können, ist es notwendig die Performance und das Verhalten des Beschleunigers und des Prozessors abzugleichen. Beispielsweise bringt es für die Beschleunigung nichts, wenn eine Komponente Rechenoperationen beherrscht, die das Gegenstück aber nicht unterstützt. Die dazu verwendeten Hardwareressourcen könnten anderweitig besser angelegt werden.

Im Rahmen dieser Arbeit sollen deshalb die existierenden Fließkomma-Operatoren des Beschleunigers, sowie andere zur Verfügung stehende oder von konkurrierenden Prozessoren verwendete Implementierungen untersucht und evaluiert werden. Besonders interessant ist hier beispielsweise die Unterstützung von denormalisierten Zahlen und Rounding-Modes, Operations-Latenzen, mögliches Pipelining, der Ressourcenverbrauch und maximaler Takt.

Student: Sebastian Focke und David Winter
Supervisor: Tajas Ruschke
Time period: 06/01/2016 - 09/08/2017

Student: Philipp Käsgen
Supervisor: Philip Gottschling
Time period: 12/01/2015 - 03/31/2016

Zur Überlagerung von zwei Datenflussgraphen werden sogenannte Kompatibilitätsgraphen erstellt, die angeben, welche Teile der beiden Graphen wiederverwendet werden können. In diesen wiederum muss anschließend der größte vollständig verbundene Teilgraph (Clique) gefunden werden. Für einen allgemeinen Graphen ist dieses Problem NP-Vollständig (Non-Polynomial). Für spezielle Arten von Graphen (Complete, Triangular, etc.) gibt es bereits Algorithmen, die das Maximum-Clique-Problem in polynomieller Zeit lösen.

Im Rahmen dieser Arbeit soll untersucht werden, inwiefern Kompatibilitätsgraphen, die aus Datenflussgraphen hervorgehen eine der besonderen Eigenschaften aufweisen.

Student: Maximilian Heer
Supervisor: Alexander Schwarz
Time period: 11/04/2019 - 03/31/2020

Derzeit wird am Fachgebiet Rechnersysteme an AMIDAR-Prozessoren geforscht, die aus mehreren unabhängigen Funktionseinheiten (FUs) aufgebaut sind und verschiedene Möglichkeiten der Rekonfiguration bereitstellen. Bisher lag der Fokus auf Ausführung von Java Bytecode, jedoch eignet sich das Grundprinzip für verschiedenste Instruktionssätze.

Nun wird die Idee verfolgt, eine speziell auf das AMIDAR-Konzept zugeschnittene Instruction Set Architecture (ISA) zu entwickeln, die einige Gedanken von Datenflussarchitekturen aufgreift. Im Unterschied zu Java Bytecode ist hier kein Operand Stack erforderlich. Stattdessen wird zur kurzzeitigen Speicherung ein Scratch Pad Memory verwendet. Daher müssen FUs implementiert werden, die an diese Speicherverwaltung angepasst sind.

Im Rahmen dieser Arbeit sollen zwei FUs entwickelt werden. Zum einen ist dies der Frame Stack. Er übernimmt die Speicherung der aufgerufenen Methoden und deren lokale Variablen. Zum anderen ist dies das Scratch Pad Memory. Es dient der kurzzeitigen Speicherung von Werten innerhalb einer Methode.

Student: Roman Ness / Sebastian Fahnenschreiber
Supervisor: Lukas Jung
Time period: 07/14/2014 - 09/19/2014

An der Professur Mikrorechner der TU Dresden wurde das Modell eines adaptiven Prozessors entwickelt, welches am Fachgebiet Rechnersysteme weiterentwickelt wird. Dieses Modell erlaubt es, dem Prozessor zur Laufzeit auf die spezifischen Anforderungen einer Applikation zu reagieren. Hierzu zählen sowohl die Anpassung von Busstrukturen, als auch die Anpassung von bestehenden und die Synthese von neuen Funktionseinheiten.

Neu synthetisierte Funktionseinheiten werden auf ein Coarse Grained Reconfigurable Array (CGRA) abgebildet. Zur Vereinfachung des Debuggens solcher Funktionseinheiten soll eine grafische Oberfläche entwickelt werden, der entnommen werden kann, welche Daten in den jeweiligen Processing Elements (PE) des CGRA verarbeitet wurden. Außerdem soll ersichtlich sein, welche Daten im Speicher des CGRA abgelegt sind.

Student: Andrei Stefanov
Supervisor: Kris Heid
Time period: 06/06/2014 - 06/07/2014

Student: Melanie Braun
Supervisor: Kris Heid
Time period: 09/11/2015 - 02/03/2016

Um ein SoC zu konfigurieren, steht dem Nutzer momentan lediglich ein grafisches Interface zur Verfügung. Hier kann ausgewählt werden, welche Komponenten miteinander verknüpft werden oder auf welchen IO Pins die Peripherie agieren soll. Diese Methode der Konfiguration ist für Nutzer die genau wissen wie das System aussehen soll mit viel Aufwand verbunden. Aus diesem Grund wurde mit der Entwicklung eines Kommandozeilen-Tools bereits begonnen, welches die Möglichkeit bietet mit wenigen Kommandos Komponenten hinzuzufügen und zu verknüpfen.

Student: Lukas Freiberger
Supervisor: Tobias Schladt
Time period: 04/13/2021 - 07/13/2021

In FPGAs werden zur Speicherung der Konfigurationsdaten SRAM-Speicherzellen verwendet. Diese stellen einen flüchtigen Speicher dar, werden also bei Unterbrechung der Spannungsversorgung gelöscht. Deswegen wird an Non-Volatile (NV)-FPGAs geforscht, die nicht-flüchtigen Konfigurationsspeicher besitzen. Eine Möglichkeit, diese zu implementieren, stellen Speicherzellen auf Memristor-Basis dar.

Memristoren sind passive Bauelemente, deren Widerstandswert von der Vorgeschichte des hindurchgeflossenen Stromes abhängt. Aufgrund fehlender Erfahrungen mit der Integration von Memristor-basierten Speichern ist davon auszugehen, dass ein gewisser Anteil der Speicherzellen fehlerbehaftet ist. Diese potentiellen Fehler müssen bei der Logiksynthese für NV-FPGAs beachtet werden.

In diesem Projektseminar sollen Alternativen zu den in FPGAs genutzten Look-Up-Tables im Hinblick auf ihre Fehlertoleranz untersucht werden. Dabei spielen alternative Funktionsdarstellungen, alternative Tabellenstrukturen sowie gänzlich neue Schaltungsstrukturen eine Rolle.

Student: Tobias Steinbach
Supervisor: Tobias Schladt
Time period: 04/12/2021 - 07/12/2021

In FPGAs werden zur Speicherung der Konfigurationsdaten SRAM-Speicherzellen verwendet. Diese stellen einen flüchtigen Speicher dar, werden also bei Unterbrechung der Spannungsversorgung gelöscht. Deswegen wird an Non-Volatile (NV)-FPGAs geforscht, die nicht-flüchtigen Konfigurationsspeicher besitzen. Eine Möglichkeit, diese zu implementieren, stellen Speicherzellen auf Memristor-Basis dar.

Memristoren sind passive Bauelemente, deren Widerstandswert von der Vorgeschichte des hindurchgeflossenen Stromes abhängt. Aufgrund fehlender Erfahrungen mit der Integration von Memristor-basierten Speichern ist davon auszugehen, dass ein gewisser Anteil der Speicherzellen fehlerbehaftet ist. Diese potentiellen Fehler müssen bei der Logiksynthese für NV-FPGAs beachtet werden.

In dieser Arbeit soll untersucht werden, inwiefern potentiell fehlerhafte Speicherzellen die Logik-Funktionen sowie das Placement und Routing für FPGAs beeinflussen. Dazu soll die Ausfallwahrscheinlichkeit einer Speicherzelle modelliert und in das FPGA-Modell einer bestehenden Logiksynthese-Toolchain (Verilog-to-Routing) integriert werden.

Student: Ali Al Hannawi
Supervisor: Johanna Rohde
Time period: 10/14/2017 - 03/14/2018

Nur für Projektseminar "Rekonfigurierbare Systeme" im Master

Das SpartanMC SoC Kit ist eine Toolchain zur Erzeugung von FPGA basierten Systemen. Zentraler Bestandteil ist ein Softcore, der durch verschiedene Hardwarekomponenten erweitert und mit Hilfe der Toolchain programmiert werden kann. Ein Forschungsprojekt innerhalb des SpartanMC SoC Kit befasst sich mit der Entwicklung eines GCC Plugins zur automatischen Erzeugung von Hardwarebeschleunigern. Das Plugin führt dazu eine statische Programmanalyse des Programmcodes durch und wählt eigenständig die Schleifen aus, die voraussichtlich die größte Ausführungszeit benötigen. Anschließend wird deren Funktionalität mit Hilfe einer High Level Synthese als Hardwarebeschleuniger implementiert.

Um die Menge an Instruktionen, die parallel ausgeführt werden können, zu erhöhen, kann es sinnvoll sein die innersten Schleifen abzurollen. Dafür stellt der GCC eine Transformation bereit, der eine Analyse vorausgeht, die bestimmen soll, ob eine solche Transformation im Hinblick auf Geschwindigkeit und Größe des Programmcodes sinnvoll ist. Für die High-Level-Synthese gelten jedoch andere Rahmenbedingungen, so dass die Analyse zu einem für diesen Zweck ungeeignetem Ergebnis kommt.

Teil dieser Aufgabe ist es, zu Analysieren in wie weit die vom GCC bereit gestellten Transformationen und Analysen für die Entwicklung eines Loop Unrolling dienlich sind. Anschließend soll ein Loop Unrolling ggf. auf Basis der vom GCC bereitgestellten Methoden implementiert werden.

Student: Philipp Müller
Supervisor: Ramon Wirsch
Time period: 10/01/2021 - 02/20/2022

Am Fachgebiet Rechnersysteme werden mehrere taktgenaue Simulatoren verwendet. Die neuesten 3 davon, basieren auf der gemeinsamen Grundlage des Simulator Frameworks.

Die Simulatoren werden für Benchmarks und Tests verwendet und sollen in Zukunft auch in studentischen Praktika für Aufgaben genutzt werden. Hierzu sollen sie möglichst schnell laufen.

Im Rahmen dieses Projektseminars sollen insbesondere zwei Methoden zur Beschleunigung des Frameworks erprobt werden. Beide sind dabei unabhängig von der simulierten Zielarchitektur zu nutzen, so dass sie möglichst für alle Simulatoren Vorteile bringen.

Es soll sowohl die Byte Code Generierung zur Laufzeit für simple, aber besonders Performance kritische stellen erprobt werden, also auch die automatische Source Code Generierung. Beide Verfahren erlauben so dem Framework eine automatische Anpassung auf die Zielsimulation, für eine Beschleunigung. Beide Verfahren sind ausführlich zu evaluieren. Die Ergebnisse könnten in anderen Arbeiten als Grundlage für die weitere, simulations-spezifische Beschleunigung genutzt werden.

Student: Simon Vetter
Supervisor: Ramon Wirsch
Time period: 12/04/2020 - 03/01/2021

Am Fachgebiet Rechnersysteme werden Hardwarebeschleuniger für eine Reihe von Architekturen entwickelt, unter anderem für RISC-V und IBM Z-Architekturen. Hierzu sollen reguläre Programme zur Laufzeit analysiert und partiell mit dem Hardwarebeschleuniger ausgeführt werden können, ohne dass sie vorher dafür angepasst werden müssen.

Für die partielle Optimierung und Ausführung auf dem Beschleuniger müssen Code-Abschnitte zu einer speziellen Kontrollflussgraphendarstellung konvertiert werden. Hierzu müssen die Binärdaten in effizient maschinell verarbeitbare Instruktionen übersetzt werden. Anschließend können diese Instruktionen in die vorgegebene Darstellung in Static-Single-Assignment Form konvertiert werden, die alle nötigen Informationen enthält, um diesen Code zu testen, zu optimieren und auf den Beschleuniger abzubilden.

Im Rahmen dieser Arbeit soll der bestehende Konverter um die Dissassemblierung von üblichen x86 Programmen nachgerüstet werden. Damit würden 2 der popärsten CISC Architekturen unterstützt werden. Weiterhin soll die Implementierung mit den beiden existierenden Versionen für RISC-V und Z abgeglichen werden, um eine möglichst universelle Vorlage zur Umsetzung weiterer Architekturen zu erhalten.

Student: Felix Hübner
Supervisor: Ramon Wirsch
Time period: 06/28/2021 - 11/01/2021

Am Fachgebiet Rechnersysteme werden Hardwarebeschleuniger für eine Reihe von Architekturen entwickelt, unter anderem für die RISC-V Architektur. Hierzu sollen reguläre Programme zur Laufzeit analysiert und partiell mit dem Hardwarebeschleuniger ausgeführt werden können, ohne dass sie hierzu vorher angepasst werden müssen.

In einer anderen Arbeit wurde schon ein Demonstrationssystem bestehend aus dem Taiga RISC-V Prozessor und einem CGRA-Hardwarebeschleuniger erstellt. Noch ist dieses System allerdings nicht in der Lage den RISC-V Code zur Laufzeit mit alternativen Instruktionen zu überschreiben, die das CGRA als Hardwarebeschleuniger einsetzen.

Im Rahmen dieser Arbeit soll deshalb der Instruktions-Cache von Taiga zum Daten-Cache kohärent gemacht werden. Weiterhin muss auch auf die Kohärenz von weiteren Daten, wie denen des Branch-Predictors geachtet werden.

Die korrekte Funktionalität soll mit einem Beispiel-Programm nachgewiesen werden, das zuerst den original Code ausführt und anschließend den Code patched, um mit dem CGRA die 2. Ausführung zu beschleunigen.

Student: Kai Meinhard
Supervisor: Ramon Wirsch
Time period: 10/24/2019 - 03/01/2020

Am Fachgebiet Rechnersysteme wird ein Hardwarebeschleuniger für RISC-V Prozessoren entwickelt. Hierzu sollen reguläre Programme ohne jegliche Anpassungen an den Hardwarebeschleuniger zur Laufzeit analysiert und partiell mit dem Hardwarebeschleuniger ausgeführt werden können.

Um die Analyse und Synthese für den Beschleuniger zu evaluieren, soll im Rahmen dieser Arbeit ein Simulator geschaffen werden, der sowohl den RISC-V Befehlssatz als auch den Beschleuniger simulieren kann. Dieser Simulator soll als Platform für die weitere Entwicklung dienen und muss daher für RISC-V kompilierte Binärdateien laden können. Da der Simulator hauptsächlich rechenlastige Benchmarks ausführen können soll, mit denen die Hardwarebeschleunigung in anderen Arbeiten evaluiert werden kann, muss nur eine rudimentäre Schnittstelle zu einem Betriebsystem implementiert werden.

Es existiert bereits ein modulares, in Java/Kotlin implementiertes Framework, dass den Hardwarebeschleuniger und eine andere Prozessor-Architektur simulieren kann, welches als Grundlage verwendet werden kann.

Student: Felix Retsch
Supervisor: Alexander Schwarz
Time period: 04/15/2019 - 08/16/2019

Derzeit wird am Fachgebiet Rechnersysteme ein Java-Prozessor auf Basis des AMIDAR-Modells implementiert, der aus mehreren unabhängigen Funktionseinheiten (FUs) besteht und verschiedene Möglichkeiten der dynamischen Anpassung an die Software bereitstellt. Der Prozessor führt bisher Java Bytecode in fast unveränderter Form in Hardware aus. Allerdings ist Java Bytecode nicht für die Ausführung in Hardware konzipiert, weshalb das Potenzial des AMIDAR-Modells damit nur schwer voll auszuschöpfen ist.

Im Rahmen dieser Arbeit soll eine binäre Codierung für die NISA-Instruktionen entwickelt werden, die später zur Ausführung in Hardware fähig ist. Anschließend sollen Software-Komponenten entwickelt werden, die die existierende Repräsentation eines Programms in Form von Java-Objekten in eine binäre Datei exportieren und aus dieser wieder importieren können.

Student: Erik Kubaczka
Supervisor: Tobias Schladt
Time period: 12/01/2020 - 10/01/2021

Das Ziel der Synthetischen Biologie ist es, biochemische Systeme von Grund auf neu zu entwickeln. Dabei spielen neben biologischen und chemischen Verfahren Methoden aus den Ingenieurswissenschaften und der Informationstechnik eine entscheidende Rolle. So wird unter anderem daran geforscht, digitale Schaltungen auf Basis genetischer Mechanismen in biologischen Zellen zu implementieren.

Für die Synthese dieser genetischen Schaltkreise kommen bisher vor allem Verfahren zum Einsatz, die nicht an die Rahmenbedingungen der Synthetischen Biologie angepasst sind. So ist die Bibliothek zur Verfügung stehender Logikgatter stark eingeschränkt und es kommt zu komplexen biochemischen Wechselwirkungen zwischen einzelnen Bausteinen. Die Robustheit einzelner Schaltungsimplementierungen kann dabei durch Simulation ermittelt werden. Das Technology Mapping, also die Wahl von Bibliotheksgattern als Realisierungen für Gatter der Schaltung, stellt somit ein kombinatorisches Optimierungsproblem dar.

In dieser Arbeit soll ein Technology Mapping-Algorithmus für genetische Schaltkreise auf Basis des Branch-and-Bound-Ansatzes entwickelt werden. Dieser soll Teillösungen mit Hilfe eines optimistischen Schätzers bewerten und gegebenenfalls vom weiteren Suchprozess ausschließen.

Student: Heiko Schüßler
Supervisor: Johanna Rohde
Time period: 02/25/2019 - 07/15/2019

Das SpartanMC SoC Kit ist eine Toolchain zur Erzeugung von FPGA basierten Systemen. Zentraler Bestandteil ist ein Soft-core, der durch verschiedene Hardwarekomponenten erweitert und mit Hilfe der Toolchain programmiert werden kann. Ein Forschungsprojekt innerhalb des SpartanMC SoC Kit befasst sich mit der Entwicklung des PIRANHA GCC Plugins zur automatischen Erzeugung von Hardwarebeschleunigern. PIRANHA führt dazu eine statische Programmanalyse des Programmcodes durch und wählt eigenständig die Schleifen aus, die voraussichtlich die größte Ausführungszeit benötigen. Anschließend wird deren Funktionalität mit Hilfe einer High-Level Synthese als Hardwarebeschleuniger implementiert.

Spekulation bezeichnet ein Verfahren zur Reduzierung des Kontrollflusses. Dabei werden beide Blöcke einer if/else Verzweigung spekulativ ausgeführt und die relevanten Ergebnisse werden hinterher durch Mutliplexer ausgewählt. Dies erhöht sowohl die Anzahl der parallel ausführbaren Instruktionen als auch die Effizienz von weiteren Optimierungen wie Chaining oder Loop Pipelining.

Die derzeitige Implementierung kann dabei nur simplen Kontrollfluss auflösen. Komplexere Strukturen, die z.B. durch verkettete Bedingungen entstehen, werden nicht optimiert.

Aufgabe dieses Projektseminares ist es, eine Mehrwegespekulation zu implementieren und dadurch die Performance der generierten Hardwarebeschleuniger zu verbessern. Durch die Optimierung des Algorithmus soll es möglich sein, Fälle abzudecken, bei denen mehr als zwei Wege zwischen dem Ausgangs- und dem Mergeblock existieren.

Student: David Volz
Supervisor: Johanna Rohde
Time period: 04/23/2020 - 11/01/2020

Ein Forschungsprojekt am Fachgebiet Rechnersysteme der TU Darmstadt befasst sich mit der automatischen Erzeugung von Hardware-Beschleunigern. Das entwickelte GCC-Plugin führt dazu eine statische Programmanalyse des Programmcodes durch und wählt eigenständig die Schleifen aus, die voraussichtlich die größte Ausführungszeit benötigen. Anschließend wird deren Funktionalität mit Hilfe einer High Level Synthese (HLS) als Hardwarebeschleuniger implementiert.

Den Flaschenhals stellen dabei die Speicherzugriffe dar. Über ein Cache-System können zwar mehrere Speicherzugriffe gleichzeitig ausgeführt werden, dennoch kommt es bei Cache-Misses und dem anschließenden Laden aus dem Hauptspeicher zu langen Wartezeiten.

Ziel dieser Arbeit ist es, einen Level-2 Cache zu entwickeln und in das Cache-System zu integrieren. Dabei ist zu beachten, dass das Cache-System in seiner Modularität nicht eingeschränkt wird. Derzeit kann neben der Wortbreite und der Anzahl an Level-1 Caches z.B. auch das Kohärenzprotokoll vom Nutzer ausgewählt werden. So soll in Zukunft die Verwendung des Level-2 Caches als zusätzliche Option möglich sein.

Dieses Projektseminar ist so konzipiert, dass es idealerweise die Voraussetzung für die Masterarbeit "Implementierung einer Prefetch Engine für HLS" realisiert.

Student: Daniel Ortiz
Supervisor: Johanna Rohde
Time period: 05/07/2020 - 11/07/2020

Ein Forschungsprojekt am Fachgebiet Rechnersysteme der TU Darmstadt befasst sich mit der automatischen Erzeugung von Hardware-Beschleunigern. Das entwickelte GCC-Plugin (PIRANHA) führt dazu eine statische Programmanalyse des Programmcodes durch und wählt eigenständig die Schleifen aus, die voraussichtlich die größte Ausführungszeit benötigen. Anschließend wird deren Funktionalität mit Hilfe einer High Level Synthese (HLS) als Hardwarebeschleuniger implementiert.

Um die Menge an Instruktionen, die parallel ausgeführt werden können, zu erhöhen, kann es sinnvoll sein die innersten Schleifen abzurollen. Dafür stellt der GCC eine Optimierung bereit. Dieser geht jedoch eine Analyse voraus, die bestimmen soll, ob eine solche Transformation im Hinblick auf Geschwindigkeit und Größe des Programmcodes sinnvoll ist. Für die High-Level-Synthese gelten jedoch andere Rahmenbedingungen, so dass die Analyse zu einem für diesen Zweck ungeeignetem Ergebnis kommt. In der Vergangenheit wurde deswegen eine eigene Optimierung implementiert, welche sowohl das komplette Abrollen als auch das partielle Abrollen von Schleifen ermöglicht.

Dennoch bleibt ungelöst, wann und in welchem Umfang das Abrollen einer Schleife für die High Level Synthese die beste Performance liefert. Ziel dieses Projektseminares ist es deswegen, mit Hilfe von Machine Learning einen Entscheider zu entwickeln.

Student: Julian Käuser und Simon Gütthoff
Supervisor: Dennis Wolf und Tajas Ruschke
Time period: 09/01/2017 - 03/28/2018

Wir suchen im Rahmen des Projektes Ultrasynth zwei Hilfswissenschaftler. Ihr sollt in Zusammenarbeit regelungstechnische Anwendungen auf CGRAs auf mehreren Ebenen simulieren. Es sollen eine High-Level Simulation und eine Simulation in ModelSim durchgeführt und abgeglichen werden. So können Fehler sowohl im Scheduling, als auch in der Hardware, erkannt und deren Quelle gefunden werden.

Bewerbungen sind nicht als Team erforderlich. Logischerweise teilen sich die Aufgabenbereiche auf die zwei Simulationen auf. Für die High-Level Simulation sollte der Inhalt der Vorlesung High-Level Synthese bekannt sein. Für die HDL Simulation werden gute Kenntnisse über (System-)Verilog vorausgesetzt. Außerdem wird Erfahrung mit Java bei beiden Anstellungen erwarten. Eine Vergütung von 36h pro Monat bis voraussichtlich Februar ist angesetzt.

Student: David Lippmann
Supervisor: Dr. Siegmar Schöne
Time period: 05/16/2008 - 05/16/2008

Student: Stefan Döbrich
Supervisor: Dipl. Inf. Stephan Gatzka
Time period: 06/01/2003 - 06/02/2003