Retargetable code generation based on an architecture description language

Hohenauer, Manuel; Leupers, Rainer

doi:2886

Retargetable code generation based on an architecture description language = Retargierbare Codegenerierung basierend auf einer Architektur Beschreibungssprache

Hohenauer, Manuel (Author)

2009

Verantwortlichkeitsangabevorgelegt von Manuel Hohenauer

ImpressumAachen : Publikationsserver der RWTH Aachen University 2009

UmfangXII, 192 S. : graph. Darst.

Aachen, Techn. Hochsch., Diss., 2009

Zsfassung in dt. und. engl. Sprache

Genehmigende Fakultät
Fak06

Hauptberichter/Gutachter
Leupers, Rainer (Thesis advisor)

Tag der mündlichen Prüfung/Habilitation
2009-01-09

Online
URN: urn:nbn:de:hbz:82-opus-28862
URL: https://publications.rwth-aachen.de/record/51237/files/Hohenauer_Manuel.pdf

Einrichtungen

Lehr- und Forschungsgebiet Software für Systeme auf Silizium (611920)

Inhaltliche Beschreibung (Schlagwörter)
Anwendungsspezifischer Prozessor (Genormte SW) ; SIMD (Genormte SW) ; COSY <Compiler-Compiler> (Genormte SW) ; Ingenieurwissenschaften (frei) ; retargierbare Compiler (frei) ; ASIP (frei) ; architecture description language (frei) ; retargetable compiler (frei) ; predicated execution (frei)

Thematische Einordnung (Klassifikation)
DDC: 620
ccs: D3.4 * C.3 * C.1.1 * C.1.2 * C.0

Kurzfassung
Die stetig wachsende Komplexität und die zunehmenden Leistungsanforderungen neuer Anwendungen aus den Bereichen drahtlose Kommunikation, Automotive oder Consumer Elektronik haben den Entwurf und die Implementierung eingebetteter Systeme nachhaltig beeinflusst. Der aktuelle Trend geht hin zu programmierbaren System-on-Chip (SoC)-Plattformen. Die Flexibilität von Software verbesserert die Design Effizienz und reduziert das Risiko und die Kosten von Hardware Neuentwicklungen. Immer mehr solcher SoC-Schaltungen verwenden dabei Prozessoren mit anwendungsspezifischem Instruktionssatz (ASIPs) als Bausteine. Sie bieten ausgezeichnete Eigenschaften in Bezug auf Rechenleistung, Leistungsaufnahme und Stückkosten. Dementsprechend sind immer mehr kommerzielle Plattformen für einen effizienten Entwurf von ASIPs verfügbar. Diese Plattformen bestehen aus retargierbaren Softwareentwicklungswerkzeugen (C-compiler, Assembler, Linker, Simulator etc.), welche sich schnell an verschiedene Prozessorkonfigurationen anpassen lassen. Die Eingangsbeschreibung solcher Werkzeuge ist üblicherweise ein Prozessormodell, das in einer dedizierten Architektur Beschreibungssprache (ADL) beschrieben wird. Fortschrittlichere ADL können zusätzlich ein synthetisierbares Hardwaremodell aus derselben Beschreibung erzeugen. Die grösste Herausforderung beim Entwurf einer ADL ist es, die Architekturbeschreibung für die Erzeugung der einzelnen Werkzeuge eindeutig und konsistent zu erfassen. Das ist insbesondere für den Compiler und den Simulator schwierig, denn beide brauchen die Informationen über die Semantik der Instruktionen, allerdings aus einem anderen Blickwinkel. Ein Compiler, oder genauer der Codeselektor, erfordert hauptsächlich die Information, was eine Instruktion tut, um C-Quellcode in äquivalente Assemblerinstruktionen zu übersetzen. Demgegenüber benötigt der Simulator die Information, wie eine Instruktion ausgeführt wird. Praktisch ist es äußerst schwierig, wenn nicht unmöglich, die eine Information aus der anderen herzuleiten. Bisherige ADL basierende Ansätze schränken daher entweder die möglichen Zielarchitekturen erheblich ein, oder unterstützen nur die Generierung eines der beiden Softwarewerkzeuge. Eine weitere Herausforderung in diesem Zusammenhang ist die retargierbare Kompilierung für Hochsprachen wie C/C++. Mittlerweile sind Compiler unabdingbar geworden, um eine hohe Softwareentwicklungsproduktivität zu erzielen und die stetig wachsende Komplexität heutiger Anwendungen zu beherrschen. Retargierbare C-Compiler sind, verglichen mit handgeschriebenen Compilern oder Assembler Programmen, allerdings oft durch ihre geringe Codequalität behindert. Üblicherweise gibt es hier einen Abtausch zwischen der Flexibilität des Compilers und der Qualität des erzeugten Codes. Um diese Lücke in der Codequalität zu schliessen, werden flexible, retargierbare Optimierungen benötigt, welche sich schnell an sich ändernde Zielprozessorkonfigurationen anpassen lassen. Zur Lösung dieser Problemstellungen sind in dieser Arbeit Konzepte entwickelt und implementiert worden, die eine vollständigen Codeselektorbeschreibung automatisch aus einer ADL erzeugen können. Der Ansatz basiert auf der Language for Instruction Set Architectures (LISA) ADL und einer Spracherweiterung zur konsistenten Beschreibung der Semantik von Instruktionen. Als Ergebnis dieser Arbeit können Compiler, als Teil des LISA basierten Entwicklungsprozesses, vollautomatisch retargiert werden und sind somit schon früh in der Architekturentwicklung verfügbar. Dies trägt zu einem insgesamt effizienteren Entwurfsprozess bei. Um eine hohe Flexibilität hinsichtlich verschiedener Zielarchitekturen gewährleisten zu können, ist die Entwicklung von drei sehr unterschiedlichen, real existierenden Prozessoren vorangetrieben worden. Weiterhin sind zwei populäre Architekturklassen ausgewählt worden, die spezifische Optimierungstechniken benötigen. Es handelt sich dabei um ASIPs mit Unterstützung für Single Instruction Multiple Data (SIMD) und Predicated Execution. Diese Arbeit implementiert diese Techniken derart, dass Retargierbarkeit und hohe Codequalität für die gegebene Prozessorklasse erreicht werden können. Darüber hinaus beschreibt sie einen retargierbarer Assembler zur effizienten Entwicklung von Optimierungen auf Maschinencodeebene (z.B. Peephole-Optimierungen).

Over the past few years, the ever increasing complexity and performance requirements of new wireless communications, automotive and consumer electronics applications are changing the way embedded systems are designed and implemented today. The current trend is towards programmable System-on-Chip platforms in order to improve the design efficiency and reduce the risk and costs of hardware redesign cycles. An increasing number of such systems employ Application Specific Instruction-set Processors (ASIPs) as building blocks due to their balance between computational efficiency and flexibility. Consequently, more and more commercial platforms are available for ASIP architecture exploration and design. These platforms comprise retargetable software development tools (C-compiler, assembler, linker, simulator etc.) that can be quickly adapted to varying target processor configurations. Such tools are usually driven by a processor model given in a dedicated Architecture Description Language (ADL). Advanced ADLs are even capable of generating the system interfaces and a synthesizable hardware model from the same specification. The most challenging task designing an ADL, though, is to capture the architectural information needed for the tool generation in an unambiguous and consistent way. This is particularly difficult for compiler and simulator as they essentially need both the information about the instruction's semantics but from different points of view. The compiler, more specifically the compiler's code selector, needs to know what an instructions does in order to select appropriate instructions for a given piece of source code, while the simulator needs to know how the instruction is executed. In practice it is quite difficult, if not impossible, to derive one information from the other. None of the existing ADLs - if compiler generation is supported at all - solves this problem in a sophisticated manner. Either redundancies are introduced or the language's flexibility is sacrificed. Another challenge in this context is retargetable compilation for high-level programming languages like C/C++. Meanwhile, compilers became a necessity in order to attain high software development productivity and to cope with the ever growing complexity of today's applications. Retargetable C compilers however, are often hampered by their limited code quality as compared to hand-written compilers or assembly code since there is usually a trade-off between the compiler's flexibility and the quality of compiled code. In order to narrow the code quality gap this demands flexible retargetable optimization techniques for common architectural features which can be quickly adapted to varying target processor configurations. This thesis presents a novel technique for extracting the code selector description fully automatically from ADL processor models. The approach is based on the Language for Instruction Set Architectures (LISA) ADL using a language extension for instruction semantics description. This enables the automatic generation of C compilers from a LISA processor description without loosing flexibility or introducing inconsistencies. In this way, a high speedup in compiler generation is achieved, that contributes to a more efficient ASIP design flow. The feasibility of the approach is demonstrated for several contemporary embedded processors. Furthermore, two popular architectural classes are selected which demand for specific code optimization techniques, namely processors equipped with SIMD instructions and those with Predicated Execution support. This thesis implements these specific techniques such that retargetability and high code quality within the given processor class are obtained. Moreover, to ease the manual creation of dedicated optimizations on the assembly level, this thesis implements a new retargetable assembler which provides an application programmer interface for user defined code optimizations like e.g. a peephole optimizer.

Fulltext:
PDF