2016

Bachelor-Arbeiten

Student*in: Florian Prott
Betreuer*in: Boris Dreyer
Zeitraum: 01.05.2015 - 12.06.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*in: Hu Yue
Betreuer*in: Boris Dreyer
Zeitraum: 20.10.2015 - 20.01.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*in: Steffen Grimm
Betreuer*in: Philip Gottschling
Zeitraum: 01.11.2015 - 30.04.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*in: Karsten Müller
Betreuer*in: Lukas Jung
Zeitraum: 02.11.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*in: Patrick Appenheimer
Betreuer*in: Lukas Jung
Zeitraum: 27.06.2016 - 26.11.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*in: Hendrik Schöffmann
Betreuer*in: Lukas Jung
Zeitraum: 01.01.2016 - 01.04.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*in: Marek Völker
Betreuer*in: Changgong Li
Zeitraum: 01.12.2015 - 01.05.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*in: Jakob Karg
Betreuer*in: Changgong Li
Zeitraum: 01.03.2016 - 01.08.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*in: Melanie Braun
Betreuer*in: Kris Heid
Zeitraum: 22.02.2016 - 22.07.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*in: Joris Beringer
Betreuer*in: Kris Heid
Zeitraum: 01.10.2015 - 01.03.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*in: Laurenz Kamp
Betreuer*in: Kris Heid
Zeitraum: 01.08.2016 - 01.11.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*in: Felix Sterzelmaier
Betreuer*in: Kris Heid
Zeitraum: 19.10.2015 - 21.03.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*in: Mohammadmehdi Peiro
Betreuer*in: Kris Heid
Zeitraum: 01.07.2016 - 01.12.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*in: Nourhan El-Hamawy
Betreuer*in: Kris Heid
Zeitraum: 29.03.2016 - 30.08.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.

Master-Arbeiten

Student*in: Hengxin Zhou
Betreuer*in: Tajas Ruschke
Zeitraum: 16.05.2016 - 15.11.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*in: Lukas Jäger
Betreuer*in: Dennis Wolf
Zeitraum: 07.04.2016 - 07.10.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*in: Thomas Ballenthin
Betreuer*in: Boris Dreyer
Zeitraum: 15.10.2015 - 15.03.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*in: Philipp Käsgen
Betreuer*in: Philip Gottschling
Zeitraum: 01.04.2016 - 30.09.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*in: Marcel Jourdan
Betreuer*in: Changgong Li
Zeitraum: 01.03.2016 - 01.09.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*in: Jan Andresen
Betreuer*in: Changgong Li
Zeitraum: 01.11.2015 - 01.05.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*in: Syed Abdul Majid Ali
Betreuer*in: Dennis Wolf
Zeitraum: 01.04.2016 - 30.09.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*in: Alexander Weisel
Betreuer*in: Changgong Li
Zeitraum: 25.04.2016 - 25.10.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*in: Alexander Schwarz
Betreuer*in: Changgong Li
Zeitraum: 01.10.2015 - 31.03.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*in: Taimoor Naveed
Betreuer*in: Tajas Ruschke
Zeitraum: 04.04.2016 - 04.10.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*in: Gregor Koch
Betreuer*in: Kris Heid
Zeitraum: 07.10.2015 - 07.04.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*in: Steven Leduc
Betreuer*in: Kris Heid
Zeitraum: 01.10.2015 - 01.04.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*in: Jakob Wenzel
Betreuer*in: Christian Hochberger
Zeitraum: 01.10.2015 - 31.03.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.

Projektseminare Bachelor

Student*in: Philipp Käsgen
Betreuer*in: Philip Gottschling
Zeitraum: 01.12.2015 - 31.03.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*in: Melanie Braun
Betreuer*in: Kris Heid
Zeitraum: 11.09.2015 - 03.02.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.