Design of special purpose processor architectures (BUILDABONG)

Internally funded project


Acronym: BUILDABONG

Start date : 01.10.1998

End date : 31.01.2009

Website: https://www.cs12.tf.fau.de/forschung/projekte/buildabong


Project details

Short description

In this project we consider the problems of conception and compiler support for application-specific instruction-set processors (ASIPs). Examples of such processors are digital signal processors (DSPs) and microcontrollers. Treated are the challenging problems of systematic design and simulation of application-specific processors and the development and exploration of better compilation methods to support them.
In the course of this project the tool ArchitectureComposer has been developed. The designer chooses from a library customizable building blocks to compose graphically his desired architecture. This is done by connecting instantiated components with each other. The library contains a lot of necessary building blocks for the processor design such as register files, memories, multiplexers, arithmetic and logic units, busses, and others. If necessary, it might be extended by further modules like caches, special interconnect structures, etc. All components are parametric, e.g., the word width of the modules can be chosen arbitrarily. Realistic microprocessors such as a MIPS processor or a DSP from Texas Instruments TMS320C6 series have been successfully modeled within hours.
ArchitectureComposer offers a hierarchical architecture entry to handle complex systems and to reuse already designed subsystems. Furthermore, HDL-generators allow the direct synthesis of microprocessors out of their graphical description. Generators for VHDL and Verilog are available. A generator for the specification language SystemC is currently being developed.
From the graphical architecture description a mixed structural/behavioral model of the architecture is generated automatically. This model is based on the formalism of Abstract State Machines (ASM). Additionally, a debugging and simulation environment which allows verifying the functionality of the given architecture on pipeline-cycle accurate and instruction-cycle accurate levels can be generated. Compared to existing microprocessor simulators a dedicated simulator is generated for a given architecture. This simulator offers several convenient features like traces, breakpoints and other profiling functions. Since the microprocessors’ behavior can be described in a compact form by ASMs, a substantial increase of the simulation speed can be achieved. To increase the simulation performance even more, we currently investigate the automatic generation of C++-based compiled simulators which exploit efficient graph partitioning and BDD strategies.
Modern microprocessors allow the parallel execution of several instructions on a number of functional units. Thus, compilers must be able to support this parallel execution, to build so-called very long instruction words (VLIW), and during compilation from high-level languages to assembly code, they must be able to analyze the data dependencies to generate efficient parallel code. Therefore, the compiler needs information of the architecture’s properties which are automatically extracted from the graphic entry. We use a retargetable ANSI C compiler with a set of sophisticated transformations, for instance, dead code elimination, variable propagation, loop unrolling, and a lot more. During code creation, an assembler program is generated from the information of the available functional units and the resource allocation.
During the composition of processors and their compilers, architecture changes with according compiler modifications can be analyzed in an exploration loop. Here, an exploration methodology has been developed for walking through the complex design space of architecture and compiler parameters returning the best architecture/compiler co-design solutions for a given application class (benchmark) to fulfill given constraints, e.g., code size, execution time, hardware resources, etc.

Scientific Abstract

Betrachtet werden die Probleme der Modellierung, Simulation und des systematischen Entwurfs anwendungsspezifischer Instruktionssatzprozessoren (engl. application-specific instruction-set processors, ASIPs). Dazu gehören beispielsweise digitale Signalprozessoren (DSPs) und Mikrocontrollerarchitekturen. Untersucht werden neuartige Simulationskonzepte sowie bessere Compilerverfahren zur Unterstützung dieser Klasse von Architekturen.
Im Rahmen dieses Projekts ist ein Entwurfssystem zur Computer-Architektur und Compiler Co-Generierung entstanden. Es beinhaltet komfortable Werkzeuge zur halbautomatischen Exploration optimaler Architektur-/Compiler-Entwürfe und zur schnellen, bitgenauen und zyklentreuen Simulation.
Ausgangspunkt eines Entwurfs ist das Werkzeug „ArchitectureComposer“. Der Entwickler wählt aus einer Bibliothek Komponenten aus und komponiert seine Architektur graphisch, indem er instanziierte Komponenten miteinander verbindet. Die Bibliothek enthält viele für den Prozessorentwurf notwendige Basisblöcke, wie arithmetische Einheiten, Speicherbausteine, Registerbänke, Multiplexer u. a., und kann gegebenenfalls um weitere Module, wie Caches, spezielle Verbindungsnetzwerke, etc., erweitert werden. Alle Komponenten sind parametrisiert, so dass beispielsweise die Wortbreite der Einheiten individuell ausgewählt werden kann. Realistische Mikroprozessoren, u. a. ein MIPS-Prozessor und ein Digitaler Signalprozessor der Texas Instruments TMS320C6-Serie, konnten erfolgreich innerhalb von Stunden entworfen werden.
Um bereits entworfene Teilsysteme mehrfach instanziieren zu können, bietet „ArchitectureComposer“ die Möglichkeit, hierarchischer Komponenten. Ferner existiert ein VHDL-Codegenerator, der die direkte Hardwaresynthese eines Mikroprozessors aus dessen graphischer Beschreibung mittels „ArchitectureComposer“ ermöglicht. Derzeit wird ein entsprechender Generator für die Spezifikationssprache SystemC entwickelt.
Aus der graphischen Eingabe wird automatisch ein gemischtes Struktur-/Verhaltensmodell der Architektur, basierend auf dem Formalismus sog. „abstrakter Zustandsmaschinen“ (ASM), generiert. Ebenfalls automatisch wird eine architekturspezifische Simulationsumgebung erzeugt, die in der Lage ist, die entworfene Prozessorarchitektur bit- und zyklengetreu zu simulieren. Um die bitgenaue Simulation der Ausführung von Instruktionen zu ermöglichen, wird eine Bibliothek von Operationen auf beliebigen Wortlängen und Zahlendarstellungen verwendet. Die Spezifikation des Anwendungsprogramms erfolgt derzeit in Assemblernotation der entsprechenden Zielarchitektur. Die Generierung eines Parsers für die Simulatoreingabe der Assemblerprogramme wird ebenfalls von der Simulationsumgebung unterstützt.
Gegenüber bekannten Simulatoren für Mikroprozessoren wird bei unserem Ansatz ein Simulator speziell für die eingegebene Architektur generiert. Dieser Simulator ermöglicht es, ein vorgegebenes Programm schrittweise abzuarbeiten. So können beliebige interne Signale im Prozessor während des Simulationsablaufs als Testpunkte ausgewählt und Datenwerte an diesen Punkten beobachtet werden. Dieser Ansatz ist flexibler als bei statischen Simulatoren, die meistens nur Speicher- und Registerwerte anzeigen können. Da sich das Verhalten von Prozessoren sehr kompakt mittels ASMs modellieren lässt, kann eine erhebliche Steigerung der Simulatorperformanz erzielt werden im Vergleich zu Modellierungsansätzen gleicher Simulationsgenauigkeit, die auf Hardwarebeschreibungssprachen basieren. Um die Simulatorperformanz nochmals erheblich zu steigern, wird derzeit die Generierung von in C++ compilierten Simulatoren untersucht. Hierbei kommen effiziente Graphpartitionierungs-Strategien zum Einsatz.
Bei modernen Mikroprozessoren können oft mehrere Instruktionen gleichzeitig auf mehreren funktionalen Einheiten abgearbeitet werden. Um diese parallele Abarbeitung zu unterstützen, muss ein Compiler in der Lage sein, bei der Übersetzung eines Hochsprachenprogramms in Maschinencode die Abhängigkeiten von Daten zu analysieren und parallelen Code zu generieren. Dazu braucht er Information über Maschineneigenschaften, welche direkt aus der eingegebenen Architektur extrahiert werden können. Wir setzen einen retargierbaren Compiler für ANSI C-Code ein, der zahlreiche Optimierungen auf dem Zwischencode unterstützt, u. a. Elimination von redundantem Code, Propagation von Variablen und Schleifenentfaltung. In der Codegenerierungsphase wird aus der Information über die Anzahl funktionaler Einheiten und der Ressourcenbelegung während der Instruktionsabarbeitung ein Maschinenprogramm generiert, das der Simulator direkt verarbeiten kann.
Architekturänderungen mit entsprechenden Compileranpassungen können in einer Schleife zur Exploration von optimalen Architektur-/Compiler-Systemen untersucht werden. Für eine modifizierte Architektur wird der Compiler angepasst und eine Menge von Benchmarkprogrammen übersetzt und auf dem ebenfalls generierten Simulator simuliert. Dies erfolgt völlig automatisch. Als Ergebnis liefert der Simulator Statistiken über Ausführungszeiten, Codegrößen von Modulen und andere Optimierungsgrößen zurück. Interessant sind hier diejenigen Architektur-/Compiler-Systeme, die bezüglich Kosten der Architektur und Effizienz des durch den Compiler generierten Codes optimal sind für eine gegebene Menge von Benchmarkprogrammen. Geeignet zu instrumentieren sind hier die Möglichkeiten der Änderbarkeit der Architektur und die Art der Anwendung von Codeoptimierungsverfahren. Beide zusammen stellen den Suchraum dieses komplexen Optimierungsproblems dar.
Unsere zukünftigen Forschungen beschäftigen sich mit Erweiterungen des Projekts zur Modellierung, Simulation und des systematischen Entwurfs von so genannten rekonfigurierbaren Instruktionssatzprozessoren (engl. reconfigurable instruction-set processors, RISPs).

Involved:

Contributing FAU Organisations: