Retargetable code generation based on an architecture description language [Elektronische Ressource] / vorgelegt von Manuel Hohenauer

Sujets

• Informatik

Informations

• Publié par: rheinisch-westfalischen_technischen_hochschule_-rwth-_aachen
• Publié le: 01 janvier 2009
• Nombre de lectures: 11
• Langue: Deutsch
• Poids de l'ouvrage: 8 Mo

Extrait

Retargetable Code Generation based on
an Architecture Description Language
Von der Fakult¨at fu¨r Elektrotechnik und Informationstechnik
der Rheinisch–Westf¨alischen Technischen Hochschule Aachen
zur Erlangung des akademischen Grades eines
Doktors der Ingenieurwissenschaften genehmigte Dissertation
vorgelegt von
Diplom–Ingenieur
Manuel Hohenauer
aus Krefeld/Nordrhein-Westfalen
Berichter:
Universit¨atsprofessor Dr. rer. nat. Rainer Leupers
Universit¨atsprofessorin Dr. rer. nat. Sabine Glesner
Tag der mu¨ndlichen Pru¨fung:
9. Januar 2009
Diese Dissertation ist auf den Internetseiten der Hochschulbibliothek online verfu¨gbar.Zusammenfassung
Die stetig wachsende Komplexit¨at und die zunehmenden Leistungsanforderungen neuer Anwen-
dungen aus den Bereichen drahtlose Kommunikation, Automotive oder Consumer Elektronik
haben den Entwurf und die Implementierung eingebetteter Systeme nachhaltig beeinflusst. Der
aktuelleTrendgehthinzuprogrammierbarenSystem-on-Chip(SoC)-Plattformen. DieFlexibilit¨at
von Software verbesserert die Design Effizienz und reduziert das Risiko und die Kosten von Hard-
ware Neuentwicklungen. Immer mehr solcher SoC-Schaltungen verwenden dabei Prozessoren mit
anwendungsspezifischemInstruktionssatz(ASIPs)alsBausteine. SiebietenausgezeichneteEigen-
schaften in Bezug auf Rechenleistung, Leistungsaufnahme und Stu¨ckkosten. Dementsprechend
sind immer mehr kommerzielle Plattformen fu¨r einen effizienten Entwurf von ASIPs verfu¨gbar.
Diese Plattformen bestehen aus retargierbaren Softwareentwicklungswerkzeugen (C-compiler, As-
sembler, Linker, Simulator etc.), welche sich schnell an verschiedene Prozessorkonfigurationen an-
passenlassen. DieEingangsbeschreibungsolcherWerkzeugeistu¨blicherweiseeinProzessormodell,
das in einer dedizierten Architektur Beschreibungssprache (ADL) beschrieben wird. Fortschritt-
lichere ADL k¨onnen zus¨atzlich ein synthetisierbares Hardwaremodell aus derselben Beschreibung
erzeugen.
Die gr¨oßte Herausforderung beim Entwurf einer ADL ist es, die Architekturbeschreibung fu¨r die
Erzeugung der einzelnen Werkzeuge eindeutig und konsistent zu erfassen. Das ist insbesondere
fu¨r den Compiler und den Simulator schwierig, denn beide brauchen die Informationen u¨ber
die Semantik der Instruktionen, allerdings aus einem anderen Blickwinkel. Ein Compiler, oder
genauer der Codeselektor, erfordert haupts¨achlich die Information, was eine Instruktion tut, um
C-Quellcode in ¨aquivalente Assemblerinstruktionen zu u¨bersetzen. Demgegenu¨ber ben¨otigt der
SimulatordieInformation,wieeineInstruktionausgefu¨hrtwird. Praktischistes¨außerstschwierig,
wennnichtunm¨oglich,dieeineInformationausderanderenherzuleiten. BisherigeADLbasierende
Ans¨atzeschr¨ankendaherentwederdiem¨oglichenZielarchitekturenerheblichein,oderunterstu¨tzen
nur die Generierung eines der beiden Softwarewerkzeuge.
Eine weitere Herausforderung in diesem Zusammenhang ist die retargierbare Kompilierung fu¨r
iiiiv
Hochsprachen wie C/C++. Mittlerweile sind Compiler unabdingbar geworden, um eine hohe
Softwareentwicklungsproduktivit¨at zu erzielen und die stetig wachsende Komplexit¨at heutiger
Anwendungen zu beherrschen. Retargierbare C-Compiler sind, verglichen mit handgeschriebenen
CompilernoderAssemblerProgrammen, allerdingsoftdurchihregeringeCodequalit¨atbehindert.
¨UblicherweisegibteshiereinenAbtauschzwischenderFlexibilit¨atdesCompilersundderQualit¨at
deserzeugtenCodes. UmdieseLu¨ckeinderCodequalit¨atzuschliessen, werdenflexible, retargier-
bare Optimierungen ben¨otigt, welche sich schnell an sich ¨andernde Zielprozessorkonfigurationen
anpassen lassen.
Zur L¨osung dieser Problemstellungen sind in dieser Arbeit Konzepte entwickelt und implemen-
tiert worden, die eine vollst¨andigen Codeselektorbeschreibung automatisch aus einer ADL erzeu-
gen k¨onnen. 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¨onnen Compiler, als Teil des LISA basierten Entwicklungsprozesses, vol-
lautomatischretargiertwerdenundsindsomitschonfru¨hinderArchitekturentwicklungverfu¨gbar.
Dies tr¨agt zu einem insgesamt effizienteren Entwurfsprozess bei. Um eine hohe Flexibilit¨at hin-
sichtlich verschiedener Zielarchitekturen gew¨ahrleisten zu k¨onnen, ist die Entwicklung von drei
sehrunterschiedlichen,realexistierendenProzessorenvorangetriebenworden. Weiterhinsindzwei
popul¨areArchitekturklassenausgew¨ahltworden,diespezifischeOptimierungstechnikenben¨otigen.
Es handelt sich dabei um ASIPs mit Unterstu¨tzung fu¨r Single Instruction Multiple Data (SIMD)
und Predicated Execution. Diese Arbeit implementiert diese Techniken derart, dass Retargier-
barkeit und hohe Codequalit¨at fu¨r die gegebene Prozessorklasse erreicht werden k¨onnen. Daru¨ber
hinaus beschreibt sie einen retargierbarer Assembler zur effizienten Entwicklung von Optimierun-
gen auf Maschinencodeebene (z.B. Peephole-Optimierungen).Abstract
Overthepastfewyears,theeverincreasingcomplexityandperformancerequirementsofnewwire-
less communications, automotive and consumer electronics applications are changing the way em-
beddedsystemsaredesignedandimplementedtoday. Thecurrenttrendistowardsprogrammable
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 de-
velopment 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
neededforthetoolgenerationinanunambiguousandconsistentway. Thisisparticularlydifficult
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
practiceitisquitedifficult,ifnotimpossible,toderiveoneinformationfromtheother. Noneofthe
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 lan-
guages 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 com-
vvi
piler’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 auto-
matically 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 with-
out 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 sup-
port. 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 assem-
bler which provides an application programmer interface for user defined code optimizations like
e.g. a peephole optimizer.Acknowledgements
This thesis is the result of more than 5 years of work during which I have been accompanied
andsupportedbymanypeople. Itisnowmygreatpleasuretotakethisopportunitytothankthem.
First and foremost, I