2015

Bachelor Theses

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: 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: 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: 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: 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

FPGAs sind heute in der Lage, externe digitale Signale mit sehr hoher Abtastrate zu erfassen. Zusätzlich enthalten moderne FPGAs auch noch DRAM-Kontroller, die in der Lage sind, die abgetasteten Signale mit hoher Bandbreite abzuspeichern. Somit hat man alle Zutaten beisammen, die für einen Low-Cost Logic Analyzer gebraucht werden.
Ziel der Arbeit ist es, auf einem vorhandenen FPGA-Board (Xilinx Spartan-6 mit DDR3 und USB-Verbindung zum PC) einen Logic-Analyzer mit folgenden Merkmalen zu implementieren:

  • 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
Die Arbeiten sind in Verilog auszuführen, optional kann eine Visualisierung hinzugenommen werden (am besten in Java, da plattformunabhängig).

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

Am Fachgebiet Rechnersysteme wird an adaptiven Prozessorstruk- turen geforscht. Die Familie der AMIDAR Prozessoren basiert da- bei auf einem Modell, welches an der Professur Mikrorechner der TU Dresden entwickelt wurde. Dieses Modell erlaubt es dem Pro- zessor zur Laufzeit einer Applikation auf deren spezifische Anfor- derungen zu reagieren. Hierzu zählen sowohl die Anpassung von Busstrukturen, als auch die Anpassung von bestehenden und die Synthese von neuen Funktionseinheiten (FU). Zur Zeit wird an einer Hardwareimplementierung von AMIDAR gearbeitet, welche sich aber bei der Ausführung vom aktuellen Simulator unterscheidet. Um das Verhalten der Hardwareimple- mentierung von AMIDAR nachbilden zu können, sind Änderun- gen an den einzelnen Funktionseinheiten vonnöten. Diese sind im Zuge dieser Arbeit durchzuführen und das Zusammenspiel dieser neuen Funktionseinheiten ist ausführlich zu testen.

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

An der Professur Mikrorechner der TU Dresden wurde das Modell eines adaptiven Prozessors entwickelt. 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 kompaktes Speicherlayout (z.B. durch Nutzung eines gemeinsamen Constant-Pools) für den Code-Memory eines Java-Prozessors entworfen werden. Dafür muss ein Werkzeug realisiert werden, welches die Klassendateien von Java laden kann und sie in eine passende, kompakte interne Darstellung umwandelt. Hierbei sollen alle symbolischen Referenzen einer Klassendatei während des Ladens aufgelöst und durch relative/absolute Adressen ersetzt werden (static binding). Dies hat zur Folge, dass alle referenzierten Klassen auch rekursiv geladen werden müssen. Nachdem alle Klassen eines Java Programms bereits komplett geladen und resolviert sind, sollen diese anhand des Speicherlayouts in eine binäre Datei exportiert werden, welche sich direkt auf das FPGA herunterladen lässt, in welchem der AMIDAR Prozessor implementiert wird.

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

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 (FU). Zur Zeit existieren in AMIDAR unter anderem die Funktionseinheiten Operandstack, Methodstack und Local Variable Memory. Im Zuge dieser Arbeit soll überprüft werden, ob eine Bündelung dieser drei FUs in eine einzige FU die Ausführung von Java Programmen auf AMIDAR beschleunigt. Zu diesem Zweck soll der AMIDAR Simulator dementsprechend umgebaut werden. Dazu sind unter anderem Änderungen an den jeweiligen FUs sowie der Token Machine vonnöten.

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

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.
Bisherige Arbeiten (www.amidar.de) haben gezeigt, dass ein deutliches Beschleunigungspotential für Applikationen im Bereich der eingebetteten Systeme besteht.
Ziel dieser Arbeit soll es sein, eine Floating-Point-ALU auf Basis des bestehenden Prozessormodells auf einem FPGA in Verilog zu implementieren. Die dadurch entstehende ALU soll dann alle Floating-Point-Operationen ausführen können, welche durch das AMIDAR-Modell definiert sind.

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

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.
Ziel dieser Arbeit soll es sein, eine Integer-ALU auf Basis des bestehenden Prozessormodells auf einem FPGA in Verilog zu implementieren. Dabei soll die Anzahl der benutzten Pipeline-Stufen mit einem Parameter festgelegt werden können. Die dadurch entstehende ALU soll dann alle Integer-Operationen ausführen können, welche durch das AMIDAR Modell definiert sind.

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

An der Professur Mikrorechner der TU Dresden wurde das Modell eines adaptiven Prozessors entwickelt. 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.
Bisherige Arbeiten (www.amidar.de) haben gezeigt das ein deutliches Beschleunigungspotential für Applikationen im Bereich der eingebetteten Systeme besteht.
Ziel dieser Arbeit soll es sein, den Heap eines AMIDAR basierten Java-Prozessor um einen Garbage Collector zu erweitern. Dieser soll auf einem FPGA in Verilog implementiert werden. Der dadurch entstehende Garbage Collector soll parallel mit dem Prozessor laufen können, ohne (oder möglichst selten) die fließende Ausführung einer Anwendung unterbrechen zu müssen.
Teilaufgaben:
  • 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

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 Object-Heap auf AMIDAR-Basis für einen Java-Prozessor realisiert werden. Die Speicherung von Objekten und Arrays soll in externem DRAM-Speicher stattfinden. Dafür müssen die Speicherlayouts für normale Objekte und Array-Objekte neu entworfen werden, um alle im Java-Bytecode definierten Heap-Operationen unterstützen zu können. Außerdem muss hierbei auch eine effiziente Cache-Struktur berücksichtigt werden um den Zugriff auf den Heap möglichst zu beschleunigen.

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

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 (FU). Zur Zeit wird an einer Hardwareimplementierung von AMIDAR gearbeitet, welche sich aber bei der Ausführung vom aktuellen Simulator unterscheidet. Um das Verhalten der Hardwareimplementierung von AMIDAR nachbilden zu können, sind einige Änderungen vonnöten. Darunter sind Einbindung des AXT-Loaders, Definition von Schnittstellen zwischen AXT-Loader und bestimmten FUs, sowie die Anpassung des Busses an die Hardwareimplementierung. Dies wird außerdem zum Anlass genommen, den Simulator tiefergehend zu Überarbeiten, um kürzere Simulationszeiten sowie bessere Anpassbarkeit des Simulators zu erreichen.

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

An der Professur Mikrorechner der TU Dresden wurde das Modell eines adaptiven Prozessors entwickelt. 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.
Bisherige Arbeiten (www.amidar.de) haben gezeigt das ein deutliches Beschleunigungspotential für Applikationen im Bereich der eingebetteten Systeme besteht.
Im Rahmen dieser Arbeit sollen die beiden vorhandenen ALUs wie folgt optimiert werden:
  • 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

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.

Student: Melanie Braun
Supervisor: Kris Heid
Time period: 02/22/2016 - 07/22/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.
Das bisherige SpartanMC-SoC-Kit ermöglicht bereits das komfortable Zusammenstellen eines SoC nach eigenen Wünschen über eine grafische Oberfläche. Jedoch muss der Nutzer Aus-/Eingänge der hinzugefügten Komponenten manuell verknüpfen und konfigurieren, was eine sehr zeitraubende und fehleranfällige Arbeit ist.
Durch diese Arbeit soll der Schritt der manuellen Konfiguration nahezu hinfällig werden. Hierzu sollen alle Komponenten mit Intelligenz in Form von ausführbaren LUA-Skripten in deren Modulbeschreibung ausgestattet werden. Durch diesen Schritt könnten sich die Komponenten beim Hinzufügen selbst konfigurieren und beispielsweise bereits eindeutig zusammengehörige Ein-/Ausgänge miteinander verknüpfen. Hierdurch würde diese Arbeit die SoC Konfiguration innerhalb von einem Bruchteil der bisherigen Zeit ermöglichen und außerdem die Komplexitätshürde erheblich senken.

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

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.
Auf modernen FPGAs können mehrere dieser Kerne Platz finden. Die einzelnen Kerne können über FIFO basierte Kommunikationsstrukturen paarweise miteinander verbunden werden, um Daten untereinander auszutauschen. Bei einer großen Zahl gleichzeitig zu realisierender Verbindungen kann die paarweise Bereitstellung von FIFOs für jede Kommunikationsbeziehung zu einer relativ ineffizienten Ressourcennutzung führen.
Ziel der Arbeit ist es einen Verteiler (Dispatcher), respektive Konzentrator zu erstellen, der die Kommunikation zwischen den Rechenkernen bündelt. Dies soll zum einen die Verknüpfung der Rechenkerne vereinfachen und zum anderen den Hardwareaufwand verringern.

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

Der SpartanMC ist ein CPU-Core der speziell auf die Anforderungen und Ressourcen von FPGAs zugeschnitten ist. Neben der Entwicklung neuer Peripheriekomponenten für den SpartanMC wird auch ständig an Erweiterungen und Verbesserungen des Prozessors selbst gearbeitet.
Um die Funktionalität des Prozessors nach solchen Erweiterungen zu sichern, ist eine gute Testumgebung für Regressionstests unerlässlich. Deshalb soll im Rahmen der Arbeit eine Testumgebung implementiert werden, die es ermöglicht, sowohl den kompletten Befehlssatz als auch relevante Kombinationen von Befehlen zu testen. Dazu soll ein Testfallgenerator entwickelt werden, mit dem es möglich ist, entsprechenden Testcode zur Verhaltenssimulation, zum Test des Prozessor in realer Hardware und für den SpartanMC Simulator zu erstellen. Dabei muss es möglich sein ohne hohen Aufwand das Testszenario um zusäzliche Tests, zum Beispiel für neue Befehle, zu erweitern.

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

Der SpartanMC ist ein Prozessor der speziell für die Verwendung in FPGAs entwickelt wurde. Der Simulator soll um ein Timer und Echtzeit-Interrupt Modul ergänzt werden. In den meisten Anwendungen für Mikrokontroller werden zeitabhängige Signale ausgelöst. Um solche Programme auch auf dem Simulator testen zu können, sollen diese I/O-Baugruppen auch in den Simulator eingebunden werden.

Student: Laurenz Kamp
Supervisor: Kris Heid
Time period: 08/01/2016 - 11/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. Um die Performance bestehender Software des SpartanMC möglichst genau zu analysieren und zu verbessern ist es nötig die Ausführungszeit verschiedener Abschnitte der Firmware zu kennen. Ein denkbarer Ansatz wäre einen Peripherie-Counter zu nutzen und in der Firmware den Zählerstand an gewissen stellen abzufragen und zu Speichern. Dies würde allerdings die Ausführungszeit verfälschen, da bei diesem Schritt die Firmware abgeändert würde. Ein wesentlich genaueres Ergebnis würde man durch die Integration eines Counters direkt in den SpartanMC Core erhalten. Ziel dieser Arbeit ist daher einen solchen Counter in den SpartanMC zu integrieren. Der Counter soll eine Tabelle von Speicheradressen erhalten zwischen denen die Ausführungszeit gemessen werden soll. Um dies zu ermöglichen müsste der Counter das PC-Register des Prozessor snoopen und mit den Speichertabellen vergleichen. Am Ende der Arbeit sollte in jConfig eine Option Performance Analyse wählbar sein und der Nutzer sollte anschließend in der Firmware Annotationen einfügen an welchen Punkten gemessen werden soll.

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

Am Fachgebiet Rechnersysteme (und an der Professur Mikrorechner der TU Dresden) wird ein SoC-Kit rund um den SpartanMC Soft-Core entwickelt. Zur einfachen Generierung des SoCs steht dem Anwender eine System-Builder-Software (jConfig) zur Verfügung. Mit Hilfe dieses Werkzeugs ist es möglich ohne detaillierte Hardware-Kenntnisse ein SoC zu erstellt.
Bisher wird das erstelle SoC jedoch nur in Form eines Baums in der GUI von jConfig dargestellt, wodurch bei umfangreicheren Projekten leicht die Übersicht verloren gehen kann. Deshalb soll im Rahmen dieser Arbeit eine grafische Visualisierung des SoCs in jConfig integriert werden, die dem Anwender einen Überblick über alle integrierten Hardware-Module und deren Verbindungen liefert.

Student: Ramon Wirsch
Supervisor: Kris Heid
Time period: 10/13/2014 - 03/13/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.
Um die Funktionalität von Prozessoren sowie Debugging zu ermöglichen wird auf Prozessoren zusätzliche Hardware verwendet, die es ermöglicht den aktuellen Zustand des Prozessors und aller Register einzusehen. Hierfür benötigt der Prozessor Break-Point Instrunktion, die es ermöglichen einen Schappschuss des aktuellen Zustands auszulösen. In Break-/Watch-Point Registern wird dieser Zustand dann zwischengespeichert. In einem letzten Schritt geht es nun darum den Prozessorzustand für den Anwender anschaulich wiederzugeben. Hier ist es denkbar ein Mini-Monitor als Java-Anwendung aus dem Computer zu erstellen und die Informationen grafisch aufzubereiten.
Ziel dieser Arbeit ist es diese Funktionalität in den SpartanMC Prozessor zu integrieren.

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

Mit dem SpartanMC SoC-Kit wurde an der Professur Mikrorechner ein Werkzeug entwickelt, welches es erlaubt, mit geringem Aufwand ein FPGA basiertes System-on-Chip (SoC) zu entwerfen und zu programmieren.
Am Beispiel einer so genannten Zeitwaage (Wikipedia) soll dieser Entwurfszyklus exemplarisch komplett durchlaufen werden (von der Bauteilauswahl, über das Platinendesign, bis zu Inbetriebnahme und Programmierung).

Student: Carsten Heinz
Supervisor: Kris Heid
Time period: 02/16/2015 - 05/04/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.
Durch die außergewöhnlichen Bitbreite und den eigenen Befehlssatz bietet kein Compiler die Kompilierung von SpartanMC C-Programmen "Out of the Box" an. Aus diesem Grund wurde der Gnu Compiler Collection (GCC) angepasst.
Zum jetzigen Zeitpunkt unterstützt der angepasste Compiler allerdings noch keine vollständige Implementierung der Lib C. Diese ist erforderlich um alle Standard-Methoden beispielsweise zur Speicherverwaltung, mathematische Operationen oder Ein- und Ausgabe Funktionen zugänglich machen zu können.
Ziel dieser Arbeit ist es, die fehlenden Funktionen wie vom GCC gefordert für SpartanMC in die Lib C zu implementieren und somit für den Nutzer zugänglich zu machen.

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

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.
Für diesen Mikrokontroller soll ein minimales Echtzeit-Betriebssystem entworfen werden, welches die folgenden Funktionen enthalten soll:

  • Task-Verwaltung mit Prioritäten
  • Semaphore als Synchronisationsmechanismus
  • Einfache Speicherverwaltung
Gegebenenfalls müssen hierfür auch noch Änderungen an der Hardware des Prozessorkerns durchgeführt werden.

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

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.
Im Rahmen dieser Arbeit soll der Befehlscode des SpartanMC optimiert werden. Durch Zuweisung verschiedener Binärmuster zu einzelnen Teilgruppen des Befehlssatzes soll die resultierende Decodierlogik im Prozessor minimiert werden. Gleichzeitig soll dabei natürlich nicht die maximale Taktfrequenz eingeschränkt werden.

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

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 SpartanMC wurde, wie der Name nahe legt, auf Spartan3 FPGAs von Xilinx entwickelt. Implementiert und eingesetzt wurde er bisher auch auf den FPGA-Familien Spartan6 und Virtex5. Grundsätzlich lässt sich der Prozessorkern aber auch auf beliebigen anderen FPGA-Familien (insbesondere auch von anderen FPGA-Herstellern) verwenden.
In einer früheren Arbeit wurde bereits mit der Portierung des SpartanMC Core auf Lattice und Altera begonnen. In dieser Arbeit soll die Portierung der Peripherie Module in Angriff genommen und getestet werden. Des weiteren ist die Lattice Toolchain zu vervollständigen.
Als Test Plattform für die Portierung stehen DE0-Nano Boards mit Altera Cyclone IV FPGAs sowie ein LatticeECP3 Evaluation Board zur Verfügung.

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

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 SpartanMC wurde, wie der Name nahe legt, auf Spartan3 FPGAs von Xilinx entwickelt. Implementiert und eingesetzt wurde er bisher auch auf den FPGA-Familien Spartan6 und Virtex5. Grundsätzlich lässt sich der Prozessorkern aber auch auf beliebigen anderen FPGA-Familien (insbesondere auch von anderen FPGA-Herstellern) verwenden.
Ziel dieser Arbeit soll die Anpassung der SpartanMC- Verilog Quellen sein, um das SoC-Kit mit ALTERA FPGAs verwenden zu können. Hardware, die zur Zeit noch durch spezielle Xilinx-Primitive realisiert wird, muss entweder durch generischen Verilog-Code oder durch andere geeignete Primitive der ALTERA FPGAs ersetzt werden. Im Weiteren muss auch die Einbindung der ALTERA Synthese-Tools kontrolliert werden.
Als Plattform für die Portierung stehen DE0-Nano Boards mit Altera Cyclone IV FPGAs zur Verfügung.

Student: Nourhan El-Hamawy
Supervisor: Kris Heid
Time period: 03/29/2016 - 08/30/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.
Zur Programmierung des SpartanMC wird die GNU Toolchain verwendet. Darin werden die Binutils für das Handling von Objekt-Dateien und Binärprogrammen verwendet. Leider unterstützt die aktuelle Portierung der Binutils nicht die Verarbeitung von Debug-Informationen.
Durch eine frühere Arbeit wurden bereits weitestgehend DWARF konforme Debug Daten während der Kompilierung erzeugt. In dieser Arbeit sollen diese Daten nun ausgewertet und die Informationen als Sourcecode-Annotationen in den SpartanMC Simulator eingetragen werden. Dieser Schritt ermöglicht das Debugging von Programmen nicht nur auf Assembler- sondern auch wesentlich komfortabler auf C-Ebene.

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

Der SpartanMC ist ein an der TU Dresden / Professur für Mikrorechner entwickelter CPU-Core, der speziell für die Verwendung in FPGAs zugeschnitten ist. Aufgrund dieser Zielplattform nutzt der SpartanMC eine Befehls- und Datenbreite von 18 Bit, welche die Strukturen aktueller FPGAs optimal ausnutzt.
Im Rahmen dieser Arbeit soll ein Tool entstehen, dass in einem bereits komplett gerouteten und platzierten FPGA-Design (Xilinx-Toolchain) des SpartanMC die BlockRAM-Inhalte gezielt austauschen kann, um ein verändertes Programm in den Bitstream zu schreiben.
Hierzu soll das XDL-Format verwendet werden. Dieses Format stellt eine textuelle Repräsentation des kompletten Designs dar und wird vom gleichnamigen Xilinx Tool (xdl) generiert. Ziel der Arbeit ist das Erstellen eines Tools, dass ein derartiges XDL-File einliest, und den darin enthaltenen BlockRAM-Instanzen neue Speicherinhalte zuordnet. Wichtig ist dabei insbesondere die korrekte Zuordnung der logischen BlockRAM-Instanzen auf HDL-Ebene zu den physikalischen Instanzen auf Chipebene.

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: 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: 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: 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.

Master Theses

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

Ziel der Arbeit ist die Analyse von C-Code für die anschließende Umwandlung in einen Graphen. Dabei sollen Pragmas gefunden werden und die Live-In und Live-Out Variablen, sowie Array-Zugriffe gefunden werden. Diese werden benötigt, um eine Ausführung auf dem CGRA vorzubereiten und zu starten. In einer anschließenden Masterarbeit kann die vollständige Graphgenerierung implementiert und getestet werden.

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

Ziel der Arbeit ist der Entwurf und die Implementierung eines Schedulers für ein generisches, resourcenbasiertes CGRA-Modell. Dafür müssen die abzubildenden Operationen aus einem Kontroll- und Datenflussgraphen ausgelesen werden und unter Berücksichtigung der belegten Elemente korrekt auf das Modell abgebildet werden. Für die Teilaufgaben des Schedulers und der Kontextgenerierung sind sinnvolle Schnittstellen zu erstellen.

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

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. Dabei ist eine zentrale Frage, ob und bis zu welcher Problemgröße auch exakte Lösungen verwendet werden können.

Ziel dieser Arbeit ist der Entwurf eines Modells und eines Verfahrens, welches das Schedulingproblem in ein Problem der Ganzzahligen linearen Optimierung (engl. integer linear programming, ILP) überführt und mit fertigen ILP-Bibliotheken löst.

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

Am Fachgebiet Rechnersysteme der TU Darmstadt wird der Einsatz von Coarse Grained Reconfigurable Arrays (CGRAs) als anpassbare Programmbeschleuniger erforscht. Dafür wird ein Problem als Graph formuliert und muss anschließend auf ein veränderbares Hardwaresystem abgebildet werden. Dabei müssen Einschränkungen in den zur Verfügung stehenden Recheneinheiten und deren Verbindungen berücksichtigt werden.

Ziel dieser Arbeit ist die Implementierung eines Graphgenerators, der Optimierungen (z.B. Entfernen gemeinsamer Teilausdrücke, Abrollen von Schleifen etc.) auf das Problem anwenden kann und schleifenübergreifende Abhängigkeiten in Arrays findet.

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.

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. Ein iterativer Ansatz verspricht Verbesserungen in der Ergebnisqualität.

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.

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. Bei der Abbildung des Graphen rückwärts vorzugehen verspricht eine Vereinfachung bei der Lösung des Routingproblems. Als alternative zur bisher umgesetzten spekulativen Operationsausführung soll eine prädizierte Ausführung angewendet werden.

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

Modern embedded processors offer trace interfaces that make internal state information available to the outside world. This can be used to create low overhead instrumentation of the software in the embedded device. This instrumentation can be used to compute e.g. code coverage. Within this work the following subtasks should be accomplished:
  • 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

Die Professur für Rechnersysteme untersucht Debug- und Trace-Schnittstellen moderner Mikrocontroller. Von besonderem Interesse sind dabei die Möglichkeiten, die sich durch eine direkte Verarbeitung der Trace-Daten in FPGAs ergeben. Dabei werden die Daten nicht in Rohform gespeichert und später am Rechner ausgewertet, sondern aus den Rohdaten wird intern der Programmablauf rekonstruiert, um anschließend nur noch für jede Speicherstelle die Anzahl an Ausführungen zu speichern. Damit lässt sich der Nachweis für Code-Abdeckung über lange Zeiträume realisieren. Dieses Verfahren wird bereits für Trace-Schnittstellen der Varianten ARM-ETM und Nexus 2003 verwendet.
Die QorIQ P4080 Prozessoren der Firma Freescale liefern ihre Trace-Daten über die Aurora-Schnittstelle nach außen. Die Aurora-Schnittstelle besteht aus einer konfigurierbaren Zahl von High-Speed Serial Links (bis ca. 5Gb/s).

Aufgaben:
  • 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.

Ein vielversprechender Ansatz für eine neue Instruction Set Architecture (NISA), 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. Bereits entwickelt wurde eine Toolchain, die es erlaubt, Binärcode für diese ISA ausgehend von Java Bytecode zu erzeugen und anschließend zu simulieren.

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

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.
Ein effizientes Bus-System ist der Kernbestandteil des oben genannten Prozessor-Modells, da verschiedene Funktionseinheiten eines AMIDAR-Prozessors asynchron voneinander arbeiten und trotzdem riesige Informationsmengen (sowohl Befehle als auch Zwischendaten) miteinander austauschen können müssen. Hierbei kann jede Funktionseinheit gleichzeitig die Master- und Slave-Rolle einnehmen. Daher müssen in das Busprotokoll Mechanismen eingebaut werden, wie sie typischerweise in hoch performanten Multi-Master Bussen (PCI, AHB, CoreConnect) verwendet werden.
Ziel dieser Arbeit soll es sein, ein generisches Bus-Protokoll für das AMIDAR-Modell zu entwerfen und exemplarisch für einen Java-Prozessor in Verilog zu implementieren. Das dadurch entstehende Bus-System soll die Datenübertragung zwischen mehreren Funktionseinheiten möglichst effizient durchführen können (möglichst wenige Stalls).
Dafür sind die folgenden Eigenschaften des Systems gefordert:

  • 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

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 bestehenden Funktionseinheiten und Busstrukturen, als auch die Synthese von neuen Funktionseinheiten. Neue Funktionseinheiten werden auf ein CGRA abgebildet.
Im Rahmen dieser Arbeit soll ein Schedulingverfahren für das in AMIDAR verwendete generische CGRA-Modell entworfen und implementiert werden. Hierbei sind neben den bekannten Ressourcen-Beschränkungen insbesondere auch Routing-Beschränkungen durch die interne CGRA-Struktur zu beachten. Es soll möglich sein, diese Beschränkungen aus einer textuellen Beschreibung zu extrahieren.

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

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. Neue Funktionseinheiten werden auf ein CGRA abgebildet.
Im Rahmen dieser Arbeit soll nun ein CGRA für AMIDAR in Verilog entworfen werden. Der Aufbau der Processing Elements und deren Interconnect soll dabei generisch beschrieben werden. Es soll möglich sein, aus einer textuellen Beschreibung des CGRAs gültigen Verilog Code zu generieren. Konzepte zur Kommunikation zwischen dem AMIDAR Prozessor und dem CGRA sowie Mechanismen zur Steuerung des Programmablaufs müssen entworfen und umgesetzt werden.

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

An der Professur Mikrorechner wurde das Modell eines adaptiven Prozessors entwickelt. Dieses Modell erlaubt es dem Prozessor zur Laufzeit einer Applikation auf deren spezifische Anforderungen zu reagieren. Die zentrale Funktionseinheit eines AMIDAR-Prozessors ist der Token-Generator. Dessen Konfiguration wird mit Hilfe von ADLA (Abstract Description Language for AMIDAR-Processors) beschrieben.
Die erzeugten Beschreibungen werden mit Hilfe eines Parsers in eine Konfiguration für den Token Generator übersetzt. Bisher ist es allerdings nicht möglich Befehlssätze zu beschreiben deren Instruktionslänge ein Byte überschreitet, oder welche variable Befehlsbreiten enthalten.
Ziel dieser Arbeit soll es sein sowohl ADLA, als auch die ADLA-Tool-Chain so zu überarbeiten, das eine Unterstützung von Befehlssätzen mit den oben beschriebenen Charakteristika möglich ist. Weiterhin soll in der Beschreibungssprache eine Möglichkeit zur Modularisierung vorgesehen werden. Diese soll es erlauben die Beschreibung eines Token Generators auf mehrere Quellen zu verteilen.

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

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 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.
Bisherige Arbeiten (www.amidar.de) haben gezeigt, dass ein deutliches Beschleunigungspotential für Applikationen im Bereich der eingebetteten Systeme besteht.
Das aktuelle Bus-Protokoll erlaubt nur M:1 Verbindung. Das heißt dass mehrere Busse am Eingang einer einzelnen Funktionseinheit angeschlossen werden dürfen, aber deren Ausgang nur an einem dieser Busse. Die Ausbauflexibilität und Performanz des ganzen Systems wird dadurch eingeschränkt. Im Rahmen dieser Arbeit soll das Bus-Protokoll erweitert werden, um M:N Verbindung zu unterstützen. Außerdem muss das erweiterte Bus-Protokoll zusätzliche Schnittstellen besitzen damit ein CGRA nahtlos mit AMIDAR-Prozessoren verbunden werden kann.

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.

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ührlichen Tests und die Verifikation durch Eigenschaftsnachweise (Property Checking) konzentrieren.

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

An der Professur Mikrorechner der TU Dresden wurde das Modell eines adaptiven Prozessors entwickelt. 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.
Bisherige Arbeiten (www.amidar.de) haben gezeigt das ein deutliches Beschleunigungspotential für Applikationen im Bereich der eingebetteten Systeme besteht.
Der Token Generator ist eine wesentliche Komponente im AMIDAR Modell. Er verteilt die Mikroinstruktionen an alle Funktionseinheiten des Prozessors und sorgt so für die korrekte Abarbeitung von Maschinenbefehlen (hier Java Bytecode). Für die Simulation solcher Prozessoren konnte in früheren Versionen des AMIDAR-Simulators der Token Generator aus der Beschreibungssprache ADLA erzeugt werden. Im Rahmen dieser Arbeit soll zunächst der vorhandene ADLA-Compiler an die aktuellen Strukturen des Simulators angepasst werden. Im zweiten Schritt soll dann aus der ADLA Beschreibung ein Token Generator für eine FPGA Implmentierung eines AMIDAR-Prozessors erzeugt werden. Dieser Token Generator soll dabei unmittelbar auf den externen Speicher zugreifen, um sich Bytecode Befehle zu holen. Gegebenenfalls bietet sich hier der Einsatz eines Instruktions-Caches an.

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

Die Herstellungskosten von hochintegrierten Schaltkreisen steigen nichtlinear mit der Integrationsdichte an. Wesentliche Ursache dafür sind die hohen Maskenkosten, die mit der steigenden Auflösung exponentiell teurer werden. Aus diesem Grund werden zukünftige Generationen eingebetteter Systeme sehr häufig auf Multi-Project/Multi-Standard Chips basieren, von deren Funktionalität ein großer Anteil rekonfigurierbar sein wird. Diese Rekonfigurierbarkeit wird durch aktuelle Architekturen lediglich statisch - also zum Zeitpunkt des Entwurfs - genutzt. Ziel dieser Arbeit ist es, Ansätze für eine dynamische Rekonfiguration einer Hardware-Einheit zu zeigen, mit deren Hilfe es möglich wird, die interne Struktur der Ausführungseinheit adaptiv an die Erfordernisse der ausgeführten Anwendung anzupassen. Als Basis für diese Arbeiten soll dabei das Modell einer Hardware-Implementierung einer JVM dienen, da hierfür durch die Kertasarie VM sehr gute Vorkenntnisse vorhanden sind.

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

Der SpartanMC ist ein an der Professur Mikrorechner der TU Dresden entwickelter CPU-Core, der speziell auf die Verwendung in FPGAs zugeschnitten ist. Aufgrund dieser Zielplattform nutzt der SpartanMC eine Befehls- und Datenbreite von 18 Bit, welche die Strukturen aktueller FPGAs optimal ausnutzt. Aktuell wird die Weiterentwicklung dieses Prozessorkerns sowohl an der TU Dresden, als auch an der TU Darmstadt im Fachgebiet Rechnersysteme betrieben. Die Firmware von Mikrocontrollern ist häufig in Form einer endlosen while-Schleife aufgebaut, welche je nach Anwendung verschiedene Aufgaben sequenziell erledigt. Falls die Anzahl und Komplexität der Aufgaben steigt, können diese je nach Anforderung nicht mehr oft genug in einem bestimmten Zeitfenster ausgeführt werden. Denkbar wäre nun einen schnelleren Mikrocontroller zu wählen (was nicht immer möglich ist) oder manche Aufgaben auf einen weiteren Mikrocontroller auszulagern. Um Teile der Firmware auszulagern, ist der Anwender gefordert, kritische Abschnitte zu erkennen, die Firmware aufzuteilen und für die nötigen Mechanismen zum Datenaustausch zwischen den Code-Segmenten zu sorgen.

Student: Muhammad Naveed Baig
Supervisor: Kris Heid
Time period: 03/01/2015 - 09/01/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.
Das bisherige SpartanMC-SoC-Kit ermöglicht bereits das komfortable Zusammenstellen eines SoC nach eigenen Wünschen über eine grafische Oberfläche. Jedoch muss der Nutzer Aus-/Eingänge der hinzugefügten Komponenten manuell verknüpfen und konfigurieren, was eine sehr zeitraubende und fehleranfällige Arbeit ist.
Durch diese Arbeit soll der Schritt der manuellen Konfiguration nahezu hinfällig werden. Hierzu sollen alle Komponenten mit Intelligenz in Form von ausführbaren LUA-Skripten in deren Modulbeschreibung ausgestattet werden. Durch diesen Schritt könnten sich die Komponenten beim hinzufügen selbst konfigurieren und beispielsweise bereits eindeutig zusammengehörige Ein-/Ausgänge miteinander verknüpfen. Um die neue Funktionalität dem Nutzer zur Verfügung zu stellen, müsste außerdem die bestehende grafische Oberfläche angepasst werden, um diese Skripte interpretieren zu können. Hierdurch würde diese Arbeit die SoC Konfiguration innerhalb von einem Bruchteil der bisherigen Zeit ermöglichen und außerdem die Komplexitätshürde erheblich senken.

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

In Eingebetteten Systemen ist die Verwendung von Prozessoren weit verbreitet, welche über ein JTAG Interface als Programmier- und Debug-Schnittstelle verfügen. Da an der Professur für Mikrorechner häufig solche Prozessoren eingesetzt werden, wird demzufolge auch eine flexible und kostengünstige Debug-Lösung benötigt.
Ziel der Arbeit ist es einen JTAG-Debugger, mit USB Schnittstelle zum Host-PC, als Soft-Core für ein FPGA zu entwickeln. Für die FPGA Implementierung soll das SpartanMC SoC-Kit verwendet werden, welches bereits den Prozessor sowie JTAG- als auch USB-Peripherie bereit hält. Im Rahmen der Arbeit ist die Platine für das FPGA und die entsprechenden Schnittstellen zu entwickeln, sowie die Firmware für den SpartanMC zu implementieren. Dabei soll zunächst nur das Debugging von ARM7-Derivaten ausgearbeitet werden. Auf der Host-Seite sollen verschiedene Möglichkeiten untersucht werden, das Debugging zu realisieren (USB nur als Serial-Adapter, oder mittls GDB-Proxy und libUSB auf dem Host).

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

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.
Das aktuelle SpartanMC SoC Kit unterstützt leider noch keine floating point Operationen. Diese Arbeit soll daher die Unterstützung für Gleitkomma Operationen bereitstellen. Die Unterstützung soll sowohl rein softwareseitig durch Übersetzung in unterstützte Befehle als auch hardwareseitig durch spezielle Peripherie gewährleistet werden.

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: 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.

Project Seminars Bachelor

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

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. Eine zentrale Frage dabei ist, ob und bis zu welcher Problemgröße auch exakte Lösungen verwendet werden können. BULB ist ein vielversprechendes Verfahren, das relativ schnell konvergiert. Allerdings ist eine Erweiterung nötig, um auch Verbindungseinschränkungen zu berücksichtigen. Ziel dieser Arbeit ist die Weiterentwicklung des BULB-Verfahrens, um für eine vergrößerte Problemklasse anwendbar zu sein.

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

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 unterzubringen und diese über einfache send und receive Funktionen kommunizieren zu lassen. Ziel des Seminars ist es dieses Interface zu erweitern um erweiterte Funktionen wie Gruppennachrichten etc. zu unterstützen.

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

p>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.

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.

Langfristiges Ziel des Unterprojekts ist es dem User ein Tool zu geben, in welchem er nur noch auswählt, welche Komponenten das System enthalten soll, und die Konfiguration sowie die Verknüpfung derer automatisch geschieht. Als erster Schritt in diese Richtung kann das Kommandozeilen-Tool gesehen werden.

Ziel dieser Arbeit ist konkret die Weiterentwicklung des Kommandozeilen-Tools um eine automatische Vervollständigung aller momentan möglichen Befehle, was eine Konfiguration noch weiter beschleunigt. Außerdem verwendet das Kommandozeilen-Tool eine abgeänderte Version der Backend Bibliothek als das grafisches Interface. Hier sollen beide Versionen angepasst werden, um ein konsistentes Backend anzubieten.

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.

Project Seminars Master

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: 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.

Ein vielversprechender Ansatz für eine neue Instruction Set Architecture (NISA), 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. Bereits entwickelt wurde ein Code Converter, der NISA-Instruktionsfolgen aus Java Bytecode erzeugt, ein Assembler und ein Simulator für diese Instruktionen. Der Code wird dem Simulator dabei in Form von Java-Objekten übergeben. Eine binäre Codierung, die in Hardware ausführbar wäre, existiert bisher noch nicht.

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.

Hiwi Jobs

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

Es ist in Java ein Werkzeug zu erstellen, mit dem man ohne große Kenntnisse über den SpartanMC eine lauffähige Variante als Auswahl aus der Vielzahl an Interfaces und Komponenten des Prozessors erstellen kann. Alle einzustellenden Werte zu jedem Modul sollen in speziellen Modulbeschreibungsdateien stehen. Das Ziel soll es sein, ein Werkzeug zu erstellen, welches beim Hinzufügen von neuen Komponenten nicht mehr verändert werden muss. Es sollte nur die Erstellung einer neuen Modulbeschreibungsdatei notwendig sein.

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

Es geht darum, die Lego-Rotationssensoren in Betrieb zu nehmen. Die interne Elektronik des Sonsors muss zum Anfang mit einem kurzen Spannungspuls aufgeladen werden, danach liefert der Sensor je nach Winkel unterschiedliche Abstufungen von Spannungen. Genauere Informationen findet man z.B. unter: www.philohome.com Es wäre folgendes zu realisieren: Mit einem MSP430 Mikokontroller muss dieses Signal ausgewertet werden und in leicht weiterverarbeitbare Signale umgewandelt werden.