INAUGURAL - DISSERTATION zur Erlangung der Doktorwürde der Naturwissenschaftlich - Mathematischen Gesamtfakultät der Ruprecht - Karls - Universität Heidelberg vorgelegt von Dipl.-Phys. Gerhard Lienhart aus Bühl Tag der mündl. Prüfung: 19. Juli 2004 Beschleunigung Hydrodynamischer Astrophysikalischer Simulationen mit FPGA-Basierten Rekonfigurierbaren Koprozessoren Gutachter: Prof. Dr. Reinhard Männer Prof. Dr. Volker Lindenstruth Beschleunigung Hydrodynamischer Astrophysikalischer Simulationen mit FPGA-Basierten Rekonfigurierbaren Koprozessoren Zusammenfassung Diese Dissertation befasst sich mit der Anwendung rekonfigurierbarer Koprozessoren zur Beschleunigung astrophysikalischer Simulationsalgorithmen, ausgehend von einer hybriden Plattform aus Standardrechner und einem Rechenbeschleuniger für die Gravitationssimulation (GRAPE). Für Simulationen, die eine Berücksichtigung der Hydrodynamik erforderlich machen, schränkt die dazu eingesetzte Simulationsmethode Smoothed Particle Hydrodynamics (SPH) die erzielbare Rechenleistung des Gesamtsystems stark ein. Es wurde der Ansatz verfolgt, durch den Einsatz einer FPGA-basierten Koprozessorplattform das SPH-Verfahren zu beschleunigen. Analysen der Simulationscodes ergaben, dass die SPH-Berechnungen unter Verwendung von Gleitkommazahlen mit 16 Mantissenbits ausreichend genau sind. Um den Ansatz zu realisieren, wurde ein FPGA-Koprozessor in Form einer PCIEinsteckkarte verwendet, ausgestattet mit einem modernen Virtex-II-3000-FPGA von Xilinx. Es wurden FPGA-Designs entwickelt, welche für die umfangreichen aber einfach strukturierten SPHBerechnungen bei ausreichend hoher Rechengenauigkeit eine Rechenleistung von über 3 GFlops erreichen. Dazu wurde eine Bibliothek arithmetischer Module für die rekonfigurierbare Logik entwickelt. Alle Module sind bezüglich der Rechengenauigkeit parametrisiert, und es wurden für verschiedene numerische Randbedingungen spezialisierte Operatoren entwickelt. Damit konnten optimal an die Problemstellung angepasste Rechenwerke in Form einer Pipeline aufgebaut werden. Für die SPHPipelines konnten 50-60 Gleitkommaoperationen unter Aufwendung von etwa 50 % der FPGARessourcen implementiert werden, mit einer resultierenden Geschwindigkeit von 66 MHz. Die Schaltungen sind in der Lage, die Berechnungen synchron zur maximalen Datenrate von Speicher und PCIInterface durchführen. Um das Beschleunigungspotential (etwa Faktor 10) effektiv auszuschöpfen, wird eine tiefgehende Umstrukturierung des Simulationsalgorithmus erforderlich, was Gegenstand der weiteren Forschung sein wird. Acceleration of Astrophysical Hydrodynamics Simulations with FPGA-Based Reconfigurable Coprocessors Abstract This dissertation deals with the application of reconfigurable coprocessors for accelerating astrophysical simulation systems, where a simulation system consisting of a host workstation and an accelerator platform for the gravity part of the simulation (i.e. GRAPE) was presumed as given. For simulation algorithms which also deal with hydrodynamics, it shows, that the method of smoothed particles hydrodynamics (SPH) which is usually used for this purpose causes a bottleneck for the overall performance of the system. Therefore the approach was chosen to accelerate the time-critical calculation steps of SPH by an FPGA-based coprocessor. By studying the astrophysical code it was shown, that calculations based on floating-point numbers with 16 mantissa bits lead to a sufficient precision for SPH. To realize the accelerator a PCI-based FPGA-coprocessor featuring a modern Xilinx Virtex-II-3000 FPGA was used. FPGA designs were developed which are able to deal with the extensive but simple structured SPH calculations at sufficient precision. With these designs a performance of more than 3 GFlops has been achieved. For the arithmetics a library of modules parameterized in precision and specialized for different numerical situations has been developed. With this library it was possible to synthesize calculation units as a pipeline, optimally matched for the problem. The SPH pipelines, consisting of 50 to 60 operators, were successfully implemented in about 50 % of the FPGA resources with a resulting speed of 66 MHz. The design is able to perform the calculations synchronously with the data rate of the PCI bus and memory. A Speedup of 10 for SPH seems within reach, but for efficient utilization of the calculation power a deep re-design of the simulation algorithm will be necessary which is subject to further research. Inhaltsverzeichnis 1 Einführung 1.1 Problemstellung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.2 Aufbau der Arbeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 Astrophysikalische Simulationsverfahren 2.1 Allgemeine Simulationsmethodik . . . . . . . . . . . . . . . . . 2.1.1 Numerische Simulation der zeitlichen Entwicklung . . . . 2.1.2 Klassifizierung der Dynamik astrophysikalischer Systeme 2.2 Simulation der Gravitation . . . . . . . . . . . . . . . . . . . . . 2.2.1 Direkte N-Körper-Simulation . . . . . . . . . . . . . . . 2.2.2 Baumbasierte Verfahren . . . . . . . . . . . . . . . . . . 2.2.3 Gitterbasierte Verfahren . . . . . . . . . . . . . . . . . . 2.3 Smoothed Particle Hydrodynamics . . . . . . . . . . . . . . . . . 2.3.1 Allgemeine Methode von SPH . . . . . . . . . . . . . . . 2.3.2 Weitverbreitete spezielle SPH-Formulierung . . . . . . . 2.3.3 Variationen des SPH-Verfahrens . . . . . . . . . . . . . . 2.3.4 Einbettung in Simulation der Gravitation . . . . . . . . . 2.4 Simulationsplattformen . . . . . . . . . . . . . . . . . . . . . . . 2.4.1 Hochleistungsrechner . . . . . . . . . . . . . . . . . . . . 2.4.2 Spezialrechner . . . . . . . . . . . . . . . . . . . . . . . 3 Rekonfigurierbare Rechnerplattformen 3.1 Rekonfigurierbare Logikbausteine . . . . . . . . . . . 3.1.1 Allgemeine Architektur von FPGAs . . . . . . 3.1.2 Details zur verwendeten FPGA-Serie Virtex-II 3.1.3 Programmierung von FPGAs . . . . . . . . . . 3.2 Allgemeine Systemarchitektur . . . . . . . . . . . . . 3.2.1 Rekonfigurierbare Rechensysteme . . . . . . . 3.2.2 Rekonfigurierbare Koprozessoren . . . . . . . 3.3 Verwendete rekonfigurierbare Plattform . . . . . . . . i . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 1 2 . . . . . . . . . . . . . . . 3 3 4 4 5 5 6 8 9 9 12 18 19 20 20 21 . . . . . . . . 27 27 27 29 36 37 38 38 38 ii 4 5 6 INHALTSVERZEICHNIS Computerarithmetik 4.1 Ganzzahlen . . . . . . . . . . . . . . . . . . . . . . . 4.1.1 Darstellungsmöglichkeiten ganzer Zahlen . . . 4.1.2 Additionsalgorithmen . . . . . . . . . . . . . 4.1.3 Multiplikationsverfahren . . . . . . . . . . . . 4.1.4 Divisionsalgorithmen . . . . . . . . . . . . . . 4.1.5 Quadratwurzel . . . . . . . . . . . . . . . . . 4.2 Festkommazahlen . . . . . . . . . . . . . . . . . . . . 4.3 Gleitkommazahlen . . . . . . . . . . . . . . . . . . . 4.3.1 Darstellung von Gleitkommazahlen . . . . . . 4.3.2 Genauigkeit von Gleitkommaoperationen . . . 4.3.3 Operationen auf Gleitkommazahlen . . . . . . 4.4 Logarithmische Zahlen . . . . . . . . . . . . . . . . . 4.4.1 Darstellung im logarithmischen Zahlensystem . 4.4.2 Operationen auf logarithmischen Zahlen . . . . 4.4.3 Semilogarithmische Zahlen . . . . . . . . . . 4.5 Berechnung von Funktionen . . . . . . . . . . . . . . 4.5.1 Table-Look-Up-basierte Methoden . . . . . . . 4.5.2 Digit-Recurrence-Algorithmen . . . . . . . . . 4.5.3 Iterative Näherungsverfahren . . . . . . . . . . 4.5.4 Kombination verschiedener Verfahren . . . . . 4.6 Stand der Forschung zu Implementierungen auf FPGAs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41 42 42 45 51 53 61 66 66 66 67 70 79 79 80 81 82 82 85 86 88 89 Anforderungen an eine Beschleunigerarchitektur 5.1 Rechenleistung . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.2 Kommunikationsbandbreite . . . . . . . . . . . . . . . . . . . . . . 5.3 Erforderliche Rechengenauigkeit von SPH . . . . . . . . . . . . . . 5.3.1 Testsimulationen mit künstlicher Reduktion der Genauigkeit 5.3.2 Simulation der Rechenwerke . . . . . . . . . . . . . . . . . 5.4 Folgerungen für die Systemarchitektur . . . . . . . . . . . . . . . . 5.4.1 Grundlegende Struktur der Rechenwerke . . . . . . . . . . 5.4.2 Datenfluss . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.4.3 Geeignetes Zahlenformat für die Rechenwerke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91 91 94 96 96 97 105 107 107 109 . . . . . . . . 111 111 111 113 118 124 127 127 128 Implementierung der Arithmetik 6.1 Festkommaarithmetik auf FPGAs 6.1.1 Addition und Subtraktion . 6.1.2 Multiplikation . . . . . . 6.1.3 Division . . . . . . . . . . 6.1.4 Quadratwurzel . . . . . . 6.2 Gleitkommaarithmetik auf FPGAs 6.2.1 Ausnahmebehandlung . . 6.2.2 Addition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . iii INHALTSVERZEICHNIS 6.2.3 6.2.4 6.2.5 6.2.6 7 8 Multiplikation . . . . . . . . . . . . . . . . . . . . Division . . . . . . . . . . . . . . . . . . . . . . . . Quadratwurzel . . . . . . . . . . . . . . . . . . . . Zusammenfassung der Implementierungsergebnisse . Implementierung des Rechenbeschleunigers 7.1 Implementierung der Rechenwerke für SPH . 7.1.1 Spline-Kernel . . . . . . . . . . . . . 7.1.2 Designmethode für die Rechenwerke 7.1.3 Dichteberechnung . . . . . . . . . . 7.1.4 Kraftberechnung . . . . . . . . . . . 7.2 Einbettung in den FPGA-Prozessor . . . . . . 7.3 Datenfluss und Steuerung . . . . . . . . . . . 7.4 Ergebnisse für den Rechenbeschleuniger . . . Zusammenfassung und Diskussion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150 156 160 164 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169 169 169 176 177 179 182 184 185 187 iv INHALTSVERZEICHNIS Kapitel 1 Einführung 1.1 Problemstellung Durch die Entwicklung leistungsfähiger Rechnerplattformen in den letzten Jahren wurde das wissenschaftliche Rechnen zu einem wichtigen Standbein der Forschung. Insbesondere die Simulation komplexer physikalischer Systeme vermag eine Brücke zwischen theoretischen Modellen und experimenteller Observation zu schlagen. Für viele Systeme korreliert die Qualität der Aussagen direkt mit der zur Verfügung stehenden Rechenkraft und so gibt es einen nicht zu sättigenden Bedarf an Rechenleistung in den Naturwissenschaften. Insbesondere im Bereich der Astrophysik ist die Rechenleistung das entscheidende Kriterium, ob eine physikalische Fragestellung gelöst werden kann oder nicht. Die observierten Phänomene des Weltalls sind beliebig komplex, selbst wenn die diese Phänomene beschreibenden Gleichungen der Dynamik einfach sind, wie z.B. im Fall der Gravitation. Bereits die Dynamik von Kugelsternhaufen aus wenigen tausend Sternen wirft ungelöste Fragen auf, deren Beantwortung entscheidend für das Verständnis der Entstehung unserer Welt sein kann. Die Entwicklung der Rechenleistung der Mainstream-Technologie ist einigermaßen vorhersehbar und folgt weitgehend dem Moorschen Gesetz des Fortschritts der Transistorendichte. Damit ist jedoch auch vorhersehbar, dass die allgemeine Rechnerentwicklung für viele numerische Fragestellungen in absehbarer Zeit nicht die nötige Rechenleistung erbringen kann. Daraus motiviert sich die große Nachfrage nach Spezialrechnerplattformen, die mit aktueller Technologie eine weit höhere Leistung erreichen können als Standardsysteme. Diese Arbeit befasst sich mit dem Ansatz, rekonfigurierbare Plattformen für numerische Simulationsaufgaben im Bereich Astrophysik einzusetzen. Der Ansatz wird für eine spezielle Klasse von Algorithmen ausgeführt - die Simulation von Systemen, für welche Nahwechselwirkungen einen entscheidenden Einfluss auf die Dynamik haben. Darunter fallen insbesondere die hydrodynamischen Phänomene, wie sie für eine Vielzahl von astrophysikalischen Problemstellungen berücksichtigt werden müssen. Dazu gehören beispielsweise Fragen zur Entstehung der Strukturen im Kosmos, zur Dynamik von Galaxien oder zur Sternentstehung. Die Konzentration auf diese Phänomene ist deshalb interessant, da hier der Einsatz von Rechenbeschleunigern sehr vielversprechend ist, denn die Behandlung der Gasdynamik ist derzeit die rechenzeitkritische Komponente, wenn die Berechnung der Gravitationskräfte durch bereits existierende Spezial1 2 KAPITEL 1. EINFÜHRUNG rechnerplattformen beschleunigt wird. Solche Systeme werden in Abschnitt 2.4.2 vorgestellt. Für diese Arbeit wird davon ausgegangen, dass eine solche Plattform vorliegt. Ein aktueller Rechenbescheuniger (GRAPE-6) erreicht 1 TFlop Spitzenrechenleistung in einem Gehäuse der Größe einer Workstation. Damit reduziert sich die Rechenzeit für die Gravitationswechselwirkung auf einen Bruchteil der Gesamtrechenzeit. Wird auch der hydrodynamische Anteil der Simulationen durch eine zweite Spezialrechnerarchitektur beschleunigt, lässt sich mit relativ geringem Hardwareaufwand ein hoher Speedup erreichen, wie im Verlaufe dieser Arbeit gezeigt wird. Die Berechnungen der Hydrodynamik sind wesentlich komplexer als die der Gravitation und zudem in der genauen Formulierung applikationsabhängig. Die Struktur der Berechnungen ist jedoch sehr einfach. In dieser Arbeit wird gezeigt, dass aktuelle rekonfigurierbare Rechensysteme für hydrodynamische Berechnungen geeignet sind und eine im Vergleich zu Standardprozessoren sehr hohe Rechenleistung erreichen. 1.2 Aufbau der Arbeit In Kapitel 2 werden die wissenschaftlichen und algorithmischen Grundlagen der wichtigsten astrophysikalischen Simulationsverfahren vorgestellt. Dabei werden die Vorzüge und Einschränkungen der verschiedenen Herangehensweisen motiviert und gegen die dieser Arbeit zugrunde liegenden Algorithmen abgegrenzt. Es wird in diesem Kapitel auch eine kurze Übersicht über die bisher eingesetzten Rechensysteme gegeben. Das Kapitel 3 wird in die hardwareseitigen Grundlagen dieser Arbeit einführen. Da sich der Hauptteil dieser Arbeit mit der Implementierung von Algorithmen auf FPGA-basierten Systemen beschäftigt, wird hier detailliert auf die technologischen Aspekte solcher Systeme eingegangen. Insbesondere wird das in dieser Arbeit verwendete System beschrieben. In Kapitel 4 werden die für den Implementierungsteil der Arbeit benötigten Grundlagen der Computerarithmetik eingeführt. Es werden die elementaren Zahlensysteme vorgestellt und deren Eigenschaften in Bezug auf die Umsetzung von Rechenwerken beleuchtet. Eine Analyse der für eine Implementierung maßgeblichen Randbedingungen an die Rechenleistung und Rechengenauigkeit sowie der sich aus den Algorithmen ergebenden Strukturen und Datenflüsse wird in Kapitel 5 diskutiert. Kapitel 6 und 7 beschäftigen sich mit der Implementierung der Simulationsalgorithmen auf rekonfigurierbaren Systemen. Den Hauptteil bildet die Diskussion zur Implementierung der Arithmetik. Für einen modernen Algorithmus wird die Implementierung auf der vorhandenen Plattform beschrieben und analysiert. In Kapitel 8 werden die Ergebnisse der Arbeit zusammengefasst und diskutiert und es wird eine Ausblick auf die zukünftigen Schritte und Möglichkeiten des in dieser Arbeit verfolgten Ansatzes gegeben. Kapitel 2 Grundlagen Astrophysikalischer Simulationen In diesem Kapitel werden die grundlegenden Konzepte der Simulation astrophysikalischer Systeme vorgestellt. Es kann hier kein vollständiger Abriss aller Varianten der Simulationsmethodik gegeben werden. Vielmehr sollen die gebräuchlichen Konzepte motiviert werden, um den Rahmen der speziellen Formulierung, mit der sich der Implementierungsteil der Arbeit befasst, abzustecken. 2.1 Allgemeine Simulationsmethodik Ziel astrophysikalischer Simulationen ist es, das dynamische Verhalten von astrophysikalischen Systemen numerisch zu studieren. Dies motiviert sich aus dem fehlenden experimentellen Zugang zur zeitlichen Entwicklung von astrophysikalischen Systemen, vor allem aufgrund der extremen Zeitskalen der Evolution solcher Systeme, aber auch aus der Unzugänglichkeit von inneren Größen beobachtbarer Systeme. Andererseits können die sich aus den theoretischen Modellen für diese Systeme ergebenden komplexen dynamischen Prozesse in den meisten Fällen analytisch nicht gelöst werden. Deshalb ist die numerische Simulation das wichtigste Bindeglied zwischen Observation und Theorie. Die Behandlung der Gravitation ist für die Modellierung astrophysikalischer Systeme die wichtigste Komponente. Die Gravitation ist eine Fernwechselwirkung, denn sie wird mit dem Abstand r der Objekte quadratisch schwächer – die Oberfläche einer Kugelschale mit Radius r wächst jedoch mit r2 und somit auch die Anzahl an Objekten, die sich ungefähr in einer Entfernung r befinden können. Dies hat zur Folge, dass die Gravitationskräfte von weit entfernten Objekten nicht vernachlässigt werden können. Für die Kraftberechnung eines jeden simulierten Massepunktes muss also die Masseverteilung des kompletten simulierten Systems herangezogen werden. Abhängig von der Art der zu simulierenden Systeme (siehe Abschnitt 2.1.2) gibt es eine Vielzahl verschiedener Algorithmen. Ein Überblick dazu folgt in Abschnitt 2.2. Die Simulation zusätzlicher Physik, insbesondere auch die in dieser Arbeit im Mittelpunkt stehende Hydrodynamik, ist eng an die durch die Gravitationssimulation vorgegebene Codearchitektur gekoppelt, da 3 4 KAPITEL 2. ASTROPHYSIKALISCHE SIMULATIONSVERFAHREN alle Komponenten des Systems der Gravitationskraft unterworfen sind. Dies ist der Grund dafür, dass in dieser Arbeit so detailliert auf die Simulation der Gravitation eingegangen wird. Im Folgenden werden einige grundlegende Aspekte astrophysikalischer Simulationen diskutiert. 2.1.1 Numerische Simulation der zeitlichen Entwicklung Im Allgemeinen wird eine numerische Simulation zeitlich diskretisiert, indem Zeitschritte definiert werden. Für jeden Zeitschritt ti werden die Wechselwirkungen der Systembestandteile ermittelt und daraus über einen so genannten Integrator die Veränderungen der Zustandsgrößen des Systems gegenüber dem Zeitschritt ti−1 berechnet. Beispielsweise sind für ein System aus Punktmassen die Zustandsgrößen gegeben durch die Teilchenpositionen ~ri , die Geschwindigkeiten ~vi und die Massen mi . Die Wechselwirkungen sind hier die Gravitationskräfte, die in jedem Zeitschritt ti ermittelt werden. Aufgrund der berechneten Kräfte ermittelt der Integrator die neuen Positionen und Geschwindigkeiten für den Zeitpunkt ti+1 . Dazu werden die newtonschen Bewegungsgleichungen integriert. Die in der Astrophysik verwendeten Integratoren unterscheiden sich im Wesentlichen in der Ordnung der Propagation von Zustandsvariablen und den dazu erforderlichen Wechselwirkungstermen, die gegebenenfalls in höherer Ordnung zu berechnen sind. Die Verfahren legen insbesondere auch die Anzahl der Zeitschritte (ti ,ti−1 ...) fest, die in die Propagation der Zustandsvariablen auf ti+1 einbezogen werden. Weitverbreitete Verfahren sind beispielsweise Runge-KuttaVerfahren verschiedener Ordnung, Leap-Frog und Hermite-Algorithmen (siehe z.B. [107]). Die Auswahl des Integrationsschemas hängt ab von der erwarteten Dynamik der Anwendung und der Art der Berechnung der Wechselwirkungsterme. Eine wichtige Optimierungsmethode, um Wechselwirkungsberechnungen einzusparen, besteht darin, variable Zeitschritte einzusetzen. Entsprechend eines Kriteriums zur Dynamik einer Variablen können die Zeitschritte, für welche die entsprechenden Wechselwirkungsterme berechnet werden, angepasst werden. Dies hat zur Folge, dass die Bestandteile des Systems mit hoher Aktivität öfter neu berechnet werden als die Teile mit geringer Dynamik. 2.1.2 Klassifizierung der Dynamik astrophysikalischer Systeme Es soll im Folgenden davon ausgegangen werden, dass die gravitativ wechselwirkenden Systembestandteile durch Massepunkte dargestellt werden (Teilchen). Astrophysikalische Systeme werden grundsätzlich danach unterschieden, ob sie als stoßfrei betrachtet werden können oder nicht. Stöße bedeuten in diesem Zusammenhang, dass sich Elemente des Systems so nahe kommen, dass eine starke Änderung der Impulse aufgrund der Wechselwirkung zwischen zwei oder mehreren Elementen resultiert. Ein Maß dafür, ob ein stoßfreies oder stoßdominiertes System vorliegt, ist der Verleich der Relaxationszeit trelax mit der so genannten Crossing-Time tcross . Letztere beschreibt die Zeitspanne für ein Teilchen mit einer typischen Geschwindgkeit vt , sich einmal durch das System zu bewegen. Für ein kugelförmiges System aus N Teilchen mit Radius R und Gesamtmasse N · m kann über das Virialtheorem folgende Crossing-Time angesetzt werden (sie- 5 2.2. SIMULATION DER GRAVITATION he z.B. [107]): R tcross = ≈ vt r R3 , GNm (2.1) mit der Gravitationskonstante G. Die Relaxationszeit ergibt sich aus dem Zeitraum, in dem sich durch die Wechselwirkung mit dem System senkrecht zur Geschwindigkeit eines Teilchens im Mittel eine Änderung in der Größenordnung von vt ergibt. Es lässt sich für die Relaxationszeit folgende Beziehung finden (siehe [14], vergleiche auch z.B. mit [1]): N . (2.2) trelax = tcross 8 ln N Als stoßfrei können nun solche Systeme angesehen werden, für die tcross trelax gilt. In diesen Fällen sieht ein Teilchen nur ein geglättetes Gravitationspotential der anderen Teilchen. Beispiele dafür sind Galaxien und kosmologische Simulationen ohne starke Cluster-Bildung. Gilt dagegen tcross ≥ trelax müssen die Wechselwirkungen zwischen einzelnen Teilchen exakt simuliert werden. Dies ist beispielsweise für Kugelsternhaufen der Fall. 2.2 Algorithmen zur Simulation der Gravitationswechselwirkung In diesem Unterkapitel werden nun die grundlegenden Simulationsmethoden zur Gravitation vorgestellt. Die verschiedenen Methoden haben gemeinsam, dass die betrachteten Systeme als diskrete Verteilung von Massepunkten angenommen werden. Dabei kann es mit Ausnahme von sehr kleinen Systemen keine Eins-zu-Eins-Zuordnung von Sternen zu Massepunkten geben. Noch weniger können die Moleküle oder Staubpartikel des interstellaren Mediums im Einzelnen simuliert werden. Deshalb werden ganze Regionen von Sternen bzw. dunkler Materie zu einem Massepunkt zusammengefasst. Die Masse dieser Pseudoteilchen beträgt viele Sonnenmassen (typischerweise 106 – 108 MJ ). 2.2.1 Direkte N-Körper-Simulation Die naheliegendste Variante der Gravitationskraftberechnung auf ein Teilchen i mit Position ~ri und Masse mi besteht darin, die Beiträge aller anderen Punktmassen m j des Systems aufzusummieren. Diese Methode wird Direct Summation oder auch PP (Particle-Particle-Methode) genannt und führt auf folgende Gleichung: m j ~ri −~r j ~Fgrav,i = −Gmi ∑ (2.3) 3 , j6=i ε 2 + |~ ri −~r j |2 2 wobei G die Gravitationskonstante ist. Die Gleichung unterscheidet sich von der bekannten Formel für die Gravitation zwischen Punktmassen um den Term ε 2 . Dieser zusätzliche Term vermeidet unphysikalisch hohe Kräfte, wenn sich Pseudoteilchen, welche viele Sternenmassen als Massepunkt repräsentieren, sehr nahe kommen. 6 KAPITEL 2. ASTROPHYSIKALISCHE SIMULATIONSVERFAHREN Um die wechselseitigen Kräfte in einem System aus N Punktmassen zu berechnen, müssen − 1) Paarwechselwirkungen berechnet werden. Wie weiter unten vorgestellt wird, gibt es weit schnellere Methoden. Bei Systemen, wo eine sehr hohe Genauigkeit der Kraftberechnung notwendig ist, wie bei der Betrachtung nicht-kollisionsfreier Systeme, zum Beispiel bei der Dynamik von Sternhaufen, wird PP nach wie vor eingesetzt (siehe z.B. [107], [118]). Seit einigen Jahren wird diese Methode wieder vermehrt eingesetzt, da extrem leistungsfähige Spezialrechner verfügbar wurden. In Abschnitt 2.4.2 wird beschrieben, wie mit der PP-Methode über den Einsatz der GRAPE (GRAvity PipE) genannten Systeme ein enormes Leistungspotential erreicht werden kann. Eine Optimierung von PP folgt aus der Beobachtung, dass bei vielen astrophysikalischen Konstellationen extreme Kontraste der Masseverteilungen auftreten und entsprechend Regionen unterschiedlicher Dynamik existieren. Die Idee ist dabei, die Simulationen mit unterschiedlichen Zeitschritten durchzuführen, wie es bereits in Abschnitt 2.1 erwähnt wurde. Für Teilchen in Regionen hoher Dynamik werden die Wechselwirkungsterme öfter neu berechnet als in Regionen niedriger Dynamik. Dies kann in Situationen mit hohen strukturellen Kontrasten zu einer drastischen Reduktion des Rechenaufwandes führen. In [73] wurde demonstriert, wie dies zu einer Reduktion des Rechenaufwandes ∝ N führen kann. N 2 (N 2.2.2 Baumbasierte Verfahren In Simulationsanwendungen, bei denen die Gravitation leicht fehlerbehaftet berechnet werden darf, sind baumbasierte Verfahren (Tree-Algorithmen) eine weitverbreitete Methode, den Rechenaufwand stark zu reduzieren. Das Prinzip besteht darin, die Kräfte auf weit entfernte Teilchen darüber zu berechnen, dass eine ganze Gruppe von Teilchen als ein einzelnes Wechselwirkungsteilchen betrachtet wird, welches im Schwerpunkt dieser Gruppe liegt und durch Multipolmomente geringer Ordnung beschrieben wird. Dies jedoch nur, wenn ein Akzeptanzkriterium (Multipole Acceptance Criterion = MAC) für die Teilchengruppe erfüllt ist. Dieses Kriterium begrenzt den Fehler, der durch die Vernachlässigung höherer Multipolmomente entsteht. Ein Beispiel für ein solches Kriterium ist der Öffnungswinkel, unter dem diese Teilchengruppe erscheint. Ist der Winkel geringer als ein Schwellenwert, wird die Wechselwirkung anhand der Multipolmomente der Teilchengruppe berechnet, ansonsten muss die Teilchengruppe in Untergruppen aufgelöst werden. Die Wahl des Akzeptanzkriteriums ist kritisch für die Genauigkeit der Simulation, siehe z.B. [99]. Die Erzeugung der Interaktionslisten, welche sowohl aus Teilchen als auch aus den Repräsentanten von Teilchengruppen bestehen, geschieht über eine Baumstruktur, in der die Teilchen über ein Abstandskriterium oder durch eine rekursive Aufteilung des Raumes angeordnet werden. Mit zunehmender Entfernung von dem Teilchen, für das die Gravitationskraft berechnet werden soll, steigt die Anzahl der Zweige des Baumes, die als Wechselwirkungspartner gesehen werden. Dies führt dazu, dass die baumbasierten Algorithmen mit O(N logN) in der Rechenzeit für die Kräfte skalieren. Der absolute Rechenaufwand hängt stark von der Rechengenauigkeit ab, die über das MAC gesteuert werden kann, (siehe auch [99]). Angewendet werden baumbasierte Verfahren beispielsweise für die Simulation von Galaxiendynamik und Sternentstehung. Für Simulationen mit sehr hohen Präzisionsanforderungen sind Tree-Algorithmen weniger geeignet, da mit sehr kleinem Öffnungswinkel die Kosten höher als bei Direct Summation werden können (z.B. bei Sternhaufen). 2.2. SIMULATION DER GRAVITATION 7 Im Folgenden werden die wichtigsten Tree-Algorithmen kurz vorgestellt werden. Barnes-Hut-Tree-Algorithmus Diesem von Barnes und Hut entwickelten Top-Down-Verfahren [5] liegt für dreidimensionale Simulationen ein Oct-Tree zugrunde. Dies bedeutet, dass von jedem Knoten des Baumes acht Zweige ausgehen. Jeder Knoten entspricht einer kubischen Zelle des Raumes. Das Verfahren führt eine hierarchische Unterteilung des Raumes durch, indem – ausgehend von einer den ganzen Raum umgebenden Zelle – die Zellen jeweils in 8 kleinere Kuben unterteilt werden. Die Unterteilung wird so weit fortgesetzt, bis in jeder Zelle höchstens noch ein einziges Teilchen liegt. Für alle Knoten werden die Gesamtmasse, der Schwerpunkt und gegebenenfalls höhere Multipolmomente berechnet. Die Interaktionsliste für die Kraftberechnung auf Teilchen i wird durch Absteigen in den Baum ermittelt. Wenn eine angetroffene Zelle weit genug von ~ri entfernt ist, also z.B. das Öffnungswinkelkriterium erfüllt ist, wird diese Zelle in die Interaktionsliste aufgenommen, ansonsten wird eine Ebene tiefer in die Subzellen abgestiegen. Die Methode, den Raum rekursiv geometrisch zu unterteilen führt zu einer einfachen Parallelisierungsstrategie, wenn global eine gleichmäßige Masseverteilung vorliegt wie bei kosmologischen Simulationen. Bei starker Konzentration der Verteilung auf unregelmäßige Strukturen wird eine Parallelverarbeitung jedoch sehr ineffizient. Überdies repräsentiert die Baumstruktur in solchen Fällen die Massestrukturen nur schlecht. Für solche Situationen eignet sich die nachfolgend vorgestellte Baumstruktur besser. Zu modernen Implementierungen paralleler Codes basierend auf den Barnes-Hut-Trees siehe z.B. [98], [24] und [123]. Press Tree Es handelt sich hierbei um einen Binärbaum, welcher Bottom-Up aufgebaut wird. Unter den Teilchen wird das Paar wechselseitig nächster Nachbarn gesucht und durch einen Knoten abgebildet, wobei die beiden Teilchen die Zweige des Knotens bilden. Dann wird unter den verbliebenen ungepaarten Teilchen und den Knoten wieder das Paar wechselseitig nächster Nachbarn gesucht und erneut durch einen Knoten und zwei Zweige ersetzt. Dieser Prozess wird so lange wiederholt, bis nur noch ein Knoten, die Wurzel des Baumes, übrig ist. Das Verfahren hat den Vorteil, dass sich die räumliche Gruppierung der Teilchen in der Baumstruktur wiederfindet und passt sich deshalb gut an die physikalischen Strukturen einer Verteilung an. Wie beim Barnes-Hut-Algorithmus bekommen die Knoten die Summe der Masse, den Schwerpunkt und eventuell höhere Multipolmomente zugewiesen und die Erzeugung der Interaktionslisten kann auf die gleiche Weise geschehen. Zu modernen Implementierungen basierend auf Binärbäumen siehe z.B. [111] und [126]. Ein moderner Code mit Binärbaum, der auf einer rein geometrischen Raumaufteilung basiert, wird in [121] vorgestellt. Fast Multipole Method (FMM) Dies ist ein Tree-Code, dessen Baumstruktur dem BarnesHut-Tree entspricht. Die Baumstruktur wird jedoch anstatt zur Berechnung der Kräfte zur Bestimmung des Gravitationspotentials für beliebige Positionen benutzt. Dazu werden auch Multipolmomente höherer Ordnung berücksichtigt und es wird zudem eine lokale Entwicklung des Feldes für die Knoten berechnet. Die Methode kann eine hohe Genauigkeit erreichen und eignet 8 KAPITEL 2. ASTROPHYSIKALISCHE SIMULATIONSVERFAHREN sich gut für Systeme, bei denen alle Teilchen die gleichen Zeitschritte bekommen. Sie ist jedoch asymptotisch um einen Faktor 2 langsamer als der Barnes-Hut-Tree-Algorithmus und führt zu Schwierigkeiten bei Systemen mit hohen Dichtekontrasten [19]. Sie ist deshalb wenig verbreitet. 2.2.3 Gitterbasierte Verfahren Bei Systemen, wo angenommen werden kann, dass sich die Bestandteile nahezu kollisionsfrei bewegen, sind Gittermethoden ein weitverbreitetes Werkzeug (siehe z.B. [47]). Es wird angenommen, dass jedes Teilchen nur das geglättete Potential einer großen Zahl anderer Teilchen spürt. Dieses Potential wir mit Hilfe eines Gitters berechnet, indem die gegebene Masseverteilung durch eine Verteilung auf einem Gitter approximiert wird. Particle-Mesh-Methode PM Dies ist eine Methode, die ursprünglich für die Elektrostatik und Plasmaphysik verwendet wurde. Eine Übersicht über die klassische PM-Methode gibt Sellwood [102]. Die grundsätzliche Vorgehensweise besteht darin, dass über den Raum ein Gitter mit Ng Gitterpunkten gelegt wird. Diesen Punkten wird eine Masse abhängig von den Teilchen in der Umgebung der Gitterpunkte zugewiesen, wobei es für diese Zuordnung verschiedene Verfahren gibt. Mit dem so erhaltenen Massepunktgitter wird dann das Potential ermittelt, indem die Poisson-Gleichung für das Gitter gelöst wird. Dies geschieht über die Anwendung der FFT (Fast Fourier Transformation). Die Methode führt im dreidimensionalen Fall zu einem von der FFT dominierten Rechenaufwand O(Ng logNg ). Neuere Implementierungen nutzen Techniken zur adaptiven Gitterverfeinerung (engl. AMR = Adaptive Mesh Refinement). Hier werden, falls nötig, feinere Untergitter hinzugefügt oder Teile des Gitters vergröbert (siehe z.B. [34]). Wichtigster Vorteil der PM-Methode ist ihre hohe Geschwindigkeit. Die Auflösung des Potentials ist mit einigen Gitterabständen jedoch nur sehr gering. P3 M Die P3 M-Methode (Particle-Particle Particle-Mesh) ist ein Mischverfahren von PM und PP (Direct Summation). Hierbei wird die Wechselwirkung mit nahen Teilchen über Direct Summation berechnet, während die Kräfte aufgrund des Potentials entfernter Teilchen durch eine PMMethode berücksichtigt werden. Damit gewinnt man eine sehr hohe Genauigkeit für Wechselwirkungen auf kurzen Längenskalen, kann aber weiterhin von der hohen Rechengeschwindigkeit von PM profitieren. Die Methode eignet sich für Simulationen mit hohen Dichtekontrasten, wo bei reinem PM für die gleiche Genauigkeit ein wesentlich feineres Gitter erforderlich wäre. Periodische Randbedingungen ergeben sich ohne zusätzlichen Aufwand. Das Verfahren kann durch adaptive Gitterverfeinerung wie bei PM optimiert werden (AP3 M-Methode). Weite Verbreitung findet diese Methode bei kosmologischen Simulationen (siehe z.B. [19]). 2.3. SMOOTHED PARTICLE HYDRODYNAMICS 2.3 9 SPH-Algorithmen zur Simulation der hydrodynamischen Kräfte In der Astrophysik hat sich zur Behandlung hydrodynamischer Phänome das Simulationsverfahren Smoothed Particle Hydrodynamics (SPH) als Standardmethode etabliert. Es wurde aus der Motivation heraus entwickelt, nicht-achsensymmetrische astrophysikalische Systeme effizient behandeln zu wollen ([70],[36]). Im Gegensatz zu den in anderen wissenschaftlichen Disziplinen häufig eingesetzten gitterbasierten Methoden, wie beispielsweise die Finite-Elemente-Methoden, handelt es sich dabei um eine teilchenbasierte Methode ohne Verwendung eines Gitters. So wird eine Lagrange’sche Beschreibung der Hydrodynamik möglich. Dadurch überwindet die Methode Einschränkungen der Geometrie, Dichteverteilung und Dynamik, denen andere Simulationsmethoden unterliegen. Für dreidimensionale Simulationen mit Berücksichtigung der Gravitation durch eine Teilchenmethode hat sich SPH als überaus erfolgreiche Methode erwiesen und ist entsprechend weit verbreitet. Im folgenden Abschnitt wird die Methode allgemein dargestellt. In 2.3.2 wird eine weitverbreitete spezielle Formulierung für die Hydrodynamik astrophysikalischer Systeme gegeben, auf die sich der Großteil dieser Arbeit beziehen wird. Dies ist jedoch nicht die einzig mögliche Darstellung, weshalb in 2.3.3 auf diverse Variationen eingegangen wird. Abschnitt 2.3.4 zeigt schließlich, wie sich die Methode in die Simulation der Gravitation einfügt. 2.3.1 Allgemeine Methode von SPH Der Grundgedanke des SPH-Verfahrens besteht darin, eine Lagrange’sche Beschreibung der Hydrodynamik zu formulieren, wobei gasförmige Materie in diskretisierter Form durch ein Ensemble von statistisch entsprechend der Dichte verteilten Teilchen repräsentiert wird. Diese FluidTeilchen sind durch Position, Geschwindigkeit und Masse parametrisiert und die für die Hydrodynamik wichtigen inneren Größen wie Druck, Temperatur, innere Energie und Entropie etc. werden damit berechnet. Die Wechselwirkungskräfte auf ein Fluid-Element werden ausschließlich durch die Verteilung benachbarter Teilchen und deren innere Größen bestimmt. Durch diese Wechselwirkungskräfte angetrieben, bewegen sich die Fluid-Teilchen gemäß der Newton’schen Bewegungsgleichungen. Einen guten Überblick über diese Methode geben die Veröffentlichungen von W. Benz [11] und J. J. Monaghan [77]. Glättungskernmethode Der Übergang von der Teilchendarstellung zu den hydrodynamischen Gleichungen, welche naturgemäß für kontinuierliche Verteilungen definiert sind, kann als Teil der Interpolationstheorie verstanden werden. Die Idee dabei ist, eine kontinuierliche Wahrscheinlichkeitsverteilung durch eine bekannte diskrete Verteilung zu approximieren. Als statistisches Verfahren wird hierzu die Glättungskernmethode verwendet, welche als Näherung eines Integrals durch eine Monte-CarloMethode verstanden werden kann [36]. Die Methode geht von der Glättung von ortsabhängigen 10 KAPITEL 2. ASTROPHYSIKALISCHE SIMULATIONSVERFAHREN Funktionen f (~r) durch eine Kernfunktion W (engl. Smoothing Kernel) aus: h f (~r)i = Z W ~r −~r0 , h f (~r0 ) d 3 r0 . (2.4) V Der Kern W ist eine Funktion mit scharfem Peak bei ~r =~r0 und ist parametrisiert durch h, das die Breite der Kernfunktion bestimmt. Für W wird folgende Normierungsbedingung verlangt: Z W (~r, h) d 3 r = 1. (2.5) V Die Kernfunktion muss außerdem die Beziehung h f (~r)i → f (~r) für h → 0 (2.6) garantieren, was bedeutet, dass für h → 0 der Kern W gegen die δ -Funktion konvergiert. Die Funktion W wird weiterhin sphärisch-symmetrisch gewählt (W (~r, h) = W (|~r|, h)), was dazu führt, dass die Näherung h f i in zweiter Ordnung genau bezüglich h ist: h f (~r)i = f (~r) + O(h2 ). (2.7) Geeignete Kernfunktionen sind Gaußfunktionen wie z.B. W (~r, h) = 1 −(|~r|/h)2 e h3 π 3/2 (2.8) und bestimmte Spline-Funktionen. Für letztere wird im nächsten Unterkapitel eine explizite Formel gegeben. Spline-Kerne haben gegenüber Gaußfunktionen den Vorteil, dass sie auf einem kompakten Träger definiert werden können und außerhalb dieses Bereichs identisch 0 sind. Dadurch muss bei der Berechnung der Interpolationsintegrale nach Gleichung 2.4 nur eine Sphäre um~r berücksichtigt werden. Diskretisierung Es soll nun davon ausgegangen werden, dass die Funktion f nur an N diskreten Punkten ~r j bekannt ist, die entsprechend folgender Teilchenzahldichte verteilt sind: N n(~r) = ∑ δ (~r −~r j ). (2.9) j=1 Die Teilchenzahldichte kann wie andere skalare Funktionen durch die Glättungskernmethode genähert werden, wobei für die Anwendung von Gleichung 2.4 für hn(~r)i nach Gleichung 2.7 dann folgende Beziehung gilt: N ∑ W (|~r −~r j |, h) = n(~r). h→0 lim hn(~r)i = lim h→0 j=1 (2.10) 2.3. SMOOTHED PARTICLE HYDRODYNAMICS 11 Abbildung 2.1: Veranschaulichung der Berechnung von SPH-Größen durch Gewichtung der Beiträge aus einer Nachbarschaftsumgebung mit kompaktem Träger. Zu den variablen Glättungslängen siehe Abschnitt 2.3.2. Durch Durchmultiplizieren des Integrands von Gleichung 2.4 mit n(~r0 )/ hn(~r0 )i, wonach die Glei chung in O(h2 ) genau bleibt, und Ersetzen von 1/ n(~r j ) durch m j /ρ(~r j ) (m j ist die Masse von Teilchen j und ρ(~r j ) ist die Dichte an der Position von Teilchen j) kann folgender Ausdruck hergeleitet werden, welcher weiterhin eine mit O(h2 ) genaue Näherung von f ist: N h f (~r)i = ∑ f (~r j ) j=1 mj W (|~r −~r j |, h). ρ(~r j ) (2.11) Wird diese Formel angewendet, um aus der diskreten Verteilung der Teilchen eine kontinuierliche Dichteverteilung ρ(~r) zu gewinnen, ergibt sich folgender Ausdruck: N hρ(~r)i = ∑ m jW (|~r −~r j |, h). (2.12) j=1 Anschaulich ausgedrückt, wird die diskrete Verteilung der Fluid-Teilchen durch Faltung mit der Glättungsfunktion W zu einer kontinuierlichen Verteilung verschmiert, woraus sich der Name der Methode ableitet. Die auf diese Weise numerisch erhaltene Dichte wird zur Bestimmung weiterer Größen nach Gleichung 2.11 dort für ρ(~r j ) eingesetzt. Behandlung von Ableitungen Die SPH-Methode wird erst dadurch interessant, dass nicht nur Funktionswerte f (~r) sondern auch deren Ortsableitungen ~∇ f (~r) an den Teilchenpositionen ~r = ~ri aus einer diskreten Verteilung bekannter Funktionswerte f (~r j ) bestimmt werden können. Dazu betrachte man folgende Gleichung für die Approximation von ~∇ f (~ri ) welche analog zu Gleichung 2.4 ist: D E Z ~∇ f (~ri ) = ~∇ f (~r0 ) W |~ri −~r0 |, h d 3 r0 . (2.13) V Durch partielle Integration erhält man: Z D E Z ~∇ f (~ri ) = f (~r0 ) W |~ri −~r0 |, h d~S + f (~r0 ) ~∇iW |~ri −~r0 |, h d 3 r0 , S V (2.14) 12 KAPITEL 2. ASTROPHYSIKALISCHE SIMULATIONSVERFAHREN wobei “~∇i ” bedeutet, dass der Gradient nach den Koordinaten ~ri des Teilchens i gebildet wird. Unter der Annahme, dass das Integrationsvolumen so weit ausgedehnt ist, dass die Funktion f (~r0 ) oder W (|~ri −~r0 |, h) an dessen Oberfläche verschwinden, kann der Oberflächenterm vernachlässigt werden. Diese Bedingung ist bei den meisten astrophysikalischen Simulationsproblemen, für die SPH eingesetzt wird, erfüllt und soll für diese Arbeit stets vorausgesetzt werden. Dann kann wie bei der Ableitung von Gleichung 2.11 diskretisiert werden und man erhält: N ∑ D E ~∇ f (~ri ) = f (~r j ) j=1 mj ~ ∇iW (|~ri −~r j |, h). ρ(~r j ) (2.15) D E Es sei hier angemerkt, dass dies nicht unbedingt die numerisch beste Formulierung für ~∇ f (~ri ) ist. Wie in [77] gezeigt, kann es sinnvoll sein, die Dichte in die Operatoren einzubeziehen. Damit kann alternativ folgende Näherung für ~∇ f (~ri ) hergeleitet werden: D E ~∇ f (~ri ) = 1 ρ(~ri ) N ∑ mj f (~r j ) − f (~ri ) ~∇iW (|~ri −~r j |, h). (2.16) j=1 Hier seien schließlich noch zwei mögliche numerische Formulierungen zur Approximation von ~∇ ×~g gegeben: D E ~∇ ×~g(~ri ) = N ∑ j=1 D E ~∇ ×~g(~ri ) = mj ~ ∇iW (|~ri −~r j |, h) ×~g(~r j ), ρ(~r j ) 1 ρ(~ri ) N ∑ m j ~g(~ri ) −~g(~r j ) × ~∇iW (|~ri −~r j |, h). (2.17) (2.18) j=1 Da wir hier mit sphärisch-symmetrischen Glättungskernen arbeiten, ergibt sich für den Gradienten von W folgende Rechenvorschrift: ~∇iW (|~ri −~r j |, h) = ∂W (x, h) ~ri −~r j ∂x |~ri −~r j | (2.19) Gemäß der SPH-Methode können nun beliebige gasdynamische Variablen und ebenso deren Ableitungen über eine einfache Summierung einer Funktion der Teilchenparameter, multipliziert mit dem Glättungskern oder einer Ableitung davon, berechnet werden. Dies führt zu einem sehr einfachen Rechenschema für die zu betrachtenden hydrodynamischen Gleichungen. 2.3.2 Weitverbreitete spezielle SPH-Formulierung Es wir nun eine seit einigen Jahren bewährte Formulierung des SPH-Algorithmus im Detail ausgeführt, wie sie insbesondere für den Implementierungsteil dieser Arbeit verwendet wurde. Die Formeln entsprechen weitgehend der in [11] beschriebenen Methode. Zu Implementierungsdetails und numerischen Eigenschaften siehe beispielsweise auch [111], [126], [6]. 13 2.3. SMOOTHED PARTICLE HYDRODYNAMICS 2 pi*W(r,l/2**(1./3)) pi*W(r,l) pi*W(r,l*2**(1./3)) pi*W(r,h) 1.5 1 0.5 0 0 0.5 1 r/l 1.5 2 Abbildung 2.2: Kubische Splinefunktion des Standard-Glättungskernes nach √ Gleichung √ 2.20. Dargestellt ist der Verlauf für drei verschiedene Werte der Glättungslänge h (l/ 3 2, l, l · 3 2). Spline-Kern Für die Wahl der SPH-Glättungsfunktion W (r, h) gibt es verschiedene Möglichkeiten. So werden bei theoretischen Betrachtungen über die SPH-Methode vor allem Gaußfunktionen als Kernfunktion verwendet. Diese sind in vielen Fällen aber auch für numerische Simulationen anwendbar. Weiter verbreitet sind jedoch kubische Spline-Funktionen. Diese haben den Vorteil, dass sie auf kompaktem Träger definiert werden können, sodass sie außerhalb einer durch h vorgegebenen Umgebung um den Nullpunkt identisch Null sind. Entsprechend ist für die Berechung von physikalischen Größen für ein Teilchen an der Position~r eine SPH-Summation nur über die Teilchen, für die sich (~r0 −~r) in dieser Umgebung befindet, auszuführen. Dies reduziert den Rechenaufwand von O(N 2 ) auf O(N · Nn ), wobei Nn die durchschnittliche Zahl von Nachbarteilchen ist, für welche die SPH-Summe gebildet werden muss. Gleichung 2.20 zeigt den inzwischen zum Standard gewordenen Spline-Kern, wie er von Monaghan und Lattanzio vorgestellt wurde [79]. Der Graph dieser Kurve ist in Abbildung 2.2 zu sehen, wobei die Kernfunktion für drei verschiedene Werte von h dargestellt ist. Die in dieser Arbeit beschriebene Implementierung wird auf dieser Standard-Formulierung basieren. 1 − 32 v2 + 34 v3 : 0 ≤ v < 1 3 1 W (r, h) = πh1 3 : 1≤v<2 4 (2 − v) 0 : sonst r mit v = h . (2.20) Variable Glättungslänge Gängige Praxis in der Anwendung von SPH bei astrophysikalischen Simulationen ist es, für jedes Teilchen mit Index i eine eigene Glättungslänge hi zu verwenden (siehe z.B. [43] und [11]). Diese 14 KAPITEL 2. ASTROPHYSIKALISCHE SIMULATIONSVERFAHREN Glättungslänge hängt von der Dichte des Gases an der Stelle ~ri ab und variiert mit der Dynamik des Ensembles. Damit lässt sich erreichen, dass durch die Faltung mit der Glättungsfunktion trotz extremer Dichtekontraste stets eine glatte kontinuierliche Verteilung resultiert. Im Simulationscode geschieht dies, indem die Zahl der SPH-Nachbarn für jedes Teilchen näherungsweise konstant gehalten wird, was durch Anwendung folgender Gleichung erreicht werden kann (siehe [11]): dh 1 ~ = h ∇ ·~v. (2.21) dt 3 Dadurch werden die numerischen Eigenschaften des Codes weitgehend unabhängig von der Geometrie der Masseverteilung, was einer der wichtigsten Vorteile von SPH gegenüber anderen Methoden ist. Zudem kann der Rechenaufwand pro SPH-Teilchen nahezu konstant gehalten werden. Um die Impulserhaltung zu garantieren, ist es nun wichtig, dass die Kräfte von Teilchen i auf Teilchen j und umgekehrt von Teilchen j auf Teilchen i übereinstimmen. Dies kann von den Interpolationsformeln nur gewährleistet werden, wenn eine Symmetrisierung der Formeln in h erfolgt. In dieser Arbeit wird deshalb stets vom Ansatz ausgegangen, dass h in allen Gleichungen durch die Form h(~r) + h(~r0 ) 0 (2.22) h(~r,~r ) = 2 ersetzt wird, was für die diskrete Formulierung die Verwendung von hi j entsprechend folgender Gleichung bedeutet: h(~ri ) + h(~r j ) hi + h j = . (2.23) hi j = 2 2 In Abschnitt 2.3.3 wird eine alternative Möglichkeit zur Sicherstellung der Antisymmetrie der Kräfte im Fall variabler Glättungslängen gezeigt. Benz weist in [11] darauf hin, dass die dynamische Adaption von h für die exakte Berechnung von ~∇iW (|~ri − ~r j |, h) zu einem Korrekturterm ∂W /∂ h ~∇h führt, welcher sehr schwierig zu berechnen ist. Dieser Term kann jedoch vernachlässigt werden, solange dh/dt h gilt, was für diese Arbeit vorausgesetzt werden soll. Bei bestimmten Problemstellungen gilt diese Voraussetzung jedoch nicht, beispielsweise bei Systemen, die starke Schockwellen enthalten, jedoch über globale Zeitschritte integriert werden. Für solche Fälle zeigen Nelson und Papaloizou in [84], wie durch Einfügen der ~∇h-Korrekturen drastische Verbesserungen der SPH-Simulationen erreicht werden können. Es sei an dieser Stelle noch angemerkt, dass die Verwendung variabler Glättungslängen mit der Symmetrisierungsvorschrift nach Gleichung 2.23 dazu führt, dass für ein Teilchen mit Index i nicht mehr alle Teilchen in der Sphäre |~r −~ri | ≤ 2 hi SPH-Nachbarn sind, sondern anstatt dessen die Beziehung |~r j −~ri | ≤ 2 hi j die Zugehörigkeit von Teilchen j zur Nachbarschaftsliste von Teilchen i definiert. Schritt 1: Berechnung der Dichte Wie in Gleichung 2.11 und 2.15 zu sehen ist, benötigt man zur Berechnung von Funktionswerten durch die SPH-Methode stets die Dichten ρ(~r j ) an den Positionen der Fluid-Teilchen. Deshalb 15 2.3. SMOOTHED PARTICLE HYDRODYNAMICS besteht der erste Schritt einer Berechnung nach der SPH-Methode darin, diese Dichten zu bestimmen. Dies geschieht nach folgender Formel entsprechend Gleichung 2.12: N ρi = hρ(~ri )i = r j |, hi j ). ∑ m jW (|~r|i −~ {z } j=1 (2.24) r~i j Um im zweiten Schritt die hydrodynamische Druckkraft berechnen zu können, müssen zuvor die Drücke an den Positionen der Teilchen bestimmt werden. Dazu können abhängig von den Eigenschaften der zu simulierenden Gase verschiedene thermodynamische Zustandsgleichungen angewendet werden. Im einfachsten Fall ist der Druck Pi an den Teilchenpositionen ~ri nur von ρi abhängig, wie bei isothermen oder isentropen Gasen. Es können jedoch auch sehr komplexe Zustandsgleichungen auftreten, beispielsweise im Zusammenhang mit Phasenübergängen. Bei der Berechnung der Zustandsgleichungen handelt es sich um einen mit O(N) skalierenden laufzeitunkritischen Teil des Algorithmus, der somit nicht Bestandteil der zu beschleunigenden Berechnungen ist. Deshalb soll hier nicht näher darauf eingegangen werden. Schritt 2: Kraft- und Energieberechnung Die wichtigste Gleichung der Hydrodynamik ist die der Impulserhaltung, welche als EulerGleichung folgende Gestalt hat1 : ~∇P d~v ∂~v ~ = + ~v · ∇ ~v = − . dt ∂t ρ (2.25) Aus dieser Gleichung ergibt sich die Beschleunigung der Fluid-Elemente. Durch Aufstellen der Faltungsgleichungen nach 2.4 und Näherungen mit der Genauigkeit der SPH-Methode kann nach W. Benz [11] folgende Gleichung für die approximierte Beschleunigung hergeleitet werden: d P P ~ ~ h~vi = −∇r − ∇r hρi . (2.26) dt ρ ρ2 Mit dem SPH-Verfahren zur Diskretisierung dieser Integrale analog zu Gleichung 2.15 ergibt sich diese Gleichung zu: ! N Pj ~ d~vi Pi = − ∑ mj + 2 ∇iW ~ri j , hi j . (2.27) 2 dt ρi ρj j=1 Dies ist die am häufigsten verwendete Form der Bestimmung der Beschleunigung aus der Druckverteilung des Gases. Diese Gleichung sichert sowohl die Impulserhaltung als auch die lokale Erhaltung des Drehmoments. 1 Die Berücksichtigung des Gravitationspotentials führt auf der rechten Seite von Gleichung 2.25 zu einem zusätzlichen Term −~∇Φ, welcher aus Gründen der Übersichtlichkeit an dieser Stelle nicht berücksichtigt werden soll. 16 KAPITEL 2. ASTROPHYSIKALISCHE SIMULATIONSVERFAHREN Die einfache Euler-Gleichung 2.25 ist nicht in der Lage, Dissipation von kinetischer Energie in Wärme zu beschreiben, wofür Viskosität des Fluids notwendig wäre. Sollen jedoch Schockwellen simuliert werden, wird die ansonsten vernachlässigbar geringe molekulare Viskosität astrophysikalischer Gaskomponenten signifikant und die Vernachlässigung der Dissipation führt zu unphysikalischem Verhalten (z.B. starke Oszillationen des Systems). Deshalb wird die EulerGleichung für solche Simulationsprobleme um einen Term ~Pvisc für eine künstliche Viskosität erweitert, welcher als zusätzlicher künstlicher viskoser Druck verstanden werden kann: 1 d~v = − ~∇r P + Pvisc . (2.28) dt ρ Üblicherweise werden zwei verschiedene Arten von viskosem Druck verwendet, die so genannte künstliche Volumenviskosität Pα = −α ρ l cs ~∇ ·~v, (2.29) und die so genannte von Neumann-Richtmyer-Viskosität 2 2 ~ Pβ = β ρ l ∇ ·~v , (2.30) wobei α und β freie Parameter sind, welche die Stärke der Viskosität kontrollieren, l eine typische Längenskala angibt, über die sich eine Schockfront ausbreitet und cs die Schallgeschwindigkeit ist2 . Würde man diese Formel derart auswerten, dass ~∇ ·~v über die SPH-Methode approximiert wird und die Korrekturterme dann analog zu 2.27 berechnet werden, könnten die auftretenden unerwünschten Oszillationen nicht in ausreichendem Maße abgeschwächt werden. Die Ursache dafür ist, dass auf diese Weise Geschwindigkeitsfluktuationen auf Skalen kleiner als h nicht gedämpft werden können. Deshalb wird üblicherweise das von Monaghan und Gingold [78] vorgeschlagene Verfahren verwendet, statt der Größe ~∇ ·~v einen Term µi j zu verwenden, welcher als Schätzwert für den Beitrag von Teilchen j zur Divergenz der Geschwindigkeit am Ort ~ri verstanden werden kann: hi j ~vi − ~v j · ~ri −~r j . (2.31) µi j = ~ri −~r j 2 + η 2 h2 ij Der Term η 2 h2i j sorgt dafür, dass µi j für kleine Teilchenabstände nicht divergiert. Dann nimmt die Berechnung von d~v/dt folgende Gestalt an: ! N Pj Pi d~vi ~∇iW ~ri j , hi j = − ∑ mj + + Π (2.32) i j 2 2 dt ρi ρj j=1 2 −αci j µi j + β µi j : ~vi j~ri j ≤ 0 Πi j = (2.33) ρ i j 0 : ~vi j~ri j > 0 ci j = cs (~ri ) + cs (~r j ) ρi + ρ j , ρi j = , v~i j = ~vi − ~v j . 2 2 (2.34) 2 Die Schallgeschwindigkeit kann in Schritt 1 für jedes Teilchen aus der Dichte und dem Druck berechnet werden 2.3. SMOOTHED PARTICLE HYDRODYNAMICS 17 Diese Art der Formulierung hat sich als sehr erfolgreich erwiesen. Es hat sich jedoch gezeigt (Balsara [4]), dass bei Scherströmen viel Entropie erzeugt wird. Dieser unerwünschte Effekt wird vermieden, wenn statt Gleichung 2.31 folgende von Balsara vorgeschlagene Formel verwendet wird: µi j = fi = hi j~vi j~ri j fi + f j 2 ~ri j + η 2 h2i j 2 (2.35) |h~∇ ·~vii | . |h~∇ ·~vii | + |h~∇ ×~vii | + η 0 ci /hi (2.36) Dies ist die Formulierung, die für diese Arbeit verwendet wird. Man erkennt, dass zur Berechnung der Balsara-Koeffizienten fi die Erwartungswerte für die Divergenz und Rotation von v für das Teilchen i erforderlich sind. Diese können in Schritt 1 zusätzlich zur Dichteberechnung bestimmt werden, wobei analog zu den Formeln 2.16 und 2.18 gerechnet werden kann: ρi (~∇ ·~v)i = N ∑ m j (~v j −~vi) ~∇iW (|~ri j |, hi j ), (2.37) j=1 ρi (~∇ ×~v)i = N ∑ m j (~vi − ~v j ) × ~∇iW (|~ri j |, hi j ). (2.38) j=1 Auf diese Weise brauchen die Dichten ρi für die Summation noch nicht bekannt sein. So lässt sich eine weitere Schleife über alle Nachbarteilchen zwischen Schritt 1 und Schritt 2 vermeiden, die bei Anwendung der Gleichungen 2.15 und 2.17 erforderlich sein würde. Im Allgemeinen reichen die Gleichungen zur Impulserhaltung (2.25) und die Zustansgleichung des Gases nicht aus, um ein hydrodynamisches System vollständig zu beschreiben. Während für isotherme und isentrope Zustandsgleichungen keine weiteren Größen zu berechnen sind, wird im Fall der idealen Gasgleichung für adiabatische Zustandsänderungen beispielsweise die Temperatur oder innere Energie benötigt. Das System von Gleichungen kann vervollständigt werden, wenn die Gleichung für die Energieerhaltung einbezogen wird. Für ein reibungsfreies ideales Gas lässt sich die hydrodynamische Formulierung der adiabatischen Energieerhaltung wie folgt aufstellen: p ∂u + (~v · ~∇)u = − ~∇ ·~v. (2.39) ∂t ρ Daraus ergibt sich analog der Herleitung von Gleichung 2.15 folgende Formel: dui Pi = 2 dt ρi N ∑ m j v~i j · ~∇iW (|~ri j |, hi j ). (2.40) j=1 Die oben eingeführte künstliche Viskosität führt an Schockfronten zusätzlich zu einer Erhitzung des Gases. Aus diesem Grund wird Gleichung 2.40 ein Term hinzugefügt, welcher die Entropieänderung aufgrund der künstlichen Viskosität berücksichtigt. Für diese Arbeit wird deshalb 18 KAPITEL 2. ASTROPHYSIKALISCHE SIMULATIONSVERFAHREN folgende SPH-Form für die Energiegleichung verwendet, welche die Erhaltung der Gesamtenergie sichert: dui Pi = 2 dt ρi N 1 ∑ m j v~i j · ~∇iW (|~ri j |, hi j ) + 2 j=1 N ∑ m j Πi j v~i j · ~∇iW (|~ri j |, hi j ). (2.41) j=1 Der erste Summand der rechten Gleichungsseite kann direkt aus dem bereits für die Berechnung von fi ermittelten Wert für h~∇ ·~vii durch Multiplikation mit Pi /ρi bestimmt werden. Der zweite Summand kann leicht in die Schleife zur Berechnung von d~v/dt einbezogen werden. Zusammenfassung des SPH-Algorithmus Es sollen hier noch einmal die wesentlichen Punkte des eben gegebenen SPH-Formalismus zusammengefasst werden, um den Ablauf der Berechnungen zu verdeutlichen. • Es wird ein Spline-Glättungskern mit kompaktem Träger verwendet. Dies führt dazu, dass nur die Beiträge einer Anzahl nächster Nachbarn um ein Teilchen in die Berechnung von SPH-Größen einfließen. Für jedes Teilchen wird also eine Nachbarschaftsliste erstellt und für die SPH-Formeln wird nur über diese Liste summiert. • Für jedes Teilchen i wird in einer ersten SPH-Schleife über die Nachbarn durch die Summenformel 2.24 die Dichte ρi bestimmt. In der gleichen Schleife werden die Summationen für ~∇ ·~v (Gleichung 2.37) und ~∇ ×~v (Gleichung 2.38) durchgeführt. • Für jedes Teilchen wird nun der Druck, die Schallgeschwindigkeit und der Balsarakoeffizient fi (Gleichung 2.36) bestimmt. • Für alle Teilchen können dann in einer zweiten SPH-Schleife über die Nachbarn die Kräfte (Gleichung 2.32 mit 2.35 für die Berechnung von µi j ) und Energien (Gleichung 2.41) berechnet werden. Es gibt also zwei Schleifen über die Nachbarschaftslisten der SPH-Teilchen, in welchen eine Summation von SPH-Beiträgen der Nachbarn durchgeführt wird. 2.3.3 Variationen des SPH-Verfahrens Die Formeln zur Berechnung von SPH-Erwartungswerten, wie sie im letzten Abschnitt entwickelt wurden, sind keineswegs die einzig mögliche Variante. Es gibt insbesondere unterschiedliche Ansätze, eine Symmetrie der Beiträge von Teilchen j zu einem Erwartungswert von Teilchen i und umgekehrt zu erreichen. Diese Symmetrie ist notwendig, damit eine antisymmetrische paarweise Wechselwirkung zwischen Teilchen möglich wird, was grundlegende Voraussetzung für die Impulserhaltung ist. So können beispielsweise die Kernel-Beiträge bei unterschiedlichen Glättungslängen hi 6= h j anstatt durch hi + h j W |~ri −~r j |, 2 2.3. SMOOTHED PARTICLE HYDRODYNAMICS 19 auch durch 1 W (|~ri −~r j |, hi ) +W (|~ri −~r j |, h j ) 2 symmetrisiert werden. Ein anderes Beispiel ist die Symmetrisierung von P/ρ 2 , wie sie für die Berechnung der Beschleunigung gebraucht wird. Anstatt das arithmetische Mittel ! Pj 1 Pi + 2 2 2 ρi ρj zu berechnen, kann auch das geometrische Mittel verwendet werden: p Pi Pj . ρi ρ j Die eben beschriebenen Symmetrisierungsvarianten wurden in [43] eingeführt und diskutiert. Besonders viele Variationen gibt es bei der Behandlung der künstlichen Viskosität. Diese Größe ist nicht direkt physikalisch motiviert, sondern soll lediglich unphysikalisches Verhalten der SPH-Simulation bei starken Schockwellen und Turbulenz vermeiden. Sie hat den ungewollten Seiteneffekt einer unphysikalisch hohen Energiedissipation. Deshalb gibt es zahlreiche Modifikationen, welche für verschiedene Simulationsszenarien optimiert sind. Es soll an dieser Stelle nicht näher darauf eingegangen werden. 2.3.4 Einbettung in Simulation der Gravitation Auf den ersten Blick unterscheidet sich die algorithmische Struktur von SPH sehr stark von den Verfahren zur Berechnung der Gravitationskraft, und es erscheint schwierig, eine Verbindung herzustellen. Jedoch basieren alle bisher beschriebenen Methoden auf der Repräsentation des astrophysikalischen Systems durch Teilchen. Deshalb können die Fluidteilchen direkt in die Gravitationsbehandlung für das Gesamtsystem einbezogen werden. Umgekehrt werden für die wichtigsten N-body-Codes auch Nachbarschaftsbeziehungen in die Berechnung einbezogen, was sich ebenso für die Erzeugung von Nachbarschaftslisten für SPH ausnutzen lässt. So wenden die P3 M-Codes für kurze Distanzen eine PP-Methode an und die Ermittlung der dafür benötigten Nahbereichsteilchen leistet bereits viel Vorarbeit für den Aufbau der SPH-Nachbarschaftslisten (siehe z.B. [20]). Und bei baumbasierten Verfahren beinhaltet die hierarchische Datenstruktur bereits die Information über die Nachbarschaftsbeziehungen. Hernquist und Katz beschreiben in [43] ihren TREESPH-Code, der auf einem Barnes-Hut-Tree aufbaut und für die Nachbarschaftssuche die Baumstruktur ähnlich wie für den Aufbau der Gravitations-Interaktionslisten verwendet. Ein aktuelleres Beispiel für einen mit einem Barnes-Hut-Tree gekoppelten SPH-Code ist GADGET [106]. Ein Beispiel für die Verwendung eines Binärbaumes in Verbindung mit SPH ist der GASOLINE-Code [121]. Diese Arbeit orientiert an der Implementierung eines Codes basierend auf dem Press-Tree wie in [111] und [126]. Die Gravitation wird sowohl für die N-body-Teilchen3 als auch für SPHTeilchen gerechnet. Zur Beschleunigung kann ein GRAPE-System verwendet werden (siehe Abschnitt 2.4.2, [110] und [126]). Für die SPH-Teilchen werden dann Korrekturen notwendig, da 3 N-body-Teilchen sind rein gravitativ wechselwirkende Teilchen. 20 KAPITEL 2. ASTROPHYSIKALISCHE SIMULATIONSVERFAHREN die SPH-Teilchen zur Vermeidung von Inkonsistenzen ein nach dem SPH-Formalismus geglättetes Gravitationspotential bewirken sollten. Dazu kann im SPH-Formalismus folgende Formel angewendet werden, welche sich daraus ableitet, dass für ein Teilchen i die Glättungskernfunktion W (|~r −~ri |, hi j ) als Dichteverteilungsfunktion interpretiert wird (nach [11]): N M(|~ ri j |) r~i j −~∇Φi = −G ∑ 2 |~ ri j | ri j j=1 Rx M(x) = 4π u2W (u, hi j )du. (2.42) 0 2.4 Rechnerplattformen für astrophysikalische Simulationen Da die Qualität astrophysikalischer Simulationen von der Auflösung und damit von der simulierten Teilchenzahl abhängt, wird in der Regel mit der bei vertretbarer Rechenzeit maximal möglichen Anzahl von Teilchen gerechnet. Dazu wird vorzugsweise auf Hochleistungsrechnern gearbeitet. Grundsätzlich können sowohl Rechner-Cluster als auch Supercomputer eingesetzt werden, und beide Rechnerklassen werden abhängig von der Verfügbarkeit solcher Rechensysteme verwendet. In Abschnitt 2.4.1 werden einige Aspekte der Implementierung von Simulationscodes auf solchen Mainstream-Plattformen umrissen. Abschnitt 2.4.2 gibt einen Überblick über Spezialrechner, die für astrophysikalische Simulationen eingesetzt werden. 2.4.1 Hochleistungsrechner Supercomputer sind die klassische Plattform für astrophysikalische Simulationen. Kann die Anwendung gut parallelisiert werden, wie es beispielsweise bei kosmologischen Simulationen mit P3 M bei relativ homogener Verteilung der Massen der Fall ist, skaliert die Rechengeschwindigkeit sehr gut mit der Anzahl der Prozessoren. Hier kommen die Vorteile eines Supercomputers zum tragen, wie die hohe Rechenleistung der Knoten und die schnelle Verbindung mit kurzer Latenzzeit zwischen Rechenknoten. Sobald jedoch auch hydrodynamische Phänomene durch SPH berücksichtigt werden oder starke Inhomogenitäten durch die Zusammenballung von Massen auftreten, skaliert die Rechenleistung des Codes für mehr als ca. 30 Prozessoren schlecht (siehe z.B. [90]). Mehr und mehr werden auch Rechnercluster eingesetzt. Diese Systeme sind sehr populär geworden, seit schnelle Verbindungsnetze für Standard-PCs existieren und gute Standardprozessoren eine bei vielen Anwendungen vergleichbar hohe Leistung wie bei einem Supercomputer-Knoten erzielen. Durch den Einsatz von Standardkomponenten ergibt sich eine wesentlich bessere Price-Performance als bei Supercomputern. Mit Clustern ist eine sehr hohe Speicherkapazität pro Rechenknoten möglich, was insbesondere für hydrodynamische Codes wichtig ist. Zu aktuellen Beispielen von astrophysikalischen Simulationen auf Clustern siehe z.B. [121] und [25]. 2.4. SIMULATIONSPLATTFORMEN 21 Abbildung 2.3: Simulationssystem, bestehend aus Host-Rechner und GRAPE-6-Spezialrechner zur Beschleunigung der Gravitationsberechnung. 2.4.2 Spezialrechner GRAPE Die Behandlung der Gravitation ist der bei weitem rechenaufwändigste Teil von astrophysikalischen N-Körper-Simulationen und limitiert deshalb die Teilchenzahl, die simuliert werden kann. Aus dem wissenschaftlichen Bedarf nach höheren Teilchenzahlen (um die Auflösung und Aussagekraft der Simulationen zu steigern) motivierte sich das GRAPE-Projekt der Universität Tokio [26]. Ende der 1980er-Jahre begonnen, wurde eine Generationenfolge von Spezialrechnern entwickelt, welche auf der gemeinsamen Idee beruhen, die Gravitationskraft durch ein maßgeschneidertes Rechenwerk in der Form einer Pipeline (GRAvity Pipe = GRAPE) massiv parallel zu berechnen (siehe z.B. [113], [75] und [50]). Dieses Konzept bietet sich an, da die Gravitationskraft über eine einzige Formel, bestehend aus wenigen Operationen berechnet werden kann. Ein Simulationssystem besteht bei diesem Konzept aus einem Standard-Host-System und angeschlossenem GRAPE-Rechenbeschleuniger, wie in Abbildung 2.3 gezeigt wird. Dieser Rechenbeschleuniger ist im Wesentlichen aus parallelen Spezialprozessoren aufgebaut, in welchen die Rechenpipelines implementiert sind. Die aktuelle Plattform ist GRAPE-6 [74]. Die Konzepte, die bei dieser Architektur angewandt werden, sollen im Folgenden etwas genauer beleuchtet werden. Abbildung 2.4 zeigt eine schematische Darstellung der GRAPE-6-Architektur aus der Sicht des Anwenders. Das grundsätzliche Verarbeitungsschema ist folgendes: Die Positionen ~ri und Geschwindigkeiten ~vi der Teilchen, für welche die Kräfte berechnet werden sollen, werden lokal in den Pipelines gespeichert, die Daten der Wechselwirkungspartner werden dagegen in einem externen Speicher abgelegt. Wird die Berechnung gestartet, werden die benötigten Teilchendaten der Interaktionspartner automatisch, gesteuert über einen Adressgenerator, den Rechenwer- 22 KAPITEL 2. ASTROPHYSIKALISCHE SIMULATIONSVERFAHREN Address Generator Particle Memory t j , r j , vj ... Predictor Processor mj , rpj , vpj ... Force/Jerk Processor ri , vi . ai , ai , ϕi Abbildung 2.4: Architektur des GRAPE-6-Spezialrechners aus Anwendersicht (nach [72]). ken zugeführt. Die Architektur erlaubt neben der reinen Berechnung der Kräfte zwei wichtige algorithmische Optimierungen. Den Pipelines vorgeschaltet ist ein so genannter Predictor Processor. Dieser ermöglicht die Extrapolation von Teilchenvariablen früherer Zeitpunkte t j auf den aktuellen Zeitschritt t der Simulation: ~r j (t j ) → ~r p j ≈ ~r j (t) ~v j (t j ) → ~v p j ≈ ~v j (t). Damit können auf einfache Weise Algorithmen mit individuellen Zeitschritten implementiert werden. Als zweite Optimierung wird neben dem Potential die Teilchenbeschleunigung und deren Ableitung berechnet. Dies erlaubt es, im Integrator ein Hermite-Schema zur Bestimmung der Teilchenvariablen anzuwenden. Die Formel, die in den GRAPE-6-Plattformen berechnet wird, ist dementsprechend: ~ai = ∑ j Gm j ~ri j 3/2 ri2j + ε 2 " # 3 ~vi j ·~ri j ~ri j ~vi j ~a˙ = ∑ j Gm j − 2 5/2 2 3/2 2 ri j + ε ri j + ε 2 1 φi = ∑ j Gm j 1/2 . 2 ri j + ε 2 (2.43) Die GRAPE-6-Maschinen basieren auf eigens konstruierten ASICs, den GRAPE-6-Chips, welche in einem 0.25-µm-Prozess gefertigt sind. Die Bausteine sind so konstruiert, dass damit massiv parallele Systeme aufgebaut werden können. Ein GRAPE-6-Chip beinhaltet einen Pipeline-Prozessor, der die Netzwerkschnittstelle, das Speicherinterface und die Prediction-Einheit implementiert sowie sechs parallele Pipelines, welche selbst logisch in acht virtuelle Pipelines and (4). We adopted an architecture in which the x, y, and z components of all vector quantities are processed sequentially, in order to reduce the gate count. Thus, it takes three clock periods to calculate one interaction. 2.4. SIMULATIONSPLATTFORMEN 23 V r2 ri 2 mr -1 Function Evaluator m Σr mr-3 a r rj Σ mr r3 mj r.v vi vj . 3mr-5 (r.v) v - a Σ m v 3m (r.v)r r3 r5 + FIG. 11.ÈHARP chip Abbildung 2.5: Architektur der Pipeline zur Berechnung der Formeln 2.43 (entnommen aus [75]). aufgeteilt sind. Aus Anwendersicht beinhaltet ein solcher Chip also 48 Pipelines, welche zur parallelen Berechnung der Kräfte aller im Speicher gehaltenen Teilchen auf 48 Teilchen verwendet werden. Ein Blockschaltbild der Implementierung einer der sechs GRAPE-6-Pipelines zur Berechnung der Formeln 2.43 ist in Abbildung 2.5 dargestellt. Ein GRAPE-6-Board besteht aus 32 GRAPE-6-Chips. Die sechs Pipelines pro Chip arbeiten mit einer Taktfrequenz von 90 MHz. Pro Pipeline kann in jedem Taktzyklus eine Teilchen˙ berechnet werden, wozu 57 Gleitkommaoperationen Teilchen Wechselwirkung (φ , ~a und ~a) angesetzt werden. Für das gesamte GRAPE-6-Board ergibt dies eine Rechenleistung von 985 GFlops und es können pro Sekunde 17.3 · 109 Kraftberechnungen durchgeführt werden. Alle GRAPE-6-Chips berechnen die Wechselwirkungen auf einem gemeinsamen Satz von 48 Teilchen, aber jeweils mit unterschiedlichen Listen von Interaktionspartnern. Die Daten dieser Wechselwirkungspartner werden in lokalen Speichern abgelegt, welche direkt an die Chips angeschlossen sind. Das gesamte Board hat also genauso wie ein einzelner Chip 48 virtuelle Pipelines. Die 32 Teilergebnisse zu einer dieser Pipelines des GRAPE-6-Boards werden in einem über FPGAs implementierten Addiererbaum auf dem Board zu einem Rechenergebnis pro virtueller Pipeline reduziert und an den Host gesandt. Die GRAPE-Architektur erreicht bei Simulationen von Systemen, deren Entwicklung fast ausschließlich durch die Gravitationskraft determiniert ist, eine sehr hohe Effizienz. So wurde in Tokio ein paralleles System aus 64 GRAPE-6-Boards mit einer Spitzenleistung von 63.4 TFlops aufgebaut und für eine echte Simulationsanwendung eine durchschnittliche Leistung von über 33 TFlops nachgewiesen [74]. Mehrfach wurde für die GRAPE-Systeme bereits der Gordon-BellPreis verliehen. Tabelle 2.1 zeigt die Entwicklung der GRAPE-Plattformen. Es werden zwei unterschiedli- Th the sa 1994) chips mula bit Ño accel of vel atives obtai which Th It is rule i numb 14.2 m We st pleted delive 24 KAPITEL 2. ASTROPHYSIKALISCHE SIMULATIONSVERFAHREN che Zweige verfolgt, die sich in der Rechengenauigkeit der GRAPE-Pipelines unterscheiden. Die Plattformen mit niedriger Genauigkeit haben ungerade, die mit hoher Genauigkeit gerade Versionsnummern. Plattform GRAPE-1 GRAPE-1A GRAPE-2 GRAPE-2A GRAPE-3 GRAPE-3A GRAPE-4 GRAPE-5 GRAPE-6 Jahr 1989 1990 1990 1992 1991 1992 1995 1999 2002 Prozess Peakperf. Genauigkeit 240 MFlops niedrig 240 MFlops niedrig 40 MFlops hoch 180 MFlops hoch 14.4 GFlops niedrig 2.4 GFlops niedrig 1 µm 1 TFlops hoch 0.5 µm 38.4 GFlops niedrig 0.25 µm 63 TFlops hoch # Pipelines Frequenz 1 8 MHz 1 8 MHz 1/3 4 MHz 1 10 MHz 48 10 MHz 4 20 MHz 1692 30 MHz 16 80 MHz 12288 90 MHz Tabelle 2.1: Entwicklung der GRAPE-Systeme. Mittlerweile ist neben dem aktuellen GRAPE-6-Spezialrechner mit 32 GRAPE-6-Chips auch ein kleineres System, basierend auf einer 64-Bit-PCI-Einsteckkarte, verfügbar. Dieses enthält mit vier GRAPE-6-Chips nur 1/8 der Ressourcen des großen Boards, kostet jedoch auch nur 1/8 davon. MDM Die Molecular Dynamics Machine (MDM) ist wie GRAPE eine japanische Entwicklung und wird am Institut für Physikalische und Chemische Forschung, RIKEN, betrieben. Das System besteht aus zwei Spezialrechnerplattformen, dem MDGRAPE-2-System zur Berechnung von Van-der-Waals- und Coulombkräften im Ortsraum und dem WINE-2-System zur Berechnung der Coulombkräfte im Fourierraum [83]. Das MDGRAPE-2-System hat prinzipiell die gleiche Funktionsweise wie GRAPE, kann aber verschiedene Kraftgesetze implementieren. Die WINE2-Boards wurden ebenfalls basierend auf massiv parallelen Pipelines innerhalb spezieller ASICs konstruiert und ermöglichen unter anderem die schnelle Berechnung der DFT und IDFT. In [82] wird die Leistungsfähigkeit eines Systems bestehend aus 96 Boards mit jeweils 16 MDGRAPE2-Chips, 144 Boards mit jeweils 16 WINE-2-Chips und diversen Host-Workstations präsentiert. Das Gesamtsystem hat eine Peak-Performance von etwa 78 TFlops und für eine Simulation der Verfestigung von NaCl mit 33 Millionen Teilchen wurde eine Rechenleistung von 8.61 TFlops erreicht [82]. Die MDGRAPE-2 Plattform ist auch für die astrophysikalische Anwendung interessant, da damit auch spezielle baumbasierte Verfahren zur Gravitationsberechnung, für welche GRAPE ungeeignet ist, effizient umgesetzt werden können ([51]). PROGRAPE Das PROGRAPE-System wurde als Erweiterung der GRAPE-Plattform entwickelt. Ziel war es, wie bei den GRAPE-Systemen eine massiv parallele Rechnerarchitektur aufzubauen, welche je- 2.4. SIMULATIONSPLATTFORMEN 25 doch andere Wechselwirkungen als die Gravitation simulieren kann. Insbesondere sollte die Architektur für SPH-Berechnungen verwendet werden können. Es wurde der Ansatz verfolgt, bei ansonsten unveränderter Systemarchitektur die GRAPE-Chips der GRAPE-Boards durch rekonfigurierbare Chips zu ersetzen. In [40] wird beschrieben, wie ein Prototyp dieser Plattform für die Gravitationswechselwirkung eine Rechenleistung von knapp 1 GFlop erreicht. Es existiert bereits ein PROGRAPE-2-System mit einem moderneren FPGA (Altera APEX20K400). Dieser ist in der Lage, die Pipelines für eine etwas einfacherere SPH-Formulierung als sie in Abschnitt 2.3.2 gegeben wurde aufzunehmen. Es wird mit einem logarithmischen Zahlenformat geringer Genauigkeit gerechnet (14 Bit). Dem Autor sind jedoch noch keine diesbezüglichen Veröffentlichungen bekannt. Im Rahmen dieser Arbeit wurde 2002 in Japan auf dem PROGRAPE-2-System ein Prototyp für die SPH-Formulierung nach Abschnitt 2.3.2 implementiert. Es wurde evaluiert, dass das PROGRAPE-2-System für unsere Genauigkeitsanforderungen noch nicht geeignet ist. Für zukünftige Entwicklungen von GRAPE-Systemen räumt man in Japan den rekonfigurierbaren Rechensystemen einen hohen Stellenwert ein. Bereits jetzt werden FPGAs für die Verbindung der GRAPE-6-Chips zu parallelen Recheneinheiten eingesetzt. Für die nahe Zukunft ist geplant, ein paralleles System mit FPGAs als zentralen Rechenelementen aufzubauen, um damit massiv parallel SPH-Simulationen durchzuführen. 26 KAPITEL 2. ASTROPHYSIKALISCHE SIMULATIONSVERFAHREN Kapitel 3 FPGA-basierte, rekonfigurierbare Rechnerplattformen 3.1 Rekonfigurierbare Logikbausteine In diesem Kapitel werden die Grundlagen rekonfigurierbarer Logik erläutert, wobei ausschließlich auf die FPGA-Technologie eingegangen werden soll. Rekonfigurierbare Logik bedeutet, dass durch die Konfiguration solcher Chips elektronische Schaltungen erzeugt werden können. Diese Bausteine sind nicht nur einmal konfigurierbar sondern rekonfigurierbar. So können mit ein und demselben Chip viele verschiedene elektronische Schaltungen implementiert und jederzeit ausgetauscht werden. Daher sind diese Bauelemente ideal für Anwendungen, bei denen mit Spezialarchitekturen eine hohe Leistungsfähigkeit erreicht werden soll, aber die Flexibilität einer programmierbaren Lösung zwingend notwendig ist. Diese Arbeit beruht auf dem Ansatz, rekonfigurierbare Logik in Form von FPGAs zur Implementierung von Rechenbeschleunigern einzusetzen. In diesem Kapitel wird entsprechend detailliert auf die Architektur von FPGAs eingegangen. Damit wird das Fundament für alle weiteren Ausführungen zur Implementierung der Spezialarchitektur gelegt, mit der astrophysikalische Simulationsalgorithmen beschleunigt werden. In Abschnitt 3.1.1 wird die allgemeine Architektur von FPGAs erläutert und in Abschnitt 3.1.2 werden Details zum FPGA-Typ, der in dieser Arbeit hauptsächlich verwendet wurde, vorgestellt. Die Hochleistungs-FPGAs anderer Hersteller weisen ähnliche Eigenschaften auf, und so ist vieles aus Abschnitt 3.1.2 übertragbar. Für eine Übersicht über FPGAs anderer Hersteller sei auf [122] und Referenzen verwiesen. 3.1.1 Allgemeine Architektur von FPGAs Die Abkürzung ’FPGA’ steht für Field Programmable Gate Array. Der Name weist auf die allen FPGAs gemeinsame Struktur hin, dass sie im Wesentlichen aus einer Matrix programmierbarer Logikelemente bestehen (siehe Abb. 3.1). In diesem Kontext ist Programmierung gleichbedeutend mit Konfiguration der Eigenschaften der FPGA-Ressourcen. Durch die Konfiguration 27 28 KAPITEL 3. REKONFIGURIERBARE RECHNERPLATTFORMEN Programmierbares Verbindungsnetzwerk Logikelemente I/O Zellen Abbildung 3.1: Prinzipieller Aufbau eines FPGAs. bekommen die Logikelemente eines FPGAs ein bestimmtes digitalelektronisches Verhalten zugewiesen. Die Logikelemente sind verbunden durch ein ebenfalls konfigurierbares Verbindungsnetzwerk. Durch Programmieren des Chips kann eine beliebige digitalelektronische Schaltung erzeugt werden – natürlich im Rahmen der Logikressourcen. FPGAs werden programmiert, indem ein so genannter Konfigurationsbitstrom auf den Chip transferiert wird. Nach der Konfiguration verhält sich der Baustein wie eine für eine Anwendung speziell konstruierte Integrierte Schaltung. Im Unterschied zum ASIC (Applikation Specific Integrated Circuit) kann das elektronische Verhalten eines FPGAs jederzeit durch erneute Konfiguration geändert werden. Ein Schaltungsdesign, auf dem der Konfigurationsbitstrom für den FPGAs basiert, wird im Folgenden FPGA-Design genannt. Die am weitesten verbreiteten FPGAs benutzen auf SRAM-Zellen basierende Logikelemente. Hier werden logische Funktionen einer festen Anzahl von Signalen mittels kleiner vorprogrammierter Speicherelemente (ROM) implementiert. Die Eingangssignale einer logischen Verknüpfung werden als Adressen eines solchen Speichers geschaltet. Durch eine in das Speicherelement programmierte Look-Up-Tabelle (LUT) kann eine beliebige logische Verknüpfung der Eingangssignale gebildet werden. Diese Look-Up-Tabellen werden deshalb auch Funktionsgeneratoren genannt. Die programmierbaren Logikelemente der gängigen FPGA-Typen beinhalten eine oder mehrere LUTs, die jeweils über vier Eingangssignale adressiert werden. Logische Funktionen mit mehr als vier Eingangssignalen werden durch das Zusammenschalten mehrerer LUTs gebildet. Moderne FPGAs erweitern die Möglichkeiten der Logikzellen durch zusätzlichen Schaltungsaufwand. So sorgt eine Carry-Logik mit speziellen schnellen Carry-Verbindungen zwischen benachbarten Logikelementen für schnelle Addierer und Zähler. Die Logikzellen lassen sich meist auch als kleine RAM-Blöcke ansteuern. Die Funktionsgeneratoren werden dabei nicht als ROM-Elemente sondern als SRAM konfiguriert. Damit können beispielsweise Zwischenergebnisse innerhalb des FPGAs gespeichert oder FIFO-Elemente aufgebaut werden. Um sequenzielle Logik zu ermöglichen, beinhalten die Logikelemente eines FPGAs ein oder Architecture Virtex-II Array Overview Virtex-II devices are user-programmable gate arrays with various configurable elements. The Virtex-II architecture is optimized for high-density and high-performance logic designs. As shown in Figure 1, the programmable device is 3.1. REKONFIGURIERBARE LOGIKBAUSTEINE 29 comprised of input/output blocks (IOBs) and internal configurable logic blocks (CLBs). DCM DCM IOB Global Clock Mux Configurable Logic Programmable I/Os CLB Block SelectRAM Multiplier DS031_28_100900 Abbildung 3.2: Struktureller Aufbau eines Virtex-II-FPGAs von Xilinx (nach [127]). Figure 1: Virtex-II Architecture Overview Programmable I/Oprogrammierbare blocks provide the Registerelemente interface between (Flip-Flops). All programmable elements, including mehrere Typischerweise entspricht die Zahlthe der routing package pins and the internal configurable logic. Most resources, are controlled by values stored in static memory Register der Zahl von Funktionsgeneratoren. FPGAs sind demnach sehr reich an Registern, was popular and leading-edge I/O standards are supported by cells. These values are loaded in the memory cells during sich direktIOBs. im Programmierstil von FPGA-Designsconfiguration niederschlägt dazubemehr in Abschnitt the programmable and- can reloaded to change3.1.3. the functions of the programmable elements. Es sei hier im Voraus erwähnt, dass in einem FPGA-Design die maximale Signalverzögerung der The internal configurable logic includes four major elements kombinatorischen organized in a regular array. • Logik zwischen Register-Ausgang (oder FPGA-Eingangspad) und RegisterVirtex-II Features Eingang Logic (oderBlocks FPGA-Ausgangspad) die Geschwindigkeit eines FPGA-Designs determiniert. Je Configurable (CLBs) provide functional This section describesdes Virtex-II features. kürzerfordiese maximale desto höher kann die briefly Taktfrequenz Designs gewählt elements combinatorial andVerzögerung synchronous ist, logic, including basic storage elements. BUFTs (3-state Input/Output Blocks (IOBs) werden. buffers) associated with each CLB element drive IOBs are programmable and can be categorized as follows: dedicated segmentable horizontal routing resources. • InputVirtex-II block with an optional single-data-rate or • Block SelectRAM memory modules provide largeFPGA-Serie 3.1.2 Details zur verwendeten double-data-rate (DDR) register 18-Kbit storage elements of True Dual-Port RAM. • Output block with an optionalFPGA-Serie single-data-rate In diesem die wichtigsten Eigenschaften der verwendeten dar-or DDR • Multiplier blocks Abschnitt are 18-bit xwerden 18-bit dedicated register, and an optional 3-state buffer, to be driven multipliers. gestellt. Es wird eine Übersicht über die FPGA-Architektur gegeben, wie sie zum Verständnis directly or through a single or DDR register • DCMder (Digital Clock Manager) blocks provide der in dieser Arbeit betrachteten Schaltungen notwendig Implementierung und Optimierung • Bi-directional block (any combination of input and self-calibrating, digital solutions for clock für das Schaltungsdesign ist. Obwohlfully moderne CAD-Software eine Beschreibung der Hardware output configurations) distribution delay compensation, clock multiplication ohne genaue Kenntnisse der internen Struktur ermöglicht, ist es unerlässlich, diese Strukturen zu and division, coarse and fine-grained clock phase These registers are either edge-triggered D-type flip-flops kennen, um ressourcenschonende Schaltungsvarianten entwickelnlatches. zu können. Deshalb wird beshifting. or level-sensitive sonders detailliert auf die Schaltungsmöglichkeiten für arithmetische Module eingegangen. Für A new generation of programmable routing resources called IOBs support the following single-ended I/O standards: eine tiefergehendere derallFPGA-Technologie sei auf das Datenblatt [127] verwiesen. Active Interconnect TechnologyBetrachtung interconnects of these • LVTTL, LVCMOS (3.3 V, 2.5 V, 1.8 V, and 1.5 V) elements. The general routing matrix an array of Zur Schaltungstechnik siehe(GRM) auch is[27]. • PCI-X at 133 MHz, PCI (3.3 V at 33 MHz and 66 MHz) routing switches. Each programmable tied toVirtex-II a Abbildung 3.2 zeigt denelement Aufbauis eines FPGAs von Xilinx auf struktureller Ebe• GTL and GTLP switch matrix, allowing multiple connections to the general ne. Die IOB genannten Elemente (IOB bedeutet Input-Output-Block), bilden die Schnittstellen routing matrix. The overall programmable interconnection is • HSTL (Class I, II, III, and IV) zwischen der FPGA-internen Schaltungslogik hierarchical and designed to support high-speed designs. und den Anschlusspins des Bausteins. Die IOBs können für 25 verschiedene elektrische Verbindungsstandards konfiguriert werden wie beispielsPCI, LVTTL, Damit können diese FPGAs in einer Vielzahl Module von 1 of 4 DS031-1 weise (v1.7) October 2, 2001 AGP-2X oder LVDS. www.xilinx.com Advancedigitalelektronischen Product Specification Umgebungen eingesetzt 1-800-255-7778 3 werden, was das Design von FPGA-basierten Ko- logic, arithmetic logic gates, wide function multiplexers and two storage elements. As shown in Figure 14, each 4-input function generator is programmable as a 4-input LUT, 16 bits of distributed SelectRAM memory, or a 16-bit variable-tap shift register element. 30 The storage elements in a Virtex either as edge-triggered D-type tive latches. The D input can be d output via the DX or DY input, or ing the function generators via th enable signal (CE) is active Hig The output from the function generator in each slice drives nected, the clock enable for that s both the slice output and the D input of the storage element. KAPITEL 3. REKONFIGURIERBARE RECHNERPLATTFORMEN the active state. Figure 15 shows a more detailed view of a single slice. ORCY RAM16 MUXFx SRL16 LUT G CY Register The initial state after configurati defined by a separate INIT0 and setting the SRLOW attribute se SRHIGH attribute sets INIT1. RAM16 MUXF5 SRL16 LUT F CY In addition to clock (CK) and c each slice has set and reset s inputs). SR forces the storage el fied by the attribute SRHIGH or logic “1” when SR is asserted. S When SR is used, a second inp element into the opposite state. dominant over the set condition. Register For each slice, set and reset can or asynchronous. Virtex-II devic set INIT0 and INIT1 independen Arithmetic Logic The control signals clock (CLK set/reset (SR) are common to bo slice. All of the control signals hav Figure 14: Virtex-II Slice Configuration Abbildung 3.3: Struktur einer Slice-Einheit des Virtex-II-FPGAs (nachinverter [127]).placed on a control input DS031_31_100900 prozessoren sehr vereinfacht. sind in Abb. 3.2 die als Quadrate dargestellten konfiguModule 2 of Weiter 4 www.xilinx.com 12 (CLBs) zu sehen. Auf Details zu den CLBs wird 1-800-255-7778 rierbaren Logikblöcke weiter unten noch ausführlich eingegangen. Die Matrix der CLBs wird durchbrochen von zusätzlichen Modulen - den so genannten Block-RAMs und Multiplizierer-Elementen (auch Block-Multiplizierer genannt). Die Block-RAM-Elemente sind SRAM-Elemente, deren Eigenschaften wie Single-Port- oder Dual-Port-Modus, Bitbreite und Speichertiefe konfiguriert werden können. Je nach Größe des FPGAs gibt es vier bis 168 Block-RAM-Elemente mit jeweils 18 KBit Speicherkapazität. Sie bieten damit lokale Speicherressourcen, die weit über die Speicherfähigkeiten der CLBs hinausgehen. Sie eignen sich gut für die Implementierung von Zwischenspeichern für wenige hundert Datenworte. Die Multiplizierer-Elemente können 18-Bit-Integer-Zahlen multiplizieren. Da diese Multiplizierer durch festverdrahtete Logik aufgebaut sind, ist deren Flächenbedarf auf dem Chip weit geringer als bei gleichartigen Multiplizierern, die durch Verwendung von CLBs implementiert werden. Die Multiplizierer wurden in die Virtex-II-Bausteine integriert, um vor allem die Schaltungsmöglichkeiten für DSP-Anwendungen (Digital Signal Processing), die das Hauptanwendungsgebiet für FPGAs darstellen, zu erweitern. In dieser Arbeit spielen diese Elemente eine wichtige Rolle für die Implementierung der arithmetischen Module. Nun zurück zu den CLBs, welche die wichtigsten rekonfigurierbaren Ressourcen eines FPGAs sind. Jede CLB besteht aus vier gleichartigen Einheiten, den so genannten Slices. Um eine Vorstellung von der Logikressourcen aktueller FPGAs zu vermitteln sei an dieser Stelle angemerkt, dass der in dieser Arbeit verwendete FPGA (Xilinx XC2V3000) 14336 Slices enthält. Diese Slices sind innerhalb der CLBs durch besonders schnelle konfigurierbare Leitungen verbunden. Der Aufbau eines Slice wird in Abb. 3.3 schematisch umrissen. Es sind zwei Funktionsgeneratoren G und F mit jeweils vier Eingängen und zwei Register vorhanden. Die Elemente G und F können wahlweise als Look-Up-Tabellen, als serielle Shiftregister oder RAM konfiguriert werden. Mit einem Funktionsgenerator lässt sich eine beliebige logische Funktion von vier Eingängen bilden. Die beiden Multiplexer-Elemente MUXFx und MUXF5 erlauben die Kombination der Funkti- DS031 Adv 3.1. REKONFIGURIERBARE LOGIKBAUSTEINE 31 onseinheiten sowie die Verknüpfung logischer Zwischenergebnisse mit anderen Slices der CLB. Dadurch wird es möglich, in einem Slice beliebige logische Funktionen mit bis zu fünf Eingangssignalen, in einer CLB mit bis zu sieben Eingängen aufzubauen. Durch Einbeziehen der Nachbar-CLB können beliebige logische Funktionen mit 8 Eingängen erzeugt werden. Es lassen sich auch bestimmte logische Funktionen von mehr als sieben Eingängen in einer CLB erzeugen (z.B. logisches OR von 32 Eingängen). Die Kenntnisse über die Erzeugung von Logikelementen sind wichtig für die Optimierung von FPGA-Designs. So determiniert die Anzahl der beteiligten LUTs die Schaltungsverzögerung einer logischen Funktion. Ist eine hohe Schaltgeschwindigkeit erforderlich, sollten logische Verknüpfungen von mehr als 8 Signalen vermieden werden. Zur Implementierung von schnellen arithmetischen Operatoren ist in den Slices zusätzliche Logik vorhanden, was durch die Symbole ORCY, CY und Arithmetic Logic angedeutet wird. Es handelt sich einerseits um eine Fast-Carry-Logik zur Beschleunigung von Schaltungen wie Integer-Addierern oder Zählern. So kann mit einer CLB ein sehr schneller 8-Bit-Ripple-CarryAddierer aufgebaut werden. Die zusätzliche Logik ermöglicht außerdem die effiziente Implementierung von Multiplizier-Addier-Elementen. So kann in einer CLB eine 8-Bit-Zahl mit einem Bit multipliziert und danach zu einer zweiten 8-Bit-Zahl addiert werden. Dies ist wichtig für die Konstruktion von Multiplizierern und Akkumulatoren. Aufgrund der Bedeutung für diese Arbeit wird am Ende dieses Abschnitts detaillierter auf die Eigenschaften der CLBs bezüglich der Implementierung arithmetischer Operationen eingegangen. Die Option, die Funktionsgeneratoren F und G als 16x1 Bit RAM-Elemente zu konfigurieren ist insbesondere für die Konstruktion von FIFO-Speichern wichtig. Dabei sind sowohl synchrone Single-Port als auch synchrone oder asynchrone Dual-Port RAM-Elemente möglich. Zur Unterscheidung von den Block-RAM-Elementen soll dieser Speicher im Folgenden CLB-RAM genannt werden. Die Funktionsgeneratoren können schließlich noch als Shiftregister-Elemente konfiguriert werden. Es handelt sich dabei um einen speziellen RAM-Modus. Diese Elemente haben dann das Verhalten, dass ein Eingangsbit synchron auf die Adresse 0x0 der CLB-RAM-Zelle geschrieben wird und in jedem Takt der Speicherinhalt um eine Speicherstelle weitergeschoben wird. Nach N Takten befindet sich ein geschriebenes Datenbit in der Speicherzelle N − 1. Durch Lesezugriff auf eine Adresse 0x0..0xf erhält man somit eine Verzögerung um 1..16 Taktzyklen. Eine Verzögerungsschaltung für ein Bit um 16 Taktperioden kostet so nur einen Funktionsgenerator (1/8 CLB), während eine registerbasierte Implementierung 16 Flip-Flops (2 CLBs) aufwenden würde. Für Verzögerungsglieder werden deshalb vorzugsweise Shiftregister-Elemente eingesetzt. Zur Illustration der komplexen Schaltungsmöglichkeiten der CLBs ist in Abb. 3.7 ein schematischer Schaltplan eines halben Slice dargestellt. Die Multiplexer des Schaltbilds, die ohne Select-Eingang dargestellt sind, schalten ein festes Signal durch, welches bei der Konfiguration des FPGAs festgelegt wird. Zu Details sei wiederum auf das Datenblatt der Virtex-II Bausteine verwiesen [127]. Wie oben erwähnt, wird an dieser Stelle noch etwas ausführlicher auf die Implementierung arithmetischer Funktionen durch die FPGA-Ressourcen eingegangen. Besonders wichtig sind hier Addierer. Für die Implementierung von Addierern gibt es zahlreiche Architekturen (siehe Abschnitt 4.1.2). Wichtigster Bestandteil für FPGA-Implementierungen sind jedoch meist Halbaddierer und Volladdierer, wie sie in Abbildung 3.4 dargestellt sind. Für die 1-Bit-Eingangssignale 32 KAPITEL 3. REKONFIGURIERBARE RECHNERPLATTFORMEN a b a b cin HA cout a VA s cout s b cin VA cout s Abbildung 3.4: Halbaddierer (links) und Volladdierer (rechts). a, b und cin (Carry-Input für Volladdierer) und die resultierenden Signale s (Summe) und cout (Carry Output) ergeben sich die folgenden Gleichungen: Halbaddierer: s = a⊕b cout = a · b (3.1) Volladdierer: s = a ⊕ b ⊕ cin cout = (cin · a · b) + (cin · (a + b)) . (3.2) Würde man diese Gleichungen durch jeweils zwei LUTs im FPGA umsetzen, betrüge der Ressourcenbedarf ein Slice pro Halbaddierer oder Volladdierer. Außerdem müssten in diesem Fall die Carry-Signale über allgemeine Routing-Ressourcen geleitet werden. Um diese Situation zu verbessern, sind in den meisten handelsüblichen FPGAs, so auch in den Virtex-II-FPGAs, zusätzliche Ressourcen zur schnellen Carry-Behandlung und -Verteilung vorhanden. Gleichung 3.2 kann folgendermaßen umformuliert werden, was sich leicht anhand der Logiktabelle 3.4 nachvollziehen lässt: s = a ⊕ b ⊕ cin cout = ((a ⊕ b) · cin ) + (a ⊕ b) · b . (3.3) b a⊕b 0 0 1 1 0 1 1 0 0 0 1 1 0 1 1 0 (3.4) cin 0 0 0 0 1 1 1 1 a 0 0 1 1 0 0 1 1 s cout 0 0 1 0 1 0 0 1 1 0 0 1 0 1 1 1 Gleichung 3.3 führt zu einer Implementierung eines Volladdierers, wie sie in Abbildung 3.5 gezeigt wird. Ist das Signal S des Multiplexers MUXCY auf logisch 1 (wenn genau eines der Signale a oder b gleich 1 ist, also a ⊕ b = 1) wird cin an cout weitergeleitet (propagate), ansonsten wird cout generiert (a = b = 1) oder gelöscht (a = b = 0). Die Carry-Signale der Slices 33 3.1. REKONFIGURIERBARE LOGIKBAUSTEINE c out S I3 b a I2 I1 I0 LUT 0 c out MUXCY 1 S O I3 I2 I1 I0 sub a b s XORG cin LUT 0 1 MUXCY O s XORG cin Abbildung 3.5: Implementierung eines Volladdierers (links) oder Addier/Subtrahier-Elements (rechts) durch 1/2 Slice eines Virtex-II-FPGA. c out S I3 I2 a b g 0 1 MUXCY LUT O s I1 I0 XORG cin MULTAND Abbildung 3.6: Implementierung eines Volladdierers mit Selektion des Eingangs b durch g mit 1/2 Slice eines Virtex-II-FPGA. sind durch sehr schnelle Carry-Chains verbunden (siehe Abbildung 3.8). Damit können auf einfache und ressourcensparende Weise Ripple-Carry-Addierer mit sehr kurzen Laufzeiten für die Propagation der Carry-Signale erzeugt werden. Dies erübrigt in den meisten Fällen den Einsatz von schnelleren Addiererarchitekturen wie Carry-Save- oder Carry-Lookahead-Addierer. Mit dem gleichen Ressourcenaufwand können auch Addier/Subtrahier-Elemente aufgebaut werden, was die rechte Seite von Abbildung 3.5 zeigt. Diese Elemente werden genauso miteinander verbunden wie im Fall des Ripple-Carry-Addierers. Das Carry-Signal cin des Addierers für das niedrigstwertige Bit muss dann mit dem Signal sub verbunden sein. Für effiziente Umsetzungen von Multiplizierern und Akkumulatoren wurde in die Slices außerdem die MULTAND-Logik eingebaut. Damit lässt sich mit einem halben Slice die Addition von cin , a und (g · b) erreichen, also die durch g (Gate) selektierte Addition von b zu a. Formel 3.5 beschreibt die erforderliche Schaltungslogik. Die resultierende Schaltung ist in Abbildung 3.6 dargestellt. s = a ⊕ (b · g) ⊕ cin cout = (cin · a · b · g) + (cin· (a + b · g)) = ((a ⊕ b · g) · cin ) + (a ⊕ b · g) · (b · g) (3.5) 34 KAPITEL 3. REKONFIGURIERBARE RECHNERPLATTFORMEN R Virtex-II 1.5V Field-Programmable Gate Arrays COUT SHIFTIN ORCY SOPIN SOPOUT 0 Dual-Port Shift-Reg G4 G3 G2 G1 WG4 WG3 WG2 WG1 A4 LUT A3 RAM A2 ROM A1 D WG4 G WG3 WG2 MC15 WG1 WS DI YBMUX YB MUXCY 1 0 1 GYMUX Y DY XORG FF LATCH ALTDIG MULTAND 1 0 DYMUX G2 PROD G1 CYOG BY CE CLK D Q Q Y CE CK SR REV BY SLICEWE[2:0] WSG WE[2:0] WE CLK WSF SR SHIFTOUT DIG MUXCY 1 0 CE CLK Shared between x & y Registers SR CIN Figure 15: Virtex-II Slice (Top Half) Abbildung 3.7: Schaltung einer halben Slice-Einheit des Xilinx Virtex-II (obere Hälfte). Das Element MUXFx von Abb. 3.3 ist hier nicht dargestellt (nach [127]). DS031-2 (v1.9) November 29, 2001 Advance Product Specification www.xilinx.com 1-800-255-7778 Module 2 of 4 13 35 3.1. REKONFIGURIERBARE LOGIKBAUSTEINE COUT to S0 of the next CLB COUT to CIN of S2 of the next CLB O I MUXCY FF LUT (First Carry Chain) SLICE S3 O I MUXCY FF LUT CIN COUT O I MUXCY FF LUT SLICE S2 O I O I MUXCY MUXCY FF LUT FF LUT O I SLICE S1 MUXCY FF LUT CIN COUT O I (Second Carry Chain) MUXCY FF LUT O I SLICE S0 MUXCY FF LUT CIN CIN CLB DS031_07_110200 Abbildung 3.8: Verschaltung der Carry-Signale innerhalb einer CLB des Xilinx Virtex-II (nach [127]). 36 3.1.3 KAPITEL 3. REKONFIGURIERBARE RECHNERPLATTFORMEN Programmierung von FPGAs Es wurde oben bereits erwähnt, wie ein FPGA durch die Konfiguration bzw. Programmierung seiner Logikelemente und des Verbindungsnetzwerks seine Funktion als digitalelektronische Schaltung erhält. Zwischen FPGA-Design und FPGA-Konfiguration gibt es durch hochentwickelte Designwerkzeuge eine ähnlich hohe Abstraktion der Programmierung wie zwischen Hochsprachenprogrammierung und Maschinencode. Um zu verdeutlichen, wie in der Praxis FPGAs programmiert werden, soll hier kurz auf den Design-Flow programmierbarer Logik eingegangen werden. Das Analogon zur Hochsprache bei der Mikroprozessorprogrammierung ist im FPGA-Design die Hardwarebeschreibungssprache (Hardware Description Language, HDL). Besonders weit verbreitet sind die Sprachen VHDL und Verilog. Auf dieser Ebene geschieht das Schaltungsdesign mit den gleichen Techniken wie beim ASIC-Design, jedoch mit etwas unterschiedlichen Design-Kriterien, worauf weiter unten eingegangen wird. Diese Sprachen ermöglichen sowohl ein strukturelles Design der Schaltungen, also das hierarchische Zusammenbauen von Schaltungen aus gegebenen Bausteinen, als auch das verhaltensmäßige Beschreiben von Schaltungsbausteinen. Letzteres war ursprünglich für die reine Simulation von Schaltungsideen gedacht. Die aktuellen Designwerkzeuge unterstützen jedoch inzwischen bei den meisten verhaltensmäßig beschriebenen Konstrukten (bei allen, wenn gewisse syntaktische Regeln eingehalten werden) die Synthese in eine Schaltung. Da im programmierten FPGA die Fehlersuche nur begrenzt möglich ist, muss vor der Synthese eine gründliche Simulation auf HDL-Ebene durchgeführt werden. Die Transformation der in der HDL formulierten Schaltung in eine Netzliste, in der die schaltungstechnische Struktur festgehalten wird, wird meist Synthese genannt. Das Synthesewerkzeug führt bereits eine Abbildung der Schaltungslogik auf die elementaren Elemente des FPGAs durch, jedoch noch ohne die FPGA-Implementierung festzulegen. Dies ist Aufgabe des Place&RouteWerkzeugs, welches in der Regel vom Hersteller des verwendeten FPGAs bereitgestellt wird. Dort wird die Netzliste eingelesen, die Logikelemente werden auf die FPGA-Ressourcen platziert und die logische Verbindungsstruktur wird durch ein automatisches Routing-Verfahren auf die physikalischen FPGA-Verbindungselemente abgebildet. Grundsätzlich werden, bis auf wenige Ausnahmen, FPGA-Schaltungen nach dem Prinzip der synchronen Verarbeitung entwickelt (synchrones Design). Hierbei werden sämtliche Signale auf ein oder mehrere Taktsignale bezogen. Die maximale Signallaufzeit zwischen zwei Registern, die synchron zu einem Takt getriggert werden, oder zwischen solchen Registern und den Einoder Ausgängen des FPGAs, bestimmt dann die maximale Frequenz dieses Taktes, bis zu der die Schaltung vorhersehbar korrekt arbeitet. Diese Vorhersehbarkeit ist nur beim synchronen Design gegeben, da im Allgemeinen die Funktion von asynchronen Designs von den relativen Verzögerungen der Logikpfade abhängen kann. Diese Signalverzögerungen in rein kombinatorischer Logik lassen sich jedoch durch die im Place&Route-Prozess unterschiedlich zugeordneten Verbindungslängen zwischen den Logikelementen nur schwer kontrollieren. Die Anwendung asynchroner Techniken ist deshalb sehr fehlerträchtig. Während im VLSI-Design Register viel Chipfläche verbrauchen und deshalb nach Möglichkeit vermieden werden, sind FPGAs reich an Registern. Wie oben gesehen, ist in der Regel jeder LUT ein Register zugeordnet - es braucht also nicht an Registern gespart zu werden. Damit wird 37 3.2. ALLGEMEINE SYSTEMARCHITEKTUR Reconfig. Coprocessor Reconfig. Coprocessor Bus/Interface Host Abbildung 3.9: Grundlegende Systemarchitektur eines rekonfigurierbaren Rechensystems aus Steuerrechner (Host) und rekonfigurierbaren Koprozessoren. die Technik des Pipelinings für das Design von FPGA-Schaltungen zu einem Schlüsselprinzip. Die Konstruktion einer Pipeline für eine Schaltung beruht darauf, die Verarbeitung in Schritte aufzuteilen, die zeitlich nacheinander ausgeführt werden können. Zwischen den Verarbeitungsschritten können Register eingeführt werden. Der Datendurchsatz verändert sich dadurch nicht, es entsteht jedoch eine Verzögerung der Ausgangssignale relativ zu den Eingangssignalen um eine Anzahl von Taktzyklen, die der Anzahl von Registerstufen entspricht. Die maximale Taktfrequenz einer derart aufgebauten Schaltung wird durch die Signalverzögerung der Logik zwischen den Registern bestimmt. Ein tiefes Pipelining bedeutet eine feine Aufteilung der Schaltung in Verarbeitungsschritte mit kurzen Signalverzögerungen. Mit der Tiefe des Pipelinings steigt die erreichbare Taktfrequenz und damit die Geschwindigkeit des Designs. Dagegen vergrößert sich die Anzahl der Taktzyklen zwischen Signaleingang und Ausgang. Diese Zeit soll im Folgenden Latenzzeit (engl. Latency) oder Latenz genannt werden. 3.2 Allgemeine Systemarchitektur rekonfigurierbarer Plattformen In diesem Abschnitt wird die Struktur von rekonfigurierbaren Plattformen umrissen. Es kann hier kein allgemeiner Überblick über alle Varianten des rekonfigurierbaren Rechnens gegeben werden. Der Abschnitt soll eher eine Idee von den möglichen Rechnerarchitekturen, die auf rekonfigurierbaren Systemkomponenten basieren, vermitteln. Einen weiterführenden Überblick geben beispielsweise [17], [117], [3] und [41]. 38 KAPITEL 3. REKONFIGURIERBARE RECHNERPLATTFORMEN 3.2.1 Rekonfigurierbare Rechensysteme Rekonfigurierbare Rechensysteme werden in der Regel als Hybridsysteme aus Standardcomputerplattform und rekonfigurierbaren Koprozessoren zusammengesetzt. Dabei bilden Mikroprozessorbasierte Computer den/die Steuerungsrechner (Host) für die rekonfigurierbare Plattform. Dieser Aufbau wird in Abb. 3.9 dargestellt. Die rekonfigurierbaren Systeme werden entweder direkt über ein Bus-System (z.B. PCI-Bus) oder indirekt über Schnittstellenkarten des Host mit diesem verbunden. Die rekonfigurierbaren Koprozessoren können jedoch darüber hinaus direkt untereinander verbunden sein. Dieser hybride Aufbau aus Host und Koprozessoren ist aus folgenden Gründen zweckmäßig: • FPGAs erhalten ihre Schaltungsfunktionalität erst durch die Programmierung mit einem Konfigurationsbitstrom. In der Regel geschieht die Konfigurierung durch einen Steuerrechner. Moderne FPGAs unterstützen zwar auch die Konfigurierung über ROM-Bausteine, allgemeiner verwendbare rekonfigurierbare Rechensysteme benötigen jedoch die Option, häufig und schnell die FPGA-Designs wechseln zu können. • Das rekonfigurierbare Rechensystem muss mit Daten aus Standardquellen wie Festplatten oder Netzwerkressourcen versorgt werden. Die Nutzung von Standardcomputern ist die einfachste Möglichkeit, solche Datenquellen bereitzustellen. • Eine rekonfigurierbare Plattform eignet sich nur zur Beschleunigung laufzeitkritischer Teile eines Algorithmus wie z.B. innere Schleifen eines Kraftberechnungsverfahrens. Simulationsalgorithmen beinhalten jedoch oft komplexe, aber laufzeitunkritische Programmteile, die besser über sequentielle instruktionsbasierte Ausführung in einem Mikroprozessor ausgeführt werden. 3.2.2 Rekonfigurierbare Koprozessoren Den prinzipiellen Aufbau FPGA-basierter Koprozessoren zeigt Abb. 3.10. Die zentralen Bausteine sind ein oder mehrere FPGAs, die entweder durch direkte Punkt-zu-Punkt-Verbindungen kommunizieren oder über einen oder mehrere Busse Daten austauschen. Die FPGAs haben meist direkten Anschluss an Speicherressourcen. Viele rekonfigurierbare Koprozessoren verfügen überdies über weitere Elektronikressourcen wie z.B. Signalprozessoren sowie über Anschlussmöglichkeiten an periphere Hardware, beispielsweise durch Stecker für Aufsteckplatinen. Diese Ressourcen können durch einen Bus oder direkten Anschluss an einen FPGA in den Koprozessor eingebunden sein. 3.3 Verwendete rekonfigurierbare Plattform Im laufe dieser Arbeit wurde mit vier verschiedenen FPGA-Plattformen gearbeitet. Der Hauptteil der Arbeit wurde jedoch mit der MPRACE-Plattform umgesetzt, weshalb hier nur diese beschrieben werden soll. Abb. 3.11 zeigt das MPRACE-Board [55]. Dieses System wurde 2001/2002 3.3. VERWENDETE REKONFIGURIERBARE PLATTFORM Periphery RAM RAM FPGA FPGA Bus/Connection Topology Reconfig. Coprocessor Host-Interface Abbildung 3.10: Grundlegende Architektur eines rekonfigurierbaren Koprozessors. Abbildung 3.11: Der rekonfigurierbare Koprozessor MPRACE. 39 40 KAPITEL 3. REKONFIGURIERBARE RECHNERPLATTFORMEN Port A RAM RAM Port B FPGA RAM RAM PLD PCI Interf. SDRAM Abbildung 3.12: Schematischer Aufbau des MPRACE Koprozessors. an der Universität Mannheim als Prototypplattform für verschiedene Anwendungen im Bereich der Hochenergiephysik, Bildverarbeitung und des Hochleistungsrechnens entwickelt. Es handelt sich um eine Koprozessorkarte die über den 64-Bit-PCI-Bus in einen handelsübliches PC-System eingebaut werden kann. In Abb. 3.12 ist der Aufbau der Karte schematisch dargestellt. Im Zentrum steht ein moderner und leistungsfähiger FPGA der Virtex-II-Serie von Xilinx. Die Boards können sowohl mit einem Virtex-XC2V3000-FPGA als auch mit einem Virtex-XC2V6000, der gegenüber dem XC2V3000 etwa die doppelte Zahl an Logikressourcen hat, bestückt werden. Zur Verdeutlichung der Logikkapazität sei erwähnt, dass der XC2V3000-FPGA über 28672 4-InputLUTs und ebensoviele 1-Bit-Register1 verfügt. Hinzu kommen 96 18×18-Bit-Multiplizierer und ebensoviele 18-KBit-Block-RAM-Elemente. Der FPGA ist mit vier voneinander unabhängigen SRAM-Modulen mit jeweils 36 Bit Datenbreite und einem Notebook-SDRAM-Speicherriegel verbunden. Zwei Erweiterungsstecker PortA und PortB öffnen den Koprozessor für den Anbau von Erweiterungskarten. Als PCI-Interface-Chip wurde der PCI-9656 von PLX verwendet. Der Datenaustausch zwischen PCI-Interface und FPGA geschieht über einen lokalen 32-Bit-66MHz-Bus. Die Übertragungsbandbreite zum FPGA ist demnach maximal 264 MByte/sec. Über den PLD erfolgt die Konfiguration des Boards. So ermöglicht dieser Baustein unter anderem die Kontrolle der FPGA-Konfigurierung und das Clock-Management auf dem Board. Der sich auf dem MPRACE-System befindliche FPGA von Xilinx wurde ab Herbst 2001 kommerziell vertrieben. Die Reihe der Virtex-II-FPGAs war die erste Serie von FPGAs mit Block-Multiplizierer-Ressourcen. Erst damit wurde es möglich, über ein PCI-basiertes System in der Art des MPRACE-Boards ein rekonfigurierbares Rechensystem in der Komplexität aufzubauen, wie es für diese Arbeit geschehen ist. 1 Genau genommen sind es noch mehr, wenn man die Register in den IO-Zellen hinzurechnet. Kapitel 4 Grundlagen der Computerarithmetik In diesem Kapitel wird der Stand der Forschung zur Computerarithmetik zusammengefasst, jedoch konzentriert auf die Grundlagen, die für die Implementierung von Rechenwerken im Rahmen dieser Arbeit benötigt werden. Alternative Verfahren werden nur kurz umrissen, um eine Einordnung in das weite Feld der Architekturen für arithmetische Operationen zu ermöglichen. Das Kapitel ist entsprechend den wichtigsten Darstellungsmöglichkeiten von Zahlen unterteilt in die Abschnitte zu Ganzzahlen, Festkommazahlen, Gleitkommazahlen und logarithmischen Zahlen. Im Abschnitt für Ganzzahlen werden auch kurz Restklassensysteme und im Abschnitt über logarithmische Zahldarstellungen die Klasse der semilogarithmischen Zahlensysteme umrissen. Die Eigenschaften der verschiedenen Zahlenformate werden herausgestellt und die Auswirkungen der verschiedenen Darstellungsmöglichkeiten auf die Implementierung von Operatoren erläutert. Dabei wird die Implementierung von Operationen auf ganzen Zahlen in Abschnitt 4.1 besonders eingehend betrachtet, da diese den Kern der Implementierung von Operationen – auch in anderen Zahlensystemen – bilden. Die elementaren Operationen auf Festkommazahlen werden in Abschnitt 4.2 auf die Verarbeitung von Ganzzahlen zurückgeführt. Darauf aufbauend wird in Abschnitt 4.3 die Verarbeitung von Gleitkommazahlen erläutert. Als Alternativen zur Gleitkommaarithmetik werden in Abschnitt 4.4 die Arithmetik auf logarithmischen und semilogarithmischen Zahlen diskutiert. Bis zu dieser Stelle beschränken sich die Beschreibungen auf Implementierungskonzepte der elementaren Operatoren. In Abschnitt 4.5 werden ergänzend dazu verschiedene Methoden zur Berechnung von Funktionen einer Variablen ausgeführt. Die vorgestellten Rechenverfahren sind inzwischen weitgehend Standard und werden in der Auswahl und Formulierung präsentiert, wie sie für die Implementierung auf FPGAs Verwendung findet. Einen guten Überblick über die gebräuchlichen Techniken der Computerarithmetik gibt das Buch [89]. Weitere Standardwerke zur Computerarithmetik sind [114], [53], [101], [125], [104] und [56]. Das Kapitel schließt mit einem Überblick über den Stand der Forschung zur Implementierung der Arithmetik für wissenschaftliches Rechnen auf FPGAs in Abschnitt 4.6. 41 42 4.1 4.1.1 KAPITEL 4. COMPUTERARITHMETIK Ganzzahlen Darstellungsmöglichkeiten ganzer Zahlen Die elementare Form, ganze Zahlen darzustellen, ist die eines Stellen- oder Positionssystems von k Ziffern xi , deren Wertigkeit Potenzen einer Basiszahl (Radix) r sind, wie in Gleichung 4.1 ausgedrückt wird. k−1 (xk−1 · · · x0 )r = ∑ xiri, xi ∈ [−α, β ] = {−α, −α + 1, . . . , β − 1, β }. (4.1) i=0 Beispielsweise handelt es sich bei (r = 2, α = 0, β = 1) um das Dual- oder Binärsystem, bei (r = 10, α = 0, β = 9) um das Dezimalsystem und bei (r = 16, α = 0, β = 15) um Hexadezimalzahlen. Für (β − α ≥ r) ergeben sich redundante Zahlendarstellungen, bei denen Zahlwerte mit unterschiedlichen Ziffernkombinationen dargestellt werden können. Im Bereich der Digitalelektronik sind die Binärzahlen besonders ausgezeichnet, da die elektronische Repräsentation von Zahlen als Folge von Bits die Interpretation der Bits als Binärziffern nahe legt. Zahldarstellungen mit höherer Basis spielen jedoch eine wichtige Rolle bei der elektronischen Implementierung von schnellen Operatoren auf Ganzzahlen. Hier werden die Ziffern jeweils durch mehrere Bits kodiert. Die folgende Diskussion verschiedener Darstellungsmöglichkeiten ganzer Zahlen bezieht sich auf Erweiterungen der elementaren Zahldarstellung nach Gleichung 4.1, um auch negative Zahlen elektronisch darstellen zu können und die elementaren arithmetischen Operationen in diesen Zahlensystemen zu optimieren. In dieser Arbeit werden ganze Zahlen gelegentlich auch mit dem englischen Begriff Integer und die Untermenge der positiven ganzen Zahlen mit Unsigned-Integer bezeichnet. Am Ende dieses Abschnitts wird kurz auf Restklassensysteme eingegangen, welche sich grundsätzlich von den Positionssystemen unterscheiden. Vorzeichen-Betrag-Darstellung Bei dieser Darstellung wird zum Zahlenformat von Gleichung 4.1 eine Vorzeicheninformation hinzugefügt. Im Fall von Binärzahlen wird dem höchstwertigen Bit xk−1 ein Vorzeichenbit s vorangestellt: k−1 (s xk−1 · · · x0 )r = (−1)s · ∑ xi ri . (4.2) i=0 Vorteile dieser Darstellung sind die konzeptuelle Einfachheit, der symmetrische Umfang des darstellbaren Zahlenbereichs und die einfache Operation des Invertierens, indem lediglich das Vorzeichenbit zu negieren ist. Die grundlegende Operation Addition ist dagegen aufwändiger zu realisieren als für Zahlen in Komplement-Darstellung, wie weiter unten gezeigt wird. Darstellungen mit Bias Eine weitere Möglichkeit, negative Zahlen darzustellen, besteht darin, auf alle darzustellenden Zahlen x einen konstanten Wert bias hinzuzuaddieren, sodass das Resultat positiv ist. Die kleinste 43 4.1. GANZZAHLEN darstellbare Zahl ist demnach −bias. Die größte darstellbare Zahl reduziert sich gegenüber der Darstellung ohne Bias um bias. Darstellungen mit Bias führen zu einem leicht erhöhten Aufwand für die Addition und Subtraktion, wie man an Gleichung 4.3 sehen kann (a und b sind Zahlen in der Darstellung mit Bias) . Der Wert für bias kann jedoch so gewählt werden, dass der Aufwand für die zusätzliche Addition oder Subtraktion eines Bias vernachlässigbar gering ist (z.B. 2k−1 für Dualzahlen mit k Stellen). x + y + bias = (x + bias) + (y + bias) −bias | {z } | {z } | {z } a+b a b x − y + bias = (x + bias) − (y + bias) +bias. | {z } | {z } | {z } a−b a (4.3) b Multiplikation und Division sind hier wesentlich komplexer als bei anderen Ganzzahlrepräsentationen. Diese Darstellung wird deshalb nur in Spezialfällen eingesetzt, wo nur Addition und Subtraktion benötigt und durch die spezielle Wahl für bias einfache Operationen und Größenvergleiche möglich werden. Die Darstellung mit Bias wird beispielsweise für die Exponenten von Gleitkommazahlen verwendet. Komplement-Darstellungen In der Komplement-Darstellung werden negative Zahlen wie bei der Darstellung mit Bias in positive Zahlen überführt, indem eine hinreichend große Konstante M addiert wird. Positive Zahlen bleiben dagegen unverändert. Um die Überschneidung von positiven und negativen Zahldarstellungen zu vermeiden, muss M ≥ N + P + 1 gelten, wobei P und N die betragsmäßig größten darstellbaren positiven und negativen Zahlen sind. Für M = N + P + 1 ergibt sich die maximale Codierungseffizienz der Darstellung. In der Komplement-Darstellung werden Additionen unabhängig vom Vorzeichen der Argumente als Unsigned-Integer-Addition der Komplement-Zahlen modulo M durchgeführt. Dies funktioniert, da in der Modulo-M-Arithmetik die Addition von M − x identisch mit der Subtraktion von x ist. Subtraktionen werden erzeugt, indem vom Subtrahenden das Komplement gebildet wird. Im Spezialfall einer Darstellung zur Basis r = 2 mit k Binärstellen ergeben sich die Zweierkomplement- und Einserkomplement-Darstellung auf folgende Weise. 1er-Komplement-Darstellung Hier wird M = 2k − 1 gewählt. Dies führt für die Berechnung von M − |x| zur Darstellung einer Zahl x < 0 zur einfachen Rechenvorschrift, alle Bits von x zu invertieren. Die Addition zweier 1er-Komplement-Zahlen a und b modulo M nimmt folgende Gestalt an: a + b + 1 : (a + b) > 2k − 1 (a + b) mod M = a+b : (a + b) ≤ 2k − 1 a + b + 1 : (a + b) ≥ 2k (4.4) = a+b : (a + b) < 2k . 44 KAPITEL 4. COMPUTERARITHMETIK a b a Selective Complement a±b Selective Complement Sub carry-in carry-out (A) b carry-out (B) Sub carry-in a±b Abbildung 4.1: Aufbau eines Addier/Subtrahier-Operators für Zahlen in der 1er-KomplementDarstellung (A) und 2er-Komplement-Darstellung (B). Der Wert 2k entspricht dem Carry-Out einer Hardwareschaltung des Addierers. Die Fallunterscheidung bedeutet in Hardware, dass ein Carry-Out sofort in das Carry-In des Addierers zurückgeführt wird, was auch End-Around Carry genannt wird. Es sei noch erwähnt, dass für den Ergebniswert 0 die Darstellung (1 1 · · · 1)2 auftreten kann, was als zweite Repräsentation der 0 interpretiert werden kann. Abbildung 4.1 zeigt auf der linken Seite den schematischen Aufbau eines kombinierten Addier/Subtrahier-Operators für 1er-Komplement-Zahlen. 2er-Komplement-Darstellung In dieser Darstellung wird M = 2k gewählt. Die Addition modulo M kann durch einen einfachen Unsigned-Integer-Addierer umgesetzt werden, bei dem das Carry-Out mit der Wertigkeit 2k ignoriert wird. Die Vorschrift, bei der Subtraktion vom Subtrahenden b das Komplement zu bilden, kann zerlegt werden in die Erzeugung des 1er-Komplements b̄ und der Addition von 1. Letzteres kann ohne zusätzlichen Hardwareaufwand durch ein CarryIn in einen Unsigned-Integer-Addierer erfolgen. Abbildung 4.1 zeigt auf der rechten Seite die Realisierung eines kombinierten Addier/Subtrahier-Operators. Redundante Darstellung Redundante Darstellungen von Zahlen ergeben sich wie oben erwähnt aus der Wahl eines Satzes von Ziffern, für den entsprechend der Notation in Formel 4.1 die Eigenschaft β − α ≥ r gilt. Hauptmotivation für die Einführung dieser Zahlendarstellung ist, dass damit Addierer realisiert werden können, die ohne Carry-Fortpflanzung über viele Logikstufen hinweg auskommen. Dazu ist grob gesagt die Redundanz hoch genug zu wählen, damit bei der Addition Stellenüberträge in die nachfolgende Stelle dort aufgefangen werden können, ohne dabei einen erneuten Übertrag hervorzurufen. Da Additionen grundlegender Bestandteil der Implementierung aller anderen arithmetischen Grundoperationen sind, können diese Operationen mit Hilfe redundanter Zahlenformate ebenfalls durch Schaltungen mit verkürzten Carry-Ketten erzeugt werden. Redundante 4.1. GANZZAHLEN 45 Zahlendarstellungen gehen einher mit einem erhöhten Aufwand für die Speicherung und den Datentransport und einem hohen Aufwand der Konvertierung in nicht-redundante Darstellungen. Die Vor- und Nachteile redundanter Zahlendarstellungen hängen stark von den Eigenschaften der physikalischen Schaltungstechnik und der Art der Operatoren ab. Für Implementierungen auf FPGA-basierten Systemen ist die Verwendung redundanter Zahldarstellungen wenig verbreitet. Restklassensysteme (Residue Number Systems) Ganze Zahlen lassen sich in einem endlichen Zahlenbereich eindeutig durch Reste xi darstellen, welche bei der Division durch ganzzahlige Moduln mi entstehen. Voraussetzung ist, dass die mi relativ prim zueinander sind. Der Zahlenbereich ist bei der Darstellung von positiven Zahlen durch 0 ≤ x < ∏ni=1 mi gegeben, wenn n die Zahl der Moduln ist. Restklassensysteme (engl. Residue Number Systems = RNS) erlauben eine übertragsfreie Berechnung von Summen und Produkten, da Addition und Multiplikation stellenweise modulo mi durchgeführt werden können. Die Grundoperation Division ist dagegen sehr schwierig durchzuführen (siehe z.B. [44]) und für die Berechnung der Quadratwurzel existiert kein Verfahren. Überdies sind Größenvergleiche nicht direkt möglich. Während die Überführung einer Zahl von einem Positionssystem in ein Restklassensystem leicht umzusetzen ist, ist die Rückumwandlung in ein Stellensystem sehr aufwändig. Die Implementierung von Rechenwerken basierend auf Restklassensystemen ist vor allem im Bereich der digitalen Signalverarbeitung verbreitet, wo bei vielen Aufgabenstellungen ausschließlich Multiplikationen und Additionen durchgeführt werden müssen (z.B. FIR-Filter [95], Wavelet Transformation [96]). Es lassen sich dann sehr schnelle und ressourcensparende Rechenwerke aufbauen. Aufgrund der genannten Nachteile wurden Restklassensysteme für diese Arbeit nicht weiter in Betracht gezogen. 4.1.2 Additionsalgorithmen Im letzten Abschnitt wurde bereits die Implementierung von Addierern für Zahlen in der 1erKomplement- und 2er-Komplement-Darstellung allgemein skizziert, ohne auf die Hardware für die Unsigned-Integer-Addierer einzugehen. Bevor die Schaltungstechnik dieser elementaren Addiererelemente beschrieben wird, soll noch auf die Implementierung eines Additions/Subtraktions-Operators für Zahlen in der Vorzeichen-Betrags-Darstellung eingegangen werden. Den Aufbau eines solchen Operators zur Berechung von a ± b (ein Signal Sub zeigt an, ob subtrahiert werden soll) zeigt Abbildung 4.2. Diese Schaltung wird hier ausführlich erklärt, da sie in ähnlicher Form auch Bestandteil der Gleitkommaaddierer ist. Kern der Architektur ist ein Unsigned-Integer-Addierer, der, wie oben bereits beschrieben, geeignet ist, um Zahlen in der Komplement-Darstellung zu addieren. Unterscheiden sich die Argumente a und b im Vorzeichen und ist Sub = 0 oder haben a und b das gleiche Vorzeichen und ist Sub = 1, gilt die Beziehung |a ± b| = ||b| − |a||. Entsprechend wird in diesem Fall das Komplement der Zahl a berechnet. Wird das 2er-Komplement verwendet, kann dies dadurch geschehen, dass |a| negiert wird und das Carry-In des Addierers auf 1 gesetzt wird. Das höchstwertige Bit nach der Addition gibt das Vorzeichen des Resultats an. Bei Vorliegen einer negativen Zahl wird erneut das Komplement davon gebildet, um |a ± b| zu erhalten. Das 46 KAPITEL 4. COMPUTERARITHMETIK sign(a) sign(b) |a| compl |a| |b| Selective Complement carry-out Sub carry-in Control sign compl result sign(a±b) Selective Complement |a ± b| Abbildung 4.2: Aufbau eines Addier/Subtrahier-Operators für Zahlen in der Vorzeichen-BetragDarstellung. Vorzeichen des Ergebnisses kann aus den Vorzeichen von a und b, dem Signal Sub und dem Signal sign ermittelt werden. Für die elementare Unsigned-Integer-Addition sollen hier die wichtigsten Prinzipien kurz vorgestellt werden. Welches Verfahren bei einer Anwendung gewählt wird, hängt vor allem von der verwendeten Technologie ab. In der Regel müssen die konkurrierenden Faktoren Geschwindigkeit und Ressourcenbedarf gegeneinander abgewogen werden. Ripple-Carry-Addierer Die einfachste Weise, elementare Volladdierer zu N-Bit-Addierern zusammenzuschalten, besteht im Aufbau eines Ripple-Carry-Addierers. Hier werden die cout -Signale der Volladdierer (Übertragsausgang) in die Eingänge cin der nächsthöheren Stufe gegeben. Dieses Additionsschema ergibt sich aus folgender, in logische Operationen auf den Binärstellen der Argumente aufgeschlüsselten mathematischen Formulierung für s = a + b + cin : (sk−1 · · · s0 ) si gi pi ci+1 = = = = = (ak−1 · · · a0 ) + (bk−1 · · · b0 ) + (0 · · · 0 cin ) ai ⊕ bi ⊕ ci ai · bi ai ⊕ bi gi + ci · pi , c0 = cin , cout = ck . (4.5) Die Signale gi und pi geben an, dass in Stufe i ein Carry-Signal ci+1 generiert (gi = 1) oder propagiert (pi = 1) wird. Diese Formulierung für die Carry-Signale wird sich im nachfolgenden Abschnitt als nützlich erweisen. 47 4.1. GANZZAHLEN cout a3 b3 a2 b 2 a 1 b1 a 0 b0 VA VA VA VA s3 s2 s1 s0 c in Abbildung 4.3: Addierer für 4-Bit-Ganzzahlen als Ripple-Carry-Schaltung. Abbildung 4.3 zeigt einen solchen Addierer für binäre 4-Bit-Zahlen. Die Signallaufzeit verhält sich bei dieser Addiererkette linear zur Breite des Addierers. Carry-Lookahead-Addierer Carry-Lookahead-Addierer ergeben sich aus dem Prinzip, die Gleichung 4.5 für ci abzurollen, was in folgender Formel beschrieben wird: ci = = = = gi−1 + ci−1 · pi−1 gi−1 + gi−2 · pi−1 + ci−2 · pi−2 · pi−1 gi−1 + gi−2 · pi−1 + gi−3 · pi−2 · pi−1 + ci−3 · pi−3 · pi−2 · pi−1 g + gi−2 · pi−1 + gi−3 · pi−2 · pi−1 + gi−4 · pi−3 · pi−2 · pi−1 {z } | i−1 g[i−4,i−1] (4.6) +ci−4 · pi−4 · pi−3 · pi−2 · pi−1 | {z } p[i−4,i−1] .. . Für einen 4-Bit-Addierer ergeben sich somit folgende Gleichungen: c1 c2 c3 c4 = = = = g0 + c0 · p0 g1 + g0 · p1 + c0 · p0 · p1 g2 + g1 · p2 + g0 · p1 · p2 + c0 · p0 · p1 · p2 g3 + g2 · p3 + g1 · p2 · p3 + g0 · p1 · p2 · p3 {z } | (4.7) g[0,3] +c0 · p0 · p1 · p2 · p3 . {z } | p[0,3] Abbildung 4.4 zeigt die entsprechende Schaltung für einen solchen Lookahead-Carry-Generator (LCG). Die Ergebnisbits ergeben sich unter Verwendung des LCG durch die einfache Beziehung si = pi ⊕ ci . Die Latenz eines damit erzeugten 4-Bit-Addierers entspricht der Verzögerung von vier Logikgattern (jeweils eines zur Erzeugung von gi und pi , zwei Gatter für die Generierung von ci und ein Gatter für si ). Die Lookahead-Technik wird vor allem deshalb interessant, da die LCG-Elemente in einer Baumstruktur zu größeren LCG-Bausteinen gruppiert werden können. Abbildung 4.5 zeigt, wie aus fünf 4-Bit-LCG-Elementen ein 16-Bit-LCG erzeugt werden 48 KAPITEL 4. COMPUTERARITHMETIK p i+3 g i+3 pi+2 g i+2 p i+1 g i+1 p i gi ci LCG c i+4 p[i,i+3] g[i,i+3] c i+3 c i+2 c i+1 Abbildung 4.4: Lookahead-Carry-Generator (LCG) für die Erzeugung der Carry-Signale aus den Generate- (g) und Propagate-Signalen (p) aus den Summanden bzw. aus der vorausgehenden Ebene eines LCG-Baumes. Die Signale g[i,i+3] und p[i,i+3] können in die nächsthöhere Ebene eines LCG-Baumes gegeben oder im Fall der Wurzel eines solchen Baumes zur Erzeugung des Carry-Out-Signals der Schaltung verwendet werden (gepunktete Elemente). kann. Zusammen mit den Logikgattern zur Erzeugung der Signale pi , gi und si ergibt sich der dargestellte 16-Bit-Addierer. Vier solche Addierer können mit einem weiteren LCG-Element zu einem 64-Bit-Addierer verbunden werden. Für jede weitere Stufe des LCG-Baumes erhöht sich die Latenz um die Verzögerung von 4 Logikgattern (2 Gatter für die Erzeugung der Signale g[·,·] und p[·,·] für die nächste Stufe und 2 Gatter für die Rückgabe der Carry-Signale an die vorausgehende Stufe). Die Baumstruktur der LCG-Elemente führt damit dazu, dass sich die Latenz des Addierers logarithmisch zu dessen Breite verhält, im Gegensatz zum linearen Anstieg bei Ripple-Carry-Addierern. Es sei hier nur erwähnt, dass es optimierte Varianten zum eben beschriebenen Verfahren für Carry-Lookahead-Addierer gibt. Beispielsweise ergibt sich der Ling-Addierer aus einer modifizierten Formulierung, die für eine VLSI-Implementierung zur Ersparnis von Logikgattern gegenüber den hier gezeigten Schaltungen führt. Carry-Save-Addierer Ein Carry-Save-Addierer ist eine 3-2-Reduktionsschaltung, welche drei Eingangszahlen zu zwei Ausgangwerten reduziert. Dies ist mit einer einfachen Aneinanderreihung von Volladdierern möglich, wie in Abbildung 4.6 gezeigt. Die Latenzzeit ist durch die Signalverzögerung in einem der Volladdierer gegeben. Solche Addierer werden vorwiegend in Addiererbäumen eingesetzt, wo viele Argumente summiert werden müssen. Die internen Signale in Carry-Save-Darstellung können als redundante Zahlen verstanden werden. Zur Rückgewinnung von Binärzahlen am Ende des Baumes wird ein Carry-Propagate-Addierer erforderlich, wie z.B. ein Ripple-Carry- oder Carry-Lookahead-Addierer. 49 4.1. GANZZAHLEN s11 s10 s9 b11 a 11 b10 a 10 s8 b9 a 9 b8 a 8 s15 s14 b15 a 15 b14 a 14 s13 b13 a 13 p[11,8] b12 a 12 s7 s6 b7 a 7 b6 a 6 c 12 4-Bit LCG g[15,12] g[11,8] s12 s2 b3 a 3 b 2 a2 s5 b5 a 5 g[7,4] b1 a1 s0 c in b0 a 0 b4 a 4 c4 4-Bit LCG p[15,12] s1 g3 p 3 c 3 g2 p2 c 2 g1 p1 c 1 g0 p0 4-Bit LCG g[0,3] p[0,3] s4 c8 4-Bit LCG s3 p[7,4] 4-Bit Lookahead Carry Generator g[15,0] p[15,0] Abbildung 4.5: Carry-Lookahead-Addierer für 16-Bit-Ganzzahlen unter Verwendung eines zweistufigen LCG-Baumes (5 LCG-Elemente entsprechend Abbildung 4.4). a 3 b 3 c 3 a2 b 2 c 2 a1 b1 c1 a0 b0 c 0 VA t3 s3 VA t 2 s2 VA t 1 s1 VA t0 s0 Abbildung 4.6: Addierer für Ganzzahlen als Carry-Save-Schaltung. 50 KAPITEL 4. COMPUTERARITHMETIK a [k-1,k/2] b[k-1,k/2] a [k/2-1,0] b[k/2-1,0] c in 1 0 0 1S c out s [k-1,k/2] s [k/2-1,0] Abbildung 4.7: Addierer für Ganzzahlen als einstufige Carry-Select-Schaltung. a [k-1,3k/4] b[k-1,3k/4] a [3k/4-1,k/2] b[3k/4-1,k/2] 1 0 0 0 1S a [k/2-1,k/4] b[k/2-1,k/4] 1 0 1 0 0 1S 0 1 c out s [k-1,k/2] S a [k/4-1,0] b[k/4-1,0] c in 1S c k/2 s [k/2-1,k/4] s [k/4-1,0] Abbildung 4.8: Zweistufiger Carry-Select-Addierer. Carry-Select-Addierer Als letzte Variante von Addierer-Designs soll noch kurz auf die Carry-Select-Technik eingegangen werden, die vor allem bei der Konstruktion von hybriden Addiererschaltungen eingesetzt wird. Hier werden die k-Bit-Summanden a und b in l-Bit-Stücke aufgeteilt: a = a[k−1,k−l] . . . a[l−1,0] , b = b[k−1,k−l] . . . b[l−1,0] . Die Summe a[l−1,0] + b[l−1,0] wird einfach ausgewertet, die übrigen Teilsummen der l-Bit-Stücke werden zweifach berechnet, einmal für cin = 0 und einmal für cin = 1. Das Resultat wird durch einen Baum von Multiplexern anhand der Signale cout der Teilsummen zusammengesetzt. Die Abbildungen 4.7 und 4.8 zeigen zwei Beispiele für Carry-Select-Addierer. Die Latenz verringert sich gegenüber der eines k-Bit-Addierers auf die Latenz der l-Bit-Addierer plus der logarithmisch mit der Tiefe skalierenden Latenz des Multiplexer-Baumes. 51 4.1. GANZZAHLEN 4.1.3 Multiplikationsverfahren Die elementare Rechenvorschrift zur Bildung des Produkts zweier k-Bit-Radix-r-Ganzzahlen x und y ist gegeben durch die Formel k−1 k−1 x · y = (xk−1 · · · x0 ) · (yk−1 · · · y0 ) = ∑ ∑ xi y j ri+ j . (4.8) i=0 j=0 Es ist also die Summe aus k2 1-Position-Produkten zu bilden (1-Bit-Produkte für r = 2). Die verschiedenen Implementierungsstrategien unterscheiden sich im Wesentlichen in der Art und Weise, wie die Partialprodukte gebildet und aufsummiert werden. Shift/Add-Methode Die Shift/Add-Methode entspricht der Schulmethode für die Multiplikation . Hier sind die Partialprodukte die um j Stellen nach links verschobenen Produkte von x mit einer Stelle y j k−1 x·y = ∑ (xk−1 · · · x0) · y j · r j . (4.9) j=0 Dieses Rechenschema kann direkt mit einer Hardwarearchitektur zur sequentiellen Multiplikation, wie in Abb. 4.9 dargestellt, umgesetzt werden. Dazu wird Formel 4.9 durch folgendes Iterationsschema für das Zwischenergebnis s ausgewertet: s(0) = (xk−1 · · · x0 ) · y0 · rk−1 s(i) = (xk−1 · · · x0 ) · yi · rk−1 + s(i − 1) · r−1 x · y = s(k − 1). (4.10) Für den Fall r = 2 kann das k-Bit-Partialprodukt x · y j durch einen k-Bit-Multiplexer oder ein k-Bit-AND-Element gebildet werden. Das 2k-Bit-Produkt aus k-Bit-Zahlen wird hier in k Takten berechnet. Für r > 2 ergibt sich das gleiche Hardwareschema, jedoch ist die Erzeugung des (k + log2 r) Bit breiten Partialprodukts x · y j aufwändiger. Das Resultat ist in diesem Fall nach dk/ log2 re Takten verfügbar. Tree-Methode Bei dieser Technik werden die parallel berechneten Partialprodukte durch einen Addiererbaum aufsummiert. Dies ist in Abbildung 4.10 dargestellt. Zur Begrenzung der Signallaufzeiten im Addiererbaum können redundante Zahlendarstellungen gewählt werden, um die Anwendung von schnellen Carry-Save-Addierelementen zu ermöglichen. Ist die Latenz des Multiplizierers zweitrangig, kann die Schaltung durch Einfügen von Pipeline-Registern zwischen den Addiererstufen weiter beschleunigt werden. 52 KAPITEL 4. COMPUTERARITHMETIK x y Shiftreg. Partialprodukt Zwischenergebnis x·y Abbildung 4.9: Hardwareumsetzung der sequentiellen Multiplikation nach der Shift/AddMethode. x y Addiererbaum x·y Abbildung 4.10: Hardwareumsetzung der Multiplikation nach der Tree-Methode. 53 4.1. GANZZAHLEN y x x x x x·y Abbildung 4.11: Hardwareumsetzung der Multiplikation als Array-Multiplizierer. Array-Multiplizierer Multiplizierer dieser Art können als Tree-Multiplizierer mit besonderer Struktur des Addiererbaums gesehen werden. Es handelt sich hier um einen Addiererbaum mit maximaler Höhe, bei dem auf der Stufe i < k das Partialprodukt Pi = x · yi · ri zur Summe der Partialprodukte ∑ij=0 Pj addiert wird. Dies ist die langsamste Variante für einen Addiererbaum, jedoch mit sehr regulärer Struktur, was eine effiziente Umsetzung als integrierte elektronische Schaltung ermöglicht. Die Addierer für die Partialprodukte können als schnelle Carry-Save-Addierer ausgeführt werden, was einen abschließenden Addierer zur Rückführung in eine nicht-redundante Integer-Zahl erforderlich macht. Abbildung 4.11 zeigt die schematische Darstellung eines Array-Multiplizierers. In Abbildung 4.12 ist die detaillierte Schaltung für einen 4×4-Bit-Multiplizierer mit VolladdiererElementen dargestellt. Durch Pipeline-Register kann diese Architektur ebenso beschleunigt werden wie bei der Tree-Methode. 4.1.4 Divisionsalgorithmen Es gibt eine Vielzahl von Verfahren für die digitalelektronische Umsetzung der Division. In diesem Abschnitt wird eine kurze Übersicht über die gängigen Algorithmen gegeben. Die für diese Arbeit geeignet erscheinenden Methoden werden eingehend beschrieben und bezüglich der Schaltungstechnik diskutiert. Andere Verfahren werden nur erwähnt, um sie gegen die verwendeten Verfahren abzugrenzen. Da in dieser Arbeit nur Divisionsoperatoren für vorzeichenlose Ganzzahloperanden benötigt werden, werden auch nur solche Operatoren beschrieben. Es sei 54 KAPITEL 4. COMPUTERARITHMETIK x 3x2 x1 y0 y1 x0 x3 & x2 & & x1 & & 0 & & 0 VA 0 VA z0 VA z1 y2 y1 & & & VA & VA VA z2 y3 y2 & & VA & & VA VA z3 y3 & 0 VA z7 z6 VA z5 VA z4 Abbildung 4.12: Detailschaltbild eines Array-Multiplizierers für 4-Bit-Zahlen bestehend aus Volladdierern (VA), welche als dreistufiger Carry-Save-Addierer mit nachfolgender RippleCarry-Stufe geschaltet sind. Jedes Und-Element bildet ein 1×1-Bit-Produkt. 55 4.1. GANZZAHLEN jedoch erwähnt, dass die meisten hier beschriebenen Verfahren mit relativ wenig Aufwand auf Signed-Integer-Operanden erweitert werden können. Eine gute Übersicht über moderne Divisionsalgorithmen, wie sie für Mikroprozessoren angewandt werden, geben Obermann und Flynn [87] und Obermann [85]. Ein elementares Divisionsverfahren leitet sich daraus ab, dass die Division q = x/d die Umkehrung der Multiplikation x = d · q ist. Die Schritte der Shift/Add-Methode für die Multiplikation lassen sich umkehren, was zur Schulmethode für die Division führt. Damit kann die Division durch bedingte Subtraktion und Schiebeoperationen durchgeführt werden. Es sei x eine Ganzzahl mit 2k Radix-r-Stellen. Der Divisor d und der resultierende Quotient q seien Ganzzahlen mit k Stellen. Die Zahlen s(i) seien die Restbeträge nach der Iteration i. x d q s(i) = = = = x2k−1 · · · x0 dk−1 · · · d0 qk−1 · · · q0 s(i)2k−i−1 · · · s(i)0 . Es müssen bei dieser Festlegung der Zahlendarstellungen vorab zwei Ausnahmebedingungen abgefangen werden: 1. Division durch Null (d = 0) 2. Überlauf von q im Fall x ≥ rk · d Die Iteration der Schulmethode (i = 1, . . . , k) verläuft dann nach folgendem Schema: s(0) = x qk−i = max m ∈ [0, r − 1] : s(i − 1) − m · rk−i d ≥ 0 (4.11) s(i) = s(i − 1) − qk−i · rk−i d. Der Rest der Division ist gegeben durch s(k). Im Folgenden werden weit verbreitete Verfahren vorgestellt, die sich schaltungstechnisch effizient umsetzen lassen. Non-Performing und Restoring Division Dies sind einfache Verfahren, die Schulmethode nach Gleichung 4.11 für r = 2 umzusetzen. Das Iterationsschema ist dann folgendes: s(0) = x t(i) = s(i − 1) − 2k−i d 1 : t(i) ≥ 0 qk−i = 0 : t(i) < 0 t(i) : t(i) ≥ 0 s(i) = k−i s(i − 1) = t(i) + 2 d : t(i) < 0. (4.12) 56 KAPITEL 4. COMPUTERARITHMETIK Hier wird also in jedem Iterationsschritt i der um k − i Stellen linksverschobene Divisor d vom Rest s(i − 1) subtrahiert, was im Falle eines positiven Ergebnisses t(i) ≥ 0 als neuer Rest s(i) übernommen wird. Im Falle eines negativen Ergebnisses wird diese Differenz dagegen verworfen (Non-Performing Division) und der alte Restwert weiterverwendet, bzw. der frühere Rest durch eine Addition des verschobenen Divisors wieder restauriert (Restoring Division). NonPerforming Division und Restoring Division sind äquivalent und werden deshalb in der Literatur synonym verwendet. In der praktischen Ausführung wird nicht der um k − i Stellen verschobene Divisor subtrahiert, sondern der Restwert vor jeder Iteration um eine Stelle nach links verschoben, wie an folgender äquivalenter Rechenvorschrift sichtbar wird: s(0) = x t(i) = 2 · s(i − 1) − 2k · d 1 : t(i) ≥ 0 qk−i = 0 : t(i) < 0 t(i) : t(i) ≥ 0 s(i) = k 2 · s(i − 1) = t(i) + 2 · d : t(i) < 0. (4.13) Damit kann in einer seriellen Architektur zur Division der Divisor in einem Register gespeichert werden, während nur der Restwert, der sich in jedem Takt ändern kann, linksverschoben oder durch den linksverschobenen neuen Restwert ersetzt wird. Dies kann beispielsweise über einen einfachen Multiplexer, der einem Restwert-Register vorgeschaltet ist, geschehen. Eine alternative Implementierung wäre ein parallel ladbares Shiftregister. Abbildung 4.13 zeigt eine Hardwareimplementierung dieses Verfahrens. Vor der Operation wird das Restwertregister S mit dem Dividenden x geladen und das Register D mit d. In jedem Zeitschritt wird der Inhalt von S um eine Position nach links verschoben. Das MSB (Most Significant Bit) geht dabei in das Flip-Flop M. Der Addierer bildet die Differenz der Bits 2k − 1 . . . k von S mit dem Divisor. Ein Carry cout = 1 signalisiert, dass das Ergebnis der Subtraktion positiv ist, da Werte mit unterschiedlichen Vorzeichen addiert wurden (die versteckten Vorzeichenbits würden sich mit dem Carry zu 0 addieren). Das Ergebnis kann ebenfalls als positiv interpretiert werden, wenn das Bit M logisch 1 ist, da dann in jedem Fall der Rest größer als der Divisor ist. In beiden Fällen werden die Bits 2k − 1 . . . k von S mit dem Subtraktionsergebnis geladen (die Bits k − 1 . . . 0 bleiben unverändert) und qk−i als logisch 1 ausgegeben. Ansonsten wird S nicht neu geladen (Non-Performing-Schritt) und qk−i als logisch 0 ausgegeben. Die Ergebnisbits qk−i werden seriell in das Register Q geladen. Dieses Register kann auch mit S überlagert werden, da beide Register synchron linksverschoben werden. Nach k Iterationen ist die Division beendet. Das Verfahren kann durch eine Pipeline parallelisiert werden, in der für jede Iteration eine eigene Schaltungslogik vorhanden ist. Dazu sind die Subtrahier-Elemente zu vervielfachen und in einer Pipeline anzuordnen. Die Auswahl, ob mit dem neuen oder alten Restwert weitergearbeitet wird, geschieht dann nicht über das Laden oder Nicht-Laden eines Registers, sondern durch Auswahl und Weiterleiten eines der Werte über einen Multiplexer. Die im nächsten Abschnitt beschriebene Divisionsmethode ermöglicht bei ähnlicher Struktur der Verarbeitung die Parallelisierung ohne den Einsatz von Multiplexern. 57 4.1. GANZZAHLEN Divisor D Rest M S Quotient Q q k-i Complement c out 1 Abbildung 4.13: Serieller Dividierer nach der Non-Performing-Methode. Non-Restoring Division Dies ist ebenfalls ein Verfahren für r = 2. Es wird bei diesem Verfahren der Umstand ausgenutzt, dass die Restaurations-Addition von (2k−i d) in Gleichung 4.12 bei negativem t(i) und nachfolgende Subtraktion von (2k−(i+1) d) im nächsten Iterationsschritt äquivalent ist mit der Addition von (2k−(i+1) d). Die Restauration eines früheren Restwertes und die testweise Subtraktion eines verschobenen Divisors für den nächsten Iterationsschritt können deshalb zusammengefasst werden, indem der verschobene Divisor im nächsten Iterationsschritt addiert wird. Die folgende Gleichung zeigt die Formulierung dieses Verfahrens ähnlich der Darstellung in Gleichung 4.13: s(0) = x 2 · s(i − 1) − 2k · d s(i) = 2 · s(i − 1) + 2k · d 1 : s(i) ≥ 0 qk−i = 0 : s(i) < 0. : : s(i − 1) ≥ 0 s(i − 1) < 0 (4.14) Die Non-Restoring-Methode kann ähnlich in einer seriellen Hardwarearchitektur umgesetzt werden, wie oben für die Non-Performing-Methode beschrieben wurde. Es soll hier jedoch die parallelisierte Implementierungsvariante vorgestellt werden. In Abbildung 4.14 ist ein paralleler Dividierer für 8-Bit-Dividenden x und 4-Bit-Divisoren d gezeigt (k = 4). Die Signale, die von einer Addiererreihe an die nächste weitergegeben werden, entsprechen den verschobenen Restwerten s(i). Durch die den linken Eingängen der Addierer vorangehenden XOR-Elemente werden Addier/Subtrahier-Elemente gebildet, wobei ein Eingang der XOR-Bausteine Addition oder Subtraktion selektiert. Die Breite der Addiererreihen muss k + 1 betragen, da einerseits die Summe oder Differenz des um eine Stelle linksverschobenen Restwertes mit dem k-Bit-Divisor berechnet werden muss, andererseits keine Vorzeichen berücksichtigt werden müssen. Letzteres ergibt sich daraus, dass die Vorzeichen der Summanden immer verschieden sind und das CarryOut einer Addiererreihe identisch ist mit dem Carry-Out, das entstünde, wenn die Vorzeichenbits 58 KAPITEL 4. COMPUTERARITHMETIK x7 d3 x6 d 2 x5 d 1 x4 d0 x3 0 q3 VA VA XOR q2 VA VA XOR q1 VA VA XOR q0 VA VA VA XOR VA XOR VA XOR VA VA XOR VA XOR VA XOR VA VA XOR 1 x2 VA XOR x1 VA XOR x0 VA Abbildung 4.14: Detailschaltbild eines Non-Restoring Array-Dividierers für 8-Bit-Zahlen x und 4-Bit-Divisoren d, bestehend aus Volladdierern (VA), welche mit Hilfe der XOR-Elemente als Addier/Subtrahier-Elemente in Ripple-Carry-Schaltung aufgebaut sind. Die Volladdierer der ersten Spalte und der untersten Zeile können durch Logik für cout ersetzt werden, da deren Additionsergebnis nicht benötigt wird. in einem (k + 2)-Bit-Addierer mitverarbeitet würden. Zugleich zeigt das Carry-Out ein positives Resultat an und gibt damit neben dem Quotientenbit die Verarbeitung in der folgenden Addiererreihe vor. SRT-Division Bei VLSI-Implementierungen sehr weit verbreitet ist die so genannte SRT-Division. Diese Methode wurde benannt nach Sweeney, Robertson und Tocher. Die Methode basiert auf einer Verallgemeinerung der Non-Restoring-Methode für Radix-r ≥ 2 und Anwendung einer redundanten Darstellung der Quotientenstellen. Durch Erhöhung von r kann die Zahl der Iterationen zur Berechnung der Division verringert werden, da eine Stelle dann aus mehreren Bits besteht, nach wie vor aber pro Iterationsschritt eine Ergebnisstelle resultiert. Die redundante Darstellung der Quotientenstellen ermöglicht die Vereinfachung des Auswahlverfahrens für diese Stellen. Für die SRT-Division hat die Iteration über die Restwerte s(i) mit gleicher Nomenklatur wie 59 4.1. GANZZAHLEN bei Gleichung 4.14 folgende Gestalt: s(0) = x s(i) = r · s(i − 1) − qk−i d. (4.15) Die Quotientenstellen qk−i ∈ (−(r − 1), r − 1) liegen nun in redundanter Radix-r-Zahlendarstellung vor und können beispielsweise über einen Carry-Propagate-Addierer in ein nicht-redundantes Ergebnis umgewandelt werden. Das Schlüsselproblem bei der Division ist, die Stellen qk−i mit geringem Hardwareaufwand zu finden. Die Idee der SRT-Division besteht nun darin, die durch die redundante Darstellung von q gewonnene Freiheit in der Wahl der Quotientenstellen dahingehend auszunutzen, dass nur wenige Bits von s(i) und d(i) ausgewertet werden müssen, um die qk−i mit ausreichender Genauigkeit zu bestimmen, sodass die Iteration konvergiert. Abbildung 4.15 zeigt das Prinzipschaltbild eines Dividierers nach der SRT-Methode. Die Auswahl der redundanten Quotientenstelle qk−i geschieht im Baustein Select qk−i . Im Block Multiple Generation/Selection werden die Produkte qk−i d auf möglichst effiziente Weise gebildet. Durch geschickte Wahl der qk−i kann z.B. bei Radix-4-Dividierern erreicht werden, dass der Divisor lediglich verschoben und danach eventuell das Komplement gebildet werden muss, was beides durch einen geringen Hardwareaufwand zu erreichen ist. Während die SRT-Methode für serielle Dividierer-Architekturen wie in Abbildung 4.15 eine Vervielfachung der Rechenleistung erbringen kann, verschwinden diese Vorteile bei einer parallelen FPGA-Implementierung. Einfache Abschätzungen des Implementierungsaufwands pro Ergebnisbit zeigen, dass die Non-Restoring-Methode bei geringerer Komplexität des Algorithmus mindestens ebenso gut abschneidet wie beispielsweise die SRT-Implementierung eines Radix4-Dividierers. Voraussetzung dafür ist, dass zwei Addier/Subtrahier-Rechenwerke für die NonRestoring-Methode genauso ressourceneffizient implementiert werden können wie ein Multiplexer und 1er-Komplement-Generator, wie sie bei der SRT-Methode für die Auswahl der Vielfachen des Divisors (Multiple Generation/Selection) notwendig werden und ein nachfolgender Addierer. Dies ist beispielsweise beim verwendeten Virtex-II-FPGA der Fall. Gegen die Anwendung der SRT-Methode bei FPGA-Implementierungen spricht außerdem, dass die Geschwindigkeit und Latenz eines parallelen SRT-Dividierers wesentlich schwieriger über das Einfügen von Pipeline-Registern kontrolliert werden kann, als es beispielsweise bei Array-Dividierern nach Abbildung 4.14 geschehen kann. Aus diesen Gründen wurde die Implementierung von Dividierern nach der SRT-Methode für diese Arbeit nicht weiter in Betracht gezogen. Weitere Divisionsverfahren Für die Berechnung der Division gibt es zahlreiche weitere Algorithmen. Eine Übersicht über Hardwarealgorithmen für Divisionsoperatoren in modernen Prozessoren geben z.B. [85] und [87]. Für Verfahren zur Berechnung der Division mit doppelter Genauigkeit siehe auch [60] und [92]. Die bisher beschriebenen Verfahren gehören alle zur Klasse der Digit-RecurrenceVerfahren mit einer Ergebnisstelle pro Iteration, also linearer Konvergenz. Ein Verfahren mit quadratischer Konvergenz ist die Division durch wiederholte Multiplikation (auch unter dem Namen Goldschmidt-Verfahren bekannt [38]; siehe auch [28]). Hierbei werden in mehreren Durchläufen i = 0, . . . , m − 1 jeweils sowohl der aktuelle Dividend x(i), x(0) = x als auch der Divisor 60 KAPITEL 4. COMPUTERARITHMETIK Divisor Rest d s Redundant Quotient Multiple Generation/ Selection q k-i d Select q k-i q q k-i or its complement Redundant to Binary Result q Abbildung 4.15: Blockschaltbild eines einfachen seriellen Dividierers nach der SRT-Methode. d(i), d(0) = d mit Zahlen ti multipliziert, und zwar so, dass d(i) gegen 1 konvergiert. Dann konvergiert x(i) gegen q = x/d, denn es gilt: x(m−1) z }| { x x · t0 · t1 · · ·tm−1 q= = d d · t0 · t1 · · ·tm−1 . | {z } ≈1 Die Faktoren ti werden gewählt zu ti = 2 − di . Damit ergibt sich die Iteration zu: x(i + 1) = x(i) · (2 − di ) d(i + 1) = d(i) · (2 − di ). (4.16) Die quadratische Konvergenz folgt direkt aus der Beziehung 1 − d(i + 1) = (1 − d(i))2 . Für eine Genauigkeit von k Bits müssen dlog2 ke Iterationen berechnet werden, wobei zur Vermeidung der Akkumulation von Rechenfehlern mit höherer Genauigkeit als k Bits gerechnet werden muss (mindestens log2 m Zusatzbits). Für k = 24 ist m = 5. Es müssen also 2m − 1 = 9 Multiplikationen durchgeführt werden (d(m − 1) braucht nicht berechnet zu werden). Wie im vorangegangenen Abschnitt gezeigt, benötigt eine Hardwareimplementierung eines Dividierers nach der Non-Restoring-Methode in voll parallelisierter Ausführung weniger als doppelt so viele Ressourcen wie ein Array-Multiplizierer und damit etwa fünfmal weniger Ressourcen als die parallele Implementierung der Division durch wiederholte Multiplikation. Letzteres Verfahren kommt deshalb für eine FPGA-Implementierung nicht in Frage. Einige weitere Verfahren zur Berechnung der Division basieren auf dem Ansatz, zuerst die reziproke Zahl 1/d zu approximieren und dann den Quotienten durch eine nachfolgende Multiplikation mit x zu bilden. Die Berechnung von I(d) = 1/d gehört zur Problemstellung der 61 4.1. GANZZAHLEN Funktionsberechnung. Zur Lösung können beispielsweise Näherungsverfahren wie die NewtonRaphson-Methode angewandt werden. Näheres dazu wird in Abschnitt 4.5 folgen. Da jedes dieser Verfahren mehrere Multiplikationen und Additionen erforderlich macht, spielt diese Herangehensweise für eine parallele FPGA-Implementierung ebenfalls keine Rolle. Diese Methoden sind jedoch wichtig für die schnelle Berechnung von Divisionen und anderen Operationen mit hoher Genauigkeit (z.B. Double-Precision) in Mikroprozessoren. Die ebenfalls in 4.5 beschriebenen Verfahren, welche auf Table-Look-Up1 basieren, könnten ebenfalls in Betracht gezogen werden. Aufgrund der großen, exponentiell mit den Genauigkeitsanforderungen steigenden Speicher, die für die Look-Up-Tables benötigt werden, wurde dieser Ansatz ebenfalls nicht umgesetzt. Diese Verfahren hatten jedoch für FPGA-Implementierungen bis vor wenigen Jahren noch eine große Bedeutung, als die Implementierung durch Logikressourcen noch nicht möglich war. 4.1.5 Quadratwurzel Die Ganzzahl-Quadratwurzel q einer Zahl x mit Rest s ist durch folgende Gleichung definiert: x = q2 + s, (4.17) wobei für s die Beziehung s ≤ 2q gilt. Letzteres folgt aus dem Widerspruch s > 2q ⇒ x ≥ q2 + 2q + 1 = (q + 1)2 . Daraus ergibt sich, dass für die Repräsentation von s maximal eine Stelle mehr benötigt wird als für q. Für die Quadratwurzel existiert ein ähnliches iteratives Verfahren wie jenes, das bei der Division vorgestellt wurde. Die Papier-und-Bleistift-Methode dazu ist nicht allgemein bekannt und wird deshalb hier kurz hergeleitet. Es sei x der Radikand mit 2k Radix-r-Stellen. Die resultierende Quadratwurzel q sei eine Ganzzahl mit k Stellen und die Zahlen q(i) (k Bits) und s(i) (2k Bits) seien die vorläufigen Quadratwurzeln und Restbeträge nach der Iteration i: x q q(i) s(i) s = = = = = x2k−1 · · · x0 qk−1 · · · q0 q(i)k−1 · · · q(i)0 s(i)2k−i−1 · · · s(i)0 s(k) = sk · · · s0 . Für die vorläufigen Quadratwurzeln q(i) seien die führenden i Bits bestimmt, die übrigen Bits seien identisch Null. Die Zahlen q(i) und die Restwerte s(i) sind über die Beziehung s(i) = x − q(i)2 1 Mit Table-Look-Up ist ein Verfahren gemeint, das Tabellen (LUTs = Look-Up-Tables) zur schnellen Bestimmung von Funktionsergebnissen verwendet. 62 KAPITEL 4. COMPUTERARITHMETIK miteinander verknüpft. Für q(i) gilt: q(i) = qk−1 · · · qk−i 0 · · · 0 = q(i − 1) + rk−i qk−i q(0) = 0 ··· 0 (4.18) 2 q(i)2 = q(i − 1) + rk−i qk−i = q(i − 1)2 + 2q(i − 1)qk−i rk−i + q2k−i r2k−2i , woraus sich für s(i) auf folgende Weise eine Iterationsgleichung herleiten lässt: s(i) = = = = x − q(i)2 x − q(i − 1)2 + 2q(i − 1)qk−i rk−i + q2k−i r2k−2i s(i − 1) − 2q(i − 1)qk−i rk−i + q2k−i r2k−2i s(i − 1) − 2q(i − 1)rk−i + qk−i r2k−2i · qk−i . (4.19) Das neue Quadratwurzelbit qk−i wird im Iterationsschritt i festgelegt durch die Bedingung der Minimierung von s(i) > 0. Es ergibt sich somit folgendes Iterationsschema: s(0) = x qk−i = max m ∈ [0, r − 1] : s(i − 1) − 2q(i − 1)rk−i + mr2k−2i · m ≥ 0 s(i) = s(i − 1) − 2q(i − 1)rk−i + qk−i r2k−2i · qk−i . (4.20) Dieses Iterationsverfahren lässt sich intuitiver als Papier-und-Bleistift-Methode erkennen, wenn man s(i) durch s0 (i) = r−2k+2i s(i) ersetzt und q(i) durch q0 (i) = r−k+i q(i). Dann folgt: s0 (0) = x · r−2k q0 (i) = 0 · · · 0 qk−1 · · · qk−i qk−i = max m ∈ [0, r − 1] : r2 s0 (i − 1) − (2rq0 (i − 1) + m) · m ≥ 0 (4.21) s0 (i) = r2 s0 (i − 1) − (2rq0 (i − 1) + qk−i ) · qk−i s = s0 (k). Die Zahlen q0 (i) sind weiterhin Ganzzahlen, während s0 (i) Festkommazahlen sind. Durch die Multiplikation von s(i − 1) mit r2 wird ausgedrückt, dass in jedem Iterationsschritt zwei weitere Stellen von x in die Berechnung einbezogen werden (die Nachkommastellen von s0 (i − 1) beeinflussen die Wahl von q√ k−i nicht). Abbildung 4.16 zeigt ein Beispiel zu dieser Methode mit r = 10 und k = 3, wobei q = 123456 berechnet wird. Für r = 2 können wie bei der Division Non-Performing-, Restoring- und Non-RestoringMethoden zur Berechnung angewandt werden. 63 4.1. GANZZAHLEN . . . s0 (0) = 10−6 x = .1 2 .. 3 4 .. 5 6 .. . . . 100 s0 (0) = 1 2 ...3 4 .. 5 6 .. . .. .. 9 .. . . . . 100 s0 (1) = 3 3 4 ...5 6 .. . .. 3 2 5 .. . . 100 s0 (2) = 9 5 6 .. . 7 0 1 .. s = s0 (3) = 2 5 5 q(0) = 0 (20 · 0 + 3) · 3 = 9 ≤ 12 → q2 = 3 → q0 (1) = 3 (20 · 3 + 5) · 5 = 325 ≤ 334 → q1 = 5 → q0 (2) = 35 (20 · 35 + 1) · 1 = 701 ≤ 956 → q0 = 1 → q0 (3) = 351 q = q0 (3) = 351 Abbildung 4.16: Beispiel zur Berechnung der Quadratwurzel nach der Papier-und-BleistiftMethode. Non-Performing- und Restoring-Methode Diese beiden Methoden leiten sich daraus ab, dass Gleichung 4.21 für r = 2 in folgender Form geschrieben werden kann: s0 (0) = x · 2−2k t(i) = 4 · s0 (i − 1) − (4q0 (i − 1) + (01)2 ) 1 : t(i) ≥ 0 qk−i = 0 : t(i) < 0 (4.22) q0 (i) = 2 · q0 (i − 1) + qk−i t(i) : t(i) ≥ 0 0 s (i) = 0 0 4 · s (i − 1) = t(i) + (4q (i − 1) + (01)2 ) : t(i) < 0. Das Iterationsschema ist also dem der Non-Performing- oder Restoring-Methode für die Division sehr ähnlich. Hier wird bei der testweisen Subtraktion eine aus der vorläufigen Quadratwurzel q0 durch Linksverschieben um zwei Stellen und Anhängen der Bits 01 gebildete Zahl verwendet. Statt wie bei der Division in jedem Iterationsschritt den vorläufigen Restwert um eine Stelle nach links zu verschieben, ist hier eine Verschiebung um zwei Stellen erforderlich. Non-Restoring-Methode Für r = 2 kann genau wie im Fall der Division auch für die Quadratwurzel eine Non-RestoringMethode formuliert werden. Die Herleitung ist hier jedoch etwas komplizierter. Dazu betrachte man den Term, welcher in Gleichung 4.20 zur Berechnung von s(i) im Fall qk−i = 1 von s(i − 1) zu subtrahieren ist. Dieser Term wird hier u(i) genannt: u(i) = 2q(i − 1)rk−i + qk−i r2k−2i · qk−i (4.23) = 2q(i − 1)2k−i + (0 1)2 · 22k−2i . 64 KAPITEL 4. COMPUTERARITHMETIK Wird testweise t(i) = s(i − 1) − u(i) berechnet, entscheidet das Vorzeichen von t(i) über qk−i . Es gilt für qk−i = 1 die Beziehung s(i) = t(i), für qk−i = 0 jedoch s(i) = t(i) + u(i). Wie bei der NonRestoring-Methode bei der Division kann für letzteren Fall die Restauration des Restwertes und die testweise Subtraktion der nächsten Iteration zusammengefasst werden, was sich aus folgender Gleichung erschließt: t(i + 1) = s(i) − u(i + 1) = t(i) + u(i) − u(i + 1) | {z } v(i+1) v(i + 1) = u(i) − u(i + 1) q((i+1)−1)⇔qk−i =0 z }| { q(i − 1) 2k−i + (01)2 · 22k−2i ) = (2 −(2q((i + 1) − 1)2k−(i+1) + (01)2 · 22k−2(i+1) ) = 2q((i + 1) − 1) 2k−i − 2k−(i+1) + (01)2 · 22k−2i − 22k−2(i+1) (4.24) = 2q((i + 1) − 1)2k−(i+1) + (11)2 · 22k−2(i+1) v(i) = 2q(i − 1)2k−i + (11)2 · 22k−2i . Anstatt zur Berechnung von t(i + 1) vom restaurierten s(i) den Wert u(i + 1) zu subtrahieren, kann also v(i + 1) zum nicht-restaurierten Restwert t(i) addiert werden, wobei sich u(i + 1) und v(i + 1) nur um ein Bit unterscheiden. Damit ergibt sich folgendes Iterationsschema, für welches t(i) in s(i) umbenannt wurde: s(0) = x s(i − 1) − 2q(i − 1)2k−i + (01)2 · 22k−2i : s(i) = s(i − 1) + 2q(i − 1)2k−i + (11)2 · 22k−2i : 1 : s(i) ≥ 0 qk−i = 0 : s(i) < 0. s(i − 1) ≥ 0 s(i − 1) < 0 (4.25) q(i) = qk−1 · · · qk−i 0 · · · 0 q = q(k). Ersetzt man hier wie beim Übergang von Gleichung 4.20 zu Gleichung 4.21 s(i) durch s0 (i) = 2−2k+2i s(i) und q(i) durch q0 (i) = 2−k+i q(i), erhält man die einfacher zu lesende Iterationsfor- 65 4.1. GANZZAHLEN 1 q3 x7 VA 0 x5 x6 VA VA VA VA VA x1 x0 VA VA VA 1 XOR VA 0 q0 x2 1 0 q1 x3 1 0 q2 x4 VA VA XOR VA VA 1 XOR VA VA VA Abbildung 4.17: Detailschaltbild eines Quadratwurzel-Operators im Non-Restoring-Verfahren für 8-Bit-Zahlen x und 4-Bit-Ergebnisse q bestehend aus Volladdierern (VA) welche als Addier/Subtrahier-Elemente in Ripple-Carry Schaltung aufgebaut sind. mel: s0 (0) = x · 2−2k 0 4s (i − 1) − (4q0 (i − 1) + (01)2 ) : s0 (i − 1) ≥ 0 0 s (i) = 4s0 (i − 1) + (4q0 (i − 1) + (11)2 ) : s0 (i − 1) < 0 1 : s0 (i) ≥ 0 qk−i = 0 : s0 (i) < 0. (4.26) q0 (i) = 0 · · · 0 qk−1 · · · qk−i q = q0 (k). Abbildung 4.17 zeigt die Schaltung für einen Quadratwurzel-Operator für 8-Bit-Zahlen. Hier wurde das Iterationsschema auf die gleiche Weise angewandt wie beim Array-Dividierer gezeigt wurde (siehe Abbildung 4.14). Weitere Verfahren Bei der Quadratwurzel handelt es sich um die Berechnung einer elementaren Funktion. Es kann eine Vielzahl von Algorithmen, welche zur Approximation solcher Funktionen entwickelt wurden, angewandt werden. Dazu wird in Abschnitt 4.5 ein allgemeiner Überblick gegeben. Es sei hier bereits erwähnt, dass für eine parallele Implementierung die in den vorangegangenen Ab- 66 KAPITEL 4. COMPUTERARITHMETIK schnitten beschriebenen Digit-Recurrence-Verfahren im Hinblick auf den Ressourcenverbrauch den in Abschnitt 4.5 vorgestellten Implementierungsalternativen überlegen sind (wie auch im Fall der Division). Diese alternativen Verfahren erlangen ihre Bedeutung vor allem im Design programmgesteuerter Prozessoren, wo die Latenzzeit entscheidend für die Rechenleistung ist. 4.2 Festkommazahlen Eine Festkomma- oder Fixpunkt-Zahl ist durch einen Ganzzahl-Teil (k Stellen) und NachkommaTeil (l Stellen) gegeben. Die Darstellung ergibt sich aus 4.1 durch Erweiterung der Stellenwerte auf Potenzen von r mit negativen Exponenten, wie in folgender Gleichung gezeigt wird: k−1 x · · · x . x−1 · · · x−l | {z } |k−1{z }0 = Ganzzahl−Anteil Nachkomma−Teil ∑ xiri. (4.27) i=−l Die größte darstellbare Zahl hängt exponentiell von der Ganzzahl-Bitbreite k ab, die kleinste darstellbare Zahl exponentiell von der Anzahl der Nachkommastellen l. Die relative Genauigkeit, mit der eine Zahl darstellbar ist, ist von deren Größe abhängig und ist maximal für die größte darstellbare Zahl und minimal für die kleinste. Diese Darstellung eignet sich zur Funktionsauswertung nur, wenn der Wertebereich der Variablen sehr eng und a priori bekannt ist. In Festkommaarithmetik können die grundlegenden binären Operatoren auf Fixpunktzahlen a und b als Integer-Operatoren auf den Ganzzahlen (a rl ) und (b rl ) implementiert werden. a ± b = (a rl ± b rl ) · r−l a · b = (a rl · b rl ) · r−2 l a/b = (a rl ) · rk+l /(b rl ) · r−k−l . (4.28) (4.29) (4.30) Je nach Operator hat für das Integer-Resultat aus den als Integer-Werte interpretierten Fixpunktargumenten also lediglich eine Positionsverschiebung um eine feste Zahl von Stellen zu erfolgen, was für eine Hardwareimplementierung keinerlei zusätzliche Ressourcen gegenüber einer Integer-Implementierung erfordert. Die Addition führt zu einem exakten Ergebnis. Im Fall der Multiplikation und Division ist gegebenenfalls eine Rundungsoperation zu vollziehen. 4.3 4.3.1 Gleitkommazahlen Darstellung von Gleitkommazahlen Die Gleitpunktdarstellung von Zahlen beruht auf der multiplikativen Zerlegung eines Zahlenwertes in ein Vorzeichen sign ∈ {−1, +1}, eine Potenz bexp zu einer Basis b und einer normierten Mantisse signi f im Intervall [1, b): z = sign · bexp · signi f . (4.31) 67 4.3. GLEITKOMMAZAHLEN Der Exponent exp gibt somit die Größenordnung vor, in der die Zahl liegt und die Mantisse legt den Wert mit der Präzision der Mantissenbreite fest. Wir schränken uns ein auf die Basis b = 2. Die Mantisse signi f = 1. f ist dann eine Festkommazahl im Intervall [1, 2). Die Bitbreite dieser Mantisse sei M: (4.32) signi f = 1 + fM−2 2−1 + ... + f0 2−M+1 . Da das führende Bit einer normierten Mantisse immer 1 ist, werden nur die Nachkommastellen gespeichert: f = signi f − 1 (4.33) = fM−2 2−1 + .. + f0 2−M+1 . Die niedrigstwertige Stelle f0 2−M+1 wird im Folgenden auch mit LSB (Least Significant Bit) und die Wertigkeit 2−M+1 mit ulp (Unit of Least Precision) bezeichnet. Der Exponent exp wird oft durch Addition eines Offsets (bias) zu einer vorzeichenlosen Zahl transformiert, im Folgenden e genannt. Der Wert für bias wird wie folgt gewählt, wobei E die Bitbreite ist, mit der exp dargestellt wird: exp = e − bias bias = 2E−1 − 1. (4.34) Diese Wahl des Wertes für bias führt zu sehr einfachen Routinen zur Verarbeitung der Exponenten bei arithmetischen Operationen. Das Vorzeichen sign wird kodiert durch ein Bit s ∈ {0, 1} und die Vorschrift (s = 0 → sign = +1, s = 1 → sign = −1). Durch das Tripel (s, e, f ) wird folgende Zahl dargestellt: z = (−1)s · 2e−bias · (1. f ). (4.35) Der ANSI/IEEE-754-Standard [48] gibt für Gleitkommazahlen einfacher und doppelter Genauigkeit die in Tabelle 4.1 aufgelisteten Parameter vor. In der Tabelle sind weitere wichtige Eckdaten wie kleinste und größte darstellbare Zahlen aufgeführt. 4.3.2 Genauigkeit von Gleitkommaoperationen Der IEEE-754-Standard für Gleitkommazahlen gibt strenge Vorschriften für die Genauigkeit von Rechenoperationen auf diesen Zahlen vor. So wird vorgeschrieben, dass das Ergebnis einer Fließkommaoperation mit dem gerundeten Ergebnis der exakt durchgeführten Operation übereinstimmen muss. Für das Runden selbst sind die nachfolgend aufgestellten Modi vorgesehen. Hier wird die gerundete Mantisse zusammen mit dem Vorzeichen des Ergebnisses als Ganzzahl in Vorzeichen-Betrag-Darstellung (s 1 fM−2 · · · f0 ) und die Mantisse der exakten Operation als Fixpunktzahl r mit unendlich vielen Nachkommastellen interpretiert (s 1 rM−2 · · · r0 .r−1 · · · ). Diese verschiedenen Rundungs-Modi sind in Abbildung 4.18 dargestellt. • Round To Nearest Even - dieser Modus bedeutet, dass aufgerundet wird, wenn der Wert der Nachkommastellen des exakten Ergebnisses größer als ul p/2 ist. Abgerundet wird, wenn diese Stellen einen Wert kleiner als ul p/2 haben. Ist der Wert exakt gleich ul p/2, wird zur nächsten geraden Zahl gerundet. 68 KAPITEL 4. COMPUTERARITHMETIK trunc(x) rtne(x) 4 3 2 4 4 3 3 2 2 1 1 1 1 2 3 4 x 4 3 2 1 1 1 2 2 (A) 3 2 4 3 3 2 2 1 1 1 2 3 4 x 4 3 2 1 1 1 1 2 2 3 4 4 x rtminfty(x) 4 1 3 4 rtinfty(x) 3 2 (B) 3 4 4 1 (C) 3 2 3 4 x (D) 4 Abbildung 4.18: Rundungsmodi des IEEE-754-Standards für Gleitkommazahlen: (A) Round To Nearest Even, (B) Round Toward 0, (C) Round Toward ∞, (D) Round Toward −∞. 69 4.3. GLEITKOMMAZAHLEN einfache Genauigkeit Wortbreite 32 Mantissenbits 23 + 1 verborgenes Bit Exponentenbits 8 Exponenten-Bias 127 Null e + bias = 0, f = 0 e + bias = 255, f = 0 Unendlich Keine Zahl e + bias = 255, f 6= 0 Normale Zahl e + bias ∈ [1, 254] e ∈ [−126, 127] repräsentiert 1. f · 2e 2−126 ≈ 2128 min max doppelte Genauigkeit 64 52 + 1 verborgenes Bit 11 1023 e + bias = 0, f = 0 e + bias = 2047, f = 0 e + bias = 2047, f 6= 0 e + bias ∈ [1, 2046] e ∈ [−1022, 1023] repräsentiert 1. f · 2e 2−1022 ≈ 21024 Tabelle 4.1: Parameter und Eigenschaften des ANSI/IEEE-754-Standards für Gleitkommazahlen einfacher und doppelter Genauigkeit. • Round Toward 0 - hier werden alle Nachkommastellen des exakten Ergebnisses abgeschnitten (Truncation). • Round Toward ∞ - dieser Modus bedeutet Runden der Ergebnismantisse zur nächstgrößeren Ganzzahl. Für negative Zahlen bedeutet dies das Abschneiden der Nachkommastellen des exakten Ergebnisses, für Positive jedoch Aufrunden. • Round Toward −∞ - dieser Modus bedeutet Runden der exakten Ergebnismantisse zur nächstkleineren Ganzzahl. Für positive Zahlen bedeutet dies das Abschneiden der Nachkommastellen des exakten Ergebnisses, für negative Zahlen Aufrunden des Betrages. Der Modus Round To Nearest Even ist der Standardmodus. Dieser Modus gewährleistet, dass der Fehler der Ergebnismantisse kleiner oder gleich ulp/2 ist. Die sich abhängig von der Mantissenbreite daraus ergebenden maximalen relativen Rechenfehler sind in Abbildung 4.19 dargestellt. Ein Modus Round To Nearest Integer, der ebenfalls einen Ergebnisfehler kleiner oder gleich ulp/2 garantieren würde, ist nicht vorgesehen, da ein solches Rundungsverfahren eine Akkumulation von Rundungsfehlern begünstigen würde. Dies wird an folgendem Beispiel verständlich, bei dem die exakte Ergebnismantisse einer Operation nur zwei Nachkommastellen (r−1 r−2 ) ungleich 0 hat: r−1 r−2 r−1 r−2 r−1 r−2 r−1 r−2 = = = = 00 01 10 11 Abrunden ⇒ Fehler = 0 Abrunden ⇒ Fehler = −0.25 Aufrunden ⇒ Fehler = 0.5 Aufrunden ⇒ Fehler = 0.25. 70 KAPITEL 4. COMPUTERARITHMETIK 1,00E-01 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 1,00E-02 1,00E-03 1,00E-04 MaxFehler 1,00E-05 1,00E-06 1,00E-07 1,00E-08 Abbildung 4.19: Maximaler relativer Fehler von Gleitkommaoperationen abhängig von der Mantissenbreite. Kommen alle vier Fälle mit gleicher Wahrscheinlichkeit vor, ergibt sich ein durchschnittlicher Rundungsfehler von 1/4 · (0 − 0.25 + 0.5 + 0.25) = 0.125, welcher sich akkumulieren kann. 4.3.3 Operationen auf Gleitkommazahlen In diesem Abschnitt wird die Umsetzung der elementaren Operationen Addition, Multiplikation, Division und Quadratwurzel vorgestellt. Bevor die Architekturen zur Implementierung dieser Gleitkommaoperatoren erläutert werden, wird zuerst die grundlegende Struktur, der diese Umsetzungen folgen, beschrieben. Motivation dabei ist, die Ausführungen entsprechend der gemeinsamen Struktur zu untergliedern und die Beziehung zwischen den Realisierungen verschiedener Gleitkommaoperationen herzustellen. Allgemeine Struktur von Gleitkommaoperationen Abbildung 4.20 zeigt den strukturellen Aufbau eines Gleitkommaoperators. Es lassen sich drei logische Verarbeitungsblöcke separieren. Im Preparation genannten Block werden die Eingangsdaten aufbereitet, sodass die Verarbeitung auf Integer-Operationen auf den Exponenten und Festkomma-Operationen auf den Mantissen zurückgeführt werden kann. Es wird ebenfalls ein vorläufiges Ergebnisvorzeichen ermittelt. Im Block Operation werden die zentralen Rechenoperationen des Operators ausgeführt. Die damit berechnete vorläufige Ergebnismantisse und der dazugehörige Exponent werden in der Stufe Normalization schließlich in eine normalisierte und gerundete Gleitkommazahl überführt. Dabei können sich abhängig von der vorläufigen Mantisse sowohl der Exponent als auch das Vorzeichen (bei der Addition) ändern. 71 4.3. GLEITKOMMAZAHLEN sign(A) sign(B) e(B) f(A) f(B) Prepare Exp Prepare Signif Preparation Operate on Exp Fixpoint Operator Operation Adapt Exp Round and Normalize Normalization Prep Sign e(A) Adapt Sign sign(Result) e(Result) f(Result) Abbildung 4.20: Allgemeine Struktur eines Gleitkommaoperators. Addition Anhand unten stehender Gleichung 4.36 für die Addition zweier Gleitkommazahlen A und B lassen sich die erforderlichen Verarbeitungsschritte eines Fließkomma-Addierers leicht einsehen. Die Mantissen der Zahlen A und B werden hier aus Gründen der Übersichtlichkeit mit s1 und s2 bezeichnet, entgegen der Bezeichnung in 4.35. Die Vorzeichen werden ebenfalls vereinfacht als ’±’ dargestellt. A B R=A+B z }| }| }| { z { z { esum −bias e1 −bias e2 −bias ±ssum 2 = ±s1 2 + ±s2 2 2e1 −bias = ± ±s1 + s2 2e2 −e1 {z } | Festkomma-Operator → sadd (4.36) Preparation Sofort ersichtlich, können die Mantissen erst nach einer erfolgten Ausrichtung entsprechend der Differenz der Exponenten e2 und e1 durch einen Fixpunkt-Operator addiert werden. Es sei angenommen, dass e1 ≥ e2 gelte. Diese Bedingung kann dadurch erreicht werden, dass im Fall e1 < e2 die Zahlen A und B vertauscht werden. Unter dieser Voraussetzung bedeutet s02 = s2 2e2 −e1 eine Rechtsverschiebung von s2 um die Differenz der Exponenten. Haben A und B unterschiedliche Vorzeichen, ist zudem vor der Addition das Komplement einer der beiden Mantissen zu bilden. Ohne Einschränkung kann in diesem Fall das Komplement s01 der unverschobenen Mantisse s1 gebildet werden, ansonsten gilt s01 = s1 . Als vorläufiges Vorzeichen v des Ergebnisses wird dann das Vorzeichen des zu s02 gehörigen Operanden genommen, welches im Schritt Normalization abhängig vom Ergebnis der Integer-Operation gegebenenfalls 72 KAPITEL 4. COMPUTERARITHMETIK korrigiert wird. Operation Nach der Vorbereitung der Mantissen (s01 und s02 ) ist in dem Integer-Operator lediglich die Summe dieser Zahlen sadd zu berechnen. Für den vorläufigen Ergebnisexponenten wird der größere der Exponenten e1 und e2 ausgewählt, welcher als e01 bezeichnet werden soll (dies kann bereits in der Preparation-Stufe geschehen). Normalization Bis zu dieser Stelle haben wir als Ergebnis ein vorläufiges Vorzeichen v, eine nicht-normierte, eventuell negative Mantisse sadd und den vorläufigen Ergebnisexponenten e01 . Was zu tun bleibt, ist die Rückführung des Ergebnisses in eine normierte Gleitkommazahl. Dazu ist im Fall sadd < 0 das Komplement dieser Zahl zu bilden, die Zahl so zu normieren, dass das führende Bit die Wertigkeit 20 hat und das Ergebnis zu runden. Wenn für die Mantissen vor der Addition galt: s1 ∈ [1, 2) s01 ∈ (−2, 2) (4.37) s2 ∈ [1, 2) s02 ∈ [0, 2), dann gilt für das Additionsergebnis: sadd ∈ (−2, 4) |sadd | ∈ [0, 4). (4.38) Um sadd zu normieren, kann ein Rechtsshift um eine Stelle auftreten. Da bei ungleichen Vorzeichen von s01 und s02 eine Auslöschung von Bits stattfinden kann, muss |sadd | eventuell linksverschoben werden, wobei dann die Anzahl führender Nullen dieser Zahl ab der Position 20 die Verschiebungsweite festlegt. Nach der Normierung erfolgt die Rundung der Fixpunktzahl auf die Anzahl von Mantissestellen des Ergebnisses. Beim Runden kann ein Übertrag entstehen, weshalb eine zweite Normierungsstufe erforderlich ist, die den Übertrag feststellt und gegebenenfalls die Mantisse um eine Position nach rechts verschiebt. Für jede Positionsverschiebung in den Normierungsstufen muss der vorläufige Ergebnisexponent entsprechend korrigiert werden. Die Bildung des Komplements für sadd < 0 kann mit der Rundung zusammengefasst werden. Da die Normierung dann vor der Komplementlogik liegt, muss die Ermittlung der Verschiebungsweite auch bei negativen Zahlen möglich sein. Dazu werden anstatt der Nullen die führenden Einsen gezählt. Bei Vorliegen einer negativen Zahl ist keine Rechtsverschiebung notwendig, da sadd > −2 gilt (Bit mit Wertigkeit 21 ist 1). Die Zahl der führenden Einsen ab der Bitposition 20 gibt die Verschiebungsweite der erforderlichen Linksverschiebung vor. Das Vorzeichen des Ergebnisses wird aus dem vorläufigen Vorzeichen v bestimmt, welches negiert wird, falls sadd < 0 gilt. Blockschaltbild Ein Blockschaltbild eines Addierers für Gleitkommazahlen ist in Abbildung 4.21 gezeigt. Das Element Unpack zerlegt die eingehenden Fließkommazahlen in ihre Bestandteile Vorzeichen, Exponent und Mantisse. Bei den Mantissen wird die verborgene führende 1 73 4.3. GLEITKOMMAZAHLEN A B Unpack e1 e2 sign(B) sign(A) Prepare Exponents e d s1 S C Selective Complement Selective Swap Align Significands Shifts Control s2 e1' s'1 s'2 s add Adjust Exponent Normalize sign(A+B) Round&Selective Complement Adjust Exponent Normalize Pack A+B Abbildung 4.21: Funktioneller Aufbau eines Addierers für Gleitkommazahlen. 74 KAPITEL 4. COMPUTERARITHMETIK vorangestellt. Das Modul Prepare Exponent bildet die Differenz der eingehenden Exponenten von A und B. Bei negativer Differenz wird im rechts nebenstehenden Block die Funktion Selective Swap aktiviert, um die Mantissen von A und B zu vertauschen. Die Funktion Selective Complement dieses Blocks wird durch den Block Control aktiviert, wenn die Vorzeichen von A und B verschieden sind. Anschließend erfolgt im Modul Align Significands die Verschiebung der Mantisse mit zugehörigem größeren Exponenten um |e2 − e1 | Stellen. An den Ausgängen dieses Moduls liegen dann die für die Addition vorbereiteten Mantissen s01 und s02 vor. Beim IntegerAddierer ist zu sehen, dass ein Signal von control an den Carry-Eingang geht. Dieses Signal ist genau dann gesetzt, wenn auch die oben erwähnte Funktion Selective Complement aktiviert ist. Damit braucht dort nur das 1er-Komplement gebildet zu werden. Diese Schaltung entspricht damit genau der Anordnung von Abbildung 4.2. Im Fall der Subtraktion zeigt ein aktiviertes Carry-Out des Addierers dem Block control an, dass der Ausgang des Addierers positiv ist, bei Carry-Out gleich 0 ist die ausgehende Fixpunktzahl negativ. Letzteres führt dazu, dass Control die Bildung des Komplements der normierten Ergebnismantisse veranlasst. Die zweistufige Normierung mit zwischenliegendem Modul für die bedingte Komplementbildung und Rundung (Round & Selective Complement) arbeitet wie oben beschrieben. Die Anpassung des vorläufigen Ergebnisexponenten e01 entsprechend der Verschiebungen in den Normierungsstufen geschieht in den Adjust Exponent genannten Modulen. Am Ende der Schaltung werden das in Control ermittelte Ergebnisvorzeichen, der Ergebnisexponent und die Ergebnismantisse im Modul Pack zu einer Gleitkommazahl A + B zusammengefasst. Multiplikation Ähnlich wie bei der Addition wird in diesem Abschnitt anhand der Gleichung 4.39 die Verfahrensweise bei der Gleitpunktmultiplikation entwickelt. Die Gleichung zeigt, wie die Multiplikation als Operationen auf Fixpunktzahlen formuliert werden kann. Es lässt sich sofort sehen, dass Exponenten und Mantissen unabhängig voneinander verarbeitet werden können. A B R=A·B z }| }| }| { z { z { e prod −bias e1 −bias e2 −bias ±s prod 2 = ±s1 2 · ±s2 2 = ± (s · s ) 2(e1 +e2 −bias)−bias . | 1{z 2} Festkomma-Operator (4.39) Preparation Die Preparation-Stufe beinhaltet lediglich das Entpacken der Gleitkommazahlen in Vorzeichen, Exponenten und Mantissen sowie die Erzeugung des Ergebnisvorzeichens sign(A· B) = sign(A) ⊕ sign(B). Operation Die Mantissen können direkt in einem Festkommamultiplizierer, welcher nach Abschnitt 4.2 identisch mit einem Ganzzahlmultiplizierer ist, zur vorläufigen Ergebnismantisse smult verarbeitet werden. Liegen Mantissen der Breite k vor, hat smult 2k Stellen. Bei der Multiplikation müssen die Exponenten addiert werden. Da die Exponenten in Bias-Darstellung vorliegen, muss 75 4.3. GLEITKOMMAZAHLEN A B Unpack sign(B) sign(A) XOR e1 e2 s1 s2 Add Exponents Adjust Exponent Normalize sign(A·B) Round Adjust Exponent Normalize Pack A·B Abbildung 4.22: Funktioneller Aufbau eines Multiplizierers für Gleitkommazahlen. nach der Addition der Wert von Bias subtrahiert werden, um den vorläufigen Ergebnisexponenten zu bekommen. Normalization Für die Fixpunktmantisse smult gilt folgende Beziehung: smult ∈ [1, 4). (4.40) Im Normalisierungsschritt kann also eine Rechtsverschiebung um eine Position erforderlich werden. Da im Rundungsschritt ein Überlauf stattfinden kann, muss eine zweite Normalisierung folgen. Blockschaltbild Abbildung 4.22 zeigt das Blockschaltbild für die Gleitkommamultiplikation. Weil die zu verknüpfenden Mantissen nicht wie bei der Addition abhängig von den Vorzeichen und Exponenten vorverarbeitet werden müssen, ergibt sich eine wesentlich einfachere Schaltung als in Abbildung 4.21. Ausschließlich die Korrektur des vorläufigen Exponenten durch die Normalisierung der Mantisse verknüpft die Pfade von Exponenten- und Mantissenverarbeitung. 76 KAPITEL 4. COMPUTERARITHMETIK Division Das Verfahren zur Berechnung der Gleitkommadivision ergibt sich aus folgender Gleichung: A B R=A/B }| }| z z }| { { z { e1 −bias e2 −bias equot −bias / ±s2 2 ±squot 2 = ±s1 2 = ± (s /s ) 2(e1 −e2 +bias)−bias . | 1{z 2} Festkomma-Operator (4.41) Wie bei der Multiplikation folgt, dass die Verarbeitung von Exponenten und Mantissen unabhängig voneinander erfolgen kann (abgesehen von der Normalisierung). Preparation Die Preparation-Stufe beinhaltet lediglich das Entpacken der Gleitkommazahlen in Vorzeichen, Exponenten und Mantissen, sowie die Erzeugung des Ergebnisvorzeichens sign(A · B) = sign(A) ⊕ sign(B). Operation Die Mantissen können in einem Festkommadividierer zur vorläufigen Ergebnismantisse sdiv verarbeitet werden. Dazu wird die Mantisse des Operanden A erweitert, indem nach dem LSB Nullen angefügt werden. Der Dividierer muss abhängig vom gewählten Rundungsmodus mehr als k Ergebnisbits erzeugen und ebenfalls den Rest der Division berücksichtigen. Bei der Division müssen die Exponenten addiert werden. Da die Exponenten in Bias-Darstellung vorliegen, muss nach der Subtraktion der Wert von Bias addiert werden, um den vorläufigen Ergebnisexponenten zu bekommen. Normalization Für die Fixpunktmantisse sdiv gilt folgende Beziehung: sdiv ∈ (1/2, 2). (4.42) Im Normalisierungsschritt kann also eine Linkssverschiebung um eine Position erforderlich werden. Da im Rundungsschritt ein Überlauf stattfinden kann, muss eine zweite Normalisierung folgen. Für beide Normalisierungsschritte muss eine Anpassung des Exponenten erfolgen. Blockschaltbild Abbildung 4.23 zeigt den Aufbau eines Gleitkommazahl-Dividierers. Es ergibt sich eine Struktur, die sehr ähnlich der des Multiplizierers ist. Die Pfade zur Verarbeitung der Exponenten und Mantissen sind lediglich aufgrund der Normalisierungsblöcke miteinander verbunden. 77 4.3. GLEITKOMMAZAHLEN A B Unpack sign(B) sign(A) XOR e1 e2 s1 Subtract Exponents s2 x y x Adjust Exponent y Normalize sign(A/B) Round Adjust Exponent Normalize Pack A/B Abbildung 4.23: Funktioneller Aufbau eines Dividierers für Gleitkommazahlen. 78 KAPITEL 4. COMPUTERARITHMETIK A Unpack s1 e1 Prepare Exponent e'1 shift s Selective Shift Left s'1 Exponent Div 2 SQRT st Round esqrt s sqrt Pack SQRT(A) Abbildung 4.24: Funktioneller Aufbau eines Quadratwurzeloperators für Gleitkommazahlen. Quadratwurzel Die Verfahrensweise bei der Berechnung der Quadratwurzel einer Gleitkommazahl ergibt sich aus folgender Gleichung: √ R= A A z }| { ±ssqrt 2esqrt −bias = z }| { 1 2 ±s1 2e1 −bias q = ± s1 : s1 2 : e1 = e1 − 1 s01 = e01 0 s01 2(e1 −bias)/2 |{z} Festkomma-Operator (4.43) e1 − bias gerade e1 − bias ungerade : e1 − bias gerade : e1 − bias ungerade Eine Architektur für eine Hardwareimplementierung dieser Gleichungen ist in Abbildung 4.24 gezeigt und wird im Folgenden beschrieben. Preparation Bei der Quadratwurzel ist der Exponent zu halbieren. Da ungeradzahlige Exponenten nicht ganzzahlig durch zwei geteilt werden können, wird in diesem Fall die Normierung der Zahl aufgehoben, indem die Mantisse um eine Stelle linksverschoben und im Gegenzug der 4.4. LOGARITHMISCHE ZAHLEN 79 Exponent um Eins verringert wird. Da der Wert von bias ungeradzahlig ist, veranlasst ein geradzahliges e1 (e1 − bias ungerade), dass sich s01 aus der um eine Stelle nach links verschobenen Mantisse s1 ergibt, ansonsten gilt s01 = s1 . Ist e1 gerade, wird dementsprechend e01 = e1 − 1, ansonsten e01 = e1 gesetzt. Es sei hier erwähnt, dass die Verringerung des Exponenten um Eins mit der in der Operation-Stufe erfolgenden Weiterverarbeitung des Exponenten zusammengefasst werden kann. Operation In dieser Stufe ist die Quadratwurzel aus der Festkommazahl s01 mit Ergebnis st zu berechnen. Der Exponent e01 ist durch zwei zu dividieren, wobei berücksichtigt werden muss, dass der resultierende Exponent wieder in Darstellung mit Bias vorliegen muss. Dazu wird esqrt = (e01 + bias)/2 berechnet. Normalization Lag die Mantisse s01 nach Voraussetzung im Intervall [1, 4), so gilt st ∈ [1, 2). Es ist also keine Normalisierungsverschiebung notwendig. Nach dem Runden wird ebenfalls keine erneute Normalisierung notwendig, denn es gilt sogar s01 ∈ [1, 4 − 2ul p] und damit: (2 − ul p)2 = 4 − 2ul p + ul p2 > 4 − 2ul p ≥ s01 Also kann die gerundete Wurzel ssqrt in keinem Fall größer als 2 − ul p werden und ist deshalb bereits die Mantisse in der normalisierten Darstellung. Blockschaltbild Abbildung 4.24 zeigt die Struktur des Quadratwurzel-Operators. Der Implementierungsaufwand fast vollständig durch die Festkommaoperation bestimmt. 4.4 Logarithmische Zahlen Eine wichtige Alternative zur Verwendung von Gleitkommzahlen ist die Anwendung eines logarithmischen Zahlensystems. Dieses System basiert auf der Idee, dass Multiplikationen und Divisionen sich durch die einfache Addition und Subtraktion von Logarithmen exakt berechnen lassen. So lässt sich beispielsweise in Anwendungen mit einem hohen Anteil von Multiplikationen eine drastische Reduzierung der erforderlichen Hardwareressourcen erreichen [115]. In diesem Abschnitt werden die Definition des logarithmischen Zahlensystems (engl. Logarithmic Number System = LNS) und seine Implikationen bezüglich arithmetischer Operationen diskutiert. Es wird insbesondere untersucht, unter welchen Voraussetzungen dieses Zahlensystem für die Hardwareimplementierung von Spezialanwendungen einen Vorteil gegenüber der Gleitkommaarithmetik bringt. 4.4.1 Darstellung im logarithmischen Zahlensystem Eine Zahl x wird im logarithmischen Zahlensystem als Festkommazahl e des Logarithmus von x zu einer Basis b dargestellt. Im Folgenden soll immer von b = 2 ausgegangen werden (dies ist 80 KAPITEL 4. COMPUTERARITHMETIK auch die am häufigsten verwendete Basis). Um auch negative Zahlen darstellen zu können, wird ein Vorzeichen s hinzugefügt. Die Darstellung (s, e) repräsentiert also folgenden Wert: x = (−1)s · be . (4.44) Die Festkommazahl e sei eine 2er-Komplementzahl mit k Ganzzahlstellen und l Nachkommastellen: e = ek−1 · · · e0 .e−1 · · · e−l = −2k−1 ek−1 + k−2 ∑ ei · 2i i=−l Die Anzahl der Vorkommastellen legt die Größenordnung der kleinsten und größten darstellbaren Zahl fest, ähnlich wie der Exponent bei Gleitkommazahlen. Die Anzahl der Nachkommastellen gibt die Präzision der Darstellung vor, analog zur Mantissenbreite bei Gleitkommazahlen. Hier jedoch ist die Intervallbreite aufeinanderfolgender Zahlen von allen Bits von e abhängig (bei Gleitkommazahlen nur vom Exponenten). Es kann gezeigt werden, dass ein LNS mit Logarithmen in 32-Bit-Festkommazahldarstellung eine höhere Genauigkeit ermöglicht als ein SinglePrecision-Gleitkommaformat [16]. 4.4.2 Operationen auf logarithmischen Zahlen In einem LNS nehmen die wichtigsten arithmetischen Operationen auf den Zahlen x = 2s und y = 2t folgende Gestalt an: s + log2 (1 + 2t−s ) s + log2 (1 − 2t−s ) s+t s−t s = n log2 (xn ) = n · s log2 (x + y) log2 (x − y) log2 (x · y) log2 (x/y) √ log2 ( n x) = = = = (4.45) (4.46) (4.47) (4.48) (4.49) (4.50) Die Gleichungen wurden für positive Zahlen aufgestellt. Im allgemeinen Fall wird eine zusätzliche Logik geringer Komplexität für die Verarbeitung der Vorzeichen benötigt. Wie an obigen Gleichungen zu sehen ist, können Multiplikation und Division im LNS also durch einfache Addition oder Subtraktion der logarithmischen Zahlen ausgeführt werden - mit einem Rechenfehler identisch Null. Auch Wurzeln und ganzzahlige Potenzen nehmen im LNS eine sehr einfache Form an, denn es müssen nur Divisionen und Multiplikationen mit ganzzahligen Werten durchgeführt werden. Die Berechnung von Summen und Differenzen ist jedoch ungleich schwieriger. Diese Operationen erfordern die Auswertung einer nichtlinearen Funktion F(v) = log2 (1 ± 2v ). Hierfür können Interpolationsverfahren, insbesondere Table-Look-Up-basierte Verfahren, angewandt werden, wie sie in Abschnitt 4.5 vorgestellt werden. Mit der Genauigkeit skaliert die Grö- 81 4.4. LOGARITHMISCHE ZAHLEN ße der Look-Up-Tabellen exponentiell. Coleman und Chester [16] berichten für Single-PrecisionOperationen von Tabellengrößen O(100) KBits für die Addition und O(300) KBits für die Subtraktion bei Anwendung einer Taylor-Näherung ersten Grades, optimiert durch eine variierende Intervallbreite für die Interpolation und einen Fehlerkorrekturmechanismus. Die Skalierung der LUT-Größen für die Addition und Subtraktion schränkt die Anwendbarkeit des logarithmischen Zahlensystems bei FPGA-Implementierungen auf Anwendungen mit geringen Genauigkeitsanforderungen ein. Hinzu kommt ein hoher Aufwand für die Konvertierung zwischen Gleitkommazahlen und logarithmischen Zahlen (wird in Abschnitt 4.5 diskutiert). Da es in diesem Zahlensystem für die Implementierung von Addierern auf FPGAs gegenüber einer LUT-basierten Implementierung keine praktikable Alternative gibt, eignet sich der Ansatz eines logarithmischen Zahlensystems nur dann, wenn die zugrundeliegende Anwendung einen geringen Anteil von Additionen aufweist oder der FPGA-Typ reich an RAM-Ressourcen ist. 4.4.3 Semilogarithmische Zahlen Bei dieser Zahlendarstellung handelt es sich um eine Mischung aus logarithmischer und Gleitkommazahldarstellung. Wie J.-M. Muller in [80] zeigt, ermöglicht diese Darstellung einen Kompromiss zwischen Rechengeschwindigkeit und der Größe der benötigten LUTs für die arithmetischen Grundoperationen. Eine Zahl x wird repräsentiert durch: x = s · mk,x · 2ek,x , (4.51) mit einem ganzzahligen Parameter k, wobei ek,x ein Vielfaches von 2−k ist, mit: −k 2ek,x ≤ |x| < 2ek,x +2 . (4.52) Dann kann x durch folgende Darstellung repräsentiert werden: n Bits }| { z . . . 000 XXX . . . XXX ·2ek,x x = s · 1. 000 | {z } k Nullen (4.53) Die Zahl ek,x kann als Näherung von log2 |x| auf k Nachkommastellen verstanden werden. Mit k verringert sich die Breite der zu speichernden Mantisse von n auf n − k. Für k = 0 ergibt sich die Gleitkommadarstellung, für k ≥ n das logarithmische Zahlenformat. Für die Diskussion der arithmetischen Operatoren in diesem Zahlensystem sei auf [80] verwiesen. Als besonders interessant stellen sich die Zahlenformate mit k ≈ n/2 + 2 heraus. In diesem Fall bleibt der Aufwand für Multiplikation und Division ähnlich gering wie bei den logarithmischen Zahlen. Für Addition und Subtraktion werden dagegen wesentlich kleinere LUTs (wenige 10 KBits für Single-Precision), ein (n − k + 1) × n-Bit-Multiplizierer, zwei Shift-Operationen und eine geringe Menge zusätzlicher Logik benötigt. Die Umwandlung zwischen Gleitkommadarstellung und semilogarithmischer Darstellung und umgekehrt kann mit ähnlichem Aufwand wie bei der Addition durchgeführt werden. 82 KAPITEL 4. COMPUTERARITHMETIK Diese Zahlendarstellung ist eine interessante Alternative gegenüber der Verwendung von Gleitkommazahlen. Die Komplexität von Multiplikationen und Divisionen wird stark verringert. Addition und Subtraktion benötigen dagegen ähnlich viele Logikressourcen wie bei den entsprechenden Gleitkommaoperationen, zusätzlich sind hier jedoch Look-Up-Tables erforderlich, die beispielsweise bei Virtex-II-FPGAs durch wenige Block-RAMs abgebildet werden können. Für Anwendungen, bei denen deutlich mehr Multiplikationen und Divisionen als Additionen durchgeführt werden müssen, kann eine signifikante Verringerung des Logikressourcenbedarfs erreicht werden, vorausgesetzt, der FPGA-Typ hat genügend RAM-Ressourcen. Sind hingegen ähnlich viele Additionen wie Multiplikationen zu berechnen, ergibt sich grob abgeschätzt keine Ressourcenersparnis. Es findet dann lediglich eine Verlagerung von Multiplizierern auf RAMRessourcen statt. 4.5 Berechnung von Funktionen Für transzendente Funktionen wie die trigonometrischen Funktionen, die Exponentialfunktion und den Logarithmus gibt es keine exakten Berechnungsverfahren wie bei den Grundoperationen. Diese Funktionen können jedoch durch Konvergenzmethoden numerisch beliebig genau berechnet werden. Einige dieser Methoden eignen sich auch für eine direkte Hardwareumsetzung und werden damit für eine FPGA-Implementierung interessant. Alternativ dazu können in jedem Fall Funktionswerte unter Benutzung vorausberechneter Tabellenwerte gewonnen werden, wobei zur Verringerung der Tabellengröße in den meisten Fällen eine Interpolation durch Polynome angewandt wird. Im Folgenden werden verschiedene Tabellenbasierte Verfahren und Konvergenzmethoden beschrieben und hinsichtlich des Implementierungsaufwands diskutiert. Die beschriebenen Verfahren sind die Grundlage für Rechenwerke in modernen Prozessoren zur Auswertung der elementaren Funktionen wie Quadratwurzel und Kehrwertbildung mit doppelter Genauigkeit. Ziel dieses Abschnittes ist es, die Verfahren im Hinblick darauf zu diskutieren, ob sie für eine Implementierung auf FPGAs interessant sind. 4.5.1 Table-Look-Up-basierte Methoden Diese Methoden basieren darauf, Look-Up-Tables (LUTs) zu verwenden, in denen Funktionswerte oder Interpolationsparameter gespeichert sind, mit dem Ziel, durch die Vorausberechnung einen großen Teil des Rechenaufwands für die Funktionsauswertung einzusparen. Direktes Table-Look-Up Das Verfahren, Funktionswerte durch direkte Abbildung des Arguments auf eine Zahl über eine LUT zu ermitteln, eignet sich nur für Anwendungen mit sehr geringen Genauigkeitsanforderungen. Die Tabellengröße steigt exponentiell (∝ 2k · k) mit der zu erzielenden Genauigkeit von k Bits. Für eine Ergebnisgenauigkeit in der Größenordnung von Single-Precision ist diese Methode deshalb in der Regel nicht anwendbar, da alleine die LUT zur Bestimmung einer 24-Bit-Mantisse bereits 48 MBytes (224 · 24 Bits) groß sein müsste. 4.5. BERECHNUNG VON FUNKTIONEN 83 LUT-basierte polynomiale Approximation Eine Kombination von Table-Look-Up und einer stückweisen Näherung der Funktion durch Polynome geringen Grades erlaubt es, für eine vorgegebene Genauigkeit wesentlich kleinere LUTs als im Fall des direkten Table-Look-Ups zu verwenden. Durch den Grad der Interpolationspolynome kann die LUT-Größe in weiten Bereichen variiert werden. Stückweise lineare Approximation Eine einfache Methode ist die stückweise lineare Approximation einer Funktion durch eine Taylorentwicklung ersten Grades zwischen den durch die führenden k/2 Bits des Funktionsarguments gegebenen Stützstellen. Das Argument x wird also unterteilt in zwei k/2-Bit-Segmente x1 und x2 , x = (x1 , x2 ). Die Berechnung der linearen Interpolation geschieht dann auf folgende Weise: f (x) ≈ C1 (x1 ) + x2 ·C2 (x1 ), (4.54) wobei für die einfache Taylornäherung C1 (x1 ) = f (x1 ) und C2 (x1 ) = f 0 (x1 ) gilt. Durch die Modifikation von C1 und C2 kann eine bessere Approximation erreicht werden. Für die Approximationskoeffizienten werden zwei LUTs benötigt, die für k Bits Genauigkeit mit 2k/2 · (k/2 + k) in der Größe skalieren (≈ 150 KBit für k = 24) gegenüber 2k ·k (≈ 390 MBit für k = 24) beim direkten Table-Look-Up. Zusätzlich werden ein k/2 × k/2-Bit-Multiplizierer und ein k-Bit-Addierer benötigt. In [22] wird anhand der Kehrwertbildung demonstriert, wie bei gleich bleibender Genauigkeit und der Verwendung eines (k/2 + 3) × (k/2 + 3)-Bit-Multiplizierers sowie eines (k + 2)-BitAddierers eine Kompression der LUT erreicht werden kann (104 KBit für Single-Precision). In [116] wird eine ebenfalls auf der stückweise linearen Approximation basierende Methode vorgeschlagen, welche die Näherung verschiedener Potenzen mit Hilfe einer LUT ähnlicher Größe und einem (k + 1) × (k + 1)-Bit-Multiplizierer durchführt. Die Methode eignet sich für p p −p Potenzen x±2 (p ganzzahlig) und x±2 1 +2 2 (p1 ganzzahlig, p2 ≥ 0 ganzzahlig) und wird anhand der Berechnung von Kehrwerten, Quadratwurzeln und Potenzen mit p = 3 demonstriert. Je nach Operation wird von erforderlichen LUT-Größen von einigen 10 KBit berichtet (z.B. 50 KBit für Kehrwertbildung und 200 KBit für Potenzen mit p = 3). Die moderaten LUT-Größen und die geringe Komplexität der Berechnung machen diese Methoden sehr interessant für eine Implementierung auf Virtex-II-FPGAs, da diese über BlockRam- und Block-Multiplizierer-Elemente verfügen (siehe Abschnitt 3.1.2). Denn in diesem Fall können solche LUTs in einigen wenigen Block-RAM-Elementen (18 KBit pro Element) gespeichert werden. Da die Multiplikation für die Virtex-II-FPGAs durch die Block-Multiplizierer übernommen werden kann, lassen sich damit Operationen wie Quadratwurzel- und Kehrwertbildung fast gänzlich ohne die allgemeinen Logikressourcen implementieren. Näherungen höheren Grades Mit Näherungen höheren Grades kann zwar eine weitere Reduktion der LUT-Größe erreicht werden. Gleichzeitig steigt jedoch die Anzahl der Multiplikationen und Additionen, die berechnet werden müssen. In [93] wird beispielsweise ein Interpolator 84 KAPITEL 4. COMPUTERARITHMETIK Abbildung 4.25: Lineare Approximation nach der Bipartite-Table-Methode. zweiten Grades für eine Minimax-Approximation vorgestellt, für den zur Berechnung der elementaren Funktionen mit Single-Precision eine LUT-Größe von O(20 KBits) genügt. Für eine detaillierte Diskussion siehe z.B. [91]. Multipartite-Table-Methoden Die bisher beschriebenen Verfahren zur stückweisen polynomialen Approximation benötigen alle mindestens einen Multiplizierer. Multipartite-Table-Methoden basieren zwar auch auf dem Prinzip der stückweisen Approximation durch Taylorpolynome, ermöglichen jedoch eine Implementierung der stückweise linearen Interpolation ohne Multiplikationen. Die Idee bei diesen Methoden besteht darin, die Steigungen für die lineare Interpolation über mehrere durch die Stützpunkte vorgegebenen Intervalle unverändert zu lassen. Bei den Methoden mit zwei LUTs (Bipartite-Table-Methode) wird das Funktionsargument x unterteilt in drei Stücke x1 , x2 und x3 mit n1 , n2 und n3 Bits Breite, x = (x1 , x2 , x3 ). Anstelle der Gleichung 4.54 für die lineare Interpolation, wird folgende Gleichung ausgewertet: f (x) ≈ C1 (x1 , x2 ) +C2 (x1 , x3 ), (4.55) wobei C1 = f ((x1 , x2 , 0) + ξ (x1 , x2 )) und C2 = (0, 0, x3 ) · f 0 ((x1 , 0, 0) + χ(x1 )). Die Werte ξ und χ dienen der Verbesserung der Approximation. Beispielsweise entspricht ξ in [112] der halben durch x3 gegebenen Intervallbreite, χ der halben durch x2 gegebenen Intervallbreite. Die Größe der Tabelle für C2 wird bei diesem Ansatz aufgrund der Symmetrie der linearen Approximation halbiert. Abbildung 4.25 veranschaulicht dieses Verfahren für n1 = n2 = n3 = 2. Es ist möglich, mit der Bipartite-Table-Methode die Tabellengröße für die LUTs gegenüber der Methode des direkten Table-Look-Up deutlich zu verringern. So ergab sich in [21] für den Fall der Kehrwertbildung mit einer zweiteiligen Tabelle und einer redundanten Darstellung der Ergebnisse eine Tabellengröße von 22/3 k · k + 22/3 k · 2/3 k Bit (≈ 2600 KBits für Single-Precision). Die Methode aus [112] skaliert in der LUT-Größe ähnlich, führt aber zu einer besseren Kompression der Tabellen. So wird bei Single-Precision für die Kehrwertbildung eine LUT-Größe von etwa 1900 KBit erreicht (variiert abhängig von der Anzahl verwendeter GuardBits). Eine weitere Verringerung der Größe kann durch eine Unterteilung der Tabelle für C2 in kleinere Tabellen erreicht werden, jedoch mit einem erhöhten Aufwand für die Addierer. Solche Multipartite-Table-Verfahren wurden in [112] ebenfalls diskutiert und für verschiedene Funktionen angewandt. Die Verwendung von 5 Tabellen für die Single-Precision-Berechnung von 1/x 4.5. BERECHNUNG VON FUNKTIONEN 85 führt zu einem Speicheraufwand von insgesamt 620 KBit. Für eine vergleichende Diskussion der verschiedenen Multipartite-Table-Verfahren sei auf [23] verwiesen. 4.5.2 Digit-Recurrence-Algorithmen Digit-Recurrence-Algorithmen sind iterative Verfahren, welche in jedem Schritt eine feste Zahl von Ergebnisstellen produzieren. Die Restoring/Non-Performing- und Non-Restoring-Division und -Quadratwurzel sowie die SRT-Division, wie sie in den Abschnitten 4.1.4 und 4.1.5 beschrieben wurden, fallen in diese Kategorie von Algorithmen. Für serielle Architekturen ergibt sich eine sehr geringe Schaltungskomplexität. Durch eine Parallelisierung durch Abrollen der Iterationen in eine Pipeline kann der Datendurchsatz vervielfacht werden, mit proportional dazu skalierendem Ressourcenaufwand. Für die Division und Quadratwurzel wurden bereits Beispiele vollständig parallelisierter Implementierungen gegeben. Da Digit-Recurrence-Algorithmen Verfahren mit linearer Konvergenz sind, ergeben sich hohe Latenzzeiten. Während dies für Recheneinheiten in Mikroprozessoren fatal ist, spielt die Latenzzeit bei Implementierungen von Spezialpipelines für fest vorgegebene Rechenverfahren, wie es in dieser Arbeit der Fall ist, keine Rolle. Hier kommt es nur auf den Datendurchsatz an. Deshalb sind Digit-Recurrence-Algorithmen bei FPGA-Implementierungen sehr weit verbreitet. Im nächsten Abschnitt wird kurz auf eine weit verbreitete Technik zur Berechnung der nichtalgebraischen Funktionen – die CORDIC-Methode – eingegangen, welche ebenfalls zu den DigitRecurrence-Algorithmen gehört. CORDIC-Verfahren Es soll hier nicht detailliert auf diese Methode eingegangen werden - als Standardmethode ist sie Teil jedes Lehrbuchs der Computerarithmetik. Prinzipiell beruht die Methode auf der Idee, dass durch die Rotation des Einheitsvektors (0, 1) um einen Winkel φ der Ergebnisvektor die Koordinaten (cos(φ ), sin(φ )) hat. Durch eine solche Rotation können also die trigonometrischen Funktionen Sinus und Kosinus berechnet werden. Die Methode stellt im Wesentlichen ein geschicktes Verfahren bereit, solche Rotationen iterativ mit wenig Hardwareaufwand zu berechnen – es werden nur Additionen, Shift-Operationen und Table-Look-Ups benötigt. Mathematisch gehört die Iterationsmethode zu den Verfahren der additiven Normalisierung. Das verallgemeinerte CORDIC-Verfahren erlaubt es, iterativ mit einer festen, seriell arbeitenden Hardwareschaltung praktisch alle elementaren transzendenten Funktionen zu erzeugen. Dieses Verfahren ist deshalb bei Taschenrechnern sehr weit verbreitet. Eine CORDIC-Einheit kann mit drei AddierSubtrahier-Elementen und einer kleinen Lookup-Tabelle erzeugt werden, das Abrollen der Iterationsschleifen für eine parallele Implementierung führt zu einem Hardwareaufwand, der 2-3 parallelen Dividierern nach der Digit-Recurrence-Methode entspricht. Logarithmus Für die Berechnung des Logarithmus wird nun ein Konvergenzverfahren beschrieben, das auf der multiplikativen Normalisierung beruht. Es wird sich zeigen, dass dieses Verfahren mit weni- 86 KAPITEL 4. COMPUTERARITHMETIK ger Hardwareressourcen als eine Implementierung mit der CORDIC-Methode umgesetzt werden kann. Folgende Formel beschreibt das Iterationsschema zur Berechnung von q = ln(x): x(0) = x y(0) = 0 (4.56) di ∈ {−1, 0, 1} y(i+1) = y(i) − ln(c(i) ) = y(i) − ln 1 + di 2−i . Die Werte c(i) = ln 1 + di 2−i werden dabei aus einer Tabelle gelesen. Die Auswahl für di geschieht so, dass x(k) gegen 1 konvergiert. Dann konvergiert y(k) gegen ln(x), was sich aus folgenden Gleichungen einsehen lässt: x(k) = x ∏ c(i) ≈ 1 ⇒ ∏ c(i) ≈ 1x (4.57) y(k) = − ∑ ln(c(i) ) = −ln ∏ c(i) ≈ ln(x). x(i+1) = x(i) · c(i) = x(i) · 1 + di 2−i Die Methode konvergiert für folgenden Wertebereich für x: 1 1 ⇔ 0.21 ≤ x ≤ 3.45. ≤ x ≤ −i −i 1 + 2 1 − 2 ∏ ∏ (4.58) Für Werte von x außerhalb dieses Intervalls kann mit x = 2q s – wobei q so gewählt wird, dass 1 ≤ s < 2 gilt – folgende Beziehung zur Berechnung des Logarithmus herangezogen werden: ln(x) = ln (2q s) = q ln(2) + ln(s). (4.59) Bei dieser Methode werden k Iterationen benötigt, um ein Ergebnis y(k) mit k Stellen Genauigkeit zu erzeugen. Der Grund dafür ist, dass für große i die Näherung ln(1 ± 2−i ) ≈ ±2−i gilt. Dies hat zur Folge, dass die k-te Iteration den Wert von y um höchstens ulp ändert. Pro Iteration müssen nur x(i) und y(i) durch Addition/Subtraktion eines Wertes aus einer Look-Up-Tabelle verändert werden. Bei CORDIC wären pro Iteration drei Additions/Subtraktions-Operationen notwendig. Außerdem müssten zur Sicherstellung der Konvergenz bei CORDIC manche Iterationen wiederholt werden, weshalb für eine Genauigkeit von k Bits mehr als k Iterationen erforderlich wären. Diese Faktoren führen zu einem klaren Vorteil der vorgestellten Methode gegenüber einer CORDIC-Realisierung im Fall des Logarithmus. 4.5.3 Iterative Näherungsverfahren Die Anwendung iterativer Näherungsverfahren ist eine Standardmethode zur Berechnung transzendenter Funktionen in Software, wenn nur die elementaren Operationen zur Verfügung stehen. Aufgrund der schnellen Konvergenz (oft quadratisch) lässt sich das Funktionsergebnis durch wenige Iterationen mit gewünschter Genauigkeit bestimmen. Seit wenigen Jahren basieren auch die Rechenwerke einiger Mikroprozessoren zur Berechnung elementarer Funktionen wie Kehrwert und Quadratwurzel auf iterativen Näherungsverfahren (siehe z.B. [86]). In diesem Abschnitt werden einige gebräuchliche Verfahren vorgestellt und hinsichtlich ihrer Eignung für eine FPGAImplementierung untersucht. 87 4.5. BERECHNUNG VON FUNKTIONEN Newton-Raphson-Methode Diese Methode basiert auf dem Newton-Verfahren zur Berechung der Nullstellen einer Funktion f (z) = 0. Die Iterationsgleichung lautet: z(i) = z(i − 1) − f (z(i−1) f (z(i−1))0 , (4.60) wobei z(0) ein Startwert ist, welcher abhängig von der Funktion zu wählen ist. Die NewtonRaphson-Methode wird vor allem zur Berechnung von z = 1/x verwendet, wobei z in diesem Fall über die Nullstelle von f (z) = 1/z − x gefunden werden kann. Dann wird die Iterationsvorschrift 4.60 zu: z(i) = z(i − 1) (2 − z(i − 1) x) . (4.61) Das Verfahren konvergiert quadratisch. Pro Iteration müssen zwei Multiplikationen und eine Addition ausgeführt werden. Der Rechenaufwand ist also vergleichbar mit der bereits vorgestellten Methode der Division durch wiederholte Multiplikation und damit gilt auch hier, dass eine Implementierung der Division ausschließlich über dieses Verfahren nicht sinnvoll ist. Eine Kombination mit einem LUT-basierten Verfahren zur Bestimmung eines Startwertes kann jedoch eine Alternative zur Digit-Recurrence-Methode sein. Zur Implementierung der Quadratwurzel nach der Newton-Raphson-Methode siehe z.B. [100]. Hier sind pro Iteration drei Multiplikationen erforderlich. Spezielle Verfahren mit multiplikativer Konvergenz Für die Division/Kehrwertberechnung wurde bereits das Verfahren der wiederholten Multiplikation (Goldschmidt-Verfahren) vorgestellt. Ein ähnliches Verfahren existiert für die Quadratwurzel und inverse Quadratwurzel von x ∈ [1, 2) (siehe z.B. [28]). Es soll hier nun auch für diese Methode untersucht werden, ob sie für FPGA-Anwendungen in Frage kommt. Das Prinzip ist hier, eine Sequenz von Faktoren ti zu finden, sodass für eine Iterationsvariable s(m) gilt: 2 s(m) = x · t02 · t12 · · ·tm−1 → 1 (m → ∞) 2 ⇒ t02 · t12 · · ·tm−1 → 1/x (m → ∞). Dann folgt: (m → ∞) √ z(m) = x ∏i=0..m−1 ti → x (m → ∞). q(m) = ∏i=0..m−1 ti → √1 x (4.62) (4.63) Die Wahl von ti mit Startwert S1/sqrt zu: t0 = S1/sqrt 1−s(m) ti = 1 + 2 (4.64) führt zu quadratischer Konvergenz, was sich aus folgender Beziehung ergibt: εi = 1 − s(i) εi+1 = 1 − s(i + 1) = 43 εi2 + 14 εi3 . (4.65) 88 KAPITEL 4. COMPUTERARITHMETIK √ √ Zur Berechung von z = x werden s(m) und z(m) iterativ berechnet (m = 1, . . . , M), für z = 1/ x werden dagegen s(m) und q(m) iteriert. Der Ausgangswert t0 = S1/sqrt kann als 1 angesetzt werden. Alternativ können zur Beschleunigung des Verfahrens t0 und t02 durch ein Table-Look-Up √ für 1/ x und dessen Quadrat mit geringer Präzision bestimmt werden ([28]). In [91] wird demonstriert, wie durch Anwendung einer Minimax-Approximation zweiten Grades und einer einzigen Iteration mit quadratischer Konvergenz die Operationen Kehrwertbildung, Quadratwurzel und Kehrwert der Quadratwurzel mit Double-Precision berechnet werden können. In diesem Fall braucht für die Quadratwurzel nur z(2) ausgewertet zu werden, was durch drei Multiplikationen und zwei Additionen geschehen kann: z(1) = x S1/sqrt z(2) = z(1) + z(1) · 1−z(1) S1/sqrt 2 (4.66) Für eine FPGA-Implementierung mit einer Genauigkeit geringer als Single-Precision würde eine einfache lineare Approximation für S1/sqrt mit einer einzigen nachfolgenden Iteration nach Gleichung 4.66 genügen, wofür einige wenige Block-RAMs, zwei Addierer und mehrere BlockMultiplizierer erforderlich sind. Gegenüber einer parallelen Implementierung nach der DigitRecurrence-Methode ist eine solche Schaltung nur sinnvoll, wenn im FPGA abzüglich der für andere Operationen verwendeten Block-Multiplizierer noch mehrere solche Elemente ungenutzt blieben. 4.5.4 Kombination verschiedener Verfahren Die im letzten Abschnitt beschriebene Kombination eines Table-Look-Up-Verfahrens zur Generierung eines Startwerts für ein iteratives Näherungsverfahren mit einer geringen Zahl nachfolgender Iterationen lässt sich genauso für die Division nach dem Goldschmidt-Verfahren und für die Verfahren nach der Newton-Raphson-Methode anwenden. Besonders attraktiv ist dabei die Variante, nur eine einzige Iteration durchzuführen. Der Startwert muss dann eine Genauigkeit von etwa der Hälfte der Ergebnisstellen erreichen. Soll z.B. eine Ergebnisgenauigkeit von Single-Precision erreicht werden, sollte der Startwert dann mit etwa 12 Bit Genauigkeit ermittelt werden, was durch eine Bipartite-Table mit O(10) KBit erreicht werden kann. Gegenüber einer Digit-Recurrence-Implementierung werden hauptsächlich Block-RAM-Elemente und BlockMultiplizierer benötigt, dagegen nur eine geringe Zahl von allgemeinen Logikressourcen für die Addierer. Der Nachteil einer solchen Methode ist die Komplexität der Implementierung aufgrund der Verbindung unterschiedlicher Berechnungsmethoden. Insbesondere die Look-Up-Tables für die Bestimmung des Startwertes müssen für jede gewünschte Ergebnisgenauigkeit neu bestimmt werden und unterscheiden sich stark in der Größe. Letzteres führt zum Problem der effizienten Abbildung dieser Tabellen auf die vorgegebenen Block-RAMs des FPGAs. Schließlich entsteht auch das nicht unerhebliche Problem der Verifizierung der Genauigkeit für alle Implementierungen eines in der Rechengenauigkeit parametrisierten Operatormoduls. Spielen die letztgenannten Faktoren jedoch eine untergeordnete Rolle, wenn etwa die erforderliche Operatorgenauigkeit einen a priori festgelegten Wert hat, kann durch ein solches Kombinationsverfahren der Res- 4.6. STAND DER FORSCHUNG ZU IMPLEMENTIERUNGEN AUF FPGAS 89 sourcenverbrauch von den knappen allgemeinen Logikressourcen hin zu den ansonsten eventuell brach liegenden Block-Multiplizierern und Block-RAMs verschoben werden. 4.6 Stand der Forschung zu Implementierungen auf FPGAs Seit die Technik rekonfigurierbarer Logik mit den ersten leistungsfähigen FPGAs Ende der 1980er-Jahre einem breiteren Anwenderkreis bekannt wurde, wird versucht, diesen Ansatz für wissenschaftliches Rechnen zu verwenden. Aufgrund der im Vergleich zu heute geringen Menge von Logikressourcen früher FPGAs beschränkte sich die Anwendung anfangs hauptsächlich auf Aufgaben des Digital-Signal-Processing (DSP) wie Bild- und Ton-Verarbeitung, wo häufig eine geringe Genauigkeit der Arithmetik genügt. Frühe Versuche, FPGAs für Gleitkommaarithmetik nutzbar zu machen, wurden von Fagin und Renard [30], Shirazi et al. [103] und Louca et al. [69] veröffentlicht. Zu dieser Zeit war es nicht möglich, auch nur einen einzigen SinglePrecision-Multiplizierer auf einem FPGA zu implementieren, weshalb die Rechengenauigkeit eingeschränkt (in [103]), die Berechnung in mehrere Iterationen zerlegt (in [69]) oder in mehreren FPGAs implementiert wurde (in [30]). Kompliziertere Operatoren wie Dividierer wurden wie in [103] durch Table-Look-Up aus synchronen Speicherelementen umgesetzt. Für Anwendungen mit geringerem Datendurchsatz wurden serielle Digit-Recurrence-Algorithmen vorgeschlagen. Louie und Ercegovac zeigen in [68] und [67] solche Implementierungen für die Division (siehe auch [66]) und Quadratwurzel. Wenige Jahre später mit der Verfügbarkeit weit größerer FPGAs war es bereits möglich, vollständig parallele Single-Precision-Operatoren zu implementieren. Ligon et al. demonstrierten in [65] die Implementierung von Addierern und Multiplizierern. Li und Chu publizierten in [57] ihre Umsetzung von Quadratwurzeloperatoren (siehe auch [58]). Die heute verfügbaren FPGAs ermöglichen es bereits, eine große Zahl von Gleitkommaoperationen auf einem Chip zu implementieren. Entsprechend schnell wächst derzeit die Anzahl von Veröffentlichungen zu diesem Thema. Beispiele für neuere Implementierungen parametrisierbarer Gleitkommamodule sind [49], [8], [45] und [59]. Die Veröffentlichungen [49], [8] und [45] beschränken sich auf die Diskussion von Gleitkommaaddierern und -multiplizierern. In [59] vergleichen Liang et al. verschiedene Verfahren, um die Latenzzeit von Gleitkommaaddierern auf Kosten des Ressourcenverbrauchs zu reduzieren. Roesler und Nelson diskutieren in [97] die Anwendung der Block-Multiplizierer und Shift-Register, welche ab der Generation der Virtex-II-FPGAs verfügbar sind, zur Optimierung von Gleitkommaaddierern, -multiplizierern und -dividierern. Für die Dividierer wurde ein Newton-Raphson-Iterationsschema mit vorangehender Bestimmung eines Startwertes durch eine Look-Up-Table gewählt. In [13] untersuchen Beuchat und Tisserand Verfahren zur Optimierung von Multiplizierern und verschiedenen SRT-Dividierern unter Verwendung der Virtex-II-Block-Multiplizierer, einschließlich dem Skalierungsverhalten der beschriebenen Methoden mit der Breite der Operanden. Die Entwicklung von FPGA-Designs für Gleitkommaoperatoren durch den Autor dieser Arbeit verlief parallel zur Forschung anderer Gruppen in diesem Bereich ([49], [8], [45], [59], und [97], wie oben bereits diskutiert), da die im Verlaufe der Arbeit neu verfügbar gewordenen FPGAs neue Implementierungsmöglichkeiten eröffneten. In [64] veröffentlichte der Autor die Implementierung einer Bibliothek von vollständig parallelen und parametrisierbaren Gleit- 90 KAPITEL 4. COMPUTERARITHMETIK kommaoperatoren, welche Addition, Multiplikation, Division und Quadratwurzel einschließt, und demonstrierte die Leistungsfähigkeit anhand der Implementierung eines Teiles des SPHFormalismus. Eine sehr aktuelle Darstellung der Performance von Gleitkommaarithmetik auf FPGAs im Vergleich zu CPUs wird in [120] gegeben. Zur Problemstellung der Optimierung der Rechengenauigkeit einzelner Operatoren in komplexen Rechenwerken seien die Arbeiten von Gaffar et al. ([32] und [33]) erwähnt. Die in diesen Veröffentlichungen vorgestellten Optimierungsmethoden werden anhand einfacher Anwendungen im Bereich DSP, bei denen ausschließlich Additionen und Multiplikationen erforderlich sind, demonstriert. Eine Implementierung eines Rechenwerks auf einem FPGA, basierend auf dem logarithmischen Zahlensystem wurde in [76] publiziert. Im Bereich der astrophysikalischen Simulationsalgorithmen gab es 1995 von Cook et al. [18] eine Veröffentlichung über die Implementierung der Gravitationsberechnung auf einem FPGAProzessor bestehend aus acht FPGAs, die über einen Bus verbunden sind und zusammengenommen etwa 3–4 % der Logikressourcen des in dieser Arbeit verwendeten FPGAs haben. Es wurden Gleitkommazahlen in Single-Precision verarbeitet, wobei die Arithmetik durch serielle Addierer und Multiplizierer sowie eine lineare Interpolation für die Berechnung von x−3/2 implementiert wurde. Mit dieser Architektur wurde eine Rechenleistung von 40 MFlops erreicht. Eine Implementierung der Gravitationskraftberechnung unter Verwendung der in Abschnitt 2.4.2 vorgestellten PROGRAPE-Plattform wurde in [40] veröffentlicht. Die PROGRAPE-1-Plattform verfügt über etwa 30 % der Logikressourcen des MPRACE-Boards. Damit wurde unter Verwendung eines logarithmischen 12-Bit-Zahlenformats eine Rechenleistung von 0.96 GFlops erreicht, wobei für die Formel zur Gravitationskraftberechnung (nach Gleichung 2.3 in Abschnitt 2.2.1) 30 Operationen gezählt wurden. Ho et al. verwendeten in [46] die Gravitationsberechnung als Testproblem für ihre Entwicklung der Symmetric Table Addition Method zur Näherung von Funktionen. Diese Approximationsmethode wurde für die Bestimmung von x−3/2 eingesetzt. Auf ihrer Plattform basierend auf einem Virtex-FPGA von Xilinx wurde unter Aufwendung von 10260 Slices für die Berechnung mit Single-Precision (vgl.: der in dieser Arbeit verwendete FPGA enthält 14336 Slices, siehe Abschnitt 3.1.2 bzw. 3.3) wurde eine Peak-Performance von 1.5 GFlops angegeben, wobei auch hier 30 Operationen für eine Berechnung einer Paarwechselwirkung angesetzt wurden. In [54] wurden die Vorarbeiten für eine SPH-Implementierung auf einem FPGA-Prozessor veröffentlicht. Mit einer Prototypimplementierung der Formel für die SPH-Dichteberechnung (entsprechend Gleichung 2.24 in Abschnitt 2.3.2) auf einem System bestehend aus 16 FPGAs (mit zusammen etwa 10 % der Logikressourcen des für diese Arbeit verwendeten FPGAs) wurde unter Verwendung eines Gleitkommaformats mit 20 Mantissenbits eine Peak-Performance von 208 MFlops erreicht. Die Division und Quadratwurzel wurden über eine lineare Interpolation berechnet. Das in dieser Dissertation beschriebenen Projekt ist die Fortführung des in [54] vorgestellten Ansatzes. Kapitel 5 Analyse der Astrophysikalischen Algorithmen bezüglich der Anforderungen an eine Beschleunigerplattform In diesem Kapitel werden die diese Arbeit betreffenden astrophysikalischen Algorithmen nach notwendigen Kriterien für eine Beschleunigung durch eine Koprozessorplattform untersucht. Dies sind insbesondere die Rechenleistung und die Kommunikationsbandbreite. Weiter wird analysiert, welche Rechengenauigkeiten gegeben sein müssen, damit ein korrektes numerisches Verhalten der Algorithmen gewährleistet ist. Daraus wird die grundlegende Beschleunigerarchitektur abgeleitet. Es wird von einem System bestehend aus einem Rechnerknoten und einem Beschleuniger für die Gravitationsberechnung ausgegangen, wie es in Abschnitt 2.4.2 in Abbildung 2.3 gezeigt wurde. Zu diesem System soll eine zweite Spezialrechnerarchitektur hinzugefügt werden, um die rechenzeitkritischen Teile des Algorithmus zu beschleunigen. Es wird von einer modernen Implementierung eines astrophysikalischen Simulationscodes des Max-Planck-Instituts für Astrophysik, Heidelberg (WINE, siehe [126]) ausgegangen, für den detaillierte Analysen angefertigt werden konnten1 . Die Gravitationswechselwirkung wird bei diesem Code über einen baumbasierten Algorithmus berechnet, mit der Option, einen GRAPE-Rechenbeschleuniger anzuwenden. Die SPH-Berechnungen sind in der Formulierung umgesetzt, wie sie in Abschnitt 2.3.2 gegeben wurde. Da viele Codes anderer Arbeitsgruppen eine grundsätzlich ähnliche Struktur aufweisen, sind die Ergebnisse weitgehend übertragbar. 5.1 Erforderliche Rechenleistung In diesem Abschnitt wird die Skalierung des Rechenaufwands mit der simulierten Teilchenzahl, wie sie bereits in den Grundlagen erwähnt wurde, präzisiert. Anhand einer Analyse der Performance für eine Testrechnung werden konkrete Zahlen zum Rechenaufwand gegeben. Hierbei 1 Die Messungen an den Simulationscodes wurden von T. Naab, O. Kessel-Deynet und M. Wetzstein am MaxPlanck-Institut für Astronomie in Heidelberg ausgeführt. 91 92 KAPITEL 5. ANFORDERUNGEN AN EINE BESCHLEUNIGERARCHITEKTUR ist insbesondere von Interesse, welchen Anteil an der Gesamtrechenzeit die Berechnung der SPH-Formeln verursacht. Denn dieses Verhältnis ist entscheidend für den maximal erreichbaren Speedup. Skalierung des Rechenaufwandes Wie erwähnt basiert der untersuchte Code auf einem Baumverfahren für die Behandlung der Gravitation. Es wird ein Bottom-Up-Binärbaum verwendet, wie er unter der Bezeichnung Press Tree in Abschnitt 2.2.2 beschrieben wurde. Ist Ngrav die Anzahl der gravitativ wechselwirkenden Teilchen, skaliert die Rechenzeit für die Gravitationssimulation mit: tgrav,Host = α Ngrav log2 Ngrav , (5.1) mit einer Poportionalitätskonstante α, welche durch die Rechenleistung der Simulationsplattform bestimmt ist. Die Zahl Ngrav setzt sich zusammen aus der Anzahl an SPH-Teilchen NSPH und der Anzahl rein gravitativ wechselwirkender Teilchen NNbody . Es gilt also: Ngrav = NNbody + NSPH . Typischerweise liegt NSPH in der gleichen Größenordnung wie NNbody . Die Gravitationssimulation dominiert den Gesamtrechenaufwand, wenn dafür kein Rechenbeschleuniger eingesetzt wird. Der Einsatz eines Rechenbeschleunigers bewirkt folgende Veränderung der Rechenzeit: tgrav,GRAPE = β Ngrav log2 Ngrav + γNgrav , (5.2) mit β α und einem durch die Kommunikationsbandbreite mit dem Rechenbeschleuniger bestimmten Faktor γ. Für SPH ergibt sich folgende Skalierung, wenn Nneigh die durchschnittliche Anzahl von Nachbarn ist, über die in den SPH-Formeln summiert werden muss: tSPH = δ NSPH,active Nneigh . (5.3) Hier wurde anstatt NSPH die Zahl NSPH,active verwendet, was ausdrückt, dass bei Variable-Timestep-Verfahren in manchen Zeitschritten nur eine Untermenge der SPH-Teilchen neu berechnet wird. Analyse eines Simulationscodes Während die Peak-Performance moderner Prozessoren im GFlops-Bereich liegt, wird bei wissenschaftlichen Simulationsanwendungen in der Regel nur ein Bruchteil dieser Rechenleistung auch tatsächlich erzielt. Um die für die SPH-Formeln auf einem Standardprozessor erreichbare Rechenleistung abzuschätzen, wurde die innerste Schleife der Druckkraftberechnung nach Gleichung 2.32 separat implementiert und die Performance dieses Codefragments gemessen. Es ergab sich auf einem Pentium-III-System mit 1266 MHz abhängig von der Reihenfolge der Teilchen, für welche die SPH-Formeln ausgewertet wurden, eine Rechenleistung von etwa 180–320 MFlops. In echten astrophysikalischen Codes kann die Performance noch weit darunter liegen, da 5.1. RECHENLEISTUNG 93 sich durch verteilte Datenstrukturen sehr komplexe Zugriffsmuster auf den Hauptspeicher ergeben können. Es wird im Folgenden anhand des WINE-Codes diskutiert, welcher Speedup für das Gesamtsystem erreicht werden kann, wenn die laufzeitkritischen Formeln des SPH-Algorithmus beschleunigt werden. Durch Laufzeitmessungen wurde ermittelt, wie sich die Rechenzeit auf die Behandlung von Gravitation, SPH und den Rest aufteilt. Für den Fall, dass alles auf einem einzigen Rechnerknoten gerechnet wird, ergab sich, dass für Teilchenzahlen in der Größenordnung 105 etwa 70 % der Rechenzeit für die Ermittlung der Gravitationskräfte aufgewendet wird, etwa 25 % der Zeit für SPH benötigt wird und alles übrige nur wenige Prozent des Rechenaufwandes verursacht. Wird die Gravitationsrechnung durch eine GRAPE-5-Plattform beschleunigt, reduziert sich die Rechenzeit dafür auf etwa 14 %, wobei die Kommunikation mit GRAPE-5 die Rechengeschwindigkeit limitiert. Bei Anwendung der neuen 64-Bit-PCI-basierten GRAPE-6-Plattform kann eine weitere deutliche Reduktion dieses Rechenzeitanteils erwartet werden. Durch eine genauere Analyse der Rechenzeit für den SPH-Teil des Codes zeigte sich, dass etwa 70 % der Rechenzeit auf die inneren Schleifen fällt2 und etwa 30 % für die Nachbarschaftssuche3 verwendet wird, wobei die Nachbarschaftslisten für den zweiten Schritt des SPHAlgorithmus erneut berechnet werden. Für die inneren SPH-Schleifen wurde eine Rechenleistung von etwa 70 MFlops erzielt, wobei für die Messung ein System mit Pentium-III-Prozessor, 500 MHz, verwendet wurde. Für ein aktuelles System kann dagegen von einer Rechenleistung von etwa 200 MFlops ausgegangen werden. Um ein hohes Beschleunigungspotential für die Gesamtapplikation zu ermöglichen, muss der Anteil der Rechenzeit, der außerhalb der SPH-Formeln aufgewendet wird, möglichst niedrig werden. Anhand dieser Bedingung lassen sich folgende Designkriterien für ein beschleunigtes System finden: • Sehr viel an Rechenzeit kann eingespart werden, wenn die Nachbarschaftslisten für den ersten SPH-Schritt zwischengespeichert werden, so dass sie für Schritt 2 nicht mehr neu berechnet werden müssen. Der Speicherbedarf dafür ist jedoch NSPH · Nneigh (für 105 Teilchen und durchschnittlich 50 Nachbarn sind das etwa 20 MByte). Die Zwischenspeicherung wurde bisher vermieden, um neben der Baumstruktur nicht noch andere dynamische Datenstrukturen verwalten zu müssen. • Die Gravitationsberechnung sollte simultan mit der Erzeugung der Nachbarschaftslisten für SPH geschehen, damit sich die Rechenzeiten beider Teile nicht summieren. • Die Generierung der Nachbarschaftslisten kann unter Einsparung von Rechenzeit “vergröbert” werden, beispielsweise durch gemeinsame Listen für mehrere aktive Teilchen. Die Extraktion der entgültigen Nachbarschaftslisten kann dann vom Rechenbeschleuniger übernommen werden (sofern dafür noch Ressourcen verfügbar sind). 2 In diesen Schleifen werden die Berechnungen der SPH-Summen wie in der Formulierung nach Abschnitt 2.3.2 durchgeführt (siehe Gleichung 2.24, 2.32 und 2.41). 3 Nur Teilchen aus einer lokalen Umgebung tragen zu den SPH-Summen bei, siehe Abschnitt 2.3.2. Die Nachbarschaftslisten werden durch eine lokale Suche in einer verketteten Liste bestimmt. Siehe dazu [126]. 94 KAPITEL 5. ANFORDERUNGEN AN EINE BESCHLEUNIGERARCHITEKTUR Werden diese Punkte berücksichtigt, erscheint eine Reduktion des Rechenaufwands aller Codeteile außerhalb der inneren SPH-Schleifen auf unter 10 % erreichbar. Es ergibt sich dann ein Beschleunigungspotential um einen Faktor O(10). Um einen Speedup in dieser Größenordnung zu realisieren, muss die Beschleunigerplattform eine Dauerrechenleistung von mehr als 2 GFlops erreichen. 5.2 Erforderliche Kommunikationsbandbreite für einen Rechenbeschleuniger In diesem Abschnitt wird die Kommunikation für eine Architektur aus Steuerungsrechner und Rechenbeschleuniger diskutiert. Es soll davon ausgegangen werden, dass nur die zeitkritischen inneren Schleifen des Simulationscodes auf dem Rechenbeschleuniger implementiert werden. Diese Schleifen summieren die Beiträge der Teilchen aus einer Nachbarschaftsliste zu den SPHNäherungen für die Dichte ρ, die Divergenz und Rotation von ~v, die Druckkraftkomponenten und die Energien. Dann müssen für den ersten Schritt des SPH-Algorithmus folgende Daten transferiert werden: • Für die Dichteberechnung werden die Positionsvektoren~ri , Glättungslängen hi und Massen mi benötigt. • Für die Berechnung von (~∇ ·~v)i und (~∇ ×~v)i sind zusätzlich die Geschwindigkeitsvektoren ~vi zum Beschleuniger zu übertragen. • Die Endergebnisse ρi , (~∇ ·~v)i und (~∇ ×~v)i werden zurück zum Steuerungsrechner geschrieben. Ist NSPH wie oben eingeführt die Anzahl der SPH-Teilchen, die insgesamt in die Berechnungen involviert sind, werden für die erste SPH-Schleife also NSPH · 8 Gleitkommazahlen zum Rechenbeschleuniger übertragen. Für NSPH,active SPH-Teilchen, für welche die SPH-Summen ausgeführt werden, ergibt sich ein Rücktransfer von NSPH,active · 5 Gleitkommazahlen. Für die eigentlichen Berechnungen wird für jedes aktive Teilchen zusätzlich seine Nachbarschaftsliste benötigt. Bei einer mittleren Zahl an SPH-Nachbarn Nneigh , wofür Nneigh ≈ 50 ein typischer Wert ist, ergibt sich ein zusätzliches Volumen von Nactive · Nneigh Datenworten, das zum Rechenbeschleuniger übertragen werden muss. Für den zweiten Schritt der SPH-Berechnungen ergibt sich folgender zusätzlicher Kommunikationsaufwand: • Es müssen die auf dem Steuerungsrechner erzeugten Drücke Pi , Balsarakoeffizienten fi und die Schallgeschwindigkeiten ci zum Rechenbeschleuniger übertragen werden4 . 4 Es wurde hier angenommen, dass die in Gleichung 2.32 auftretenden Konstanten α und β fest sind. Bei manchen Codes werden diese Parameter individuell für jedes Teilchen berechnet und müssen dann ebenfalls zum Rechenbeschleuniger übertragen werden. 95 5.2. KOMMUNIKATIONSBANDBREITE • Als Ergebnisse werden die Druckkräfe und Entropieänderung durch die künstliche Viskosität zum Steuerungsrechner transferiert. Hier ergibt sich also ein Datenaufkommen von NSPH · 3 Worten hin zum Steuerungsrechner und NSPH,active · 4 Datenworten zurück. Falls die Nachbarschaftsliste nicht auf der Beschleunigerplattform gespeichert werden kann, ist diese für den zweiten Schleifendurchlauf erneut zu übertragen. Falls auch die Teilchendaten aus Schritt 1 nicht gespeichert werden können, beispielsweise wenn der Speicher des Rechenbeschleunigers nur einen Teil der SPH-Teilchendaten aufnehmen kann, sind diese Daten ebenfalls ein zweites Mal zu übertragen. Zusammengerechnet ergibt sich für die Berechnung der SPH-Formeln pro Zeitschritt ein minimales Datenaufkommen von: ComHost→Accel = NSPH · 11 + Nactive · Nneigh (5.4) ComAccel→Host = NSPH · 9, wobei das Transfervolumen zwischen Steuerungsrechner und Beschleuniger ComHost→Accel und in umgekehrter Richtung ComAccel→Host genannt wurde. Falls auf dem Beschleuniger keinerlei Daten aus der ersten Schleifenberechnung gespeichert werden können, ergibt sich folgendes Volumen für den Upload zum Beschleuniger: ComHost→Accel = NSPH · 19 + 2 · Nactive · Nneigh . (5.5) Es soll nun eine grobe Abschätzung für die Mindestbandbreite Bcom,min gemacht werden, ab der eine Rechenleistung von über 2 GFlops erreicht werden kann. Für die SPH-Berechnungen werden pro aktivem Teilchen 100 Gleitkommaoperationen angesetzt. Es wird der Fall NSPH = Nactive und Nneigh = 50 angenommen. Dann ergibt sich bei einer Übertragungsbandbreite Bcom für den Datentransfer zwischen Steuerungsrechner und Beschleuniger folgende Zeit, wenn vom maximalen Datentransfervolumen aus Gleichung 5.5 ausgegangen wird: tcom = (NSPH · 28 + 2 · NSPH · 50) · 4 Byte/Bcom 128 · NSPH · 4 Byte . Bcom Demgegenüber wird folgende Zeit für eine SPH-Berechnung mit 2 GFlops benötigt: (5.6) = NSPH · 50 · 100 . 1 2 · 109 sec (5.7) Bcom,min ≈ 200 MByte/sec. (5.8) t2GFlops = Für tcom = t2GFlops ergibt sich dann: Wird davon ausgegangen, dass die Nachbarschaftsliste und alle Teilchendaten auf dem Rechenbeschleuniger zwischengespeichert werden können, reduziert sich Bcom,min auf etwa 140 MByte/sec. Soll eine signifikante Beschleunigung der SPH-Berechnungen erreicht werden, muss die Kommunikationsbandbreite deutlich über diesen Werten liegen. Vor allem aber dürfen die Berechnungen selbst nicht viel länger als die Kommunikationszeit dauern, was insbesondere bedeutet, dass während der Übertragung der Daten gerechnet werden muss (zumindest beim Nachbarschaftslistentransfer, da dieser den größten Kommunikationsaufwand verursacht). 96 KAPITEL 5. ANFORDERUNGEN AN EINE BESCHLEUNIGERARCHITEKTUR 5.3 Erforderliche Rechengenauigkeit von SPH Die benötigte Rechengenauigkeit ist der entscheidende Faktor dafür, ob eine Rechenbeschleunigung mit rekonfigurierbaren Rechensystemen möglich ist, und, falls dies der Fall ist, welcher Speedup erwartet werden kann. Dies lässt sich wie folgt begründen: Zur Beschleunigung müssen die Rechenwerke hoch parallelisiert implementiert werden, denn rekonfigurierbare Prozessoren erreichen konstruktionsbedingt wesentlich geringere Taktfrequenzen als Standardprozessoren. Der Ressourcenaufwand der einzelnen Operatoren hängt wiederum stark von der zu erzielenden Rechengenauigkeit ab. Je geringer also die Genauigkeitsvorgaben sind, desto mehr Operationen können parallel implementiert werden und desto höher ist deshalb das Potential für eine Beschleunigung. Die Analyse der erforderlichen Rechengenauigkeit wurde in zwei Schritten durchgeführt. Erstens wurde ein künstlich in der Rechengenauigkeit eingeschränkter Simulationscode auf ein typisches Simulationsproblem angewandt, um die Genauigkeitsschwelle zu finden, ab der sich Abnormalitäten in der Simulation zeigen. Es wurde hier nicht jeder einzelne Rechenschritt in der Genauigkeit beschnitten. Nur die wichtigsten Zwischenergebnisse wurden verändert, damit der modifizierte Code ohne große Leistungseinbußen verwendet werden konnte. Nur so war es möglich, ein realistisches Simulationsproblem in vertretbarer Zeit zu untersuchen. Um das numerische Verhalten bei reduzierter Genauigkeit detaillierter zu analysieren, wurden in einem zweiten Schritt die SPH-Berechnungen mit künstlichen Eingangsdaten anhand einer Simulation eines Spezialrechenwerkes untersucht. Beide Schritte werden in den folgenden Unterabschnitten eingehend erläutert. 5.3.1 Testsimulationen mit künstlicher Reduktion der Genauigkeit Es wurde der Kollaps einer Gaswolke simuliert. Es handelt sich um die gleiche Simulation, die auch im Zusammenhang mit den Tests eines neuen Simulationscodes in [126] beschrieben wird5 . Gestartet wurde mit einer zu Beginn ruhenden sphärischen isothermen Gasverteilung mit Masse M, Radius R und folgendem Dichteprofil: ρ(r) = M 1 , 2πR2 r (5.9) die unter dem Einfluss der Eigengravitation kollabiert. Das System wurde mit 20000 SPHTeilchen simuliert, wobei eine durchschnittliche Zahl an Nachbarteilchen von 50 eingestellt wurde. Zur Beurteilung der Qualität der Simulationen wurden die Energieanteile des Gesamtsystems mit den Resultaten für die volle Rechengenauigkeit über den Zeitraum der Simulation miteinander verglichen. Die Energie wurde dabei aufgeschlüsselt in kinetische Energie, Gravitationsenergie und innere Energie. Dies ist das übliche Vorgehen, neue astrophysikalische Codes auf korrektes physikalisches Verhalten zu testen. Fehler in der Simulation führen zu Abweichungen 5 Die führt Messungen wurden von Markus Wetzstein am Max-Planck-Institut für Astronomie, Heidelberg durchge- 5.3. ERFORDERLICHE RECHENGENAUIGKEIT VON SPH 97 in der Dynamik des Systems, welche am einfachsten über den zeitlichen Verlauf der Energiebestandteile nachzuweisen sind. Es wurden vier Simulationen durchgeführt, in denen mit verkürzten Mantissenbreiten von 8, 12, 16 und 20 Bit gerechnet wurde. Abbildung 5.1 zeigt den Vergleich der Energien der 8Bit-Rechnung mit der Single-Precision-Rechnung. Es zeigen sich bei der 8-Bit-Version zwar geringe aber dennoch signifikante Abweichungen. Besser zu sehen sind diese Abweichungen in den Plots für die relativen Fehler, wie sie in Abbildung 5.2 auf der linken Seite gegeben sind. Es tritt neben Fehlern im Prozentbereich auch eine deutliche Akkumulation von Rechenfehlern auf. Bereits bei 12-Bit Rechengenauigkeit ist keine signifikante Fehlerakkumulation mehr zu sehen, wovon man sich anhand der rechten Seite von Abbildung 5.2 überzeugt. Die Fehler in der Energie bewegen sich durchweg in einem akzeptablen Bereich (O(0.1%)). Bei den Simulationen mit höheren Bitbreiten ergibt sich kaum noch eine Verbesserung des Verhaltens. Abbildung 5.3 zeigt die Ergebnisse im Fall von 20-Bit-Mantissen. Zur Auswertung der Simulationsdaten ist zu erwähnen, dass der Simulationscode bei unterschiedlichen Rechengenauigkeiten die Daten für unterschiedliche Zeitschritte ausgab. Für die Berechnung der relativen Rechenfehler mussten die Daten deshalb auf die Zeitschritte der Referenzsimulation interpoliert werden. Es wurden drei Interpolationsverfahren angewandt, eine lineare Approximierung, eine Spline-Interpolation, und das Verfahren der kleinsten quadratischen Fehler. Durch den Vergleich zwischen den Verfahren ergab sich, dass die Rechenfehler bereits bei 12-Bit-Mantissen etwa im Rahmen der Interpolationsfehler lagen. 5.3.2 Simulation der Rechenwerke Um einen detaillierten Einblick in das numerische Verhalten eines Rechenwerks für die SPHFormeln zu erhalten, in dem wie bei der späteren FPGA-Implementierung jede Rechenoperation mit beschränkter Genauigkeit arbeitet, wurde ein Simulationssystem für Gleitkommaoperationen mit limitierter Genauigkeit entwickelt. Dazu wurden Simulatoren für die Operationen Addition, Multiplikation, Division und Quadratwurzel erzeugt, welche das Verhalten dieser Operatoren für beliebige Mantissenbreiten auf Bit-Ebene abbilden, einschließlich verschiedener Rundungsmodi6 . Mit diesen Operatoren wurden Rechenwerke zusammengesetzt, wie sie als Pipeline in Hardware implementiert werden können. Als Eingangsdaten für die Genauigkeitssimulationen wurden fünf stark unterschiedliche künstlich erzeugte Teilchenverteilungen verwendet: 1. Gleichverteilung in alle Raumrichtungen. 2. Linear von einer Ecke eines Würfels in Richtung einer Diagonale des Würfels abfallend. 3. In X-Richtung Gaußverteilung, in Y- und Z-Richtung Gleichverteilung. 4. Um einen Punkt in X-, Y- und Z-Richtung gaußverteilt. 5. Stufenförmige Verteilung in X-, Y- und Z-Richtung. 6 Es wurden die Modi Round To Nearest Even, Round To Nearest Integer und Truncation implementiert. 98 KAPITEL 5. ANFORDERUNGEN AN EINE BESCHLEUNIGERARCHITEKTUR U E kin E tot E grav Abbildung 5.1: Vergleich der Energien bei SPH-Berechnung mit Rundung der Zwischenergebnisse auf 8-Bit-Mantissen (RD08sph) mit den Ergebnissen des Originalcodes (CH24sph, SinglePrecision). Es ist die zeitliche Entwicklung der inneren Energie (U), kinetischen Energie (Ekin ), Gravitationsenergie (Egrav ) und der Gesamtenergie (Etot ) dargestellt. Es zeigen sich signifikante Abweichungen zwischen den Kurven für hohe und niedrige Rechengenauigkeit. 5.3. ERFORDERLICHE RECHENGENAUIGKEIT VON SPH 99 Abbildung 5.2: Zeitliche Entwicklung der relativen Fehler in der Berechnung der Energien bei Rundung der Zwischenergebnisse auf 8-Bit-Mantissen (links) und 12-Bit-Mantissen (rechts). Links ist deutlich die Akkumulation von Rechenfehlern zu sehen, während rechts die Fehler um Null pendeln. Man beachte auch die links und rechts unterschiedlichen Skalen. 100 KAPITEL 5. ANFORDERUNGEN AN EINE BESCHLEUNIGERARCHITEKTUR Abbildung 5.3: Relative Fehler in der Berechnung der Energien bei Rundung der Zwischenergebnisse auf 20-Bit-Mantissen. 5.3. ERFORDERLICHE RECHENGENAUIGKEIT VON SPH 101 Die Verteilungen wurden in einem 3 × 3 × 3-Würfel erzeugt, wobei für die Teilwürfel eine Kantenlänge von a = 4 festgesetzt wurde7 . Im Zentrum des innersten Würfels war ein Teilchen mit Glättungsparameter h = 0.5 vorgegeben. Nun wurden so lange Teilchen entsprechend einer Wahrscheinlichkeitsdichtefunktion hinzugefügt, bis das Zentralteilchen in seiner durch die Sphäre mit Radius 2h gegeber Nachbarschaft 50 SPH-Wechselwirkungspartner erhielt. In Abbildung 5.4 sind mit Ausnahme der Gleichverteilung die sich ergebenden Teilchenkonstellationen dargestellt. Die Simulationen wurden für alle Teilchen im innersten Würfel durchgeführt (O(103 ) Teilchen). In allen Fällen wurde die Geschwindigkeitsverteilung durch gaußverteilte Komponenten der Geschwindigkeitsvektoren angesetzt. Es wurden folgende Formeln entsprechend den Berechnungen von Schritt 1 und Schritt 2 der in Abschnitt 2.3.2 beschriebenen speziellen SPH-Formulierung berechnet: N ρi = ∑ m jW (|~ri j |, hi j ) (5.10) j=1 ρi (~∇ ·~v)i = − ∑ m j v~i j ~∇iW (|~ ri j |, hi j ) (5.11) ∑ m j v~i j × ~∇iW (|~ri j |, hi j ) (5.12) j ρi (~∇ ×~v)i = j d~vi = −∑mj dt j ! Pj Pi ~∇iW ~ri j , hi j + + Π i j 2 2 ρi ρj duvisc,i 1 = m j Πi j v~i j · ~∇iW (|~ri j |, hi j ). dt 2∑ j (5.13) (5.14) Erwartungsgemäß zeigten die Berechnungen für die in drei Achsrichtungen gaußverteilte haufenförmige Teilchenkonstellation, welche die größten Dichtekontraste der getesteten Verteilungen hat, die größten Rechenfehler. Die mittleren relativen Fehler unterschieden sich jedoch selbst hier nicht um mehr als einen Faktor 2 von den Resultaten für die anderen Verteilungen. In Abbildung 5.5 sind die gemittelten Ergebnisse für verschiedene Mantissenbreiten dargestellt. Für alle Operatoren wurde hier mit dem Standardrundungsmodus Round To Nearest Even gerechnet. Die wichtigste Beobachtung ist, dass sich für die Dichten mittlere Fehler im Bereich der Darstellungsgenauigkeit der Gleitkommazahlen ergeben. Bereits ab 12 Bit erhält man so eine Rechengenauigkeit in der Größenordnung 10−3 –10−4 , was vergleichbar ist mit den Fehlern in der Energie aus Abbildung 5.2 (rechte Seite). Für 16-Bit-Mantissen ist der mittlere relative Fehler bereits so niedrig, dass keinerlei signifikante Fehlerfortpflanzung auf die weiteren SPHBerechnungen zu befürchten ist. Die Werte für die Divergenz- und Rotationsberechnung liegen etwa einen Faktor 50 über dem Fehler der Dichteberechnung. Etwa genauso stark weichen die Ergebnisse für die Berechnung der Kräfte und Entropieänderung ab. Verantwortlich dafür ist das hohe Maß an Auslöschung signifikanter Stellen bei der Akkumulation der Zwischenergebnisse. Der Faktor 50 läßt auf einen durchschnittlichen Verlust von fünf bis sechs führenden Mantissenbits schließen. 7 Es wurde. interessieren in diesem Zusammenhang nur relative Größen, so dass der Betrag von a beliebig gewählt 102 KAPITEL 5. ANFORDERUNGEN AN EINE BESCHLEUNIGERARCHITEKTUR Abbildung 5.4: Simulierte Teilchenverteilungen zur Analyse der Randbedingungen an die Rechenwerke. Es ist die dreidimensionale Verteilung innerhalb eines 3x3x3-Kubus und deren Projektion auf die Grundfläche des Kubus zu sehen. Die Sphäre im Zentrum des inneren Kubus entspricht der Nachbarschaftsumgebung des Teilchens in der Mitte, welche etwa 50 Nachbarteilchen einschließt. Links oben ist eine linear in alle Richtungen abfallende Verteilung, rechts oben eine Stufenverteilung, links unten eine in eine Richtung normalverteilte und rechts unten eine in alle Achsrichtungen normalverteilte Teilchenkonstellation gezeigt. 103 5.3. ERFORDERLICHE RECHENGENAUIGKEIT VON SPH 1 8 10 12 14 16 18 Mittlerer Relativer Fehler 0,1 0,01 RhoErr DivVErr RotVErr ForceErr entropyErr 0,001 0,0001 0,00001 0,000001 Mantissenbreite Abbildung 5.5: Abhängigkeit des mittleren relativen Fehlers der Berechnungen der SPH-Formeln für die Dichte (RhoErr), Divergenz (DivVErr), Rotation (RotVErr), Kraft (ForceErr) und Entropieänderung aufgrund der künstlichen Viskosität (EntropyErr) von der Genauigkeit der verwendeten Gleikommaoperationen. 1 8 10 12 14 16 18 Mittlerer Relativer Fehler 0,1 0,01 RhoErr DivVErr RotVErr 0,001 0,0001 0,00001 0,000001 Mantissenbreite Abbildung 5.6: Abhängigkeit des mittleren relativen Fehlers der Berechnungen der SPH-Formeln für die Dichte (RhoErr), Divergenz (DivVErr) und Rotation (RotVErr), wenn nur die Eingangsgrößen und einige Zwischenergebnisse in der Genauigkeit eingeschränkt werden, wie es für die Messungen bei echten astrophysikalischen Testsimulationen gemacht wurde. 104 KAPITEL 5. ANFORDERUNGEN AN EINE BESCHLEUNIGERARCHITEKTUR Um beurteilen zu können, ob die Ergebnisse zu den Simulationen der Rechenwerke vergleichbar mit den Testrechnungen aus Abschnitt 5.3.1 sind, wurden ebenfalls Simulationen durchgeführt, bei denen nur die Eingangsdaten und einige Zwischenergebnisse in der Genauigkeit reduziert wurden, wie es für die Testrechnungen geschehen ist. In Abbildung 5.6 sind die Ergebnisse dazu gezeigt. Es ergab sich, dass sich die relativen Fehler der Dichten nicht signifikant von den Fehlern für die detaillierte Rechenwerkssimulation unterschieden, die der übrigen Größen im Mittel ebenfalls nur wenig unterschiedlich waren bei etwas erhöhter Streuung der Genauigkeiten (siehe Fehlerbalken). Im einzelnen wichen die Genauigkeiten bis etwa auf einen Faktor 2–3 ab. Eine Erhöhung der Rechengenauigkeit um zwei Mantissenbits gegenüber den Testrechnungen sollte also zu einer vergleichbaren Genauigkeit der SPH-Simulation führen. Es bleibt die Ungewissheit, ob das in Abschnitt 5.3.1 beschriebene astrophysikalische System repräsentativ für eine Vielzahl anderer astrophysikalischer Simulationen bezüglich des Verhaltens bei reduzierter Genauigkeit ist. Deshalb soll im Folgenden von einer Mantissenbreite von 16 Bit ausgegangen werden, um eine Prototypimplementierung mit einigen Sicherheitsreserven bezüglich der Numerik aufzubauen. Die mögliche Variation der Genauigkeitsanforderungen, abhängig von der Applikation, motiviert den Aufbau von in der Rechengenauigkeit skalierbaren FPGA-Designs. Diese Skalierbarkeit wird im Folgenden ein wichtiges Designkriterium für die Architektur der Rechenwerke sein. Neben der Rechengenauigkeit der Operationen spielt auch das Rundungsverhalten und vor allem die Ausnahmebehandlung eine wichtige Rolle, weshalb diesbezüglich einige Designrichtlinien für die SPH-Rechenwerke gegeben werden sollen. Runden Im SPH-Formalismus werden alle Größen durch die Akkumulation von Beiträgen aus Nachbarwechselbeziehungen gebildet. Um zu vermeiden, dass sich systematische Rechenfehler akkumulieren, sollten die Berechnungen korrekt gerundet werden. Bei Testrechnungen konnte kein signifikanter Unterschied in den Rechengenauigkeiten zwischen dem Standardrundungsmodus Round To Nearest Even und dem einfacheren Modus Round To Nearest Integer festgestellt werden. Es ist jedoch nicht auszuschließen, dass es Testszenarien gibt, für die sich doch Unterschiede zeigen. Deshalb sollte für die Implementierung der Rechenwerke stets erwogen werden, ob für einen Operator die Werte der Ergebnisstellen nach dem LSB nicht statistisch gleichverteilt sind, was vor allem bei Additionen auftreten kann. In Abschnitt 4.3.2 wurde bereits ein Beispiel für das Ungleichgewicht von Rundungsfehlern gegeben. In solchen Fällen sollte der Standard-Rundungsmodus Round To Nearest Even dem einfacheren Modus Round To Nearest Integer vorgezogen werden. Für Operationen wie Multiplikation, Division und Quadratwurzel, bei denen mit hoher Wahrscheinlichkeit nach dem Rundungsbit noch weitere Bits ungleich Null folgen, kann davon ausgegangen werden, dass der Modus Round To Nearest Integer zur Vermeidung der Fehlerakkumulation ausreichend genau ist. Ausnahmebehandlung Es kann vorausgesetzt werden, dass die Berechnungen im Verlaufe einer Simulation nicht zu Überläufen von Zwischenergebnissen führen, da ansonsten die SoftwareImplementierung ebenfalls nicht korrekt arbeiten würde. Dagegen sind Underflow-Bedingungen, also die Unterschreitung der kleinsten darstellbaren Zahl, häufige Ereignisse. Sie können bei- 5.4. FOLGERUNGEN FÜR DIE SYSTEMARCHITEKTUR 105 spielsweise bei der Subtraktion gleicher Zahlen oder Multiplikation sehr kleiner Zahlen auftreten. Die für die Simulation einzig sinnvolle Antwort auf Zahl-Unterläufe ist die Ausgabe von Null, beziehungsweise die Ausgabe der kleinsten darstellbaren Zahl, falls Null durch das verwendete Zahlsystem nicht repräsentiert werden kann. Einen Underflow nicht abzufangen, wäre fatal, da anstatt Null dann eine der größten darstellbaren Zahlen ausgegeben werden könnte. 5.4 Folgerungen für die Rechenbeschleunigerarchitektur Die in den letzten Abschnitten diskutierten Randbedingungen an einen Rechenbeschleuniger lassen sich wie folgt zusammenfassen: • Für eine deutliche Beschleunigung muß eine Dauerrechenleistung von etwa 2 GFlops bereitgestellt werden. • Die Kommunikationsbandbreite zwischen Beschleuniger und Host sollte über 200 MByte/sec betragen. • Es soll eine Rechengenauigkeit entsprechend der Verwendung eines Gleitkommaformats mit 16 Mantissenbits erreicht werden. Die hohen Anforderungen an die Übertragungsbandbreite lassen sich am besten erfüllen, wenn die Beschleunigerplattform möglichst eng mit dem Host-System verbunden ist. Die geforderte Kommunikationsbandbreite kann insbesondere durch eine Bus-basierte Lösung umgesetzt werden. Ein 64-Bit-PCI-Bus mit 66 MHz hat beispielsweise eine maximale Bandbreite von über 500 MByte/sec. Eine Implementierung über eine Standard-Netzwerkschnittstelle (z.B GBit-Ethernet) kommt nicht in Frage, da damit keine Dauerübertragungsbandbreite von 200 MByte/sec erreichbar ist. Andere Schnittstellen, wie z.B. Myrinet oder proprietäre Lösungen, könnten schnell genug sein, sind aber mit einem hohen Implementierungsaufwand verbunden. Für den Aufbau einer Koprozessorplattform mit einer Dauerrechenleistung von über 2 GFlops können verschiedene Strategien in Erwägung gezogen werden. Bereits zu Beginn dieser Arbeit wurde der Ansatz motiviert, den Rechenbeschleuniger basierend auf der FPGA-Technologie zu entwickeln. Dieser Ansatz soll an dieser Stelle im Hinblick auf die nun präzisierten Anforderungen an die Rechenleistung im Vergleich zu alternativen Strategien diskutiert werden. DSPs Im Bereich der Signalverarbeitung in der Industrie werden als Rechenbeschleuniger typischerweise digitale Signalprozessoren (DSPs) verwendet. Diese lassen sich leicht parallel betreiben und erreichen für Spezialanwendungen pro Prozessor Rechenleistungen im GFlops-Bereich. Solche Anwendungen sind beispielsweise digitale Filter für die Bild- und Tonverarbeitung. Hier werden viele Multiplizier-Akkumulier-Operationen benötigt, wofür die Rechenwerke der DSPs optimiert sind. Für die SPH-Berechnung werden Signalprozessoren jedoch kaum bessere Leistungen erzielen als Standardprozessoren, da sie über ein ähnlich enges Speicherinterface verfügen und die Rechenwerksstruktur dieser Prozessoren für die SPH-Summationsschleifen keine Vorteile bringt. Ein Leistungsgewinn kann also nur durch den parallelen Einsatz mehrerer DSPs 106 KAPITEL 5. ANFORDERUNGEN AN EINE BESCHLEUNIGERARCHITEKTUR erreicht werden. Für eine Rechenleistung von 2 GFlops müssten schätzungsweise 5–10 Signalprozessoren verwendet werden, wobei völlig unklar ist, wie diese effizient mit den Teilchendaten versorgt werden können. Überdies ist die Implementierbarkeit eines Bus-basierten Koprozessors mit so vielen Hochleistungs-DSPs fraglich. Der Ansatz eines Standardrechners als Host müsste aufgegeben werden zugunsten eines Industrie-PC-Formfaktors oder einer proprietären Systemstruktur wie beispielsweise bei [35], was die Kosten vervielfachen würde8 . ASICs Die größte Rechenleistung ließe sich erzielen, wenn ein anwendungsspezifischer Spezialchip (ASIC) entwickelt würde, der für die SPH-Berechnungen maßgeschnittene Rechenwerke in Form von Pipelines enthält. Dies könnte ähnlich wie bei der Entwicklung der GRAPEPlattformen aus Abschnitt 2.4.2 geschehen. Für eine spezielle SPH-Formulierung ließen sich damit enorme Rechenleistungen erzielen. Wie in Abschnitt 2.3.3 erwähnt wurde, können die SPH-Algorithmen jedoch deutlich variieren. Sollen zusätzliche physikalische Effekte berücksichtigt werden, wie beispielsweise magnetohydrodynamische Kräfte, werden zudem Erweiterungen der Berechnungsformeln erforderlich. Eine für viele Forschergruppen anwendbare und für den Fortschritt der Simulationsalgorithmen offene Architektur kann also nicht über diesen Ansatz feststrukturierter Spezialchips geschaffen werden. FPGAs Die Verwendung von FPGAs kann als Kompromiss zwischen der Flexibilität von Prozessoren und der extrem hohen Leistungsfähigkeit von ASICs gesehen werden. Ihre Struktur ermöglicht es, wie in den nächsten Kapiteln ausführlich beschrieben wird, hochspezialisierte Rechenpipelines aufzubauen. Trotz deutlich niedrigerer Taktfrequenz als bei Prozessoren (etwa Faktor 10–20) lässt sich damit für viele Anwendungen ein wesentlich höherer Datendurchsatz erreichen als bei Standardprozessoren. Die Rekonfigurierbarkeit sichert die Flexibilität des Ansatzes. Für unterschiedliche Formulierungen von SPH brauchen nur unterschiedliche FPGADesigns aufgespielt zu werden. Es ist jedoch a priori nicht klar, ob die Logikressourcen aktueller FPGAs genügen, um die komplexen Rechenwerke für die SPH-Algorithmen zu implementieren. Dies zu zeigen wird ein elementarer Gedanke der weiteren Ausführungen dieser Arbeit sein. Die FPGA-Koprozessorkarte MPRACE, wie sie in Abschnitt 3.3 vorgestellt wurde, genügt den wesentlichen Anforderungen, wie sie in diesem Abschnitt gegeben wurden. Als Einsteckkarte für den 64-Bit-PCI-Bus stellt sie eine hohe Kommunikationsbandbreite bereit (maximal 264 MByte/sec, limitiert durch den lokalen Bus auf dem Board, siehe auch Abschnitt 5.4.2). Der moderne FPGA beinhaltet, wie sich zeigen wird, genügend Logikressourcen, um die Rechenwerke mit ausreichend hoher Geschwindigkeit und Rechengenauigkeit zu implementieren. Deshalb wurde dieses Board als Prototypplattform verwendet und alle weiteren Ausführungen beziehen sich auf diesen Koprozessor. 8 Bei einer proprietären Lösung wären zumindest die Initialkosten sehr hoch und zudem die Entwicklungszeit beträchtlich. 5.4. FOLGERUNGEN FÜR DIE SYSTEMARCHITEKTUR 5.4.1 107 Grundlegende Struktur der Rechenwerke Wie bereits motiviert wurde, kann eine Rechenleistung im GFlops-Bereich nur über die Parallelisierung der Rechenwerke erreicht werden. Dabei ist die vollständig auf Operatorebene parallelisierte Struktur als Rechenpipeline die naheliegendste Variante9 . Nimmt man für die SPHFormeln 100 Operationen an, und kalkuliert mit einer sehr konservativen Schätzung von 50 MHz Taktfrequenz im FPGA, ergibt sich für diese Stategie eine Rechenleistung von 5 GFlops. Dies entspricht sehr gut den Anforderungen and den Rechenbeschleuniger, weshalb diese Parallelisierungsstrategie für die Implementierung gewählt wurde. Die Struktur der SPH-Berechnungen ist immer gleich. Für ein Teilchen mit Index i wird eine Summation über die SPH-Beiträge der Teilchen j einer Nachbarschaftsumgebung von Teilchen i durchgeführt. Die SPH-Beiträge ergeben sich aus den Teilchendaten mit Index i und j. Wird die zu berechnende SPH-Größe S genannt und werden die Summanden mit F bezeichnet, ergibt sich folgendes Schema: Si = F(xi1 , . . . , xiN , x j1 , . . . , x jN ), (5.15) ∑ j∈Neighborlist(i) wobei die verwendeten Teilchendaten für Teilchen l mit xl1 , . . . , xlN bezeichnet wurden. Dieses Rechenschema kann in eine Hardwarearchitektur übersetzt werden, wie sie in Abbildung 5.7 gezeigt ist. In dieser Schaltung wird davon ausgegangen, dass im Speicher an der Adresse j die Daten zu Teilchen j liegen. Zu Beginn einer Summation wird das Register i-data geladen und der Akkumulator wird zurückgesetzt. In jedem weiteren Takt wird ein neuer Datensatz der Nachbarteilchen j aus dem Speicher gelesen und über das Register j-data in die Pipeline gegeben. Wurde die gesamte Nachbarschaftsliste abgearbeitet, kann das Endresultat aus dem Akkumulator ausgelesen werden. Sollen mehrere Formeln gleichzeitig ausgewertet werden, beispielsweise die Berechnung der Dichte, Geschwindigkeitsdivergenz und Rotation des Geschwindigkeitsfeldes, werden im Modul Arithmetic Unit bei unveränderter äußerer Beschaltung einfach mehrere Summationen parallel ausgeführt. 5.4.2 Datenfluss Eine hohe mittlere Datentransferrate über den PCI-Bus kann nur erreicht werden, wenn große Datenblöcke über Direct Memory Access (DMA) auf den Rechenbeschleuniger übertragen werden. Denn Einzelzugriffe über den PCI-Bus führen zu Übertragungsbandbreiten von nur etwa 5 MByte/sec für Lesezugriffe und ca. 30 MByte/sec für Schreibzugriffe, wie für das MPRACEBoard gemessen wurde. Werden DMA-Transfers eingesetzt können ab einer Blockgröße von 8 KByte sowohl für Lese- als auch für Schreibzugriffe Datenraten von 200 MByte/sec gemessen werden, wie in Abbildung 5.8 gezeigt wird. Dass gegenüber einer theoretischen Bandbreite von 512 MByte/sec nur etwa die Hälfte davon erreicht wird, folgt aus dem nur halb so schnellen lokalen Bus auf der MPRACE-Plattform. 9 Andere Ansätze wären z.B., instruktionsbasierte Rechenwerke, gesteuert durch ein Mikroprogramm, auf dem FPGA zu implementieren oder eine Reihe von Operatoren parallel zu implementieren und die Verarbeitung über dynamische Verbindungsstrecken zwischen diesen Operatoren, kontrolliert durch eine State-Machine, zu steuern. 108 KAPITEL 5. ANFORDERUNGEN AN EINE BESCHLEUNIGERARCHITEKTUR RAM data x1 ...x N Index i,j i-data Control j-data Accumulator F(x i1...x iN,xj1...xjN ) Arithmetic Unit Abbildung 5.7: Hardwarearchitektur die sich aus dem abstrakten Rechenschema der SPHFormeln ergibt. 300 250 200 Write Rate in MBytes/sec Read Rate in MBytes/sec 150 100 50 1M 512K 256K 128K 64K 32K 16K 8K 4K 2K 1K 512 256 128 64 32 16 8 0 Abbildung 5.8: Datentransferleistung über den 64-Bit 66 MHz PCI-Bus für das MPRACE-Board. 5.4. FOLGERUNGEN FÜR DIE SYSTEMARCHITEKTUR 5.4.3 109 Geeignetes Zahlenformat für die Rechenwerke Die Gleitkommaarithmetik ist in jedem Fall ein numerisch geeignetes Zahlenformat für die Simulationen. Unter Verwendung dieses Zahlenformats wurden schließlich alle bisherigen Tests durchgeführt, insbesondere auch die Genauigkeitssimulationen aus Abschnitt 5.3.2. Entscheidend dafür, ob diese Zahlendarstellung auch für eine FPGA-Implementierung eine gute Lösung darstellt, ist die zu erwartende Performance bei einer Umsetzung im FPGA. In diesem Abschnitt erfolgt deshalb anhand der Grundlagen aus Kapitel 4 eine vergleichende Diskussion für die Gleitkommaarithmetik und alternative Rechentechniken. Die sich typischerweise über viele Größenordnungen erstreckenden Werte astrophysikalischer Zustandsgrößen führen zur Grundvoraussetzung, dass das verwendete Zahlenformat einen weiten Zahlenbereich darstellen kann. Eine Verarbeitung alleine unter Verwendung von Festkommazahlen scheidet also aus. Es kann höchstens partiell mit Festkommazahlen gerechnet werden, wie beispielsweise bei der Berechnung der Glättungskernfunktionen. Diese haben als Eingangsgröße eine Zahl aus dem Intervall [0, 2], können also prinzipiell durch ein Rechenwerk mit Festkommazahlen umgesetzt werden, wobei dies für kleine Eingangsgrößen mit einem Verlust an Genauigkeit für die Ergebnisse einhergeht. Da es noch keine Untersuchungen dazu gibt, wie sich solche Rechenfehler in den Simulationen auswirken, soll vorerst auf die Verwendung von Festkommazahlen gänzlich verzichtet werden. Neben dem Gleitkommaformat sind vor allem die logarithmische und semilogarithmische Zahlendarstellung interessante Kandidaten für eine Implementierung. Es wird davon ausgegangen, dass eine logarithmische Darstellung mit 24-Bit-Zahlen eine ähnliche Rechengenauigkeit erlaubt wie eine Gleitkommadarstellung mit 16-Bit-Mantissen und 8-Bit-Exponenten (siehe dazu [16]). Wie in Abschnitt 4.4 erläutert wurde, können in logarithmischer Darstellung Multiplikationen, Divisionen, Potenzen und Wurzeln sehr einfach implementiert werden. Dagegen muss für Additionen und Subtraktionen eine nichtlineare Funktion ausgewertet werden, was in der Regel über eine LUT-basierte Approximation geschieht. Erschwerend kommt hinzu, dass für die Addition und Subtraktion verschiedene Approximationen anzuwenden sind. Ein Addier/SubtrahierOperator, wie er für die Summation vorzeichenbehafteter Zahlen erforderlich ist, erfordert also die Implementierung von zwei Operatoren (wobei alles außer den LUTs für die Approximation gemeinsam implementiert werden kann). Das Erfordernis einer Funktionsapproximation für Addierer und Subtrahierer ist das Kernproblem bei logarithmischen Zahldarstellungen. Wird diese Näherung beispielsweise durch eine wie in Abschnitt 4.5.1 beschriebene lineare Approximation durchgeführt, werden bereits bei logarithmischen 18-Bit-Zahlen pro Addition mindestens 2 Block-RAM-Elemente eines Virtex-II-FPGAs benötigt. Wie in Abschnitt 5.3 angemerkt wurde, kann es für die Simulationsrechnungen durchaus erforderlich werden, mit logarithmischen 24-Bit-Zahlen (entsprechend 16-Bit-Mantissen einer Gleitkommadarstellung) zu arbeiten, wofür bereits mehr als 16 solcher Block-RAM-Elemente für eine einzige Addition benötigt werden. Bei genauerer Betrachtung der SPH-Formeln findet man ein Verhältnis von Addierern zu Multiplizierern von etwa 2 zu 3. Es werden für eine Implementierung mit logarithmischen Zahlen bereits bei einer 18-Bit-Darstellung deutlich mehr Block-RAM-Elemente benötigt als Block-Multiplizierer 110 KAPITEL 5. ANFORDERUNGEN AN EINE BESCHLEUNIGERARCHITEKTUR im Fall einer Implementierung durch Gleitkommaarithmetik10 . Dabei ist die Verdoppelung der LUT-Anzahl für Addier/Subtrahier-Bausteine noch nicht eingerechnet. Bei Erhöhung der Genauigkeit steigt der Bedarf an Block-RAM-Elementen zudem dramatisch an. Da die entgültige Rechengenauigkeit der Rechenbeschleunigerarchitektur nicht auf die geringe Genauigkeit einer logarithmischen 18-Bit-Darstellung festgelegt werden kann, scheidet das logarithmische Zahlensystem aus. Als letzte abzuwägende Alternative zum Gleitkommaformat bleiben die semilogarithmischen Zahlen. Wie in Abschnitt 4.4.3 beschrieben wurde, kann mit diesem Zahlenformat für den hier vorliegenden Fall, dass ähnlich viele Addierer wie Multiplizierer benötigt werden, eine Verschiebung von Multiplizierer- auf RAM-Ressourcen erreicht werden. Der übrige Logikressourcenverbrauch wird jedoch nur unwesentlich verringert. Dividierer können im Vergleich mit einer Gleitkommaimplementierung wesentlich ressourcensparender aufgebaut werden, jedoch ist unklar, wie es sich für den Quadratwurzeloperator verhält. Für FPGA-Architekturen, die Block-RAMElemente enthalten, jedoch nicht über Block-Multiplizierer verfügen, ist das semilogarithmische Zahlensystem sehr vielversprechend. In unserem Fall bei Verwendung eines Virtex-II-FPGAs sind jedoch genügend Block-Multiplizierer vorhanden. Damit überwiegen die durch den LUTbasierten Ansatz entstehenden Nachteile bezüglich der Skalierbarkeit in der Rechengenauigkeit die Vorteile dieses Zahlensystems. 10 Hier wurde bereits im Vorgriff auf Abschnitt 6.2.3 verwendet, dass für einen Gleitkommamultiplizierer bis zu einer Mantissenbreite von 18 Bit die interne Festkommaoperation auf einen Block-Multiplizierer des Virtex-IIFPGAs abgebildet werden kann. Kapitel 6 Implementierung der Arithmetik auf FPGAs In diesem Kapitel wird die Entwicklung der elementaren Bausteine für eine Pipeline-Implementierung diskutiert, mit der die astrophysikalischen SPH-Algorithmen simuliert werden können. In Kapitel 5 wurde auf die Anforderungen an die Arithmetik eingegangen. Wie gezeigt, muss das verwendete Zahlenformat sowohl eine hohe Präzision garantieren als auch viele Größenordnungen darstellen können und sollte zudem in der Rechengenauigkeit leicht skalierbar sein. Geeignet dazu ist ein Gleitkommaformat mit parametrisierter Mantissenbreite, wie es in Abschnitt 4.3 dargestellt wurde. Wie in Abschnitt 5.4.3 motiviert, ist dieses Format im Fall einer SPH-Implementierung auf einer modernen FPGA-Plattform anderen Zahlenformaten überlegen. Deshalb wird im Hauptteil dieser Arbeit das Gleitkommaformat verwendet, entsprechend konzentriert sich dieses Kapitel auf die Implementierung der zugehörigen Operatoren. Alle elementaren Gleitkommaoperationen, wie in 4.3.3 gesehen, beinhalten eine Fixpunkt-Operation. Deshalb wird in Abschnitt 6.1 zuerst auf die Implementierung von Festkommaoperatoren eingegangen. Darauf aufbauend, werden in Abschnitt 6.2 die für diese Arbeit erforderlichen Gleitkommaoperatoren entwickelt. 6.1 Festkommaarithmetik auf FPGAs In diesem Abschnitt wird die Implementierung der wichtigsten Operatoren auf FPGAs vorgestellt: Addition/Subtraktion, Multiplikation, Division und Quadratwurzel. Die Diskussion von nicht-elementaren Operatoren wurde auf die Implementierung der Quadratwurzel beschränkt, da nur diese Bausteine für die Implementierung des Rechenbeschleunigers benötigt wurden. 6.1.1 Addition und Subtraktion Zentrale Rechenelemente für sämtliche Festkomma-Operatoren sind Integer-Addierer beziehungsweise Addier-Subtrahier-Elemente. Entsprechend gründlich werden die Eigenschaften verschiedener Implementierungsstrategien, wie sie in Abschnitt 4.1.2 vorgestellt wurden, analysiert. 111 112 KAPITEL 6. IMPLEMENTIERUNG DER ARITHMETIK Bei der Konstruktion von schnellen Addierer-Rechenwerken für Mikroprozessoren oder anwendungsspezifische Spezialchips (ASICs) ist es ein weitverbreitetes Standardverfahren, CarryLookahead-Addierer einzusetzen. Diese haben ein Zeitverhalten, das logarithmisch mit der Addiererbreite skaliert. Für sehr breite Operanden werden darüber hinaus Carry-Select-Addierertechniken eingesetzt. Sollen mehr als zwei Argumente summiert werden, werden die dazu erforderlichen Addiererbäume typischerweise durch Carry-Save-Addierer mit nachfolgender CarryLookahead-Stufe implementiert. Zur Untersuchung, ob für FPGAs ähnliche Design-Kriterien gelten, wurde eine Vergleichsstudie angefertigt, welche die Eigenschaften von Carry-LookaheadAddierern gegenüber der Implementierung als einfache Ripple-Carry-Addierer für verschiedene Bitbreiten gegenüberstellt. Die Carry-Lookahead-Addierer wurden nach dem in Abbildung 4.5 gezeigten Bauprinzip umgesetzt und die Ripple-Carry-Addierer entsprechend Abbildung 3.5 implementiert. Ergänzend wurde auch die Implementierung von Carry-Select-Addierern untersucht (implementiert, wie in Abbildung 4.7 und 4.8 gezeigt mit Teiladdierern in Ripple-CarryBauweise). Tabelle 6.1 gibt die Resultate wieder. Breite 4 8 16 32 64 128 256 512 Carry-Lookahead LUTs f/MHz WP 11 269 4L 28 31 57 69 117 153 246 281 497 527 984 1026 1982 206 263 140 166 106 121 75 97 58 80 50 68 51 5L 4L 7L 6L 9L 9L 13 L 11 L 17 L 13 L 19 L 15 L 18 L Ripple-Carry LUTs f/MHz WP 4 425 1L +3C 8 390 1L +7C 16 334 1L + 15 C 32 261 1L + 31 C 64 181 1L + 63 C 128 112 1L + 127 C 256 64 1L + 255 C 512 34 1L + 511 C Carry-Select LUTs f/MHz 65 86 129 167 257 330 513 652 1025 1316 249 202 189 169 138 137 87 102 54 74 WP 2 L + 16 C 3L+8C 2 L + 32 C 3 L + 16 C 2 L + 64 C 3 L + 32 C 2 L + 128 C 3 L + 64 C 2 L + 256 C 3 L + 128 C Tabelle 6.1: Leistung verschiedener Addierertechniken bei Implementierung in Virtex-II-FPGA XC2V3000-4. Abhängig von der Breite der Addierer wurden die Logikressourcen (LUTs), die maximale Taktfrequenz f und die Länge des zeitkritischen Logikpfades (WP) in LUTs (L) und Carry-Multiplexer (C) bestimmt. Es wird deutlich, dass die einfache, aber durch die FPGAs mittels spezieller Carry-PropagationNetzwerke unterstützte Implementierung von Ripple-Carry-Addierern über alle für Gleitkommaoperationen auftretende Bitbreiten deutlich schneller und zugleich um einen Faktor 3-4 ressourcensparender ist als eine Carry-Lookahead-Lösung. Erst bei sehr hohen Breiten über 256 Bit kommt das logarithmische Zeitverhalten zum Tragen. Doch auch für diesen Bereich gibt es 6.1. FESTKOMMAARITHMETIK AUF FPGAS 113 bessere Design-Strategien, wie die Spalte für Carry-Select-Addierer zeigt. Diese erreichen bei deutlich geringerem Logikaufwand wesentlich höhere Taktfrequenzen als die Carry-LookaheadAddierer. Es sei hier noch angemerkt, dass durch Pipelining die Geschwindigkeit der RippleCarry-Addierer ohne zusätzlichen Aufwand an LUTs, jedoch unter Aufwendung zusätzlicher Register erhöht werden kann, indem die Operationen zerteilt werden und die Addition der Stücke nacheinander erfolgt, entsprechend dem Erscheinen der Carry-Out-Signale der Teiladdierer. Bis jetzt wurden nur Integer-Addierer betrachtet. Daraus ergeben sich jedoch auf sehr einfache Weise auch die Festkomma-Addierer. Wie im Abschnitt 4.2 bereits gezeigt wurde, kann die Beziehung zwischen der Addition auf Festkommazahlen a und b mit Resultat c, wobei a, b und c jeweils l Nachkommastellen haben und der Implementierung durch einen Integer-Addierer durch folgende Gleichung beschrieben werden: c = a ± b = (a rl ± b rl ) · r−l . (6.1) Die Zahlen a und b können also als Integer-Werte a rl und b rl verarbeitet werden und es muss lediglich eine Kommaverschiebung des Resultats um −l Stellen erfolgen, um das FestkommaResultat c zu erhalten. 6.1.2 Multiplikation Wie die Addition kann auch die Multiplikation c = a · b von Fixpunkt-Zahlen a, b auf eine Operation auf Integer-Zahlen zurückgeführt werden, wie bereits in Abschnitt 4.2 gezeigt wurde: c = a · b = (a rl · b rl ) · r−2l . (6.2) Hier muss für das Fixpunkt-Resultat also eine Kommaverschiebung um 2 l Stellen erfolgen. Im weiteren Verlauf dieses Abschnitts kann die Diskussion deshalb auf die Implementierung von Integer-Multiplizierern beschränkt werden. Der für den größten Teil der Arbeit verwendete FPGA der Virtex-II-Serie ermöglicht die Implementierung von Multiplizierern sowohl mit programmierbaren Logikelementen, wie sie in jedem FPGA vorhanden sind, als auch über die vorhandenen Block-Multiplizierer, wie sie in Abschnitt 3.1.2 erwähnt wurden. Im Verlauf der Implementierung der Arithmetik wurde mit verschiedenen FPGA-Typen gearbeitet, weshalb beide Varianten implementiert wurden. Da die Ergebnisse dieser Arbeit auch für andere FPGA-Typen anwendbar sein sollen, wird nicht nur die einfachere Methode mit den Block-Multiplizierern beschrieben, sondern auch auf die allgemeiner verwendbare Implementierung von Multiplizierern ausführlich eingegangen. Letztere wird zwar ebenfalls in einer auf die interne Struktur von Virtex-II-FPGAs optimierten Form diskutiert, die Methode ist jedoch auf die meisten neueren FPGA-Typen mit ähnlichen Ergebnissen übertragbar. Implementierung durch Logikressourcen des FPGAs In Abschnitt 4.1.3 wurden die Array-Multiplizierer vorgestellt. Wie dort in Abbildung 4.12 zu sehen ist, bestehen diese Multiplizierer im Wesentlichen aus einem Netzwerk von Volladdierern, 114 KAPITEL 6. IMPLEMENTIERUNG DER ARITHMETIK z7 x3 0 & x3 x2 x1 x0 & & x2 & & x1 & & + + + x3 & + x2 & + x1 & + x0 & + x3 & + z6 x2 & + z5 x1 & + z4 x0 & + z3 + x0 & y0 y1 z0 y z1 2 y z2 3 Abbildung 6.1: Multipliziererschaltung für 4-Bit Integer-Zahlen mit Multiplizier-AddierPrimitiven (graue Blöcke). denen UND-Gatter vorgeschaltet sind. Diese Struktur lässt sich sehr effizient auf die FPGARessourcen eines Virtex-FPGAs abbilden. Wie in Abschnitt 3.1.2 beschrieben und in Abbildung 3.6 illustriert wurde, lässt sich ein 1-Bit-Volladdierer für die Bits a und b und Carry-Eingang cin mit einer UND-Verknüpfung auf dem Eingangsbit b mit dem Signal g durch ein halbes Slice des FPGAs implementieren. Da die verwendete LUT in diesem Fall noch einen freien Eingang besitzt, kann in derselben LUT auch das Bit a mit einem weiteren Eingangsbit h verknüpft werden, ohne zusätzliche Logikressourcen zu benötigen. Aus solchen Multiplizier-Primitiven können N × 1-Bit-Multiplizierer zusammengesetzt werden, welche über das gleiche schnelle CarryNetzwerk verbunden sind wie die im letzten Abschnitt besprochenen Ripple-Carry-Addierer. Daher verhält sich die Geschwindigkeit solcher Multiplizier-Elemente mit der Breite genau so wie bei den Addierern. Die Schaltung nach Abbildung 4.12 verwendet außer in der letzten Stufe Carry-Save-Addierer. Bei der FPGA-Implementierung ist eine Umsetzung mit den eben beschriebenen N × 1-Bit-Multiplizierern besser geeignet, da wie bei den Addierern die Vorteile der Nutzung der im FPGA vorhandenen speziellen Carry-Leitungen den Gewinn durch weniger tiefe Logikketten überwiegt. Abbildung 6.1 zeigt eine nach diesen Kriterien aufgebaute Schaltung eines 4 × 4-Bit Multiplizierers, der in 6 1/2 Slices (13 LUTs) implementiert werden kann. Tabelle 6.2 zeigt den Ressourcenverbrauch und die Geschwindigkeit von Array-MultiplizierSchaltungen für Breiten der Operanden x und y (gleiche Bezeichnung wie in Abbildung 6.1) von vier Bit bis 24 Bit. Ebenfalls sind die Ergebnisse für eine feste Breite von 24 Bit für x bei 6.1. FESTKOMMAARITHMETIK AUF FPGAS 115 variierender Breite von zwei bis acht Bit für y dargestellt. Insbesondere daran ist gut zu sehen, dass die Geschwindigkeit vor allem von der Breite des Operanden y abhängig ist, während z.B. ein 24 × 4-Multipizierer nicht sehr viel langsamer als ein 4 × 4-Multiplizierer ist. Die Daten zu den Operatoren, die wie in Abbildung 6.1 ohne Register implementiert wurden, sind in der Tabelle durch die Pipelinetiefe ∞ angedeutet. Der starken Abnahme der Geschwindigkeit mit der Breite von y kann durch Einfügen von Pipeline-Registern entgegengewirkt werden, wie in Tabelle 6.2 zu sehen ist. Die Latenzzeit des Operators steigt für einen solchen Aufbau dann linear mit der Breite von y an, wenn die Geschwindigkeit bzw. die Pipelinetiefe konstant gehalten wird. Außerdem werden zusätzliche Pipeline-Register für x, Teile von y und für die bereits ermittelten Ergebnisbits erforderlich. Während Pipeline-Register, welche die Ausgabe von LUTs (z.B. das Ergebnisbit einer MultiplizierAddier-Primitiven) speichern, in der Regel in die gleichen Slices gepackt werden wie diese LUTs, ist dies für die Pipeline-Register für x, y und die Ergebnisbits nicht der Fall. Der Logikzellenverbrauch steigt also insgesamt deutlich mit der Verkürzung der Pipelinestufen (nicht in der Tabelle dargestellt, da dies erst nach dem Place&Route-Prozess sichtbar wird). Ein anderer Weg, die Geschwindigkeit für breite Multiplizierer zu erhöhen, besteht darin, einen Multiplizierer nach der Tree-Methode, wie in Abschnitt 4.1.3 beschrieben, aufzubauen. Die Partialprodukte können durch Array-Multiplizierer mit geringer Tiefe berechnet werden und werden über einen Addiererbaum reduziert. Auf diese Weise können Multiplizierer verschiedener Breite mit einer logarithmisch entsprechend der Höhe des Addiererbaumes skalierenden Latenzzeit aufgebaut werden (für die hier betrachteten Operandenbreiten kann die Latenz sogar konstant gehalten werden). Die Multiplizierer wurden in dieser Arbeit auf diese Weise implementiert. Abbildung 6.2 zeigt als Beispiel einen 16-Bit-Multiplizierer. Tabelle 6.3 zeigt die Implementierungsergebnisse für Integer-Multiplizierer bis zu einer Breite von 24 Bit. Wie zu sehen ist, ergibt sich im Vergleich mit den Array-Multiplizierern bei einem geringen Mehrverbrauch von etwa 10 Prozent an LUTs eine hohe Geschwindigkeit bei kleiner Latenz. Alle Register sind vorausgehenden LUTs assoziiert und können damit ohne zusätzliche Logikzellen des FPGAs implementiert werden (im Gegensatz zu den Pipeline-Registern im Fall der Array-Multiplizierer). Implementierung durch Block-Multiplizierer Da die Multiplikation von Festkommazahlen bei vielen Anwendungen, für die FPGAs eingesetzt werden, wichtiger Bestandteil ist, werden in einigen neueren FPGA-Generationen MultiplizierElemente bereits als feste Schaltung integriert. So auch in den FPGAs der Virtex-II-Serie (von Xilinx Block-Multiplizierer genannt), wie in Abschnitt 3.1.2 bereits erwähnt wurde. Festverdrahtete Multiplizierer nehmen auf dem FPGA nur einen Bruchteil der Fläche ein, die für einen gleichwertigen Operator, implementiert durch die programmierbare Logik, benötigt wird. Im FPGA der Serie Virtex-II sind je nach Größe des FPGAs bis zu 168 18-Bit-Multiplizierer (für Signed-Integer-Zahlen) vorhanden. Integer-Zahlen, die breiter als 18-Bit sind, können durch Verwendung mehrerer Block-Multiplizierer mit anschließenden Additionsstufen für die Partialprodukte implementiert werden. Moderne Synthese-Werkzeuge wie z.B. das in dieser Arbeit verwendete Programm Synplify der Firma Synplicity erzeugen aus der rein verhaltensmäßigen 116 KAPITEL 6. IMPLEMENTIERUNG DER ARITHMETIK Breite x 4 8 8 12 12 12 12 16 16 16 16 20 20 20 20 24 24 24 24 24 24 24 24 24 24 24 Breite y Pipelinetiefe 4 ∞ 8 ∞ 8 4 12 ∞ 12 4 12 3 12 2 16 ∞ 16 4 16 3 16 2 20 ∞ 20 4 20 3 20 2 24 ∞ 24 4 24 3 24 2 2 ∞ 3 ∞ 4 ∞ 5 ∞ 6 ∞ 7 ∞ 8 ∞ Register LUTs 0 0 40 0 96 120 165 0 161 190 281 0 239 314 429 0 331 422 609 0 0 0 0 0 0 0 13 57 56 133 132 137 143 241 246 251 259 381 393 401 407 553 573 580 587 25 49 73 97 121 145 169 Geschwindigkeit /MHz 112 54.2 85.5 36.7 82.4 101 131 27.5 80.0 97.5 125 21.9 77.9 94.4 120 18.2 76.1 91.8 115 156 115 91.8 76.1 65.0 56.7 50.3 Latenz 0 0 2 0 3 4 6 0 4 6 8 0 5 7 10 0 6 8 12 0 0 0 0 0 0 0 Tabelle 6.2: Ergebnisse für Ressourcenverbrauch und Geschwindigkeit von ArrayMultiplizierern bei Virtex-II-FPGA XC2V3000-4 nach der Synthese mit Synplify. Eine Pipelinetiefe von ∞ bedeutet, dass keine Register verwendet wurden. Breite Register 4 8 8 40 12 72 16 112 20 160 24 216 LUTs 12 64 146 264 410 592 Geschwindigkeit/MHz 113 137 129 123 96.6 92.8 Latenz 1 2 2 2 2 2 Tabelle 6.3: Ressourcenverbrauch, Geschwindigkeit und Latenz von Integer-Multiplizierern bei Virtex-II-FPGA XC2V3000-4 nach Synthese mit Synplify. 117 6.1. FESTKOMMAARITHMETIK AUF FPGAS x y 16 16 Mult 16x4 20 Mult 16x4 0000 Mult 16x4 20 20 + 20 Mult 16x4 0000 20 + 4 0000 + 20 4 4 32 z Abbildung 6.2: Multipliziererschaltung für 16-Bit-Integer-Zahlen mit Array-Multiplizierern zur Berechnung der fünf 16-Bit×4-Bit-Partialprodukte. Beschreibung der Multiplikation in der Hardwarebeschreibungssprache automatisch die Umsetzung mit den Block-Multiplizierern. Zum Beispiel wird dann ein auf diese Weise erzeugter 24Bit-Multiplizierer nach der Divide-And-Conquer-Methode aus vier Block-Multiplizierern und zwei Addierern zusammengesetzt. Wie in [13] aufgezeigt wird, kann ein solcher Multiplizierer mithilfe der Methode nach Karatsuba und Ofman aus nur drei Block-Multiplizierern, drei Addierern und zwei Subtrahierern zusammengesetzt werden. Dies ergibt sich aus folgender Zerlegung der Multiplikation für 2k-Bit-Operanden x und y, wobei x und y in k-Bit Stücke xh , xl , yh und yl zerteilt werden: x · y = (xh 2k + xl ) · (yh 2k + yl ) = xh · yh · (22k − 2k ) + (xh + xl ) · (yh + yl ) 2k + xl · yl · (1 − 2k ). (6.3) Übersteigt die Breite der zu implementierenden Multiplizierer die Breite der Block-Multiplizierer nur wenig, ist es sinnvoll, Block-Multiplizierer und FPGA-Logikelemente für die Partialprodukte zu mischen1 , was dann jedoch manuell durch strukturellen HDL-Code erzeugt werden muss. Quadrierung Soll nicht eine allgemeine Integer-Multiplikation x · y, sondern lediglich eine Quadratur x2 berechnet werden, kann diese Operation wesentlich ressourceneffizienter als beim oben beschrie1 Beispielsweise auf die in [13] beschriebene Weise. 118 KAPITEL 6. IMPLEMENTIERUNG DER ARITHMETIK benen Multiplizierer implementiert werden. Das liegt vor allem daran, dass viele Partialsummen des Produktes identisch sind und deshalb gemeinsam berechnet werden können, wie an folgender Gleichung deutlich wird: k−1 k−1 z = (xk−1 · · · x0 )2r = ∑i=0 ∑ j=0 xi x j ri+ j k−1 k−1 k−1 2 2i xi r + 2 · ∑i=0 = ∑i=0 ∑ j=i+1 xi x j ri+ j . (6.4) 2 Damit müssen statt k2 nur noch k + k 2−k Partialprodukte summiert werden. Für r = 2 ergibt sich: z= k−1 k−1 k−1 i=0 i=0 j=i+1 ∑ xi 22i + ∑ ∑ (xi x j ) 2i+ j+1 . (6.5) In Abbildung 6.3 ist auf der linken Seite ein auf diese Weise aufgebauter Quadrierer für 4-BitGanzzahlen gezeigt. Im Vergleich zur Implementierung des 4-Bit-Multiplizierers wie in Abbildung 6.1 ergibt sich eine Ressourcenersparnis von über 50 Prozent. Eine weitere Möglichkeit, einen Quadrierer zu bauen, besteht darin, eine Look-Up-Table (LUT) dafür anzuwenden. Das Ergebnis der Operation ist nur von den k Bits des Arguments abhängig. Es gibt also bei Binärzahlen nur 2k verschiedene Quadratzahlen, im Gegensatz zu 22k möglichen Produkten bei der Multiplikation. Bei einem 4-Bit-Quadrierer genügt beispielsweise eine Tabelle mit 16 Einträgen, um alle Resultate zu speichern. Werden die 4-Bit-Argumente als 4-Bit-Adressen interpretiert und ist an der damit adressierten Speicherstelle einer LUT der Tabellenwert des Resultats gespeichert, erfüllt diese LUT die Funktion des Quadrierers. In Abbildung 6.3 ist auf der rechten Seite die Implementierung des 4-Bit-Quadrierers nach dieser Methode gezeigt und man erkennt, dass sich die gleiche Menge an Ressourcen wie für den auf Multiplizier-Addier-Elementen basierenden Quadrierer ergibt (eine 1-Bit-16-Adress-LUT benötigt genauso wie ein 1-Bit-Mult-Add-Element 1/2 Slice des Virtex-II-FPGAs). Diese Variante, einen Quadrierer für 4-Bit-Zahlen zu bauen, ist in diesem Fall die bevorzugte, da sich für die FPGA-Implementierung eine Logikverzögerung ergibt, die der einer einzigen LUT entspricht und deshalb extrem kurz ist. Größere Quadrierer werden nach der Divide-And-Conquer-Methode aus kleineren Quadrierern und Array-Multiplizierern über einen anschließenden Addiererbaum zusammengesetzt, ähnlich wie beim Aufbau größerer Multiplizierer, jedoch mit der Maßgabe, den Anteil der ArrayMultiplizierer zu minimieren. Dies führt zu einer relativ komplexen Implementierung solcher Operatoren. Abbildung 6.4 zeigt als Beispiel den Aufbau eines Quadrierers für 16-Bit-Binärzahlen. Der sich ergebende Ressourcenverbrauch, die Geschwindigkeit und die Latenz sind für verschiedene Breiten der Operanden in Tabelle 6.4 aufgestellt. 6.1.3 Division Die Division wurde in dieser Arbeit basierend auf der in Abschnitt 4.1.4 erläuterten Non-RestoringMethode implementiert. Gegenüber der dort ebenfalls erwähnten Non-Performing-Methode zeichnet sich dieser Algorithmus dadurch aus, dass anstatt des Aufbaus aus Multiplexern und Addierern bei einer parallelen Implementierung lediglich Stufen von Addier-Subtrahier-Elementen 119 6.1. FESTKOMMAARITHMETIK AUF FPGAS LUT4 z 7 LUT4 z 6 LUT4 z 5 3 LUT4 z 4 2 LUT3 z 3 1 LUT2 z 2 z7 x 3 & x 2 0 & x + z & + z & + z 6 5 x + + z 4 x 3 x 1 & x & + z2 z 1 z 0 0 0 x 0 0 z1 z 0 Abbildung 6.3: Schaltungsvarianten zur Quadrierung einer 4-Bit-Zahl. Links mit MultiplizierAddier-Primitiven, rechts mit Look-Up-Tables. x 4 4 Square 4 4 Square 4 4 Square 4 Square 4 11 4 4 4 Mult 4x4 Mult 4x4 000 000 + 11 4 11 5 Mult 8x4 16 0000000 + Mult 8x4 5 11 + 7 + 4 z Abbildung 6.4: Quadriererschaltung für 16-Bit-Integer-Zahlen aus kleinen Quadrierern und Array-Multiplizierern zur Berechnung der Partialprodukte. 120 KAPITEL 6. IMPLEMENTIERUNG DER ARITHMETIK Breite Register 4 0 8 15 12 64 16 84 20 119 24 160 LUTs 6 45 89 177 262 328 Geschwindigkeit/MHz 355 124 136 124 124 98.3 Latenz 0 1 2 2 2 3 Tabelle 6.4: Ressourcenverbrauch, Geschwindigkeit und Latenz von Integer-Quadrierern bei Virtex-II-FPGA XC2V3000-4 nach Synthese mit Synplify. notwendig werden. Wie in Abschnitt 3.1.2 gezeigt (siehe inbesondere Abbildung 3.5), ermöglicht der Virtex-II-FPGA die Implementierung eines 1-Bit-Addierer/Subtrahierer-Elements in einem halben Slice, während ein 1-Bit-Multiplexer und Addierer den doppelten Ressourcenaufwand benötigen. Die Gründe, warum die SRT-Divisionsmethode nicht verwendet wurde, wurden bereits bei der Vorstellung des Verfahrens in Abschnitt 4.1.4 diskutiert. Die Non-Restoring-Methode für Festkommazahlen soll nun in etwas modifizierter Form aufgestellt werden, da wir hier daran interessiert sind, Dividenden, Divisoren und Quotienten mit gleicher Breite der Fixpunktdarstellung zu verwenden. Dazu nehmen wir an, dass der Dividend e (engl. enumerator), der Divisor d und der Quotient q binäre Festkommazahlen mit einer Vorkommastelle und l Nachkommastellen sind: e = e0 .e−1 · · · e−l d = d0 .d−1 · · · d−l q = q0 .q−1 · · · q−l . Durch eine Kommaverschiebung in davon abweichend dargestellten Festkommazahlen e und d kann diese Form in jedem Fall erreicht werden (z.B. bei nach Gleichung 4.27 dargestellten Zahlen um k − 1 Stellen). Die Größe des Quotienten ist von dieser Verschiebung unabhängig, solange e und d um die gleiche Anzahl von Stellen verschoben werden. Das Resultat q kann nicht mehr mit einer Vorkommastelle dargestellt werden, wenn die Bedingung e ≥ 2d zutrifft – es liegt dann also ein Überlauf vor. Deshalb muss gelten: e < 2d. (6.6) Die Iterationsformel für die Non-Restoring-Methode der Division ergibt sich nun ensprechend 121 6.1. FESTKOMMAARITHMETIK AUF FPGAS Gleichung 4.14 wie folgt: s(0) = e ( s(i) = ( q1−i = 2 · s(i−1) − 2 · d : s(i−1) ≥ 0 2 · s(i−1) + 2 · d : s(i−1) < 0 1 : s(i) ≥ 0 0 : s(i) < 0 (6.7) i = 1 . . . (l + 1). Die Bedingung 6.6 garantiert, dass auch |s(i) | < 2d gilt, was man wie folgt induktiv schließen kann: s(0) = e < 2d Für s(i) ≥ 0, |s(i) | < 2d ⇒ s(i+1) = 2|{z} s(i) −2 d < 2d (i) Für s (i) (i+1) < 0, |s | < 2d ⇒ s 2 <4d (i) = |{z} 2 s +2 d > −2d >−4d Die Beziehung |s(i) | < 2d impliziert, dass s(i) dargestellt werden kann durch die Festkommare(i) (i) (i) (i) präsentation (±s1 s0 .s−1 · · · s−l ). Wird der Restwert der Division benötigt, wird bei negativem Wert von s(l+1) eine Korrekturaddition notwendig: ( 2−(l+1) s(l+1) : s(l+1) ≥ 0 rem = (6.8) 2−(l+1) (s(l+1) + 2 · d) : s(l+1) < 0 Dies entspricht dem Übergang von der Non-Restoring-Methode zur Restoring-Methode der Division im letzten Iterationsschritt. Abbildung 6.5 zeigt die Implementierung eines Dividierers für 4-Bit-Festkommazahlen nach diesem Schema, einschließlich der Erzeugung des Restwertes rem. Man beachte, dass es in den Stufen zur Erzeugung von q−1 . . . q−3 nicht notwendig ist, die Vorzeichenbits von s(i) zu verarbeiten. Der Grund dafür ist, dass in jeder Stufe zwei Binärzahlen unterschiedlichen Vorzeichens addiert werden. Ein Carry-Out aus dem Addierer mit Wertigkeit 21 würde zu einem Vorzeichenbit identisch Null führen, und zeigt damit bereits ein positives Ergebnis an. Die Einführung von Pipeline-Registern zur Reduzierung der Logiklaufzeiten kann bei einem solchen Array-Dividierer sehr einfach durch Einfügen solcher Register zwischen die AddierSubtrahier-Elemente geschehen. Die Pipeline-Register für die Ergebnisse der Addier-SubtrahierStufen können effizient in die gleichen Logikelemente für diese arithmetischen Funktionsblöcke gepackt werden und führen deshalb zu keinem erhöhten FPGA-Flächenverbrauch. Dagegen sind die Register, die für die Weiterleitung des Divisors gebraucht werden, nicht mit vorausgehenden 122 KAPITEL 6. IMPLEMENTIERUNG DER ARITHMETIK q0 q -1 q -1 0 q-2 q -2 +/- 0 q -3 +/- 0 +/- e0 - +/- +/- +/- d0 e-1 - +/- +/- +/- & d -1 e -2 - +/- +/- +/+/- d -2 e -3 d -3 0 q 0 0 +/add q -1 0 +/add q -2 + rem-3 + rem-4 & + rem-5 & + rem-6 & add Abbildung 6.5: Dividiererschaltung für 4-Bit-Festkommazahlen mit Addier-SubtrahierPrimitiven (graue Blöcke), q = e/d, rem = e − q · d. Logikblöcken verbunden und benötigen zu deren Implementierung deshalb zusätzliche Logikelemente. Im Fall der Multiplizierer wurde das bei den Array-Multiplizierern in gleicher Weise bestehende Problem, eine ressourceneffiziente Pipeline aufzubauen, dadurch gelöst, dass nur kleine Array-Multiplizierer für die Partialprodukte verwendet und diese über einen Addiererbaum reduziert wurden. Dieser Ansatz ist bei der Division nicht möglich, da die iterative Berechnung des Quotienten nicht wie bei der Multiplikation in mehrere nebenläufig lösbare Teilprobleme (dort war dies die Bestimmung der Partialprodukte) zerlegt werden kann. Trotz ähnlichen Umfangs im Ressourcenverbrauch an arithmetischen Logikbausteinen benötigen deshalb Dividierer wesentlich mehr Logikelemente des FPGAs als Multiplizierer gleicher Operandenbreite. Der Ressourcenverbrauch und die Geschwindigkeit der so erzeugten Dividierer für einen Virtex-II-FPGA, abhängig von der Breite der Festkommazahlen und der Pipelinetiefe, ist in Tabelle 6.5 aufgestellt. Die Pipelinetiefe ist als Anzahl von Quotientenbits pro Pipelinestufe angegeben und entspricht damit der Anzahl von Addier-Subtrahier-Stufen zwischen zwei Registern. Es ist zu sehen, dass sich für den Fall von Registern nach jeweils zwei Stufen bei akzeptabler Geschwindigkeit ein gutes Verhältnis von Registern zu LUTs ergibt2 . Durch noch tieferes Pipelining kann zwar die Geschwindigkeit deutlich erhöht werden, der Ressourcenverbrauch wird jedoch aufgrund der hohen Zahl von Registern etwa verdoppelt. 2 Es sei hier daran erinnert, dass es im FPGA gleich viele 1-Bit-Register und LUTs gibt. 123 6.1. FESTKOMMAARITHMETIK AUF FPGAS Breite 4 4 4 8 8 8 12 12 12 16 16 16 20 20 20 24 24 24 Quotientenbits pro Pipelinestufe 4 2 1 4 2 1 4 2 1 4 2 1 4 2 1 4 2 1 Register LUTs Geschwindigkeit/MHz Latenz 4 15 36 8 65 130 74 143 290 133 153 514 196 395 807 281 569 1157 25 26 26 73 76 79 158 164 167 278 284 287 430 436 441 614 620 630 67.0 98.9 160.8 51.5 91.7 151.2 47.2 85.2 142.7 45.2 80.2 135.8 41.7 76.2 130.0 36.6 72.7 125.0 1 2 4 2 4 8 3 6 12 4 8 16 5 10 15 6 12 24 Tabelle 6.5: Ressourcenverbrauch und Geschwindigkeit von Festkomma-Dividierern bei VirtexII-FPGA XC2V3000-4 ohne Erzeugung des Divisionsrestes. 124 6.1.4 KAPITEL 6. IMPLEMENTIERUNG DER ARITHMETIK Quadratwurzel Wie in Abschnitt 4.1.5 herausgestellt wurde, kann die Quadratwurzel nach ähnlichen Schemata wie die Division berechnet werden. Von den verschiedenen Verfahren wurde aus gleichen Gründen wie bei der Division die Non-Restoring-Methode ausgewählt. Es soll nun auch hier von einem Festkommaoperanden, nun x genannt, mit einer Vorkommastelle und l Nachkommastellen √ ausgegangen werden (x = x0 .x−1 · · · x−l ). Dann kann die iterative Lösungsmethode für q = x ähnlich wie Gleichung 4.26 auf folgende Weise aufgestellt werden: s(0) = x 2−1 q(0) = 0 4s(i−1) − 4q(i−1) + (0 1)2 : s(i) = 4s(i−1) + 4q(i−1) + (1 1)2 : ( 1 : s(i) ≥ 0 q1−i = 0 : s(i) < 0. s(i−1) ≥ 0 s(i−1) < 0 (6.9) q(i) = 0 · · · 0 q0 · · · q1−i q = q(l+1) · 2−l = q0 .q−1 · · · q−l Äquivalent dazu ist folgende Formulierung, welche die Verarbeitung der Daten etwas anschaulicher ausdrückt: s(0) = 0 s(1) = ((x0 x−1 )2 − (0 1)2 ) ( 1 : s(1) ≥ 0 q(1) = 0 : s(1) < 0 ( (s(1) x−2 x−3 )2 − (q(1) 0 1)2 : s(1) ≥ 0 (2) s = (s(1) x−2 x−3 )2 + (q(1) 1 1)2 : s(1) < 0 ( (q(1) 1)2 : s(2) ≥ 0 q(2) = (q(1) 0)2 : s(2) < 0 ( (s(i−1) x−2i+2 x−2i+1 )2 − (q(i−1) 0 1)2 : s(i−1) ≥ 0 s(i) = (s(i−1) x−2i+2 x−2i+1 )2 + (q(i−1) 1 1)2 : s(i−1) < 0 ( (q(i−1) 1)2 : s(i) ≥ 0 (i) q = (q(i−1) 0)2 : s(i) < 0 i = 3 . . . (l + 1) q = q(l+1) · 2−l (6.10) 125 6.1. FESTKOMMAARITHMETIK AUF FPGAS q x 0 x-1 x-2 q -1 0 0 - 1 - 0 q q x-3 0 0 1 q 0 q q -2 -3 +/+/+/+/add 0 q 0 q -1 +/+/+/- 0 q -1 +/- 0 1 +/- q -1 add 0 q0 q -1 q -2 +/+/+/+/- 0 q -2 +/- 0 1 +/- q -2 add Abbildung 6.6: Schaltung zur Berechnung der Quadratwurzel für 4-Bit-Festkommazahlen mit √ Addier-Subtrahier-Primitiven (graue Blöcke), q = x. Abbildung 6.6 zeigt die parallele Implementierung eines Quadratwurzel-Operators für 4-BitZahlen nach diesem Verfahren. Der Ressourcenverbrauch und die Geschwindigkeit der so erzeugten Quadratwurzel-Operatoren für einen Virtex-II-FPGA abhängig von der Breite der Festkommazahlen und der Pipelinetiefe ist in Tabelle 6.6 aufgestellt3 . Die Pipelinetiefe ist wie bei den Dividiererschaltungen als Anzahl von Ergebnisbits pro Pipelinestufe angegeben und entspricht damit der Anzahl von Addierer/Subtrahierer-Stufen zwischen zwei Registern. Die Geschwindigkeiten sind geringfügig höher als bei den Dividierern. Der Ressourcenverbrauch entspricht etwa 70% des Aufwandes für einen Dividierer gleicher Breite und liegt sogar deutlich unter dem Aufwand für die Multiplizierer (ohne Block-Multiplizierer). Der Bedarf an LUTs entspricht etwa dem Aufwand für die Quadrierer. 3 Für die erzeugten Operatoren wurde vorausgesetzt, dass eines der führenden beiden Operandenbits den Wert Eins hat, was bei der Verwendung innerhalb eines Gleitkommaoperators immer der Fall ist, wie weiter unten gezeigt wird. Dies führt zu einer Ressourcenersparnis von mehreren LUTs. 126 KAPITEL 6. IMPLEMENTIERUNG DER ARITHMETIK Breite 4 4 4 8 8 8 12 12 12 16 16 16 20 20 20 24 24 24 Ergebnisbits Register pro Pipelinestufe 4 0 2 9 1 12 4 18 2 39 1 67 4 42 2 89 1 155 4 77 2 159 1 271 4 123 2 243 1 419 4 177 2 339 1 599 LUTs Geschwindigkeit/MHz 16 15 14 52 53 53 107 107 109 177 177 183 263 265 273 365 371 379 102 177 186 69 106 172 52.7 92.2 162 49.9 86.6 153 47.0 82.0 146 44.5 78.1 140 Latenz 0 2 4 2 4 8 3 6 12 4 8 16 5 10 20 6 12 24 Tabelle 6.6: Ressourcenverbrauch und Geschwindigkeit von Implementierungen des Quadratwurzel-Operators für Festkommazahlen bei Virtex-II-FPGA XC2V3000-4. 6.2. GLEITKOMMAARITHMETIK AUF FPGAS 6.2 127 Gleitkommaarithmetik auf FPGAs In dieser Arbeit wird für alle Operanden davon ausgegangen, dass sie normale Zahlen sind, was insbesondere bedeutet, dass deren führendes Mantissebit stets den Wert Eins hat. Wie in Abschnitt 4.3.1 in Tabelle 4.1 illustriert, erlaubt der ANSI/IEEE-754-Standard für Gleitkommazahlen neben der Darstellung normaler Zahlen auch die Spezialfälle ±∞, Null und NaN (Not a Number). Zugunsten einfacherer Schaltungen wird auf die Spezialfälle verzichtet, da sie für die Auswertung der SPH-Formeln in Simulationsberechnungen keine Bedeutung haben. Es wird also insbesondere auch auf die Darstellung und Verarbeitung von Nullen verzichtet, was keine Einschränkung für die Genauigkeit der zu berechnenden Formeln bedeutet. Tritt bei den Berechnungen ein Wert identisch Null auf, wird statt einer Null die kleinste darstellbare Zahl propagiert. Die physikalisch relevanten Rechenergebnisse (z.B. Dichte, Beschleunigung) werden dadurch in keiner Weise verfälscht. Im Verlaufe dieses Abschnitts wird detailliert auf die Umsetzung der Gleitkommaoperatoren Addition, Multiplikation, Division und Quadratwurzel auf FPGAs eingegangen. Kern der Implementierungen werden die Festkommaoperatoren sein, wie sie in Abschnitt 6.1 dargestellt wurden. Eine allgemeine Darstellung der Verarbeitung von Gleitkommazahlen wurde in Abschnitt 4.3.3 bereits gegeben. Aufbauend auf diesen Grundlagen werden die Schaltungstechniken zur Implementierung auf FPGAs konkretisiert. Die Implementierungen werden darüber hinaus abhängig von verschiedenen Randbedingungen an die Schaltungen spezialisiert, sodass die FPGA-Ressourcen möglichst effizient eingesetzt werden. Die allen implementierten Operatoren gemeinsame Strategie zur Behandlung von Ausnahmen wird im folgenden Abschnitt diskutiert. In den weiteren Abschnitten zur Implementierung der Operatoren wird die Ausnahmebehandlung dann nicht weiter berücksichtigt, denn es wird davon ausgegangen, dass die Verarbeitungseinheiten so gestaltet sind (insbesondere durch interne Verbreiterung der Exponenten, s.u.), dass in den Rechenwerken keine Ausnahmen entstehen und erst in den Pack-Modulen die Ausnahmebehandlung erfolgen muss. 6.2.1 Behandlung von Ausnahmen Aufgrund der Beschränkung der Operanden auf normale Zahlen reduziert sich die Ausnahmebehandlung für die Gleitkommaoperatoren auf die Erkennung von Overflow- und UnderflowBedingungen, die sich aus der Verarbeitung der Exponenten ergeben. Auf die Erfassung der Overflow-Situationen wird verzichtet, da der Algorithmus so eingestellt ist, dass keine Überläufe auftreten4 . Es bleibt also die Behandlung der Underflow-Situationen. Bei der Quadratwurzel können keine Underflow-Ausnahmen auftreten. Bei den übrigen Grundoperationen kommen diese Ausnahmen dagegen relativ häufig vor und können unbehandelt extreme Rechenfehler hervorbringen. Die Rechenwerke können gegen Underflows während der Exponentenverarbeitung abgesichert werden, wenn die Exponenten e zuvor um ein Bit erweitert werden zu ê. Die Erweiterung geschieht mit Berücksichtigung des neuen Bias-Wertes bias0 für den breiteren Exponenten. 4 Dies ist bereits bei der Softwareimplementierung, auf der diese Arbeit aufsetzt, eine zwingende Voraussetzung für das Funktionieren des Algorithmus. 128 KAPITEL 6. IMPLEMENTIERUNG DER ARITHMETIK Ist die Breite vor der Erweiterung E Bit und danach Ê = E + 1 Bit, ergibt sich: ê = e − bias + bias0 = e − (2E−1 − 1) + 2Ê−1 − 1 = e + 2E−1 . Die Addition braucht nicht durchgeführt zu werden, denn das Bit [Ê − 1] von ê kann einfach auf den Wert von Bit [E − 1] von e gesetzt werden, das Bit [Ê − 2] auf das Inverse davon; die übrigen Bits entsprechen den Bits von e. Umgekehrt kann eine Verkürzung des Exponenten um ein Bit ausgeführt werden, indem das MSB weggelassen und das Bit [E − 1] invertiert wird. Die Underflow-Bedingung liegt vor, wenn beide führenden Bits des zu verkürzenden Exponenten identisch Null sind (sind diese Bits identisch Eins, liegt ein Überlauf vor). Denn es gibt keinen kürzeren Exponenten, der durch eine Erweiterung um ein Bit in diesen Zustand kommen könnte. Diese Verkürzung der Exponenten auf die ursprüngliche Breite mit Abfangen der Ausnahmen geschieht wie bereits erwähnt in der Pack-Einheit der Operatoren und wird im Folgenden stets implizit angenommen. 6.2.2 Implementierung von Gleitkomma-Addierern auf FPGAs Die Gleitkomma-Addierer sind die komplexesten Operatoren, die in dieser Arbeit behandelt werden. Während der Kern der Operation - die Addition von Festkommazahlen - sehr leicht und effizient in FPGAs umgesetzt werden kann, wie wir in 6.1.1 gesehen haben, ist die Preparationund Normalization-Stufe des Operators sehr aufwändig. Wie in Abschnitt 4.3.3 deutlich wurde, sind dazu Verschiebungen von Festkommazahlen um eine variable Anzahl von Stellen notwendig (siehe dazu insbesondere Gleichung 4.36). Wie solche Shift-Operationen implementiert werden, zeigt der folgende Abschnitt. Im daran anschließenden Abschnitt wird kurz auf die für die Normalisierung benötigten Elemente zur Bestimmung der Anzahl aufeinanderfolgender Nullen oder Einsen eingegangen. Daran anschließend folgt die detaillierte Diskussion verschiedener Spezialisierungen von Gleitkomma-Addierern. Die Motivation dazu besteht darin, dass durch die Spezialisierung eine Reduzierung des Ressourcenverbrauchs erreicht werden kann. So reicht es in manchen Fällen aus, Additionen ohne Berücksichtigung von Vorzeichen durchzuführen, beispielsweise wenn Quadrate summiert werden sollen. Zuerst wird die reine Addition von vorzeichenfreien Zahlen beschrieben. Dann wird auf den allgemeinen Fall der Addition von Zahlen mit Vorzeichen eingegangen. Schließlich wird noch ausführlich die Umsetzung von Akkumulatoren für Gleitkommazahlen diskutiert, welche elementare Bausteine für die in dieser Arbeit betrachteten Algorithmen sind. Innerhalb der Abschnitte wird auf weitere Spezialisierungsmöglichkeiten eingegangen, insbesondere die Implementierung der Rundungsmodi. Shift-Elemente In diesem Abschnitt wird nun die Implementierung von Verschiebungsbausteinen beschrieben, wie sie für Gleitkomma-Addierer benötigt werden. Die wichtigste Eigenschaft, die diese Elemente erfüllen müssen, ist, einen Bitvektor um eine variable Zahl von Stellen verschieben zu 6.2. GLEITKOMMAARITHMETIK AUF FPGAS 129 können. Dazu kommt eine weitere Eigenschaft, die im Zusammenhang mit dem Runden des Resultats der Addition erforderlich wird. Wie später eingehend beschrieben wird, benötigt die Rundungseinheit im Fall des Standard-Rundungsmodus die Information, ob an irgendeiner vorhergehenden Stelle der Schaltung Bits ungleich Null vernachlässigt wurden. Deshalb müssen die Verschiebungsbausteine registrieren, ob durch die Shift-Operation Bits verloren gehen. Das Flag, welches einen solchen Verlust von Bits anzeigt, wird im Folgenden entsprechend dem im Englischen gebräuchlichen Begriff Sticky-Bit genannt. Das übliche Verfahren, ein Shift-Modul für eine variable Zahl von Verschiebungen aufzubauen, basiert auf der Idee, eine Kaskade von Multiplexern aufzubauen, die in Stufe i ∈ [0, n − 1] eine wahlweise Verschiebung um 2i Stellen erlauben. Bei n Stufen ergibt sich eine maximale Verschiebung um 2n − 1 Stellen. Die Anzahl der Multiplexerstufen skaliert logarithmisch mit der maximalen Verschiebung, wobei sich die Breite dieser Stufen linear zu der Breite der zu verschiebenden Bitvektoren verhält. Mit der Breite k der Bitvektoren skaliert der Ressourcenverbrauch an Multiplexern also mit kdlog2 ke. Zur Erzeugung des Sticky-Bits kann bei einem solchen Aufbau eine sehr einfache Schaltung verwendet werden. Alle Signale, die in einer Stufe jenseits des LSBs verschoben werden könnten (2i Stück), müssen nur mit einer ODER-Verknüpfung versehen und im Fall der Verschiebung mit dem Sticky-Bit aus einer eventuell vorhergehenden Stufe (für i ≥ 1) über ein ODER-Gatter verknüpft werden. Falls in Stufe i keine Verschiebung erfolgt, wird lediglich das frühere Sticky-Bit weitergeleitet. Abbildung 6.7 zeigt eine solche Schaltung für die Verschiebung einer 32-Bit-Zahl x um bis zu 31 Stellen (Verschiebungsweite s) mit Ergebnis y und Sticky-Bit t. Soll die Schaltung zusätzlich die Möglichkeit bieten, veranlasst durch ein Signal zeroOut alle Ausgangsbits auf Null zu setzten, lässt sich dies ohne zusätzlichen Aufwand an FPGA-Ressourcen erreichen. Dazu können die Multiplexer der letzten Stufe ersetzt werden durch LUTs, welche das Multiplexer-Signal noch mit zeroOut über ein UND-Gatter verknüpfen. Da die LUTs für die 2-auf-1-Multiplexer noch einen Eingang frei haben, lässt sich dort zeroOut eingeben und in den LUTs das gewünschte Verhalten programmieren. Soll bei zeroOut = 1 ein korrektes Sticky-Bit erzeugt werden, müssen die Signale s0 bis s4 auf Eins geschaltet sein und t ist bei der vorliegenden Schaltung zusätzlich mit x31 über ein ODER-Gatter zu verknüpfen. Es sei hier bereits erwähnt, dass für die GleitkommaAddierer der Wert des Sticky-Bits für zeroOut = 1 unerheblich ist, da in einem solchen Fall das Rundungsbit nach der Addition in jedem Fall Null ist. Die Implementierung der Verschiebeelemente geschah durch verhaltensmäßige Beschreibung der Schaltungsstruktur entsprechend Abbildung 6.7, um dem Synthesewerkzeug Optimierungsmöglichkeiten zu bieten. Tabelle 6.7 zeigt den sich ergebenden Ressourcenverbrauch für Shift-Elemente verschiedener Breite, sowohl mit Sticky-Bit-Generierung als auch ohne. Es wird deutlich, dass ein Verschiebebaustein bereits mehr FPGA-Ressourcen benötigt, als ein Addierer gleicher Breite. Die Geschwindigkeit kann im Bedarfsfall leicht durch Einfügen von PipelineRegistern annähernd ohne Vergrößerung des Flächenverbrauchs erhöht werden. Deshalb sind Shift-Elemente für die Addierer nicht geschwindigkeitslimitierend. 130 KAPITEL 6. IMPLEMENTIERUNG DER ARITHMETIK x31 s0 s1 x1x0 0 0 00 >=1 0 >=1 s2 0000 >=1 0 >=1 s3 00000000 >=1 0 >=1 0000000000000000 s4 >=1 0 >=1 y31 y1 y0 t Abbildung 6.7: Schaltung zur Verschiebung eines 32-Bit-Vektors x um Null bis 31 Stellen nach rechts. Das Signal t zeigt an, ob ein Bit ungleich Null herausgeschoben wurde (Sticky-Bit). kein Sticky-Bit Breite LUTs Geschwindigkeit/MHz 8 20 199 10 30 174 12 39 161 14 48 157 16 55 151 18 73 139 20 83 136 22 96 134 24 106 133 26 117 132 LUTs 26 43 51 60 67 98 107 120 127 139 mit Sticky-Bit Geschwindigkeit/MHz 172 141 141 125 136 105 105 105 105 106 Tabelle 6.7: Ressourcenverbrauch und Geschwindigkeit von Shift-Bausteinen ohne und mit Erzeugung des Sticky-Bits bei Virtex-II-FPGA XC2V3000-4. 131 6.2. GLEITKOMMAARITHMETIK AUF FPGAS Zählen von Nullen Breite LUTs Geschwindigkeit/MHz 16 23 211 20 24 188 24 32 188 28 41 162 32 50 162 36 60 162 40 67 162 Nullen oder Einsen LUTs Geschwindigkeit/MHz 39 165 35 150 47 164 58 175 75 150 81 139 105 126 Tabelle 6.8: Ressourcenverbrauch und Geschwindigkeit von Bausteinen zum Zählen führender Nullen oder selektiver Zählung von Nullen und Einsen bei Virtex-II-FPGA XC2V3000-4. Zählen führender Nullen oder Einsen Sind bei einem Gleitkomma-Addierer die Vorzeichen der Summanden unterschiedlich, so werden die zuvor aufeinander ausgerichteten Mantissen subtrahiert. Dadurch kann es zur Auslöschung von Bits kommen, wie bereits in Abschnitt 4.3.3 beschrieben. Diese Auslöschung äußert sich bei positivem Ergebnis der Subtraktion in einer Reihe führender Nullen. Ist das Ergebnis negativ, tritt dagegen eine Reihe führender Einsen auf. Die Anzahl dieser führenden Bits mit gleichem Wert ist zu zählen, um die Weite der bei der Normalisierung erforderlichen Verschiebung nach links festzustellen. Die Module, die diese Aufgabe erfüllen, wurden in VHDL verhaltensmäßig beschrieben, wobei die Beschreibung bezüglich des Synthesewerkzeuges so weit optimiert wurde, dass die Implementierung vergleichbar effizient wie bei einer handoptimierten strukturellen Implementierung wurde. Tabelle 6.8 zeigt die erzielten Ergebnisse. Es wird deutlich, dass die Zählschaltung für führende Nullen bereits etwa 1.5-mal so viele FPGA-Ressourcen erfordert wie ein Addierer für Bitvektoren gleicher Breite. Sollen neben Nullen auch Einsen gezählt werden können, erhöht sich der Ressourcenverbrauch noch einmal um etwa 50 %. Addition vorzeichenloser Zahlen Dieser und die folgenden Abschnitte zur Implementierung von Addiererschaltungen sind wie der Grundlagenabschnitt 4.3.3 zu Gleitkomma-Addierern gegliedert in Preparation, Operation und Normalization. Dies soll es erleichtern, die Gemeinsamkeiten und Unterschiede der Implementierungen darzustellen. Die Addition von vorzeichenlosen Zahlen unterscheidet sich vom allgemeinen Fall vor allem dadurch, dass im Festkomma-Addierer der Operation-Stufe keine Auslöschung von führenden Bits mit einhergehendem Verlust an Genauigkeit des Ergebnisses stattfinden kann. Für den Ressourcenverbrauch der Implementierung bedeutet dies insbesondere, dass das aufwändige ShiftModul der Normalisierung entfallen kann. Zur Erinnerung der Nomenklatur sei hier anlehnend an Gleichung 4.36 aus Abschnitt 4.3.3 132 KAPITEL 6. IMPLEMENTIERUNG DER ARITHMETIK die Formulierung der Addition positiver Gleitkommazahlen gegeben: A B A+B }| }| z z }| { { z { e1 −bias e2 −bias esum −bias + s2 2 ssum 2 = s1 2 = s1 + s2 2e2 −e1 2e1 −bias . {z } | Festkomma-Operator → sadd (6.11) Preparation Die Unpack-Stufe aus Abbildung 4.21 ist bei allen Gleitkommaoperationen identisch und soll an dieser Stelle nur einmal kurz beschrieben werden. Einzige Aufgabe dieser Stufe ist, die eingehenden Gleitkommazahl-Operanden, welche hier entsprechend der Nomenklatur von Abschnitt 4.3.1 A = (sA , eA , f A ) und B = (sB , eB , f B ) genannt werden, in Vorzeichen sign(A) und sign(B) (das erübrigt sich hier), Mantissen s1 und s2 und Exponenten e1 und e2 zu zerlegen. Die Exponenten liegen in der Gleitkommadarstellung bereits in Ganzzahldarstellung (Breite E A Bit) mit Bias 2E−1 − 1 vor. Lediglich die als Fraction gegebenen Werte f A = fM−2 . . . f0A und B f B = fM−2 . . . f0B müssen durch Ergänzen eines führenden Bits mit Wert Eins zu den Mantissen s1 und s2 ergänzt werden. Der erste Schritt bei jeder Addition besteht darin, die Differenz e12 = e1 − e2 der Exponenten der eingehenden Operanden festzustellen. Daraus wird die Anzahl d der Stellen, um die eine der Mantissen vor der Festkomma-Addition verschoben werden muss und die Auswahl des vorläufigen Ergebnisexponenten e01 bestimmt. Ist e12 negativ, wird e01 = e2 , ansonsten e01 = e1 gesetzt. Außerdem werden für e12 < 0 die Mantissen vertauscht, damit das Verschiebemodul nur für eine Mantisse implementiert werden muss. Der Wert von d wird dann durch den Betrag von e12 festgelegt. Im Allgemeinen ist die Breite E von |e12 | größer als die Breite von d, welche durch S = dlog2 (M + 1)e gegeben ist (für diese Arbeit wurde S = 5 festgesetzt). Deshalb ist der Wert der Verschiebung durch d = min(2S − 1, |e12 |) zu berechnen. Für den Aufbau einer Schaltung, welche die beschriebene Verarbeitung der Exponenten übernimmt, sind zwei Addierer zur Berechnung der Differenz e12 und des Betrags |e12 | und zusätzliche Logik zur Auswertung der Überlaufbedingung für d erforderlich. Abbildung 6.8 zeigt die Implementierung einer solchen Schaltung5 . Abbildung 6.9 zeigt die Gesamtschaltung eines Gleitkommazahl-Addierers als Blockschaltbild. Im durch das Rechteck Preparation umrandeten Teil ist das Modul Prepare Exponents zu sehen, welches der eben beschriebenen Schaltung entspricht. Das Signal swap weist die Einheit Selective Swap an, die Mantissen zu vertauschen. Dieses Modul besteht lediglich aus zwei Multiplexern. Um Ressourcen zu sparen, wird die Ergänzung der (M − 1)-Bit-Signale f1 und f2 zu den Mantissen erst nach diesem Baustein durchgeführt. Des Weiteren wird ein Rundungsbit an die Mantissen angehängt, sodass Festkommazahlen mit M + 1 Stellen resultieren. Bei der Mantisse, die durch ein Shift-Element verschoben werden kann, wird das führende Bit nur dann als Eins 5 Genauso hätte die Bildung des 2er-Komplements über einen Addier-Subtrahier-Baustein geschehen können, mit einfacherer Feststellung des Überlaufs und Maximierung von d im Fall des Überlaufs durch ODER-Gatter. Diese Variante würde jedoch zu mehr Ressourcenverbrauch führen, da die vorgestellte Implementierung dem Synthesewerkzeug mehr Optimierungsmöglichkeiten bietet. 133 6.2. GLEITKOMMAARITHMETIK AUF FPGAS e1 e2 e12 1'compl 1 cin sign + sign detect overflow >=1 owfl & >=1 1 0 S 0...0 detect overflow + e swap d owfl owfl Abbildung 6.8: Schaltung zur Verarbeitung der Exponenten zur Bestimmung der Verschiebungsweite d und Auswahl des größeren der Exponenten e. Auf der rechten Seite ist die Schaltung zur Bestimmung des Überlaufs owfl bei Reduktion der Signed-Integer-Zahl e12 auf den Betrag dieser Zahl mit reduzierter Breite (Anzahl der Bits rechts vom grauen Balken) abgebildet. 134 KAPITEL 6. IMPLEMENTIERUNG DER ARITHMETIK A B Unpack e1 e2 d owfl e f2 Selective Swap S swap MSB sticky MSB s'1 s'2 round bit Operation e1' bit ShiftN Shifts 1 0 round Preparation Prepare Exponents f1 s add s sum Pack Normalization esum Round & Normalize sticky increment shift Adjust Exponent A+B Abbildung 6.9: Blockschaltbild für einen Gleitkommazahl-Addierer für positive Zahlen. 6.2. GLEITKOMMAARITHMETIK AUF FPGAS 135 ergänzt, wenn von Prepare Exponents kein Überlauf (Flag owfl) von der Verschiebeweite d signalisiert wird. Dadurch kann das im letzten Abschnitt beschriebene zusätzliche Signal zeroOut für das Verschiebemodul selbst für die maximal (für S = 5) erlaubte Mantissenbreite von M = 31 entfallen. Die Preparation-Stufe wird komplettiert durch den Verschiebebaustein ShiftN, welcher den eingehenden (M + 1)-Bit-Vektor um maximal 31 Stellen verschieben kann. Für M = 31 und owfl = 1 ist das resultierende Sticky-Bit aufgrund der Maskierung des MSB zwar nicht korrekt, da das Rundungsbit in diesem Falle aber Null ist, spielt das für das Standardrundungsverfahren keine Rolle. Operation Da die Auswahl des größeren der eingehenden Exponenten bereits in der Preparation-Stufe erledigt wurde, bleibt für die Operation-Stufe nur noch die Addition der Festkommazahlen s01 und s02 . Das Rundungsbit muss nicht in die Addition einbezogen werden. Deshalb genügt ein M-Bit-Addierer mit (M + 1)-Bit-Ergebnis. Es wird ein einfacher Ripple-Carry-Addierer verwendet, der (wie in Abschnitt 6.1.1 diskutiert) für die hier vorliegenden Bitbreiten die effizienteste Implementierungsvariante ist. Normalization Während im Fall der allgemeinen Addition von Gleitkommazahlen nach Formel 4.38 der Betrag des Ergebnisses der Festkommazahladdition im Intervall [0, 4) liegt, bleibt das Additionsresultat sadd für positive Gleitkommazahlen im Intervall [1, 4). Die Normalisierung kann also lediglich eine Verschiebung von sadd um eine Stelle nach rechts erforderlich machen - Linksverschiebungen sind nicht nötig. Ebenso kann nach dem Runden eine Verschiebung um eine Stelle nach rechts notwendig werden, wenn sadd ∈ [1, 2) gilt, durch das Runden jedoch eine Zahl größer oder gleich 2 entsteht. Niemals ist jedoch eine zweimalige Verschiebung notwendig, wovon man sich durch die Betrachtung der Addition der größtmöglichen Mantissen überzeugen kann: smax = sadd,max = smax + smax = 1 snorm,max = norm(sadd,max ) = 0 ssum,max ≤ snorm,max + 12 ulp = 0 + = 0 1. 1 1 . . . 1 1 | |{z} 0 Rundungsbit 1. 1 1 . . . 1 0 | 0 1. 1 1 . . . 1 1 | 0 1. 1 1 . . . 1 1 | 0 0. 0 0 . . . 0 0 | 1 1. 1 1 . . . 1 1 | 1 (6.12) Deshalb können die beiden Normalize-Stufen und die Rundungsstufe aus Abbildung 4.21 zu einer Stufe zusammengefasst werden, die lediglich aus einem Addierer für das Runden, einem nachgeschalteten 2-auf-1-Multiplexer und etwas Logik zur Bestimmung des für das Runden zu addierenden Betrags besteht. Letztere wertet das führende und die letzten zwei Bits von sadd , das Rundungsbit und das Sticky-Bit aus, um festzustellen, ob zu einem der letzten beiden Bits von sadd eine Eins addiert werden muss. Das Sticky-Bit liefert die Information, ob das exakte Additionsresultat über das LSB von sadd hinaus noch Bits ungleich Null hätte. Diese Information wird insbesondere für den Standardrundungsmodus Round To Nearest Even benötigt, da dann an der Schwelle zwischen Auf- und 136 KAPITEL 6. IMPLEMENTIERUNG DER ARITHMETIK sadd round [M,1] MSB S sticky MSB [1] [0] Analyze Rounding 0...0 r1 r0 round bit [1] [0] sticky MSB [M-1,0] 0 1 ssum Analyze Rounding r1 r0 Abbildung 6.10: Schaltung zur Rundung und Normalisierung des Resultats für die Addition von positiven Gleitkommazahlen. Rechts ist die Logik zur Umsetzung des Standard-Rundungsmodus Round To Nearest Even abgebildet. Die gepunkteten Verbindungen werden für die Schaltung nach der linken Abbildung nicht benötigt, erleichtern aber das Verständnis. Abrunden so gerundet wird, dass das LSB der Ergebnismantisse Null wird. Dies macht es erforderlich, zu bestimmen, ob sadd exakt auf der Rundungsschwelle liegt. Dies ist genau dann der Fall, wenn das Rundungsbit identisch Eins ist und alle darüber hinausgehenden Bits des exakten Additionsresultats identisch Null sind. Letztere Information wird gerade durch das Sticky-Bit angezeigt. Die Schaltung zur Rundung und Normalisierung ist in Abbildung 6.10 gezeigt und entspricht dem Block Round & Normalize aus Abbildung 6.9. Das MSB in Abbildung 6.10 zeigt gleichzeitig an, ob der vorläufige Exponent e01 inkrementiert werden muss, um den Exponenten des Resultats esum zu erhalten. Diese Anpassung des Exponenten wird im Block Adjust Exponent aus Abbildung 6.9 durchgeführt. Ressourcenverbrauch und Geschwindigkeit In Tabelle 6.9 sind die Ergebnisse für den Ressourcenverbrauch der Gleitkomma-Addierer für positive Zahlen aufgestellt. Die Ergebnisse sind aufgeschlüsselt bezüglich der Anzahl an 4-Input-LUTs und 1-Bit-Registern nach der Synthese durch Synplify und der Anzahl an Virtex-II-Slices und der maximale Taktfrequenz, bestimmt durch die Implementierung des Designs auf einem Virtex-II-FPGA (XC2V3000, Speed Grade -4). Die im weiteren Verlauf dieses Kapitels angegebenen Zahlen zu Ressourcen wurden auf die gleiche Weise ermittelt. In Abbildung 6.11 ist der Ressourcenverbrauch grafisch in Abhängigkeit von der Breite der Mantisse dargestellt. Man erkennt ein nahezu lineares Ansteigen aller Grö- 137 6.2. GLEITKOMMAARITHMETIK AUF FPGAS Round To Nearest Integer Round To Nearest Even Mantisse Bits LUTs Regs Slices Design Freq. (MHz) Mantisse Bits LUTs Regs Slices Design Freq. (MHz) 12 14 16 18 20 22 24 147 167 187 213 232 253 276 91 103 115 128 140 152 164 81 91 102 116 128 139 152 91 91 88 89 94 90 90 12 14 16 18 20 22 24 157 177 211 230 253 273 296 92 104 117 129 141 153 165 88 99 117 126 141 151 165 89 87 90 87 87 86 81 Tabelle 6.9: Ressourcenverbrauch und Geschwindigkeit von Gleitkomma-Addierern für positive Zahlen bei Virtex-II-FPGA XC2V3000-4. ßen mit der Mantissenbreite. Die zusätzliche logarithmische Komponente der Skalierung, die sich aus der Implementierung der Shifter-Elemente ergibt, ist an dem Sprung an der Anzahl von LUTs zwischen Bitbreite 14 und 16 zu sehen. Die Geschwindigkeit der Operatoren ist durch die Verarbeitung der Exponenten im Modul Prepare Exponents begrenzt. Durch tieferes Pipelining kann die Geschwindigkeit noch stark erhöht werden. Dann werden jedoch auch zusätzliche, nicht mit vorangehenden LUTs gepaarte Registerstufen für die Mantissen notwendig. Dies würde zu einem Anstieg an aufzuwendenden Slices führen. Ohnehin werden die Festkomma-Dividierer und -Quadratwurzeloperatoren, wie in Abschnitt 6.1 gezeigt, die Geschwindigkeit der Gesamtschaltung limitieren. Damit erübrigt sich eine Optimierung durch tieferes Pipelining der Addierer. Addition beliebiger Gleitkommazahlen In Abschnitt 4.3.3 wurden die Verarbeitungsschritte der Gleitkommazahl-Addition anhand folgender Gleichung motiviert: A B A+B z }| z }| }| { z { { esum −bias e1 −bias e2 −bias ±ssum 2 = ±s1 2 + ±s2 2 = ± ±s1 + s2 2e2 −e1 2e1 −bias . | {z } Festkomma-Operator → sadd (6.13) Bezugnehmend auf den letzten Abschnitt wird im Folgenden nun detailliert auf die Hardwareimplementierung dieser Berechnung eingegangen. Preparation Die Vorverarbeitung der Exponenten ist im allgemeinen Fall der Addition von Gleitkommazahlen A und B mit beliebigem Vorzeichen identisch mit dem Verfahren, das im letzten Abschnitt beschrieben wurde und die dort in Abbildung 6.8 gezeigte Schaltung kann 138 KAPITEL 6. IMPLEMENTIERUNG DER ARITHMETIK Addierer für positive Gleitkommazahlen 350 Round to nearest even Elementanzahl 300 Round to nearest integer 250 Register LUTs Slices Register LUTs Slices 200 150 100 50 0 12 14 16 18 20 22 24 Mantissenbreite Abbildung 6.11: Verlauf des Ressourcenverbrauchs für die Gleitkomma-Addierer für positive Zahlen nach Tabelle 6.9. auch hier unverändert übernommen werden. Genau wie dort werden die Mantissen vertauscht, wenn e2 > e1 gilt, damit das Shift-Modul nur für eines der Argumente implementiert werden muss. Hinzu kommt nun jedoch die Verarbeitung der Vorzeichen sign(A) und sign(B) und die Komplementbildung einer der Mantissen, falls die Vorzeichen unterschiedlich sind. Die Komplementbildung wird nur für die Mantisse aufgebaut, die nicht verschoben wird. Deshalb kann als vorläufiges Vorzeichen der Summe das Vorzeichen der in das Verschiebeelement geleiteten Zahl genommen werden. Dieses Vorzeichen soll hier sign02 genannt werden. Die Bildung des Komplements kann ohne zusätzlichen Aufwand an FPGA-Ressourcen als 1er-Komplement im Vertauschungsmodul implementiert werden. Dazu sind lediglich die LUTs für den Multiplexer für s01 mit einem zusätzlichen Eingang compl zu versehen, welcher eine Negierung aller Ausgangssignale veranlasst. Die Addition von Eins zur Bildung des 2er-Komplements kann auf den Additionsvorgang von s01 und s02 verschoben werden. Für ein im Normalization-Schritt durchzuführendes korrektes Runden nach dem StandardVerfahren müssen die Mantissen am niederwertigen Ende um zwei Bits erweitert werden, ein Guard- und ein Round-Bit. Das Sticky-Bit wird ebenfalls benötigt. Die Begründung dafür erfolgt in der Beschreibung zur Normalization-Stufe. Die Erweiterung geschieht für s01 durch Anfügen von Einsen, wenn eine Komplementbildung erfolgte, ansonsten durch Nullen. Wie wir später sehen werden, brauchen Round- und Guard-Bit für s01 nicht weiterverarbeitet zu werden - es erleichtert aber das Verständnis der Schaltung, die Erweiterung anzunehmen. Für s02 werden bereits vor dem Shift-Modul am niederwertigen Ende zwei Nullen angehängt. Da in der nachfolgenden Operation-Stufe Festkommazahlen in Komplementdarstellung verarbeitet werden, müssen die 6.2. GLEITKOMMAARITHMETIK AUF FPGAS 139 Mantissen am höherwertigen Ende um zwei Stellen erweitert werden. Für s02 genügt es, Nullen voranzustellen, für s01 ergeben sich die voranzustellenden Bits aus dem Signal compl, welches die Komplementbildung veranlasst. In Abbildung 6.12 ist die Gesamtschaltung des Gleitkomma-Addierers gezeigt und man vergleiche die gezeigte Preparation-Stufe mit der Schaltung aus Abbildung 6.9. Der Ressourcenverbrauch für die Preparation-Stufe ist nur geringfügig höher als für den Addierer für positive Zahlen. Der Mehrverbrauch entsteht vor allem im Modul ShiftN, da ein um eine Stelle breiterer Bitvektor verschoben werden muss. Operation Diese Stufe wird wie beim Addierer für positive Zahlen durch die Anwendung eines einfachen Ripple-Carry-Addierers als Festkommazahl-Addierer implementiert. Die zusätzliche Addition eines LSB für den Fall, dass s01 eine 1er-Komplement-Zahl ist, wird durch ein Carry-In in den Addierer realisiert. Sowohl Sticky-Bit als auch Guard- und Round-Bit brauchen nicht in die Addition einbezogen zu werden. Diese Bits würde sich durch die Addition nicht verändern, da einerseits für compl = 0 nur Nullen addiert würden, andererseits für compl = 1 die LSBs 111 plus dem Carry-In addiert würden, was durch das Carry-In in den um diese Bits gekürzten Addierer erledigt werden kann. Abhängig vom Vorzeichen der sich nach der Addition ergebenden Festkommazahl in 2erKomplement-Darstellung ist das vorläufige Vorzeichen sign02 zu invertieren. Dies hätte man auch der Normalization-Stufe zuordnen können. Normalization In dieser Stufe ist nun die 2er-Komplement-Festkommazahl sadd (einschließlich Guard-Bit g und Round-Bit r) zu einer normalisierten und korrekt gerundeten Mantisse zu überführen. Wie in Abschnitt 4.3.3 beschrieben, kann die Normalisierung bereits in der 2erKomplement-Darstellung von sadd geschehen. Dies hat den Vorteil, dass der Addierer, der für die Umwandlung von sadd in den Betrag davon benötigt würde, entfallen kann. Die Betragsbildung kann mit der Rundungsschaltung, welche der Normalisierung folgt, verbunden werden. Das führende Bit von sadd entspricht dem Vorzeichen und soll signadd genannt werden. Die Zahl sadd hat dann folgende Darstellung: sadd = signadd y1 y0 .y−1 · · · y−M+1 g r. (6.14) Für sadd gilt, wie bereits in Gleichung 4.38 festgestellt wurde: sadd ∈ (−2, 4) |sadd | ∈ [0, 4). (6.15) Deshalb kann bei positivem sadd eine Rechtsverschiebung um eine Stelle oder unabhängig vom Vorzeichen von sadd eine Linksverschiebung um die volle Breite von sadd erforderlich werden. Für signadd = 0 gibt y1 = 1 eine Rechtsverschiebung um eine Stelle vor. Für y1 = 0 gibt die Anzahl der führenden Nullen in y0 .y−1 · · · y−M+1 g r die Zahl der Stellen an, um die linksverschoben werden muss. Für signadd = 1 sind die führenden Einsen in y0 .y−1 · · · y−M+1 g r zu zählen, um die Weite der Linksverschiebung zu bestimmen. Damit ein Shift-Modul verwendet werden 140 KAPITEL 6. IMPLEMENTIERUNG DER ARITHMETIK A B Unpack e d owfl MSB compl 0 1 00guard round S MSB guard round ShiftN Shifts sign s'2 s add Normalize signsum incr. shift Adjust Exponent Sel. 2's Compl. Round Normalize s sum esum Normalization s norm sticky shifts Adjust Exponent sticky Operation s'1 e1' sign'2 Preparation sign(B) sign(A) e1 e2 f1 f2 Prepare swap Selective Swap S Exponents C Sel. 1's Complement Pack A+B Abbildung 6.12: Blockschaltbild für einen Gleitkommazahl-Addierer für beliebige Gleitkommazahlen. 6.2. GLEITKOMMAARITHMETIK AUF FPGAS 141 kann, das eine Verschiebung in nur eine Richtung durchführt, wird ein leicht abgewandeltes Verfahren angewandt. Die Zahl sadd wird in jedem Fall um eine Stelle rechtsverschoben zur Zahl s0add = signadd y1 .y0 · · · y−M+1 g r, was keinerlei Hardwareressourcen braucht. Danach wird durch die Anzahl der führenden Nullen für signadd = 0 oder Einsen für signadd = 1 in y1 .y0 · · · y−M+1 g r die Weite pShifts der Linksverschiebung bestimmt. Als Resultat der Normalisierung ergibt sich die (M + 2)-Bit-Zahl snorm = signadd y00 .y0−1 · · · y0−M+1 r0 mit dem neuen Rundungsbit r0 , also eine um zwei Bits kürzere Zahl als sadd . Aus den am niederwertigen Ende herausgefallenen Bits und dem alten Sticky-Bit wird über eine ODER-Verknüfung das neue Sticky-Bit gewonnen. Die Detailschaltung der ersten Normalisierungsstufe zeigt Abbildung 6.13. Entsprechend den Verschiebungen der Mantisse bei der Normalisierung muss der vorläufige Exponent e01 angepasst werden. Dazu ist von e01 die Zahl pShifts zu subtrahieren und aufgrund der vorausgegangenen Rechtsverschiebung eine 1 zu addieren. Von der normierten Zahl snorm muss nun der gerundete Betrag gebildet werden. Das Runden geschieht auf ähnliche Weise wie beim Addierer für positive Zahlen. Hier ist zusätzlich noch das 2er-Komplement zur Erzeugung des Betrags notwendig, falls snorm negativ ist. Wird zum Runden anstatt des Addierers ein Addier-Subtrahier-Baustein verwendet, kann diese Komplementbildung ohne weitere Hardwareressourcen gemeinsam mit der Rundungsaddition geschehen. Die Schaltung für das Modul Selective 2’s Complement & Round & Normalize des Addierers ist für das Standardrundungsverfahren in Abbildung 6.14 gezeigt. Die Schaltung Analyze Rounding benötigt wie bei der Addition ohne Vorzeichen nur 2 LUTs des FPGAs. Der Multiplexer zur abschließenden Normalisierung im Fall eines Überlaufs durch das Runden kann hier entfallen. Der Grund dafür ist, dass ein Übertrag auf das Bit mit Wertigkeit 21 nur stattfinden kann, wenn vor der Rundungsaddition alle Bits von der Wertigkeit 20 bis einschließlich des Rundungsbits den Wert Eins und folglich danach alle den Wert Null haben. Das MSB der normierten Mantisse ausgenommen, welches immer Eins ist und deswegen in der Pack-Stufe entfällt, haben die anderen Mantissebits, egal ob um eine Stelle rechtsverschoben oder nicht, bereits den richtigen Wert. Es muss also lediglich anhand des Bits mit der Wertigkeit 21 der Exponent des Ergebnisses korrigiert werden, was durch eine selektive Inkrementierung in der zweiten Adjust-Exponent-Einheit geschieht. Die beiden Adjust-Exponent-Module hätten mit Ersparnis eines Addierers zusammengefasst werden können. Da die Module auf verschiedenen Tiefen in der Pipeline liegen und eine Zusammenlegung deshalb zusätzliche Register erfordert hätte, welche die Ersparnis wieder aufwiegen, wurden sie getrennt implementiert. Ressourcenverbrauch und Geschwindigkeit Die Ergebnisse zum Ressourcenverbrauch für die Addierer in Abhängigkeit von der Mantissenbreite und die erzielte Geschwindigkeit sind in Tabelle 6.10 und in Abbildung 6.15 aufgetragen. Es ergibt sich ein ähnlicher Verlauf wie im Fall des Addierers für positive Zahlen, allerdings auf einem um etwa 70% höheren Niveau. Der logarithmische Anteil der Skalierung der Shifter-Elemente zeigt sich hier bereits am überproportionalen Anstieg der LUT-Anzahl zwischen der Bitbreite 12 und 14, da ein zusätzliches Guard-Bit verschoben werden muss. Für die Geschwindigkeit ergeben sich geringfügig schlechtere Werte als bei den Addierern für vorzeichenlose Zahlen. Auch hier limitiert die Schaltung für die Verarbeitung der Exponenten 142 KAPITEL 6. IMPLEMENTIERUNG DER ARITHMETIK 1 0 sign 2 2 sadd guard M+2 g r round sticky M+3 Leading Zeros/Ones ones 5 shifts ShiftN M+3 [0,1] M+1 snorm sticky Abbildung 6.13: Normalisierung der Mantisse beim Gleitkommazahl-Addierer. sign s norm sticky [M,0] [1] [0] r [M,1] sign [1] [0] sticky Analyze Rounding bothers b0 Selective Complement MSB [M,0] Analyze Rounding [M-1,0] incr. exp. ssum b others b0 Abbildung 6.14: Schaltung zur 2er-Komplement-Bildung und Rundung der Mantisse beim Addierer für beliebige Gleitkommazahlen. Die abschließende Normalisierung beschränkt sich auf die Feststellung einer erforderlichen Inkrementierung des Exponenten (siehe Text). Rechts ist die Logik zur Umsetzung des Standardrundungsmodus Round To Nearest Even abgebildet. 143 6.2. GLEITKOMMAARITHMETIK AUF FPGAS Round To Nearest Integer Round To Nearest Even Mantisse Bits LUTs Regs Slices Design Freq. (MHz) Mantisse Bits LUTs Regs Slices Design Freq. (MHz) 12 14 16 18 20 22 24 232 270 312 339 374 403 437 143 160 177 193 209 225 241 139 158 181 197 214 233 251 83 88 83 85 88 86 85 12 14 16 18 20 22 24 275 318 346 382 419 447 480 157 166 183 198 214 231 247 162 183 199 219 240 257 276 83 85 87 85 78 82 78 Tabelle 6.10: Ressourcenverbrauch und Geschwindigkeit von Gleitkomma-Addierern bei VirtexII-FPGA XC2V3000-4. in der Preparation-Stufe die Geschwindigkeit der Addierer. Durch tieferes Pipelining kann die Geschwindigkeit noch stark erhöht werden, diese Optimierung wurde jedoch aus den gleichen Gründen wie beim Addierer für vorzeichenlose Zahlen nicht durchgeführt. Akkumulation vorzeichenloser Zahlen Die Akkumulation von Gleitkommazahlen, also die Addition aufeinanderfolgender Gleitkommazahlen, ist für die in dieser Arbeit betrachteten Berechnungen stets erforderlich, um die SPHGrößen aus den Einzelbeiträgen von Nachbarteilchen zu gewinnen. Bei der gegebenen DesignStrategie einer Rechen-Pipeline, die pro Takt eine Wechselwirkung berechnet, müssen die Akkumulatoren in der Lage sein, pro Takt eine Akkumulation durchzuführen. Bei der Addition zweier Zahlen hängt das Ergebnis der Operation nur von den beiden Summanden ab. Spielt es keine Rolle, ob das Ergebnis erst nach mehreren Takten erscheint, kann deshalb bei der Implementierung der Operation beliebig tiefes Pipelining angewendet werden. So konnten bei den bisher vorgestellten Implementierungen zur Erhöhung der Taktfrequenz zwischen eingehenden Mantissen und dem Festkommazahl-Addierer zwei Pipelinestufen arbeiten. Bei der Akkumulation von Zahlen verhält es sich grundlegend anders. Hier ist ein neuer Summand zur Summe aller vorangegangenen Summanden zu addieren. Das aktuelle Zwischenergebnis muss also in der Operation-Stufe in dem Moment korrekt ausgerichtet am Festkommaaddierer bereitstehen, wenn dort der neue Summand ansteht. Die Schwierigkeit dabei besteht darin, dass das Resultat der Festkommaaddition abhängig vom neuen Summanden um eine variable Anzahl von Stellen verschoben werden muss. Ein entscheidender Punkt für die Implementierung schneller Akkumulatoren ist, dass die zu den sich gerade in der Festkommaaddiererstufe befindlichen Zahlen gehörenden Exponenten frühzeitig berechnet werden können. Bereits bei Eingang eines neuen Summanden kann aus dessen Exponenten und den Exponenten der vorher eingegangenen Summanden der temporäre Exponent berechnet werden, der aktuell sein wird, wenn die Mantisse des neuen Summanden in der Operation-Stufe angelangt. Deshalb kann die Preparation-Stufe für die eingehenden Operanden durch Pipelinestufen genauso beschleunigt 144 KAPITEL 6. IMPLEMENTIERUNG DER ARITHMETIK Addierer für beliebige Gleitkommazahlen 600 Round to nearest even Elementanzahl 500 Round to nearest integer 400 Register LUTs Slices Register LUTs Slices 300 200 100 0 12 14 16 18 20 22 24 Mantissenbreite Abbildung 6.15: Verlauf des Ressourcenverbrauchs für die Gleitkomma-Addierer nach Tabelle 6.10. werden, wie es bei den Addierern der Fall war. Es bleibt das Problem, dass das Zwischenergebnis der Operation-Stufe um eine variable Zahl von Stellen verschoben werden muss. Der Schlüssel für eine schnelle Implementierung liegt darin, die möglichen Verschiebeweiten einzuschränken, indem nur um ein Vielfaches einer ganzen Zahl P verschoben wird. Dies wird dadurch erreicht, dass intern die Exponenten auf Vielfache von P aufgerundet werden. Um einen Verlust von Rechengenauigkeit aufgrund der vergröberten Verschiebeweiten zu vermeiden, wird die Mantissenbreite am niederwertigen Ende um P − 1 Bits erhöht. Für diese Arbeit wurde P = 8 verwendet, was dazu führt, dass statt eines fünfstufigen Verschiebeelementes nur ein dreistufiges Element erforderlich wurde. Außerdem wurde anstatt eines Ripple-Carry-Addierers ein CarrySave-Addierer verwendet. Damit konnte die Signalverzögerung auf vier Logikstufen begrenzt werden, was zu einer für diese Arbeit ausreichend schnellen Implementierung führt. Nachfolgend werden die drei Verarbeitungsstufen im Detail vorgestellt. Preparation Im ersten Schritt der Preparation-Stufe wird der eingehende Exponente ein im Vergleich zum internen temporären Exponenten et , welcher zur Zwischensumme der OperationStufe gehört, analysiert. Da intern auf einem vergröberten Exponentenbereich gearbeitet wird, ist zuerst ein auf ein Vielfaches von P = 8 aufzurunden. Der Exponent ein liegt zwar in BiasDarstellung vor - das spielt hier jedoch keine Rolle, da für die Verarbeitung bei der Addition nur die relativen Bezüge zwischen den Exponenten wichtig sind. Deshalb wird ein ohne Einschränkung als positive Ganzzahl interpretiert. Das Aufrunden von ein = ein,E−1 · · · ein,0 zu eru = eru,E−1 · · · eru,0 geschieht durch Null-Setzen der Bits [2, 0] und Addition einer Eins zu Bit 6.2. GLEITKOMMAARITHMETIK AUF FPGAS 145 [3], wenn die ODER-Verknüpfung der drei Bits ein,2 · · · ein,0 Eins ergibt. Zur Feststellung der Verschiebungsweite der Mantisse des neuen Summanden sin oder der Mantisse der Zwischensumme st wird die Differenz v = et − eru gebildet. Ist v positiv, muss sin rechtsverschoben werden und zwar um den Betrag d = v + eru − ein . Für v < 0 muss sin dagegen nur um d = eru − ein Stellen rechtsverschoben werden. Im letzteren Fall ist st um |v| Stellen nach rechts zu verschieben. Ist v < 0 wird für die nächste Akkumulation et = eru gesetzt, ansonsten bleibt et unverändert. Abbildung 6.16 zeigt die Umsetzung der Exponentenanalyse als Schaltung. In Abbildung 6.17 wird dieser Teil der Schaltung als Prepare Exponents bezeichnet. Es sind weiterhin der Verschiebebaustein für die Mantisse sin und die beiden Verschiebebausteine für die in Carry-Save-Form vorliegende Zwischensumme ssum gezeigt. Letztere verschieben st um das P-fache der angezeigten Verschiebeweite shi f ts (hier gilt P = 8). Die ursprünglich M Bit breiten Mantissen werden intern in einem erweiterten Format verarbeitet. Zum Ausgleich der Verschiebung durch das Aufrunden der Exponenten auf Vielfache von 8 werden extru = 7 Stellen hinter das LSB angehängt. Zur Erhöhung der Genauigkeit der Akkumulation können weitere Guard-Bits (extLSB ) angehängt werden. Da während der Akkumulation keine Analyse der Zwischensummen auf führende Nullen stattfindet, müssen die Mantissen auch am höherwertigen Ende erweitert werden. Sollen bis zu N Summanden akkumuliert werden, müssen extMSB = dlog2 Ne Bits hinzugefügt werden. Die Flusssteuerung Control sichert das korrekte Arbeiten des Akkumulators, indem für eingangsseitiges valid = 0 die Registerinhalte der Exponentenvorverarbeitung und der verschobenen Mantissen fixiert werden. Durch das Signal f irst getriggert, veranlasst die Steuerung den Reset der Register in Prepare Exponents und unterdrückt die Eingänge B und C des CSA. Das Signal last induziert die Meldung eines fertigen Akkumulationsresultats durch Setzen des ausgangsseitigen valid-Signals. Operation Wie bereits erwähnt, arbeitet der Addierer zur Akkumulation einer neuen Mantisse zur vorherigen Zwischensumme (beide in erweiterter Darstellung mit extMSB + M + extru + extLSB Bits Breite) als Carry-Save-Addierer. Damit wird der Addierer so schnell wie eine einfache LUT des FPGAs, erfordert jedoch doppelt so viele Logikressourcen wie ein Ripple-Carry-Addierer. Zudem liegt das Additionsergebnis st in Carry-Save-Form vor und muss nachfolgend in der Normalization-Stufe durch einen Carry-Propagate-Addierer in eine Binärdarstellung umgewandelt werden. Aufgrund der Verschiebeelemente im Logikpfad des Addierers wurde diese Implementierungsvariante zur Gewährleistung einer hohen Geschwindigkeit notwendig. Normalization Wie in Abbildung 6.17 gezeigt, beginnt die Normalization-Stufe mit der Erzeugung einer Binärzahl für st . Dazu wird ein Ripple-Carry-Addierer verwendet. Die Zwischensumme kann maximal extMSB +extru führende Nullen aufweisen. Die Anzahl führender Null-Bits wird ähnlich wie beim Gleitkommazahl-Addierer gezählt, woraus die Verschiebeweite zur Normierung der Mantisse bestimmt wird. Für die Verschiebung um diese Verschiebeweite müssen nur extMSB + M + extru Bits einbezogen werden. Das führende Bit braucht nicht verschoben zu werden, da das MSB nach der Verschiebung nach Voraussetzung den Wert Eins haben wird, und deshalb ignoriert werden kann. Das letzte Bit ist das niederwertigste Bit, welches durch eine Ver- 146 KAPITEL 6. IMPLEMENTIERUNG DER ARITHMETIK ein first [2,0] [E-1,3] 0...0 001 1'compl + + CE temp Exp et eru [E,3] [2,0] 1'compl sign 1 + cout cin [E] v [3] [E,5] [4,0] >=1 0...0 1'compl + et w 1 cin owfl d Abbildung 6.16: Schaltung zur Vorverarbeitung der Exponenten im Akkumulatorbaustein (Prepare Exponents). Ermittelt wird die erforderliche Verschiebeweite d der eingehenden Mantisse (owfl = 1 zeigt einen Überlauf der Verschiebung an) und die Weite w in Vielfachen von P = 8 der Rechtsverschiebung der Zwischensumme sowie der vorläufige Exponent der Zwischensumme et . 147 6.2. GLEITKOMMAARITHMETIK AUF FPGAS valid first last A Unpack f in e in et w d 0...0 MSB owfl Shifts ShiftN Shift Mult P Preparation Prepare Exponents Shifts A Reset B & C B C CSA Control Operation et st esum Round & Normalize s sum Normalization Shifts shift Adjust Exponent Pack valid S Abbildung 6.17: Blockschaltbild für einen Akkumulator für positive Gleitkommazahlen. Es sind nur die für die Funktion notwendigen Register gezeichnet. Zur Beschleunigung können – mit Ausnahme der Rückkopplungsschleife des CSA – weitere Pipeline-Register eingefügt werden. Die Steuerungssignale sind grau dargestellt. 148 KAPITEL 6. IMPLEMENTIERUNG DER ARITHMETIK positive Zahlen beliebige Zahlen Mantisse Bits LUTs Regs Slices Design Freq. (MHz) Mantisse Bits LUTs Regs Slices Design Freq. (MHz) 12 14 16 18 20 22 24 417 454 497 532 580 619 644 255 275 296 316 337 357 377 236 259 278 298 322 346 356 93 92 91 92 91 91 90 12 14 16 18 20 22 24 483 521 573 617 656 712 742 345 371 397 423 449 475 501 330 355 383 418 437 471 494 95 95 94 95 91 91 95 Tabelle 6.11: Ressourcenverbrauch und Geschwindigkeit von Akkumulatoren für Gleitkommazahlen bei Virtex-II-FPGA XC2V3000-4. schiebung zum Rundungsbit werden kann. Der verschobene Bitvektor soll sn genannt werden. Die Rundung selbst geschieht durch Addition einer Eins zu den führenden M Bits von sn . Eine zweite Normierung nach der Rundung braucht wie beim Addierer nicht durchgeführt zu werden. Ein Überlauf kann nur stattfinden, wenn die führenden M Bits von sn alle Eins sind, dann aber sind diese Bits nach der Rundung alle Null und die ausgegebene Mantisse (ohne führende 1) bleibt auch ohne Verschieben korrekt. Es muss also nur das Carry-Out des Rundungs-Addierers registriert werden, um den Exponenten des Ergebnisses entsprechend zu korrigieren. Die Anpassung des Exponenten geschieht anhand der Anzahl führender Nullen, der Zahl extMSB und des eben erwähnten Carry-Out-Signals. Ressourcenverbrauch und Geschwindigkeit Tabelle 6.11 zeigt auf der linken Seite den Ressourcenverbrauch für die Akkumulatoren für positive Gleitkommazahlen in Abhängigkeit von der Mantissenbreite. Es ist zu sehen, dass etwa 40% mehr FPGA-Ressourcen benötigt werden als für den allgemeinen Gleitkommazahladdierer. Die Designs sind hier etwas schneller als bei den Addierern, was daran liegt, dass die Vorverarbeitung des eingehenden Exponenten durch tieferes Pipelining schneller als bei den Addierern wurde. Akkumulation beliebiger Gleitkommazahlen Sollen positive und negative Gleitkommazahlen akkumuliert werden, ergibt sich das Problem der Auslöschung führender Stellen in der Operation-Stufe. Zur Kompensation des damit einhergehenden Genauigkeitsverlustes müssten deutlich mehr Guard-Bits (extLSB ) und wesentlich größere Verschiebeelemente für die Zwischenergebnisse st implementiert werden. Um dies zu vermeiden, wurde stattdessen die Idee verfolgt, positive und negative Summanden getrennt zu addieren. Mit dieser Lösung kann der Aufbau des Akkumulators weitgehend gleich bleiben wie für die Akkumulation positiver Zahlen. Es liegt nämlich pro Takt immer nur ein Summand, positiv oder negativ, an. Es kann also so getan werden, als wären zwei Akkumulatoren, jeweils einer 149 6.2. GLEITKOMMAARITHMETIK AUF FPGAS Akkumulator 800 Für allgemeine Gleitkommazahlen Elementanzahl 700 Für positive Gleitkommazahlen 600 500 Register LUTs Slices Register LUTs Slices 400 300 200 100 0 12 14 16 18 20 22 24 Mantissenbreite Abbildung 6.18: Verlauf des Ressourcenverbrauchs für die Gleitkomma-Akkumulatoren nach Tabelle 6.11. für positive und negative Zahlen, vorhanden und abhängig vom Vorzeichen der eingehenden Summanden wird der eine oder andere aktiv. Es müssen dazu nur die Register zur Zwischenspeicherung der temporären Exponenten und Mantissen verdoppelt und über Multiplexer selektiert werden, die übrige Hardware kann für beide Akkumulatoren geteilt werden. Damit erhält man einen 2-Kanal-Akkumulator für Gleitkommazahlen ohne Vorzeichen. Um daraus einen allgemeinen Gleitkommazahl-Akkumulator zu machen wird eine zusätzliche Kontroll-Logik erforderlich. Als Kontrollsignale von außen werden die Anzeige der ersten (first) und der letzten (last) zu akkumulierenden Gleitkommazahl benötigt. Das Signal first setzt die Zwischenergebnisse zurück, last triggert die Ausgabe der Ergebnisse. Damit der Akkumulator in der Lage ist, einen kontinuierlichen Zahlenstrom zu verarbeiten, können die beiden Kanäle nicht nach Vorzeichen geordnet werden. Stattdessen wird die eingehende Zahl für first = 1 in Kanal 1 verarbeitet und das Vorzeichen gespeichert. Alle folgenden Zahlen mit gleichem Vorzeichen kommen ebenfalls in Kanal 1, die mit abweichendem Vorzeichen werden in Kanal 2 geleitet. Für last = 1 wird das Ergebnis aus Kanal 1 ausgegeben, ein Takt danach das Ergebnis aus Kanal 2. Die ausgegebenen Vorzeichen ergeben sich aus dem gespeicherten Vorzeichen für den ersten Kanal. In Abbildung 6.19 ist die Schaltung für einen solchen Akkumulator gezeigt. Es ist zu sehen, dass sowohl für die Zwischenergebnisse in der CSA-Rückkopplungschleife als auch für die vorläufigen Ergebnisse nach der Normalisierungsstufe zwei Registersätze eingefügt wurden, die über Multiplexer selektiert werden. Genauso ist das Register für die Zwischenspeicherung des temporären Exponenten im Modul Prepare Exponents zu verdoppeln. Dies wird durch die grau- 150 KAPITEL 6. IMPLEMENTIERUNG DER ARITHMETIK en Kontrollsignale zu diesem Modul hin angedeutet, welche zwei Clock-Enable-Signale und ein Reset-Signal darstellen. Die Kontrolle über die Clock-Enable-, Reset- und Select-Signale wird von der Control State Machine übernommen. Tabelle 6.11 zeigt auf der rechten Seite den Ressourcenverbrauch und die Geschwindigkeit der auf diese Weise erzeugten Akkumulatoren in Abhängigkeit von der Mantissenbreite (siehe auch den grafischen Verlauf in Abbildung 6.18). Gegenüber dem Akkumulator für positive Zahlen ergibt sich ein Offset im Ressourcenverbrauch von etwa 40 %. Die Geschwindigkeit bleibt dagegen unverändert. 6.2.3 Implementierung von Gleitkomma-Multiplizierern auf FPGAs In diesem Abschnitt wird zuerst detailliert auf den allgemeinen Fall der Multiplikation von zwei Zahlen eingegangen. Danach wird kurz der Spezialfall der Quadratur diskutiert. Allgemeine Multiplikation In Abschnitt 4.3.3 wurden die Verarbeitungsschritte eines Gleitkommazahl-Multiplizierers anhand Gleichung 4.39 motiviert, die hier zur Erinnerung noch einmal wiedergegeben wird: A B R=A·B z }| }| }| { z { z { e prod −bias e1 −bias e2 −bias ±s prod 2 = ±s1 2 · ±s2 2 = ± (s · s ) 2(e1 +e2 −bias)−bias . | 1{z 2} Festkomma-Operator (6.16) Durch Abbildung 4.22 und die zugehörige Erklärung ist bereits der grundsätzliche Aufbau eines Gleitkomma-Multiplizierers gezeigt worden. Dieser Aufbau wird nun etwas detaillierter, insbesondere in Bezug auf eine FPGA-Implementierung, ausgeführt. Die Struktur der sich ergebenden Schaltung ist in 6.20 skizziert. Preparation Hier ändert sich nichts im Vergleich zu den Ausführungen in 4.3.3. Das Vorzeichen des Ergebnisses ergibt sich aus einer XOR-Verknüpfung der Operanden-Vorzeichen. Entsprechend der Bezeichnungen in Gleichung 6.16 sind e1 und e2 die Exponenten, s1 und s2 die Mantissen der entpackten Operanden. Operation In dieser Stufe müssen die Exponenten addiert und die Mantissen multipliziert werden. Die Multiplikation von s1 und s2 geschieht über einen Festkomma-Multiplizierer in der Realisierung nach der Tree-Methode, wie in Abschnitt 6.1.2 vorgestellt. Die Multiplikation von M-Bit-Mantissen mit MSB der Wertigkeit 20 und LSB der Wertigkeit −M+1 2 führt zu einem Zwischenergebnis smult mit 2M Stellen, wobei das MSB die Wertigkeit 21 hat ( s1, s2 ∈ [1, 2) ⇒ s1 · s2 ∈ [1, 4) ). Für die Addition der Exponenten ist zu berücksichtigen, dass sie in einer Darstellung mit Bias vorliegen. Nach der Addition von e1 und e2 muss deshalb der Wert bias subtrahiert werden, 151 6.2. GLEITKOMMAARITHMETIK AUF FPGAS valid first last A Unpack fin sign ein 0...0 MSB Shifts CECE S ShiftN 1 0 S 1 Shift Mult P Shifts A B C Reset B & C 0 Operation et Control State Machine CECE Preparation Prepare Exponents et w d owfl CSA st CE S sign 1 Round & Normalize RS CE 0 CE S esum 1 RS 0 Normalization CE Shifts shift Adjust Exponent ssum Pack valid S Abbildung 6.19: Blockschaltbild für einen Akkumulator für Gleitkommazahlen. Positive und negative Summanden werden getrennt akkumuliert. Die Kontrollsignale sind grau dargestellt. 152 KAPITEL 6. IMPLEMENTIERUNG DER ARITHMETIK um den vorläufigen Exponenten et zu erhalten. Da bei einer Exponentenbreite von E Bit nach Gleichung 4.34 gilt: bias = 2E−1 − 1, bedeutet eine Subtraktion dieser Zahl die Addition einer Eins zu Bit [E − 1] und [0]. Die Addition einer Eins zum LSB kann bereits durch ein Carry-In im Addierer für e1 und e2 umgesetzt werden und die Addition einer Eins zum MSB entspricht der Invertierung des MSB. Effektiv ist also der Hardwareaufwand für die Addition der Exponenten identisch mit der Addition von 2er-Komplement-Zahlen. Normalization Dass die vorläufige Ergebnismantisse der Operation-Stufe im Wertebereich [1, 4) liegt, war bereits beim Addierer für positive Zahlen der Fall. Auch hier überzeugt man sich durch die Betrachtung der Operation auf den größtmöglichen darstellbaren Mantissen (s1 = s2 = 2 − ul p) leicht davon, dass das gerundete Ergebnis niemals größer oder gleich 4 wird: < 2 ul p z }| { (2 − ul p)(2 − ul p) + ul p = 4 − 4 ul p + ul p2 + ul p < 2 · (2 − ul p). (6.17) Deshalb kann hier die gleiche Normalisierungs- und Rundungseinheit wie bei diesen Addierern verwendet werden, also die Schaltung nach Abbildung 6.10. Das Sticky-Bit ergibt sich aus der ODER-Verknüpfung aller Bits von smult mit niedrigerer Wertigkeit als 2−M+1 (Bits [M − 2, 0]), das Rundungsbit ist Bit [M − 1], die Bits [2M − 1, M] entsprechen dem Bitvektor sadd in dieser Abbildung. Auch hier muss der Exponent durch Inkrementieren korrigiert werden, falls eine Rechtsverschiebung der Mantisse notwendig wurde. Ressourcenverbrauch und Geschwindigkeit Die Resultate für den Ressourcenverbrauch und die Geschwindigkeit der implementierten Gleitkomma-Multiplizierer sind in den Tabellen 6.12 und 6.13 differenziert nach Rundungsmodus und Verwendung von Block-Multiplizierern aufgelistet. Die Abbildungen 6.21 und 6.22 zeigen den grafischen Verlauf der Ergebnisse. Für den Fall, dass keine Virtex-II-Block-Multiplizierer verwendet werden, ergibt sich ein klarer quadratischer Zusammenhang zwischen Mantissenbreite und Ressourcenaufwand. Ausschlaggebend ist die Skalierung der Festkomma-Multiplikation. Durch die Exponentenverarbeitung und Normalization-Stufe ergibt sich ein Overhead von 15–40 %, abhängig von der Mantissenbreite. Quadratur Die Architektur zur Implementierung der Quadratur ist weitgehend identisch mit der der allgemeinen Multiplikation. Statt zweier Operanden ist nur A zu entpacken und die Vorzeichenverarbeitung entfällt komplett. Der Festkomma-Multiplizierer wird mit großer Ressourcenersparnis ersetzt durch eine Quadrierer-Einheit. Die Addition der Exponenten wird reduziert auf eine Verdoppelung des eingehenden Exponenten. Dazu wird der Exponent um eine Stelle linksverschoben und zur Bias-Korrektur das LSB auf Eins gesetzt und das MSB invertiert. Der Ressourcenaufwand dafür ist mit einem Inverter für das MSB also minimal. Die weitere Verarbeitung in der Normalization-Stufe ist identisch mit dem Multiplizierer für Gleitkommazahlen. Die Resultate sind in Tabelle 6.14 und in Abbildung 6.23 aufgetragen. Es wurde nur der Rundungsmodus 153 6.2. GLEITKOMMAARITHMETIK AUF FPGAS A B Preparation Unpack sign(B) sign(A) e1 e2 s1 s2 XOR Operation sign(A·B) Add Exponents st [M-2,0] et >=1 Adjust Exponent increment Round & Normalize Normalization [2M-1,M] sticky round s mult emult Pack A·B Abbildung 6.20: Blockschaltbild für einen Multiplizierer für Gleitkommazahlen. 154 KAPITEL 6. IMPLEMENTIERUNG DER ARITHMETIK Round To Nearest Integer Round To Nearest Even Mantisse Bits LUTs Regs Slices Design Freq. (MHz) Mantisse Bits LUTs Regs Slices Design Freq. (MHz) 12 14 16 18 20 22 24 46 50 57 119 118 133 145 54 58 62 124 82 88 94 34 36 40 92 68 76 82 104 92 91 76 73 71 70 12 14 16 18 20 22 24 50 55 60 126 125 138 150 54 58 62 128 100 108 116 39 42 45 101 84 91 97 95 88 81 76 73 71 70 Tabelle 6.12: Ressourcenverbrauch und Geschwindigkeit von Gleitkomma-Multiplizierern bei Virtex-II-FPGA XC2V3000-4 unter Benutzung der Block-Multiplizierer-Ressourcen des FPGAs. Bis zu einer Mantissenbreite von 18 Bit wird ein 18x18-Bit-Block-Multiplizierer verwendet, darüber hinaus vier dieser Elemente. Round To Nearest Integer Round To Nearest Even Mantisse Bits LUTs Regs Slices Design Freq. (MHz) Mantisse Bits LUTs Regs Slices Design Freq. (MHz) 12 14 16 18 20 22 24 202 259 328 400 482 574 672 102 130 146 180 198 238 258 107 138 170 210 247 297 342 113 101 101 96 92 87 84 12 14 16 18 20 22 24 206 264 334 406 489 582 680 116 146 164 200 220 262 284 114 146 179 219 256 307 352 104 101 104 94 90 87 82 Tabelle 6.13: Ressourcenverbrauch und Geschwindigkeit von Gleitkomma-Multiplizierern bei Virtex-II-FPGA XC2V3000-4 ohne Benutzung der Block-Multiplizierer-Ressourcen des FPGAs. 155 6.2. GLEITKOMMAARITHMETIK AUF FPGAS Multiplizierer ohne 18x18-Block-Mult-Elemente 800 Round to nearest even Elementanzahl 700 Round to nearest integer 600 500 Register LUTs Slices Register LUTs Slices 400 300 200 100 0 12 14 16 18 20 22 24 Mantissenbreite Abbildung 6.21: Verlauf des Ressourcenverbrauchs für die Gleitkomma-Multiplizierer nach Tabelle 6.13. Multiplizierer mit 18x18-Block-Mult-Elementen 1 Mult18x18-Element 160 4 Mult18x18-Elemente Round to nearest even Elementanzahl 140 Round to nearest integer 120 100 Register LUTs Slices Register LUTs Slices 80 60 40 20 0 12 14 16 18 20 22 24 Mantissenbreite Abbildung 6.22: Verlauf des Ressourcenverbrauchs für die Gleitkomma-Multiplizierer nach Tabelle 6.12. 156 KAPITEL 6. IMPLEMENTIERUNG DER ARITHMETIK mit Block-Multiplizierern ohne Block-Multiplizierer Mantisse Bits LUTs Regs Slices Design Freq. (MHz) Mantisse Bits LUTs Regs Slices Design Freq. (MHz) 12 14 16 18 20 22 24 36 40 45 82 89 96 103 49 53 57 73 79 85 91 23 25 27 42 46 49 53 107 96 91 102 102 99 97 12 14 16 18 20 22 24 132 193 222 271 320 364 390 92 106 116 142 155 236 250 70 102 117 143 168 204 216 108 97 85 86 95 103 112 Tabelle 6.14: Ressourcenverbrauch und Geschwindigkeit von Gleitkomma-Quadrierern bei Virtex-II-FPGA XC2V3000-4 mit und ohne Benutzung der Block-Multiplizierer-Ressourcen des FPGAs. Bei Verwendung der Block-Multiplizierer werden bis zu einer Mantissenbreite von 18 Bit eines, darüber hinaus drei dieser Elemente implementiert. Round To Nearest Integer implementiert. Der Fall, dass das Rundungsbit 1 ist und sich ein StickyBit identisch Null ergibt, wird bei der Quadratur von physikalischen Größen nur extrem selten auftreten6 . Es ist also kein signifikanter mittlerer Offset der Rechenergebnisse zu befürchten, wie er beispielsweise bei der Addition auftreten kann. Bei den Multiplizierern konnte diese Annahme nicht vorausgesetzt werden, da beispielsweise die Situation einer Multiplikation einer Konstante (z.B. 3.0) mit einer physikalischen Größe bei diesem Rundungsmodus durchaus zu einem mittleren Offset führen kann. Gegenüber den Multiplizierern ergibt sich für die Umsetzung ohne Block-Multiplizierer eine Ressourcenersparnis von 30–40 %. Der grafische Verlauf in Abbildung 6.23 zeigt kein quadratisches Verhalten, was darauf hindeutet, dass die Festkomma-Quadrierer nicht optimal implementiert sind. Der Ressourcenverbrauch liegt bei 12-Bit-Mantissen fast 50 %, bei 24-Bit-Mantissen dagegen nur etwa 19 % höher als bei den Festkommaquadrierern (vergleiche Tabelle 6.4). Die Geschwindigkeit der Designs ist vergleichbar mit den Ergebnissen für die Gleitkomma-Multiplizierer. 6.2.4 Implementierung von Gleitkomma-Dividierern auf FPGAs Zur Erinnerung der Verarbeitungsschritte eines Dividierers für Gleitkommazahlen sei hier die bereits in Abschnitt 4.3.3 gegebene Gleichung für die Division (4.41) nochmals aufgestellt: A B R=A/B z }| }| }| { z { z { equot −bias e1 −bias e2 −bias ±squot 2 = ±s1 2 / ±s2 2 = ± 6 Dazu (s /s ) 2(e1 −e2 +bias)−bias . | 1{z 2} Festkomma-Operator (6.18) müssten bei einer Mantisse 1.x−1 . . . x−M+1 mit ungerader Mantissenbreite M das Bit x(M+1)/2 ungleich 0 und die Bits x(M+1)/2−1 . . . x−M+1 identisch 0 sein. 157 6.2. GLEITKOMMAARITHMETIK AUF FPGAS Elementanzahl Quadrierer 450 400 350 300 250 200 150 100 50 0 1 Mult18x18-Element 3 Mult18x18-Elemente ohne Mult18x18 Elemente mit Mult18x18 Elementen Register LUTs Slices Register LUTs Slices 12 14 16 18 20 22 24 Mantissenbreite Abbildung 6.23: Verlauf des Ressourcenverbrauchs für die Gleitkomma-Quadrierer nach Tabelle 6.14. Die schaltungstechnische Umsetzung dieser Berechnung, deren grundlegende Struktur bereits in Abschnitt 4.3.3 ausgeführt wurde (siehe Abbildung 4.23), wird nun konkretisiert. In Abbildung 6.24 ist die Struktur der FPGA-Implementierung für den Dividierer gezeigt, wie sie im Folgenden beschrieben wird. Preparation Diese Stufe ist identisch mit der des Gleitkomma-Multiplizierers, da auch hier die Exponenten keine Vorverarbeitungsschritte der Mantissen bedingen. Es ist lediglich das Vorzeichen des Ergebnisses zu bilden. Operation In dieser Stufe muss die Differenz der Exponenten e1 und e2 und der Quotient der M-Bit-Mantissen s1 und s2 gebildet werden. Für die Division der Mantissen wird ein FestkommaDividierer nach der Non-Restoring-Methode, wie er in Abschnitt 6.1.3 vorgestellt wurde, implementiert. Hierbei ist zu erwähnen, dass s1 und s2 im Intervall [1, 2) liegen und deshalb die Bedingung 6.6 in jedem Fall erfüllt ist - es kann also kein Überlauf auftreten. Um das Ergebnis korrekt runden zu können, ist es erforderlich, den vorläufigen Quotienten st auf mindestens M +2 Stellen zu berechnen. Dies folgt daraus, dass gilt: st ∈ (0.5, 2), und deshalb vor dem Runden eine Normalisierungsverschiebung um eine Stelle nach links erfolgen kann. Insbesondere für den Standardrundungsmodus muss auch ein Sticky-Bit erzeugt werden. Dieses kann aus dem Rest der Division ermittelt werden, denn das Sticky-Bit ist genau dann identisch Null, wenn der Rest Null ist. Es muss also ein Dividierer mit Ausgabe des Restwertes rem verwendet werden. Das 158 KAPITEL 6. IMPLEMENTIERUNG DER ARITHMETIK Sticky-Bit ergibt sich dann aus der ODER-Verknüpfung der Bits von rem. Bei der Subtraktion der Exponenten, welche in der Darstellung mit Bias vorliegen, ist zu berücksichtigen, dass der Wert bias = 2E−1 − 1 hinzuaddiert werden muss, um den vorläufigen Exponenten et ebenfalls in der Bias-Darstellung zu erhalten. Für et gilt also: et = e1 − e2 + 2E−1 − 1 = e1 + e2 + 2E−1 . Es muss deshalb nur das 1er-Komplement von e2 zu e1 addiert und das MSB des Resultats invertiert werden, um et zu erhalten. Normalization Wie bereits erwähnt, führt die Beziehung st ∈ (0.5, 2) dazu, dass eine Linksverschiebung um eine Stelle zur Normalisierung der Mantisse erforderlich werden kann. Dass niemals eine gerundete Mantisse größer oder gleich 2 entstehen kann, wird aus der Betrachtung der Division der größtmöglichen Mantisse (smax = 2 − ul p) durch die kleinstmögliche Mantisse (smin = 1) ersichtlich: smax + ul p = 2 − ul p + ul p = 2 − ul p smin 2 1 2 2 = 1. 1 1 . . . 1 1 | |{z} 1 . Rundungsbit (6.19) Es wird nun st in jedem Fall um eine Stelle nach links verschoben, sodass sich st0 = 2 · st ∈ (1, 4) ergibt. Die Mantisse st0 kann nun mit der gleichen Round & Normalize-Schaltung normalisiert und gerundet werden, wie sie für den Addierer für positive Gleitkommazahlen und den Multiplizierer verwendet wurde (Abbildung 6.10). Zeigt diese Schaltung eine erfolgte Rechtsverschiebung um eine Stelle an, macht das die Linksverschiebung von st zu st0 rückgängig und der vorläufige Exponent et ist auch der Exponent des Ergebnisses. Wurde dagegen keine Rechtsverschiebung vorgenommen, ist et um Eins zu verringern. Ressourcenverbrauch und Geschwindigkeit Die Tabellen 6.15 und 6.16 zeigen die erzielten Ergebnisse bezüglich Ressourcenverbrauch und Geschwindigkeit der Gleitkomma-Dividierer für verschiedene Pipelinetiefen und Rundungsmodi. Abbildung 6.25 illustriert die Skalierung des Ressourcenverbrauchs für die Dividierer mit Rundungsmodus Round To Nearest Even. Wie bei der Diskussion der Festkomma-Dividierer deutlich wurde, sind Dividierer mit einer Pipelinetiefe von vier Stufen inakzeptabel langsam, bei einer Pipelinetiefe von 1 dagegen wird der Ressourcenverbrauch von den Registern dominiert. Deshalb wurden nur die Pipelinetiefen 2 und 3 näher untersucht. Wie bei der Muliplikation ergibt sich ein quadratisch skalierender Ressourcenaufwand. Während sich die Anzahl an LUTs nur wenig (< 10 %) von den Zahlen für die Mutiplizierer unterscheidet, ergibt sich für eine Pipelinetiefe von 2 ein Mehrverbrauch von etwa 50 %, welcher, wie bereits bei der Diskussion der Festkomma-Dividierer erwähnt, von der großen Zahl an Registern stammt, die nicht einer vorangehenden LUT zugeordnet werden können. Der Übergang von einer Pipelinetiefe von 3 zu einer Tiefe von 2 führt zu einem Mehrverbrauch an Slices 159 6.2. GLEITKOMMAARITHMETIK AUF FPGAS A B sign(B) sign(A) e1 e2 s1 XOR s2 [M-1,0] [M-1,0] d Division q [M+1,0] rem [2M-2,0] Operation sign(A/B) e Sub Exponents Preparation Unpack [M-1,0] et >=1 Adjust Exponent decr. equot Round & Normalize Normalization [M+1,1] sticky round s quot Pack A/B Abbildung 6.24: Blockschaltbild für einen Dividierer für Gleitkommazahlen. 160 KAPITEL 6. IMPLEMENTIERUNG DER ARITHMETIK 3 Quotientenbits pro Pipelinestufe 2 Quotientenbits pro Pipelinestufe Mantisse Bits LUTs Regs Slices Design Freq. (MHz) Mantisse Bits LUTs Regs Slices Design Freq. (MHz) 12 14 16 18 20 22 24 228 288 359 438 522 617 720 153 173 226 287 325 388 469 147 180 230 285 332 399 471 71 69 69 64 61 61 59 12 14 16 18 20 22 24 230 292 362 440 526 620 722 200 257 322 395 476 565 662 161 206 257 314 377 446 521 91 91 90 85 84 79 78 Tabelle 6.15: Ressourcenverbrauch und Geschwindigkeit von Gleitkomma-Dividierern ohne Rundung des Ergebnisses bei Virtex-II-FPGA XC2V3000-4. in der Größenordnung 12–14 %. Die Implementierung des Rundungsmodus Round To Nearest Even führt gegenüber dem Truncation-Modus zu einem Mehraufwand von 15–20 %. Nicht aufgeführt wurden die Daten zum ebenfalls implementierten Rundungsmodus Round To Nearest Integer. Hier liegen die Zahlen zum Ressourcenverbrauch relativ genau zwischen den Werten der Tabellen 6.15 und 6.16. 6.2.5 Implementierung der Gleitkomma-Quadratwurzel auf FPGAs Wie bei den vorangegangenen Abschnitten soll auch hier die in Abschnitt 4.3.3 angeführte Gleichung für die Operation auf Gleitkommazahlen wiedergegeben werden, um davon ausgehend die in jenem Abschnitt bereits grundlegend beschriebene Verarbeitung der Gleitkommaeinheit für die Quadratwurzel zu konkretisieren. Es handelt sich hier um die Wiedergabe von Gleichung 4.43: √ R= A A z }| { esqrt −bias ±ssqrt 2 = z }| { 1 2 ±s1 2e1 −bias q = ± (6.20) s1 : e1 − bias gerade s 2 : e1 − bias ungerade 1 e1 : e1 − bias gerade = e1 − 1 : e1 − bias ungerade. s01 = e01 0 s01 2(e1 −bias)/2 |{z} Festkomma-Operator Abbildung 6.26 zeigt die Implementierung des Operators, wie sie im Folgenden erläutert wird. 161 6.2. GLEITKOMMAARITHMETIK AUF FPGAS 3 Quotientenbits pro Pipelinestufe 2 Quotientenbits pro Pipelinestufe Mantisse Bits LUTs Regs Slices Design Freq. (MHz) Mantisse Bits LUTs Regs Slices Design Freq. (MHz) 12 14 16 18 20 22 24 277 347 426 509 603 706 807 151 199 254 283 351 426 477 174 223 279 325 389 463 523 70 69 67 62 62 59 59 12 14 16 18 20 22 24 281 350 436 513 606 708 818 219 279 347 423 527 621 723 198 249 311 366 434 509 588 86 83 89 76 75 77 78 Tabelle 6.16: Ressourcenverbrauch und Geschwindigkeit von Gleitkomma-Dividierern mit Rundungsmodus Round To Nearest Even bei Virtex-II-FPGA XC2V3000-4. Elementanzahl Division mit Rundung (Round To Nearest Even ) 900 800 700 600 500 400 300 200 100 0 Register nach jeweils 2 Stufen Register nach jeweils 3 Stufen Register LUTs Slices Register LUTs Slices 12 14 16 18 20 22 24 Mantissenbreite Abbildung 6.25: Verlauf des Ressourcenverbrauchs für die Gleitkomma-Dividierer nach Tabelle 6.16. 162 KAPITEL 6. IMPLEMENTIERUNG DER ARITHMETIK Preparation Dass bei der Quadratwurzel der Exponent ganzzahlig durch zwei dividiert werden muss, dieser jedoch nicht notwendigerweise geradzahlig ist, macht eine Vorverarbeitung der eingehenden Mantisse erforderlich. Ist e1 gerade, was bedeutet, dass e1 − bias ungerade ist, wird s1 um eine Stelle linksverschoben, ansonsten belassen. Die Schaltung dazu besteht aus einem einfachen Multiplexer, dessen Select-Signal durch das LSB von e1 bestimmt ist. Die bearbeitete Mantisse ist s01 . Für ein gerades e1 müsste nun e01 durch Subtraktion von Eins berechnet werden. Um dazu nicht einen eigenen Subtrahierer aufzuwenden, wird diese Operation auf die OperationStufe verschoben, indem lediglich ein Signal decr = 1 = 0 weitergeleitet wird (decr = 1 für e1 ungerade). Operation Der Exponent des Ergebnisses ergibt sich aus der Beziehung: esqrt = (e01 − bias)/2 + bias = (e1 + bias − decr)/2. Diese Operation kann auch folgendermaßen formuliert werden: e1 − 1 bias − 1 + + 1 : decr = 0 2 2 esqrt = e1 bias − 1 + : decr = 1. 2 2 Dies bedeutet, dass e1 um eine Stelle nach rechts verschoben werden muss und dabei das LSB vernachlässigt werden kann. Die Addition von bias−1 = 2E−1 − 1 und Eins im Falle decr = 0 2 geschieht über einen einfachen Addierer, dessen Carry-In mit decr verbunden ist. Die Quadratwurzel der (M + 1)-Bit-Zahl s01 (MSB mit Wertigkeit 21 ) muss auf M + 1 Stellen berechnet werden (MSB mit Wertigkeit 20 ) - das LSB ist dann das Rundungsbit, welches in der Normalization-Stufe benötigt wird. Das Festkomma-Quadratwurzelergebnis ist st . Normalization Diese Stufe beinhaltet lediglich die Addition von ulp/2 zu st , um das Resultat ssqrt zu erhalten. Ein Sticky-Bit wie bei den bisher besprochenen Operationen ist im Fall der Quadratwurzel nicht erforderlich. Dies liegt daran, dass der Fall eines nichtverschwindenden Rundungsbits bei gleichzeitigem Verschwinden aller Bits eines exakten Ergebnisses über das Rundungsbit hinaus nicht auftreten kann. Wäre dies der Fall, stellte st die exakte Wurzel von s01 dar. Da die Quadrierung von st dann zu einem nichtverschwindenden Bit der Wertigkeit ulp2 /2 führt, welches nicht in s01 vorliegt, ergibt sich daraus jedoch ein Widerspruch. Wie bereits in Abschnitt 4.3.3 festgestellt, bedarf es weder nach der Festkomma-Quadratwurzel noch nach der Rundung einer Normalisierungs-Verschiebung. Ressourcenverbrauch und Geschwindigkeit In den Tabellen 6.17 und 6.18 sind die erzielten Werte für den Ressourcenverbrauch und die Geschwindigkeiten für die Gleitkomma-Quadratwurzelberechnung aufgeführt. Abbildung 6.27 zeigt den Verlauf des Ressourcenverbrauches aus Tabelle 6.18. Es ergibt sich qualitativ der gleiche Verlauf wie bei den Dividierern. Die Operatoren benötigen jedoch grob nur etwa 60 % der Ressourcen der Dividierer gleicher Mantissenbreite, 163 6.2. GLEITKOMMAARITHMETIK AUF FPGAS A e1 [E-1,0] s1 0 [M-1,0] 0 LSB MSB LSB decr S 1 s'1 [E-1,1] 0 [M-1,0] Carry Out + Carry In SQRT [M+1,0] round [M+1,1] Round esqrt s sqrt Pack Normalization [E-1,0] Operation 011..1 Preparation Unpack SQRT(A) Abbildung 6.26: Blockschaltbild für einen Quadratwurzel-Operator für Gleitkommazahlen. 164 KAPITEL 6. IMPLEMENTIERUNG DER ARITHMETIK 3 Ergebnisbits pro Pipelinestufe 2 Ergebnisbits pro Pipelinestufe Mantisse Bits LUTs Regs Slices Design Freq. (MHz) Mantisse Bits LUTs Regs Slices Design Freq. (MHz) 12 14 16 18 20 22 24 134 171 210 253 303 356 413 79 114 124 164 208 212 262 92 119 144 178 213 243 284 70 67 66 66 64 61 62 12 14 16 18 20 22 24 134 172 215 258 309 362 420 112 144 183 216 264 310 366 102 129 161 191 230 269 313 96 93 95 89 87 86 87 Tabelle 6.17: Ressourcenverbrauch und Geschwindigkeit von Gleitkomma-QuadratwurzelOperatoren ohne Rundungsfunktion bei Verwendung des Virtex-II-FPGAs XC2V3000-4. was sich vor allem durch die gegenüber den Festkommadividierern um etwa 30 % geringere Größe der Festkommaquadratwurzeln ergibt. Die erzielten Geschwindigkeiten sind etwas höher als bei den Dividierern. Beim Übergang von Pipelinetiefe 3 zu 2 ergibt sich ein Mehraufwand an Slices in der Größenordnung 10 %. 6.2.6 Zusammenfassung und Vergleich der Implementierungsergebnisse zu den Operatoren In den letzten Abschnitten wurden die wichtigsten Gleitkommaoperatoren, die im Rahmen dieser Arbeit entwickelt wurden, im Detail diskutiert. Wichtigstes Optimierungskriterium war, einen möglichst geringen Ressourcenaufwand bei akzeptabler Geschwindigkeit zu erreichen. Bei den Digit-Recurrence-Methoden für die Divisions- und Quadratwurzelberechnung wurde durch die Parametrisierung der Pipelinetiefe eine direkte Einflussmöglichkeit auf die Geschwindigkeit und den Ressourcenverbrauch der Schaltungen gegeben. Es wurden zahlreiche Spezialisierungen der Operatoren entwickelt, um abhängig von den numerischen Eigenschaften eines Algorithmus jeweils die optimale Implementierung wählen zu können. So wurde bei der Addition und Akkumulation unterschieden, ob die Operanden über ein Vorzeichen verfügen oder ausschließlich positiv sind. Es wurden getrennte Designs für die Multiplikation und die Quadratur aufgebaut. Außerdem wurde die Unterstützung verschiedener Rundungsmodi eingeführt. Für die einzelnen Operatoren wurden bereits die Implementierungsergebnisse in Abhängigkeit von der Darstellungsgenauigkeit der verarbeiteten Gleitkommazahlen tabellarisch und grafisch dargestellt, wobei die Resultate bezüglich des Aufwands an 4-Input-LUTs, 1-Bit-Registern und Slices sowie der erzielten Geschwindigkeit aufgeschlüsselt wurden. Dies macht es möglich, bereits vor der Implementierung neuer Rechenwerke den Aufwand relativ genau abzuschätzen. Um für Ressourcenabschätzungen den Vergleich zwischen verschiedenen Operationen zu erleichtern, sind in Abbildung 6.28 einige Ergebnisse bei Mantissenbreiten von 16 und 24 Bit ein- 165 6.2. GLEITKOMMAARITHMETIK AUF FPGAS 3 Ergebnisbits pro Pipelinestufe 2 Ergebnisbits pro Pipelinestufe Mantisse Bits LUTs Regs Slices Design Freq. (MHz) Mantisse Bits LUTs Regs Slices Design Freq. (MHz) 12 14 16 18 20 22 24 157 195 237 282 335 391 450 91 126 168 178 224 274 280 103 131 161 188 224 262 294 66 70 69 66 61 63 62 12 14 16 18 20 22 24 159 200 244 292 344 400 460 124 158 194 234 278 326 378 113 140 170 203 239 278 320 94 101 95 88 88 92 88 Tabelle 6.18: Ressourcenverbrauch und Geschwindigkeit von Gleitkomma-QuadratwurzelOperatoren mit Rundungsmodus Round To Nearest Even bei Verwendung des Virtex-II-FPGAs XC2V3000-4. Elementanzahl Quadratwurzel mit Rundung (Round To Nearest Even ) 500 450 400 350 300 250 200 150 100 50 0 Register nach jeweils 2 Stufen Register nach jeweils 3 Stufen Register LUTs Slices Register LUTs Slices 12 14 16 18 20 22 24 Mantissenbreite Abbildung 6.27: Verlauf des Ressourcenverbrauchs für die Quadratwurzel-Operatoren nach Tabelle 6.18. 166 KAPITEL 6. IMPLEMENTIERUNG DER ARITHMETIK Operator Add Mult Div SQRT Lienhart Slices Freq. Latenz (MHz) 276 78 6 97 70 3 588 78 15 320 88 14 Nallatech Slices Freq Latenz (MHz) 290 152 14 126 113 6 730 154 26 330 151 29 Quixilica Slices Freq. Latenz (MHz) 365 137 10 358 128 7 738 139 27 675 175 27 Tabelle 6.19: Vergleich der Implementierungsergebnisse des Autors mit kommerziellen Produkten für den FPGA Virtex-II-4. Verglichen werden folgende Operatoren: Addierer für allgemeine Zahlen (Add), Muliplizierer (Mult), Dividierer (Div) und Quadratwurzel-Operator (SQRT), alle mit Single-Precision und Standardrundungsmodus. ander gegenübergestellt, wobei die Zahlen für den jeweils besten implementierten Rundungsmodus verglichen werden7 . Für die Dividierer und Quadratwurzel-Operatoren wurde eine Pipelinetiefe von zwei Addier/Subtrahier-Stufen zwischen den Registerstufen gewählt. Damit erreichen alle aufgeführten Operatoren eine Geschwindigkeit von etwa 90 MHz. Entscheidend für den Flächenverbrauch auf dem FPGA ist die Anzahl an Slices. Es sei an dieser Stelle daran erinnnert, dass eine Slice zwei 4-Input-LUTs und zwei 1-Bit-Register enthält. Liegt die Anzahl der Slices deutlich über der Hälfte der LUTs, bedeutet dies, dass viele Register nicht mit vorangehenden Logikstufen gepaart sind, beispielsweise durch direkt aufeinanderfolgende Pipelining-Register. In diesem Fall wird noch tieferes Pipelining den Flächenverbrauch weiter steigern. Sehr deutlich ist dies bei den Dividierern und Quadratwurzel-Operatoren zu sehen. Die Addierer und Multiplizierer haben dagegen ein sehr gutes Verhältnis von Slices zu LUTs. Hier gibt es noch Spielraum für eine Geschwindigkeitsoptimierung, ohne den Flächenverbrauch wesentlich zu erhöhen. Besonders auffallend ist die Skalierung des Ressourcenaufwands. Während die Addierer und Akkumulatoren bei 24-Bit- gegenüber 16-Bit-Mantissen einen Mehraufwand an Slices von etwa 30–40 % verursachen, ergibt sich bei den übrigen Operatoren etwa eine Verdoppelung. Deutlich wird auch die enorme Einsparung von Logikressourcen für die Multiplizierer und Quadrierer, wenn die Block-Multiplizierer-Elemente des Virtex-II-FPGAs verwendet werden. Allerdings ist zu berücksichtigen, dass für 24-Bit-Mantissen vier 18×18-Bit-Multipliziererelemente für die Multiplizierer und drei dieser Elemente für die Quadrierer benötigt werden, während nur jeweils einer dieser Bausteine bei 16-Bit-Mantissen gebraucht wird. In Tabelle 6.19 werden die Implementierungsergebnisse für die Operatoren mit 24-Bit-Mantissen und Rundungsmodus Round To Nearest Even mit den Leistungsdaten kommerzieller Produkte verglichen. Für den Vergleich wurden die FPGA-IP-Cores der Firmen Nallatech Limited [81] und QinetiQ Limited (Quixilica Cores, [94]) angeführt. Die Operatoren des Autors weisen in allen Fällen einen geringeren Ressourcenverbrauch auf als die kommerziellen Produkte. Al7 Mit Ausnahme der Quadrierer wurde der Standardmodus Round To Nearest Even verwendet. Bis auf extrem seltene Ausnahmen führt der Modus Round To Nearest Integer im Fall der Quadrierer zum gleichen Rechenergebnis, siehe dazu die Diskussion der Gleitkomma-Quadrierer. 167 6.2. GLEITKOMMAARITHMETIK AUF FPGAS Ressourcenverbrauch von Gleitkommaoperatoren für 16-Bit-Mantissenbreite 700 Elementanzahl 600 500 LUTs Regs Slices 400 300 200 100 0 unsgn. Add RTNE Add RTNE unsgn. Accu Accu Mult RTNE Mult RTNE BM Square RTNI Square RTNI BM Div RTNE SQRT RTNE Operator Ressourcenverbrauch von Gleitkommaoperatoren für 24-Bit-Mantissenbreite 900 Elementanzahl 800 700 600 500 LUTs Regs Slices 400 300 200 100 0 unsgn. Add RTNE Add RTNE unsgn. Accu Accu Mult RTNE Mult RTNE BM Square RTNI Square RTNI BM Div RTNE SQRT RTNE Operator Abbildung 6.28: Vergleich des Ressourcenaufwands für verschiedene Gleitkommaoperatoren für 16-Bit- und 24-Bit-Mantissen für die Implementierung auf Virtex-II-FPGAs. “BM” bezeichnet die Verwendung von Block-Multplizierern des Virtex-II-FPGAs. Die Bezeichnungen “RTNE” und “RTNI” stehen für die Rundungsmodi Round To Nearest Even und Round To Nearest Integer. 168 KAPITEL 6. IMPLEMENTIERUNG DER ARITHMETIK lerdings werden auch deutlich niedrigere Taktfrequenzen erreicht. Wie an den Zahlen für die Latenzzeiten (in Taktzyklen) zu sehen ist, wurde in den kommerziellen Produkten ein etwa doppelt so tiefes Pipelining der Operatoren implementiert und so ergibt sich ein Geschwindigkeitsvorteil um bis zu einen Faktor 2. Für die Addierer und Quadratwurzel-Operatoren werden bei Nallatech trotz erheblich größerer Pipelinetiefe nur wenig mehr Logikressourcen benötigt. Der Grund dafür ist, dass Nallatech intern ein eigenes 38-Bit-Zahlenformat verwendet, sodass die Rundungsund Normalisierungs-Logik vereinfacht werden kann. Die Quixilica-Designs sind in der Rechengenauigkeit skalierbar, wie die Designs des Autors. Die Module von Nallatech sind dagegen auf Single-Precision festgelegt. Für diese Arbeit war vor allem wichtig, eine in der Rechengenauigkeit skalierbare Bibliothek von Gleitkommaoperationen mit möglichst geringem Logikressourcenaufwand für die Operatoren aufzubauen. Motivation dafür war, mit den gegebenen FPGAs auch sehr komplexe Formeln vollständig parallelisiert implementieren zu können. Dieses Ziel wurde sehr gut erreicht. Alle Operatoren des Autors weisen ein ausgewogenes Verhältnis von Geschwindigkeit und Ressourcenverbrauch auf und selbst mit einer Genauigkeit von Single-Precision kann mit voller Geschwindigkeit des PCI-Bus (66 MHz) gerechnet werden. Im folgenden Abschnitt wird sich zeigen, dass aufgrund der limitierten Speicherbandbreite auf der verwendeten Koprozessorplattform derzeit eine Erhöhung der Taktfrequenz für die Rechenwerke über 66 MHz hinaus ohnehin nicht sinnvoll erscheint. Wird für zukünftige FPGA-Designs eine Erhöhung der Taktfrequenz erforderlich, bieten die derzeitigen FPGA-Designs des Autors noch reichlich Potential für eine Geschwindigkeitssteigerung. Kapitel 7 Implementierung des Rechenbeschleunigers 7.1 Implementierung der Rechenwerke für SPH In diesem Abschnitt werden die FPGA-Designs der Rechenwerke für eine Prototypimplementierung eines Rechenbeschleunigers beschrieben. Es wird von einer SPH-Formulierung ausgegangen, wie in Abschnitt 2.3.2 vorgestellt. Die für die SPH-Simulation zentralen Formeln der Dichteberechnung (Schritt 1) und Kraftberechnung (Schritt 2) wurden vollständig parallel implementiert. Details der Umsetzung werden in den Abschnitten 7.1.3 und 7.1.4 ausgeführt. Zuvor werden in Abschnitt 7.1.1 die Rechenwerke für den Spline-Kernel und dessen Gradienten vorgestellt, welche Kern der Implementierung von SPH-Formeln sind. Dieser Abschnitt wurde von der Beschreibung der SPH-Rechenwerke separiert, da für die Umsetzung der Kernfunktionen spezielle Ressourcen sparende Operatorbausteine verwendet wurden, auf welche kurz eingegangen werden soll. Demgegenüber sind die in den Abschnitten 7.1.3 und 7.1.4 beschriebenen Rechenwerke im Wesentlichen aus bereits diskutierten Bausteinen zusammengesetzt. 7.1.1 Rechenwerke für die Bestimmung der Spline-Kernel-Werte Berechnung des SPH-Kerns W(r, h) Es wird hier von der Kernfunktion ausgegangen, wie sie in Abschnitt 2.3.2 in Formel 2.20 als Funktion von v = hr aufgestellt wurde und hier noch einmal wiedergegeben ist: 3 3 2 1− 3 2v + 4v : 0 ≤ v < 1 1 1 (2 − v)3 : 1 ≤ v < 2 W (r, h) = 3 4 πh 0 : sonst. 169 (7.1) 170 KAPITEL 7. IMPLEMENTIERUNG DES RECHENBESCHLEUNIGERS Abbildung 7.1: Spline-Kernfunktion für SPH entsprechend Formel 7.2. Lässt man den Skalierungsfaktor Intervall [0, 2) ungleich Null ist: 1 πh3 weg, ergibt sich folgende skalare Funktion, welche im 3 3 2 1− 3 2x + 4x : 0 ≤ x < 1 1 (2 − x)3 : 1 ≤ x < 2 W 0 (x) = 4 0 : sonst (7.2) Abbildung 7.1 zeigt den Graphen dieser Funktion. Zur Implementierung können hier beispielsweise die Table-Look-Up-Methoden, welche in 4.5.1 diskutiert wurden, verwendet werden. Stattdessen wurde der Weg gewählt, eine direkte Implementierung durch Gleitkommaoperatoren durchzuführen. Dies hat folgende Vorteile: • Architekturunabhängigkeit, da keine Block-RAM- oder externe RAM-Ressourcen benötigt werden. • Gute Skalierbarkeit in der Rechengenauigkeit, da lediglich die Genauigkeit der Einzeloperatoren angepasst werden muss. Für eine LUT-basierte Implementierung müssten die Look-Up-Tables für jede Operandenbreite neu berechnet werden. Zudem vergrößert sich die LUT-Tiefe exponentiell mit der Genauigkeit. • Leicht verifizierbare Korrektheit der Implementierung, da Schaltungsfehler bereits bei einer geringen Zahl von Testrechnungen sichtbar werden. Bei LUT-basierten Implementierungen ist die Verifizierung weit schwieriger (prominentes Beispiel: Pentium-Bug). Durch die Anwendung von Spezialoperatoren konnten die Ressourcenanforderungen der direkten Implementierung auf ein Niveau vergleichbar mit zwei Multiplikationen und zwei Additionen 7.1. IMPLEMENTIERUNG DER RECHENWERKE FÜR SPH r ij hij 1 Special2MinusX Test x≥1 2−x 1 0 S y 2 Sqare 3 Mult z2 z1 ExpMinusX 1 2 ExpMinusX 1 4 sign = 1 4 Add 5 6 Underflow Mult3 x+2x Special1MinusX 1−x z4 0 z3 1 force Zero S r ij W'( h ) ij Abbildung 7.2: Schaltung zur Berechnung der Spline-Kernfunktion nach Gleichung 7.2. 171 172 KAPITEL 7. IMPLEMENTIERUNG DES RECHENBESCHLEUNIGERS geführt werden, was ungefähr dem Aufwand für die Interpolationseinheit einer LUT-basierten Näherung zweiten Grades entspricht. Die Implementierung des Rechenwerks für den Spline-Kernel zeigt Abbildung 7.2. Es wird vorausgesetzt, dass das Teilchen mit Index j ein echter SPH-Nachbar von Teilchen i ist, was bedeutet, dass x = ri j /hi j < 2 gilt1 . Die Fallunterscheidung, ob x < 1 oder x ≥ 1 gilt, wird im Modul Test durchgeführt. Darin ist lediglich zu testen, ob der Exponent von x identisch mit dem Exponenten-Bias der Gleitkommadarstellung ist. Im Fall x < 1 kann die Berechnung von W 0 nach Gleichung 7.2 in folgende Operationen zergliedert werden, wobei die eingekreisten Nummern auf die in Abbildung 7.2 gleichermaßen gekennzeichneten Operatoren verweisen. y z2 z1 z02 z01 z12 z012 z4 W (x) = = = = = = = = = x y2 z2 y z2 · 21 z1 · 14 z01 − z02 2 · |z12 | + |z12 | 1 − z012 z4 . 2 3 (7.3) 4 5 6 Für 1 ≤ x < 2 ergibt sich dagegen folgender Ablauf: y z2 z1 z3 W (x) = = = = = 2−x 1 2 y 2 z2 y 3 1 z1 · 4 z3 . (7.4) Für Operator 1 (Special2MinusX) wurde eine spezielle Variante eines Addierers implementiert. Dieser Operator wird nur benötigt, wenn 1 ≤ x < 2 gilt. Die Zahl x entspricht dann der Mantisse. Somit kann ein Festkomma-Subtrahierer angewandt werden, der sich aufgrund des zweiten Arguments, welches identisch 2 ist, auf eine 2er-Komplement-Logik reduziert. Abschließend ist die Differenz wie bei der Gleitkommaaddition zu normalisieren, wobei der Fall der Rechtsverschiebung nicht auftreten kann. Bei den Operatoren 2 , 3 und 4 handelt es sich um normale Gleitkommaoperationen, die gegen Underflow-Ausnahmen abgesichert sein müssen. Der Operator 5 (Mult3) ist eine spezielle Version eines Addierers für positive Zahlen. Die Auswertung der Exponenten und Verschiebung der Mantissen in der Preparation-Stufe kann entfallen. Nach der Addition der Mantisse zur um eine Stelle linksverschobenen Mantisse geschieht die Normalisierung wie im Fall des Addierers für positive Zahlen aus Abschnitt 6.2.2. 1 Falls eine Routine zur Bereitstellung der Nachbarindizes dies nicht garantieren kann, ist es erforderlich, den Fall x ≥ 2 zu erkennen und daraufhin die Ausgabe von W 0 (x) = 0 zu erzeugen. 7.1. IMPLEMENTIERUNG DER RECHENWERKE FÜR SPH 173 Für den Operator 6 kann ebenfalls eine Ressourcen sparende spezielle Addierervariante implementiert werden. Denn es gilt die Beziehung z012 <= 3/4. Damit vereinfacht sich die Normalisierungsstufe erheblich, denn es kann höchstens eine Verschiebung um zwei Stellen nach links erforderlich werden. Die Divisionen durch 4 und 2, welche auf z1 und z2 anzuwenden sind, werden durch eine einfache Subtraktionsoperation auf den Exponenten dieser Zahlen implementiert, wofür nur sehr wenig Logikressourcen benötigt werden. Bei der Division z1 /4 muss ein auftretender ExponentUnderflow festgestellt werden, um für x ≥ 1 gegebenenfalls das Ergebnis W 0 auf Null zu setzten. Bis auf diesen Fall braucht keine weitere spezielle Aktion bei auftretenden UnderflowAusnahmen implementiert zu werden. Falls im Logikpfad zur Bestimmung von z4 an irgendeiner Stelle ein Underflow auftritt, ist der in den Operator 6 eingehende Exponent so klein, dass automatisch z4 = 1 ausgegeben wird. Auf der anderen Seite wird jeder auftretende Underflow im Logikpfad für z3 zu einem erneuten Underflow in ExpMinusX führen, welcher wie beschrieben behandelt wird. Berechnung des Gradienten ∇W(r, h) Der Gradient des Spline-Kernes aus Gleichung 7.1, der insbesondere für die Kraftberechnung der SPH-Methode benötigt wird, berechnet sich wie folgt (x = |~ri −~r j |/h): −3 + 49 x : 0 ≤ x < 1 1 ~r ∇W (|~ri −~r j |, h) = ij − 43 x + 3 − 3x : 1 ≤ x < 2 π h5 (7.5) 0 : sonst 3 ~r Ω(x). = ij π h5 Der Kern dieser Funktion ist die skalare Funktion Ω(x), die hier noch einmal separat aufgestellt wird: −1 + 43 x : 0 ≤ x < 1 1 Ω(x) = (7.6) −1 4 x+1− x : 1 ≤ x < 2 0 : sonst. Abbildung 7.3 zeigt den Verlauf dieser Funktion. Sie wurde nicht aus Modulen für die Standardoperationen zusammengesetzt, sondern es wurde dafür ein spezieller Gleitkomma-Operator aufgebaut, um optimal von den Eigenschaften dieser speziellen Funktion zu profitieren. Abbildung 7.4 zeigt die Umsetzung der Schaltung. Es wurden zwei getrennte Rechenwerke zur Berechnung von 1 − 3/4x (links) und 1/4 x + 1/x − 1 (rechts) implementiert. Die Unterscheidung, welche Formel angewandt wird, kann allein aufgrund des Exponenten getroffen werden. Liegt die Zahl im Intervall [1, 2), ist der Exponent der Zahl identisch mit dem Bias der Exponentendarstellung. In diesem Fall wird durch einen Multiplexer das Ergebnis der rechten Schaltung ausgewählt, ansonsten das der linken Schaltung. Kann eine Eingangszahl größer oder gleich 2 auftreten, ist dies durch Test auf e > bias festzustellen und in diesem Fall die Ausgabe auf Null zu setzen (in der Schaltung nicht gezeigt). 174 KAPITEL 7. IMPLEMENTIERUNG DES RECHENBESCHLEUNIGERS Abbildung 7.3: Kernfunktion Ω für SPH entsprechend Formel 7.6. Linkes Rechenwerk Dieses Rechenwerk ist eine Abwandlung des Operators Special1MinusX aus Abbildung 7.2 (Operator 6 ), denn es wird ebenfalls eine Zahl ≤ 3/4 von 1 subtrahiert. Hier wird jedoch zusätzlich die Berechnung des Produktes 3/4 x in den Operator integriert, da diese Operation dann über eine einfache Festkommazahlberechnung auf der eingehenden Mantisse s ausgeführt werden kann. Die Multiplikation von x mit drei erfolgt durch die Addition der um eine Stelle linksverschobenen Mantisse s zu s. Die resultierende Zahl (mit MSB der Wertigkeit 22 ) wird über das Modul ShiftN rechtsverschoben, genauso wie es in der Preparation-Stufe bei allen Gleitkomma-Addierern durchgeführt wird. Die Verschiebeweite ergibt sich hier aus der Differenz des Exponenten-Bias mit dem eingehenden Exponenten e. Die Division durch 4 erfolgt durch die Interpretation der Shifter-Ausgabe als Zahl mit einem MSB der Wertigkeit 20 , wobei die beiden LSBs dann die Stelle eines Guard- und Round-Bits annehmen. Die Differenz 1 − 3/4x ergibt sich dann durch Bildung des Zweierkomplements und Invertierung des MSBs. Das Ergebnis kann maximal zwei führende Nullen aufweisen, welche in der Normalisierungseinheit eine entsprechende Linksverschiebung induzieren. Entsprechend den Werten der beiden MSBs kann der Exponent des Resultats über eine Look-Up-Table mit drei Einträgen in LookupExponent gefunden werden. Um Ressourcen zu sparen, wurde keine Rundungsoperation implementiert. Rechtes Rechenwerk Da das rechte Rechenwerk nur für x ∈ [1, 2) zum Zuge kommt, entfällt der Preparation-Schritt. Die aufwändigste Operation dieses Rechenwerkes ist die Kehrwertberechnung der Mantisse. Diese wird mit einer Genauigkeit von M + 1 Stellen durchgeführt. Die Addition von 1/4 x erfolgt über einen einfachen Ripple-Carry-Addierer, die nachfolgende Subtraktion von 1 durch die Invertierung des MSB des Additionsresultats. Die resultierende Festkommazahl liegt im Intervall [0.25, 0]. Es kann also eine Linksverschiebung um M + 1 Stellen notwendig werden, mindestens jedoch um zwei Stellen. Letzteres impliziert, dass bereits der Addierer um zwei führende Stellen gekürzt werden kann und auch die Operation InvertMSB ent- 175 7.1. IMPLEMENTIERUNG DER RECHENWERKE FÜR SPH A Unpack e s 1 − 3/4 A 1/4 A+ 1/A − 1 M Analize Exponent equal bias s +2s 1 s M+2 d M+1 00 ShiftN Shifts M+2 LSB M+2 2s Complement Invert MSB Invert MSB M+2 Normalize Normalize Shifts M Lookup Exponent S0 M Generate Exponent 1 S0 1 Pack Ω (A) Abbildung 7.4: Spezialoperator zur Berechnung der Kernfunktion Ω für SPH entsprechend Formel 7.6. 176 KAPITEL 7. IMPLEMENTIERUNG DES RECHENBESCHLEUNIGERS behrlich ist (aus Gründen der Verständlichkeit wurde diese Vereinfachung nicht in Abbildung 7.4 gezeigt). Der Ergebnisexponent wird alleine durch die Verschiebeweite bestimmt. Er wird im Element GenerateExponent gebildet. Eine Rundung des Ergebnisses erfolgt wie im linken Rechenwerk nicht. 7.1.2 Designmethode für die Rechenwerke Alle FPGA-Designs wurden in VHDL entwickelt. Um die aus insgesamt über 100 Gleitkommaoperatoren bestehenden Designs sowohl für die Erzeugung der Codes als auch für die Simulation der Schaltungen beherrschbar zu machen, wurden folgende Methoden angewandt: • Die Schaltungen wurden hierarchisch aufgebaut. Es wurden nur vier Hierarchiestufen verwendet: die elementaren Operatoren (z.B. Addition, Multiplikation), die zusammengesetzten Operatoren (z.B. Skalarprodukt), Formelteile (z.B. Berechung der Glättungskerne) und das Gesamtrechenwerk. Dadurch wurde ein Kompromiss zwischen der Codelänge für die Module und der Übersichtlichkeit der Signale bei der Simulation erreicht. • Für die Ebene der Formelteile und des Gesamtrechenwerks wurde ein Design-Schema angewandt, welches durch Abstraktion der Gleitkommazahlsignale und Vereinheitlichung des Codes für das Verbinden von Operatoren eine übersichtliche und leicht zu verifizierende Design-Erstellung erlaubt. Der zweite Punkt soll nun noch etwas weiter ausgeführt werden. Die Simulation eines komplexen Rechenwerks ist extrem schwierig, wenn die Zwischenergebnisse nur als Bitvektoren vorliegen. Deshalb wurde eine abstrahierende Datenstruktur für die Zwischenergebnisse implementiert, die für die Syntheseversion die Bitvektoren für Mantisse, Exponent und Vorzeichen enthält. Für die Simulation ist dagegen zusätzlich ein Gleitkommafeld vorhanden, welches zu jeder Zeit die durch die Bitvektoren dargestellte Zahl anzeigt. Einzelne Operatoren werden verbunden, indem über einheitliche VHDL-Prozeduren eine Verknüpfung der abstrahierten Gleitkommasignale zu den Ein- und Ausganssignalen der Operatoren erzeugt wird. Diese Signale bleiben vorerst ebenfalls in der abstrahierten Darstellung, und werden erst bei der Erzeugung der Operatoren aufgelöst. Auf diese Weise lässt sich sehr intuitiv die Verbindungsstruktur des Rechenwerks programmieren und der große Overhead an Code zur Erzeugung der Operatoren wird in einen separaten Codeabschnitt verschoben. In diesem von der strukturellen Beschreibung abgesonderten VHDL-Code werden die Instanzen der Operatoren durch ein festes Schema implementiert. Die Ein- und Ausgangssignale haben für alle Operatoren die gleichen Bezeichnungen und unterscheiden sich nur in der Operatornummer. Die noch abstrahierten Eingangssignale werden in Bitvektoren aufgelöst und mit dem betreffenden Operator verbunden. Die Ausgangssignale werden sofort wieder in eine abstrahierte Darstellung überführt. Auf diese Weise kann die Operatorinstanziierung sehr schnell anhand von Vorlagen geschehen. Die Operatoren können für verschiedene Mantissenbreiten verschiedene Latenzzeiten aufweisen. Deshalb wurde auch die Erzeugung von Ausgleichsgliedern zwischen den Operatoren 7.1. IMPLEMENTIERUNG DER RECHENWERKE FÜR SPH 177 schematisiert. Zu jedem Operator gibt es eine Funktion, welche in Abhängigkeit von den Operatorparametern die Latenzzeit zurückgibt. Anhand dieser Funktionen wird jedem Zwischenergebnis eine Latenzzeit zugeordnet. Basierend auf diesen Zahlen wird das Einfügen von Ausgleichsgliedern durch ein ähnliches Abstraktionsschema umgesetzt wie bei der Erzeugung der Operatoren. Das Verfahren kann automatisiert werden, indem beispielsweise anhand der abstrahierten Signale nur die Verbindungsstruktur programmiert wird und der Rest durch einen Codegenerator erzeugt wird. Diese Automatisierung wurde noch nicht implementiert. 7.1.3 Rechenwerk für die SPH-Dichteberechnung Struktur Wie in der Formulierung nach Abschnitt 2.3.2 sind im ersten Schritt des SPH-Formalismus folgende Formeln zu berechnen: ρi = ∑ m j W (|~ri j |/hi j ) (7.7) ∑ m j (~v j −~vi) ∇iW (|~ri j |/hi j ) (7.8) ∑ m j (~vi − ~v j ) × ∇iW (|~ri j |/hi j ). (7.9) j ρi (∇ ·~v)i = j ρi (∇ ×~v)i = j Zur Implementierung der Summationsvorschrift nach Gleichung 7.7 ist anzumerken, dass die Kernfunktion W (|~ ri j |/hi j ) über die Gleichung W (|~ ri j |/hi j ) = 1/π · W 0 (|~ ri j |/hi j )/h3i j implementiert wurde (siehe Beschreibung zu Gleichung 7.2). Der Vorfaktor 1/π wurde weggelassen, was leicht im Steuerungsrechner korrigiert werden kann. Der Gradient von W wird nach der in Gleichung 7.5 gegebenen Formel berechnet. Auch hier wird die Multiplikation des Vorfaktors 3/π auf eine Korrekturmultiplikation im Steuerungsrechner verschoben. Es ergibt sich damit folgendes Rechenschema für die Gleichungen 7.7 bis 7.9: π ρi = mj ∑ h3 j π − ρi (∇ ·~v)i = 3 π ρi (∇ ×~v)i = 3 ∑ h5 (~ vi j · r~i j ) Ω(|~ ri j |/hi j ) (7.11) (~ vi j × r~i j ) Ω(|~ ri j |/hi j ). (7.12) ij mj ∑ h5 j (7.10) ij mj j W 0 (|~ ri j |/hi j ) ij Ausschlag gebend für die Architektur der Implementierung des Rechenwerkes für diese Formeln war die Maßgabe, möglichst wenig Ressourcen zu verwenden und daher die Anzahl an Operatoren zu minimieren. Gemäß dieser Regel bleibt nur eine geringe Gestaltungsfreiheit, die sich im Wesentlichen auf die Anordnung nacheinander folgender kommutierender Operationen begrenzt. In Abbildung 7.5 ist der Aufbau der resultierenden Implementierung zu sehen. 178 KAPITEL 7. IMPLEMENTIERUNG DES RECHENBESCHLEUNIGERS Data Interface r provide i, r j, v i, v j, h ,i h ,j m j Difference Vector v ij = v i − v j Difference Vector r ij = r i − r j Mean Value h +h h ij = i j 2 Inverse Vector Square Crossprod vxr ij = v ij r ij u ij = r ij2 = r ij ⋅ r ij Scalarprod vrij = v ij ⋅ r ij mj 1 h ij Square Root Square u2ij r ij = sqrt(r2ij ) Mult n ij = r ij u ij Kernel Kernel Ω( n ij ) W' ( n ij ) Mult u 3ij = u ij u ij2 Mult mu3ij = mj u ij3 Mult mu5ij = muij3 u ij2 Mult V ij = muij5 Ω Density ρij ρij = mu3ij W' Accumulate Curl rotv i,x = rotv i,x + Vijvxrij,x rotv i,y = rotv i,y + Vijvxrij,y rotv i,z = rotv i,z + Vijvxrij,z Accumulate Divergence divv i = divv i + Vijvrij Accumulate Density ρi = ρi + ρij Abbildung 7.5: Blockschaltbild zur SPH-Dichteberechnung. 7.1. IMPLEMENTIERUNG DER RECHENWERKE FÜR SPH 179 Bewertet man die Berechnung von Ω nach Gleichung 7.6 mit vier Operationen, sind für das gesamte Rechenwerk 54 elementare Gleitkommaoperatoren zu implementieren. Darunter sind 20 Multiplizierer, 5 Quadrierer, 15 Addierer, 5 Akkumulatoren, jeweils ein Dividierer und ein Quadratwurzel-Operator und diverse spezielle Operatoren für die Kernfunktionen. Für alle Operationen wurde die gleiche Mantissenbreite implementiert. Bis auf die Berechnung von Ω wurde für alle Operationen der Rundungsmodus Round To Nearest Integer verwendet, da die Simulation bei Verwendung dieses Modus gegenüber dem Standardmodus keinerlei Nachteile zeigte, sich jedoch etwa 10 % der FPGA-Ressourcen einsparen lassen. Sollten sich für spätere astrophysikalische Simulationen bezüglich des Rundungsmodus Probleme ergeben kann auch der Modus Round To Nearest Even verwendet werden, da wie im letzten Kapitel beschrieben auch dieser Modus von den implementierten Gleitkommaoperationen unterstützt wird. Implementierungsaufwand Die Implementierung des Rechenwerks für den ersten Schritt des SPH-Algorithmus führte zu folgendem Ressourcenverbrauch, wobei in Klammern die Anteile an den insgesamt zur Verfügung stehenden Ressourcen eines Virtex-II-FPGAs vom Typ XC2V3000 notiert sind: 10618 LUTs (37 %) 8196 1-Bit-Register (29 %) 25 18×18-Bit-Blockmultiplizierer (26 %) 6924 Slices (48 %) Für das Rechenwerk wird also etwas weniger als die Hälfte eines FPGAs mittlerer Größe aufgewendet. Damit gibt es also noch Erweiterungsspielraum für zusätzliche Gleichungen, beispielsweise für die Berücksichtigung zusätzlicher Physik. Laut Synthese-Werkzeug kann das Rechenwerk mit einer Taktfrequenz von 74 MHz betrieben werden. Die unter Verwendung dieses Rechenwerks erzielte Rechenleistung und Rechengenauigkeit wird in Abschnitt 7.4 diskutiert werden. 7.1.4 Rechenwerk für die SPH-Kraftberechnung Struktur Für den zweiten Schritt des SPH-Algorithmus wurden die Formeln für die Druckkraft des Gases einschließlich Berücksichtigung der künstlichen Viskosität implementiert. Entsprechend den 180 KAPITEL 7. IMPLEMENTIERUNG DES RECHENBESCHLEUNIGERS Gleichungen 2.32 und 2.35 sind dazu folgende Berechnungen durchzuführen: ! Pj d~vi Pi ~∇iW ~ri j /hi j = −∑mj + + Π i j dt ρi2 ρ 2j j 2 −αci j µi j + β µi j : ~vi j~ri j ≤ 0 Πi j = ρi j 0 : ~vi j~ri j > 0 µi j = hi j (~vi j ·~ri j ) ~ri2j + η 2 h2i j fi j . (7.13) (7.14) (7.15) Die Größen fi j , ci j und ρi j sind Mittelwerte aus den Balsara-Faktoren, Schallgeschwindigkeiten und Drücken für Teilchen i und j, genau wie bei hi j . Die Berechnung des Entropieterms aufgrund der künstlichen Viskosität nach Gleichung 2.41 wurde vorerst nicht implementiert. Wird eine isotherme oder isentrope Zustandsgleichung angenommen, ist dieser Term entbehrlich. Soll stattdessen auf Grundlage einer adiabatischen Zustandsänderung simuliert werden, lässt sich dieser Term leicht einbauen. Es werden lediglich zwei weitere Multiplizierer und ein Akkumulator dazu benötigt. Der erste Multiplizierer bildet dann das Produkt der für die Viskosität berechneten Terme Πi j · (~ vi j · r~i j ), welches danach mit dem ebenfalls bereits für die Druckkraftberechnung bestimmten Faktor mi j /h5i j Ω zu multiplizieren ist. Das Schema entspricht genau der Vorgehensweise zur Berechnung von ρi (~∇ ·~v)i im letzten Abschnitt (siehe Gleichung 7.11). Für Gleichung 7.13 kann folgendes Rechenschema angewendet werden: ! m j Pi Pj π d~vi = −∑ 5 + + Π Ω |~ r |/h . (7.16) i j i j i j 3 dt ρi2 ρ 2j j hi j Für diese Berechnung müssen 52 Operatoren implementiert werden, wobei nur die “großen” Operatoren gezählt wurden. Rechnet man entsprechend der Operatorzahl einer Softwareimplementierung, wo auch Divisionen durch Potenzen von 2 eine volle Gleitkommaoperation bedeuten, kommt man auf 60 Operationen. Von den elementaren Operatoren werden drei Akkumulatoren, 9 allgemeine Addierer, 8 Addierer für positive Zahlen, 14 Multiplizierer, 10 Quadrierer, drei Dividierer und ein Quadratwurzel-Operator benötigt. Hinzu kommt der Ω-Operator aus Abschnitt 7.1.1. In Abbildung 7.6 ist die resultierende Schaltung skizziert. Wie für den ersten Schritt des SPH-Algorithmus wurde auch hier für alle Operatoren die gleiche Mantissenbreite verwendet. Es wurde ebenfalls wieder, mit Ausnahme der Berechnung von Ω, ausschließlich der Rundungsmodus Round To Nearest Integer verwendet. Implementierungsaufwand Die Implementierung des Rechenwerks für den zweiten Schritt des SPH-Algorithmus führte zu folgendem Ressourcenverbrauch (In Klammern der Anteil an den Gesamtressourcen des VirtexII XC2V3000): 181 7.1. IMPLEMENTIERUNG DER RECHENWERKE FÜR SPH Data Interface provide r i , r j , v i , v j , h i , h j , ρ i , ρj , p i , pj , f i , f j , c i, c j , mj Difference Vector v ij = v i − v j Difference Vector r ij = r i − r j Mean Value h +h h ij = i j 2 Scalarprod Vector Square w ij = v ij ⋅ r ij r ij2 = r ij ⋅ r ij Mean Value c +cj c ij = i 2 Mean Value f +f f ij = i j 2 pDivRho2 qi = p /ρ 2 i i or q j = p j / ρ j2 Mean Value ρi + ρj ρ ij = 2 µ µ ij = mj h ij wij f ij r 2ij + h 2ij η2 qj qi Π Π ij = − α c ij µ ij + β µ 2ij ρ ij : wij ≤ 0 0 : wij > 0 h ij Square Root r ij = sqrt(r2ij ) u ij = 1 h ij 5 u ij Scalar Factor V Kernel 5 Ω( r ij , u ij ) Vij = m j u ij ( q i + q j + Π ij ) Ω Accumulate Acceleration a i,x = a i,x +Vij r ij,x a i,y = a i,y +Vij r ij,y a i,z = a i,z +Vij r ij,z Abbildung 7.6: Blockschaltbild zur Berechnung der Beschleunigung durch den Druckgradienten und künstliche Viskosität. 182 KAPITEL 7. IMPLEMENTIERUNG DES RECHENBESCHLEUNIGERS 10900 LUTs (38 %) 8433 1-Bit-Register (29 %) 25 18×18-Bit-Blockmultiplizierer (26 %) 7097 Slices (49 %) Für dieses Rechenwerk wird also leicht mehr an FPGA-Ressourcen aufgewendet als für die Schaltung zu Schritt 1 des SPH-Formalismus. Es gibt auch hier noch Erweiterungsspielraum für zusätzliche Berechnungen. Laut Synthese-Werkzeug kann das Rechenwerk ebenfalls mit einer Taktfrequenz von 74 MHz betrieben werden. Zur erzielten Rechenleistung und Rechengenauigkeit sei auf Abschnitt 7.4 verwiesen. 7.2 Einbettung in den FPGA-Prozessor Es wurden getrennte FPGA-Designs für den ersten und zweiten Schritt des SPH-Algorithmus implementiert. Ein gemeinsames FPGA-Design für beide Schritte wurde für die Prototypimplementierung aus folgenden Gründen nicht angestrebt: • Die verfügbaren Logikressourcen sind für zwei eigenständige Rechenwerke für Schritt 1 und Schritt 2 nicht ausreichend. Es müssten unter hohem Entwicklungsaufwand Designs erstellt werden, die beide Rechenschritte mit überlappenden Teilrechenwerken umsetzen, was die Effizienz der Implementierung deutlich senken würde. • Schon aufrund der begrenzten Speicherbandbreite können die beiden Schritte nicht simultan gerechnet werden. Die gleichzeitige Berechnung erscheint aufgrund der Struktur des Simulationscodes auch wenig sinnvoll. • Die Konfigurationszeit des FPGAs beträgt etwa 40 Millisekunden, wenn sich der Konfigurationsbitstrom bereits im Speicher befindet. Demgegenüber liegt die Rechenzeit pro SPH-Schleife bei typischerweise über 10 Sekunden. Für die Prototypimplementierung bedeutet die Rekonfigurierung deshalb nur eine unwesentliche Verschlechterung der Rechenleistung. Das FPGA-Design der Rechenbeschleunigerarchitektur wurde unter dem Gesichtspunkt der leichten Portierbarkeit auf andere Systeme aufgebaut. Es wurde ein modulares Design gewählt, bei dem die Rechenwerke logisch von der Peripherie getrennt wurden. Die Rechenpipeline kommuniziert über eine architekturunabhängige Schnittstelle mit einem Interface-Modul (SPH-Interface). Dieses implementiert alle plattformspezifischen Schnittstellen zur Umgebung. Dies sind insbesondere die Anbindung an Speicherressourcen und die Verbindung mit dem FPGA-Interface, welches mit der Außenwelt kommuniziert. Abbildung 7.7 zeigt die Struktur bei Verwendung des MPRACE-Boards aus Abschnitt 3.3. Es wurden auch Portierungen auf andere Systeme implementiert, insbesondere auf das japanische PROGRAPE-System aus Abschnitt 2.4.2. Das Modul SPH Pipeline nimmt die Rechenwerke für Schritt 1 oder 2, die in den letzten Abschnitten beschrieben wurden, auf. Es verfügt über getrennte Eingänge für die Daten von Teilchen mit Index i und j (Nomenklatur wie bei der Formulierung der SPH-Gleichungen). Als 183 7.2. EINBETTUNG IN DEN FPGA-PROZESSOR MPRACE SRAM 1 SRAM SPH-Interface 2 i-data j-data results SRAM 3 SRAM 4 SPH Pipeline control PCI Interface FPGA-Interface FPGA Abbildung 7.7: Modulares Design des Rechenbeschleunigers zur Abstraktion der Hardwareumgebung. Flusskontrolle wird signalisiert, wann die Daten für eine Berechnung übernommen werden sollen, ob eine neue Summation begonnen wird und wann die letzten Daten eingehen. In Abbildung 7.7 sind diese Signale durch die Bezeichnung control angedeutet. Registriert das Modul SPH Pipeline das Eingehen eines abschließenden Datensatzes, wird die aktuelle Akkumulation abgeschlossen und das Resultat an SPH-Interface übertragen. Die Pufferung der Resultate muss von dieser Schnittstelle übernommen werden. Denn die Pipeline ist dazu ausgelegt, kontinuierlich Berechnungen durchzuführen, weshalb die Akkumulatorinhalte sofort nach Abschluß einer Akkumulation gelöscht werden. Das MPRACE-Board verfügt über vier unabhängige SRAM-Bänke mit einer Breite von jeweils 36 Bit. Darin werden die Teilchendaten für die SPH-Berechnung in einer Form abgelegt, sodass auf sie parallel zugegriffen werden kann. Für das in der Prototypimplementierung verwendete Gleitkommaformat mit 16-Bit-Mantissen und 8-Bit-Exponenten werden pro Zahl 24 Bit benötigt. Damit kann also maximal auf sechs Werte gleichzeitig zugegriffen werden. Für die Kraftberechnung werden jedoch 12 Teilchenvariablen benötigt. Deshalb wird das Speicherinterface mit doppelter Taktfrequenz relativ zur Pipeline betrieben. Damit können in jeder Taktperiode die benötigten Teilchendaten parallel ausgelesen werden und die Pipeline kann mit voller Auslastung arbeiten. Auf dem MPRACE-Board können die Daten von maximal 65536 Teilchen gespeichert werden. 184 KAPITEL 7. IMPLEMENTIERUNG DES RECHENBESCHLEUNIGERS A Update SRAM Particle Data HOST PIPELINE FIFO B Calculate Neighbor List SRAM Particle Data HOST PIPELINE Results FIFO Results Abbildung 7.8: Datenfluss zwischen Host und Rechenbeschleuniger für die Prototypimplementierung. Vor der Berechnung werden die Teilchendaten aktualisiert (A). Die Berechnung geschieht synchron mit der Übertragung der Nachbarschaftslisten (B). 7.3 Datenfluss und Steuerung der Prototypimplementierung Aus dem derzeitigen Design des Rechenbeschleunigers ergibt sich ein Kommunikationsschema in zwei Phasen, wie es in Abbildung 7.8 dargestellt ist. In der ersten Phase werden die benötigten Teilchendaten über einen DMA-Zugriff in das SRAM des MPRACE geschrieben. Während dieser Phase ruhen die Rechenwerke. In der zweiten Phase werden die Nachbarschaftslisten der Teilchen transferiert, für welche die SPH-Formeln berechnet werden sollen. Diese Listen bestehen aus den Speicherindices für die Daten der Nachbarteilchen. Diese Indices werden direkt zur Addressierung der Teilchendaten im Speicher verwendet und die so ausgelesenen Daten werden für den nächsten Berechnungsschritt in die SPH-Pipeline geführt. Die Pipeline rechnet synchron mit den Zugriffen auf die Teilchendaten und pro Takt kann eine SPH-Summation durchgeführt werden. Die Resultate der Rechenpipeline müssen gepuffert werden. Um eine hohe Übertragungs- 185 7.4. ERGEBNISSE FÜR DEN RECHENBESCHLEUNIGER LUTs Regs Slices 18×18-BlockMultipizierer Design Freq. (MHz) Design mit Pipeline Design mit Pipeline für SPH-Schritt 1 für SPH-Schritt 2 11049 (38.5 %) 11139 (38.8 %) 9028 (31.5 %) 9597 (33.5 %) 7625 (53.2 %) 7975 (55.6 %) 25 25 67 69 Tabelle 7.1: Ressourcenverbrauch und Geschwindigkeit der FPGA-Designs für die Prototypimplementierung auf dem Virtex-II-FPGA XC2V3000-4. bandbreite zwischen Host und MPRACE zu gewährleisten, wurde von einer DMA-Blockgröße von 8 KByte ausgegangen, wofür sowohl für Schreib- als auch Lesezugriffe etwa 200 MBytes/sec erreicht werden (siehe Abbildung 5.8 aus Kapitel 5). Dann müssen 2000 Resultate zwischengespeichert werden. Da in der Prototypimplementierung die Resultate eine Breite von 24-Bit haben, genügen dafür bereits drei Block-RAM-Elemente des Virtex-II-FPGAs, die als FIFO betrieben werden können. Mit neun Rechenergebnissen pro Nachbarschaftsliste bei der Pipeline zur Dichteberechnung (inklusive Divergenz und Rotation der Geschwindigkeit; positive und negative Ergebnisse werden getrennt akkumuliert) können die Ergebnisse von 227 Berechnungen gepuffert werden. Die zugehörigen Nachbarschaftslisten haben bei durchschnittlich 50 Nachbarn pro Teilchen dann eine Größe von etwa 40 KByte. 7.4 Ergebnisse für den Rechenbeschleuniger In Tabelle 7.1 sind die Resultate für den Ressourcenverbrauch und die Geschwindigkeit der in Abschnitt 7.2 beschriebenen Prototypimplementierung gezeigt. Die Pipelines zu Schritt 1 und Schritt 2 des SPH-Algorithmus entsprechen genau den in den Abschnitten 7.1.3 und 7.1.4 beschriebenen Schaltungen. Beide FPGA-Designs können mit der Taktfrequenz des PCI-Bus rechnen. Wird der erste Schritt des SPH-Algorithmus mit 54 Operationen bewertet, resultiert für das erste Design eine Peak-Rechenleistung von 3.5 GFlops. Für das zweite Design ergibt sich bei 60 Operationen eine Spitzenleistung von 3.9 GFlops. Solange Nachbarschaftslisten mit 66 MHz bereitgestellt werden, kann diese Rechenleistung aufrecht erhalten werden. Etwa 20 Prozent der Rechenleistung für Schritt 1 und 15 Prozent für Schritt 2 gehen dadurch verloren, dass die Ergebnisse zurück zum Host transferiert werden müssen. Berücksichtigt man noch den Transfer der Teilchendaten vor der Berechnung (Etwa 20 % des Volumens der Nachbarschaftslisten), findet man, dass die Prototyparchitektur nur mit etwa 50 % Auslastung rechnen kann (ca. 1.75 GFlops für Schitt 1 und 1.95 GFlops für Schritt 2). Mit der aktuellen Prototyparchitektur sind die Pipelines zwar in der Lage, mit einer Geschwindigkeit von 66 MHz zu arbeiten, jedoch hat sich gezeigt, dass das mit doppelter Taktrate betriebene SRAM des MPRACE nicht bis 133 MHz betrieben werden kann. Es wurde eine Re- 186 KAPITEL 7. IMPLEMENTIERUNG DES RECHENBESCHLEUNIGERS Größe ρ ~∇ ·~v ~∇ ×~v d~v/dt mittlerer relativer Fehler für FPGA-Implementierung (2.85 ± 1.53) · 10−5 (0.84 ± 0.38) · 10−3 (0.88 ± 0.23) · 10−3 (1.3 ± 0.8) · 10−3 mittlerer relativer Fehler nach Simulation (2.24 ± 1.04) · 10−5 (0.88 ± 0.26) · 10−3 (0.86 ± 0.19) · 10−3 (1.2 ± 1.1) · 10−3 Tabelle 7.2: Rechengenauigkeit der FPGA-Implementierung für Schritt 1 und Schritt 2 des SPHAlgorithmus im Vergleich mit der Simulation aus Abschnitt 5.3.2. Es wurde mit den gleichen Teilchenverteilungen gerechnet, die für die Simulation in Kapitel 5 verwendet wurden. duktion der Taktfrequenz auf 50 MHz erforderlich, wodurch sich die Spitzenleistung auf 2.7 GFlops für den ersten SPH-Schritt und 3 GFlops für den zweiten reduziert. Um damit eine Dauerrechenleistung von über 2 GFlops zu erreichen, wie in Abschnitt 5.4 gefordert wurde, muss ein Re-Design des SPH-Algorithmus und der FPGA-Architektur erfolgen, sodass mit komprimierten Nachbarschaftslisten gearbeitet werden kann. Nur so kann das derzeit die Rechenleistung limitierende Speicher- und Kommunikationsbandbreitenproblem gelöst werden. Ein möglicher Ansatz besteht darin, auszunutzen, dass sich die Nachbarschaftslisten benachbarter SPH-Teilchen stark überlappen, also viele der Listeneinträge übereinstimmen. Berücksichtigt man zudem, dass die Akkumulatoren mit geringem Aufwand mit der Fähigkeit ausgestattet werden können, mehrere unabhängige SPH-Summen überlappend auszuführen, sollte sich das Bandbreitenproblem lösen lassen. Diese Strategie wird Bestandteil der weiteren Entwicklungen in diesem Projekt sein. In Tabelle 7.2 sind die erzielten Rechengenauigkeiten der FPGA-Implementierungen gezeigt. Zur deren Messung wurden die gleichen Bedingungen angesetzt, die schon in Kapitel 5 in Abschnitt 5.3.2 im Zusammenhang mit der Simulation der Rechenwerke vorgestellt wurden. Zum Vergleich wurden in Tabelle 7.2 auch die Simulationsergebnisse aufgeführt. Für die Dichteberechnung ergeben sich leicht erhöhte Rechenfehler, die jedoch gegenüber der Schwankung der Fehler für die verschiedenen Teilchenverteilungen nicht signifikant sind. Die Abweichungen gegenüber der Simulation lassen sich aus dem speziellen Ressourcen sparenden Aufbau des Rechenwerks für den Spline-Kern erklären. Hierfür wurden Spezialoperatoren für (2 − x) und (1 − x) verwendet (siehe Abschnitt 7.1.1), die in dieser Art nicht simuliert wurden. Für alle übrigen Fehlergrößen aus Tabelle 7.2 lassen sich keine signifikanten Abweichungen feststellen. Die spezielle Architektur zur Berechnung von Ω nach Abschnitt 7.1.1 führt also nicht zu einer Verschlechterung der Genauigkeit. Die erzielten Ergebnisse bestätigen den Grundgedanken der Arbeit, dass basierend auf der FPGA-Technologie ein Rechenbeschleuniger für SPH-Algorithmen aufgebaut werden kann. Dabei kann die Rechengenauigkeit auf solch hohem Niveau gehalten werden, dass keinerlei Anomalien im dynamischen Verhalten der simulierten Systeme zu befürchten sind. Die erreichbare Rechenleistung genügt für einen deutlichen Speedup der Gesamtanwendung, jedoch bedarf es zur Ausschöpfung der Beschleunigung noch weiterer Entwicklungen an den Simulationsalgorithmen, um die derzeitigen Einschränkungen durch die Datenkommunikation zu überwinden. Kapitel 8 Zusammenfassung und Diskussion In dieser Arbeit wurde untersucht, wie das Verfahren Smoothed Particle Hydrodynamics zur Simulation der Hydrodynamik astrophysikalischer Systeme durch den Einsatz eines rekonfigurierbaren Koprozessors beschleunigt werden kann. Damit wurde ein wichtiges Teilproblem astrophysikalischer Simulationen unter dem Aspekt der Anwendbarkeit neuer Rechentechniken behandelt. Es konnte ein System aufgebaut werden, welches für die zeitkritischen Berechnungsschritte des SPH-Formalismus eine Rechenleistung von über 3 GFlops erreicht. Daraus ergibt sich für astrophysikalische Simulationen ein Beschleunigungspotential um den Faktor 10. Dieses Potential kann jedoch erst ausgeschöpft werden, wenn die Simulationscodes tiefgreifend verändert werden. Dies wird Gegenstand der weiteren Forschung sein. Motivation und Strategie Der Ansatz, Spezialarchitekturen zu verwenden, motiviert sich aus dem grundsätzlichen Problem, dass die Entwicklung von allgemein verwendbaren Rechnersystemen die Untersuchung dringender astrophysikalischer Fragestellungen auf absehbare Zeit nicht ermöglichen wird, obwohl die Entwicklung der Rechenleistung durchaus beeindruckend ist. Mit dem Gedanken, durch Spezialarchitekturen die Rechenleistung linear sowohl an die Steigerung der Transistorzahl als auch der Taktfrequenz zu koppeln, erhofft man sich, die Mainstream-Entwicklung der Rechenleistung weit übertreffen zu können. Dies würde einen Durchbruch in den Möglichkeiten astrophysikalischer Simulationen bedeuten. Eine solche Skalierung mit der Chipentwicklung ist möglich, wenn ein Algorithmus auf der Ebene der Rechenoperationen durch Spezialrechenwerke parallel implementiert werden kann, so dass die Schaltung dauerhaft ausgelastet wird. Für die Berechnung der Gravitationswechselwirkung hat sich dieser Ansatz bereits als sehr erfolgreich erwiesen. So erreichen die GRAPE-Spezialrechner (beschrieben in Abschnitt 2.4.2) mit einem einzigen System in der Größe einer Workstation eine Rechenleistung eines Supercomputers (1 TFlop). Kann SPH durch einen ähnlichen Ansatz ebenfalls beschleunigt werden, lässt sich für viele Anwendungen eine Vervielfachung der Simulationsleistung erreichen. Diese Arbeit wurde interdisziplinär durchgeführt. Die Grundlagen von Seiten der Astrophysik wurden in Kapitel 2 eingeführt, in den Kapiteln 3 und 4 dagegen wurden die notwendigen Grundlagen der Technik und Computerarithmetik ausgeführt. In Kapitel 5 wurden anhand 187 188 KAPITEL 8. ZUSAMMENFASSUNG UND DISKUSSION von Messungen an den astrophysikalischen Codes und Abschätzungen des Speedups einer hybriden Rechnerarchitektur aus Standardrechner und Rechenbeschleuniger die Voraussetzungen aus Physik und Informatik zusammengeführt. Daraus ergaben sich die Kriterien nach denen die Beschleunigerarchitektur entwickelt wurde. Der Ansatz, einen FPGA-Koprozessor zu verwenden und Gleitkommaarithmetik mit beschränkter Genauigkeit anzuwenden, konnte als geeignete Strategie herausgestellt werden. Für die Architektur innerhalb des FPGAs wurde die vollständige Parallelisierung der SPH-Berechnungen in Form von Rechenpipelines gewählt. Demzufolge wurden die Rechenelemente für ein FPGA-basiertes System entwickelt (Kapitel 6), und aufbauend darauf ein Prototyp für einen Rechenbeschleuniger synthetisiert (Kapitel 7). Es soll nun auf diese Schritte im einzelnen eingegangen werden. Voraussetzungen von Seiten der astrophysikalischen Simulationsalgorithmen In Kapitel 2 wurden die Standardmethoden der numerischen Simulation astrophysikalischer Systeme erläutert. Es wurde gezeigt, dass für stoßfreie Systeme wie Galaxien effiziente Simulationsverfahren existieren, die im Rechenaufwand mit N log N skalieren (Teilchenzahl N). Die für eine Vielzahl von astrophysikalischen Systemen zu berücksichtigende Hydrodynamik kann durch das SPH-Verfahren durch eine Teilchenmethode (wie die Gravitation) berücksichtigt werden. In SPH wird über eine Glättungskernmethode mit lokal begrenzten Wechselwirkungen zwischen den Teilchen gerechnet. Es ergibt sich ein Rechenaufwand von N · Nneigh , wenn Nneigh die durchschnittliche Zahl von Nachbarteilchen ist, die einen Wechselwirkungsbeitrag leisten. Der SPH-Algorithmus zerteilt sich in zwei Berechnungsschritte. Im ersten Schritt wird für alle Teilchen die Dichte an deren Positionen im Raum berechnet, denn diese Werte werden für alle weiteren Berechnungen benötigt. Im zweiten Schritt werden die Beschleunigungen, Energien und eventuell weitere Größen berechnet. In typischen astrophysikalischen Codes liegt der Rechenaufwand für die Gravitation etwa um einen Faktor 2–3 über dem der Hydrodynamik. Wird für die Gravitation ein GRAPE-Rechenbeschleuniger eingesetzt, dominiert die SPH-Berechnung die Simulationszeit. Dies wurde in Abschnitt 5.1 anhand der Analyse eines aktuellen Simulationscodes demonstriert. Voraussetzungen von Seiten der Informatik Die Funktionsweise von rekonfigurierbaren Koprozessoren basierend auf FPGAs wurde in Kapitel 3 beschrieben. Im Wesentlichen stellen FPGAs einen Pool von programmierbaren Logikressourcen bereit, die zu beliebigen digitalen Schaltkreisen zusammengesetzt werden können, limitiert nur durch die Anzahl an verfügbaren Logikelementen. In Kapitel 4 wurden verschiedene Strategien diskutiert, für unterschiedliche Zahlensysteme arithmetische Operatoren mit FPGAs zu implementieren. Es wurde dabei kein spezieller FPGA-Typ vorausgesetzt, da die Ergebnisse der Arbeit auf andere Architekturen übertragbar sein sollen. So wurden für alle Operationen Berechnungsmethoden formuliert, die ohne spezielle FPGA-Ressourcen wie Block-Muliplizierer auskommen. Es wurde zusätzlich auf die Optimierungsmöglichkeiten bei modernen FPGAs, insbesondere für den verwendeten Virtex-II-FPGA eingegangen. Als Kern der Operationen in anderen Zahlensystemen wurden Ganzzahloperationen besonders eingehend analysiert. Für Addierer 189 wurden die wichtigsten Standardmethoden wiedergegeben. In Abschnitt 6.1.1 erwies sich, dass in FPGAs die einfachen Ripple-Carry-Addierer die beste Performance erreichen. Für Multiplizierer ergab sich die Architektur eines Array-Multiplizierers als besonders vielversprechend für eine FPGA-Implementierung. In Abschnitt 6.1.2 wurde dagegen die Kombination aus kleinen ArrayMultiplizierern mit einem nachfolgenden Addiererbaum als bessere Implementierungsstrategie begründet. Sind im FPGA Block-Multiplizierer vorhanden, können natürlich diese verwendet werden. Für die Dividierer und Quadratwurzeloperatoren konnten Digit-Recurrence-Methoden gefunden werden, die sich optimal auf die FPGA-Ressourcen abbilden√lassen. Es wurden alternative Verfahren zur Berechnung elementarer Funktionen wie 1/x und x diskutiert (in Abschnitt 4.5), wie sie auch in Mikroprozessoren eingesetzt werden. Diese Alternativen sind teilweise auch für eine FPGA-Implementierung interessant, für diese Arbeit überwogen jedoch deren Nachteile. Die einfachen Digit-Recurrence-Methoden stellten sich als beste Implementierungsvariante heraus. In den Abschnitten 4.3 und 4.4 wurden die für die Implementierung von SPH-Rechenwerken interessantesten Systeme der Gleitkommazahlen, der logarithmischen und der semilogarithmischen Zahlen diskutiert. Kriterien für die Beschleunigerarchitektur Ausgehend von der Analyse eines aktuellen astrophysikalischen Simulationscodes wurden in Kapitel 5.1 die Anforderungen an einen Rechenbeschleuniger abgeleitet. Für ein System bestehend aus einer Workstation und einem GRAPE-5-System ergab sich ein Anteil von etwa 14 % für die Gravitationskraftberechnung, wobei die Rechenzeit von der Kommunikation mit dem GRAPE dominiert wird. Bis auf wenige Prozent entfällt der Rest der Rechenzeit auf den SPHAlgorithmus. Für die neuen Bus-basierten GRAPE-6-Systeme kann erwartet werden, dass dann nur deutlich unter 10 % der Zeit für die Gravitationsberechnung aufgewendet wird. Es ergibt sich ein Beschleunigungspotential der Gesamtanwendung von 10, wenn für SPH ein Speedup auf eine Dauerrechenleistung von mehr als 2 GFlops erreicht wird. Dazu kann ein Rechenbeschleuniger eingesetzt werden, der eine Kommunikationsbandbreite mit dem Host-System von etwa 200 MByte/sec aufweisen muss. Voraussetzung ist auch eine Bereitstellung der Nachbarschaftslisten mit dieser Übertragungsrate. Bei der aktuellen Struktur des Simulationscodes wird noch etwa 30 % der Rechenzeit für die Generierung dieser Listen aufgewendet. Es wurde davon ausgegangen, dass dieser Anteil durch eine Änderung des Simulationscodes ausreichend gesenkt werden kann, wobei die erforderlichen Optimierungsstrategien skizziert wurden. Ein zentraler Aspekt für eine Implementierung auf einem rekonfigurierbaren Rechensystem ist die Rechengenauigkeit, da davon der Ressourcenverbrauch abhängt. Der Ressourcenaufwand entscheidet wiederum über daß Maß an Parallelisierung und damit über die Rechengeschwindigkeit. Die erforderliche Rechengenauigkeit wurde eingegrenzt, indem Testsimulationen mit künstlich eingeschränkter Genauigkeit durchgeführt wurden und signifikante Abweichungen im Zeitverhalten der Energien als Indikator für eine zu geringe Rechengenauigkeit angenommen wurden. Bereits bei einer Mantissenbreite von 12 Bit ergab sich eine sehr hohe Qualität der Simulation. Zur detaillierteren Analyse wurde eine Simulationsumgebung für Rechenwerke mit beschränkter Genauigkeit erstellt. Es konnte gezeigt werden, dass die Testsimulationen das Verhal- 190 KAPITEL 8. ZUSAMMENFASSUNG UND DISKUSSION ten von Rechenwerken für Gleitkommazahlen mit reduzierter Mantissenbreite bis auf einen Unsicherheitsfaktor von 1–2 Bits korrekt wiedergeben. Für die Dichten ergab sich eine Rechengenauigkeit im Bereich der Darstellungsgenauigkeit. Für eine Mantissenbreite von 16 Bits übertreffen bereits sämtliche lokale SPH-Größen die Genauigkeitsanforderungen von O(0.1) % an die makroskopischen Größen (z.B. Energien). Mit großer Sicherheit genügt also ein den Berechnungen zugrunde liegendes Gleitkommaformat mit 16 Mantissenbits, mit hoher Wahrscheinlichkeit sind bereits 13–14 Bits ausreichend, was Spielraum für Optimierungen eröffnet. Die verbleibende Unsicherheit bezüglich der optimalen Rechengenauigkeit führt zum Design-Paradigma, dass alle Rechenwerke in der Genauigkeit skalierbar sein müssen. Die Strategie, die Rechenwerke mit Gleitkommaarithmetik zu implementieren, konnte gegenüber der Verwendung logarithmischer oder semilogarithmischer Zahlensysteme am meisten überzeugen. Implementierung der Rechenoperatoren für den Beschleuniger In Kapitel 6 wurde detailliert auf die Implementierung der Gleitkommaarithmetik auf FPGAs eingegangen. Es wurde eine leistungsfähige Bibliothek von Gleitkommaoperatoren aufgebaut, welche für verschiedene FPGA-Typen anwendbar ist. Alle Operatoren sind in einem weiten Bereich in der Rechengenauigkeit skalierbar. Der Leitgedanke bei der Implementierung war, möglichst wenig Logikressourcen für die Operatoren aufwenden zu müssen und dennoch eine akzeptable Geschwindigkeit zu erreichen. Es wurden die Operationen Additon, Multiplikation, Division und Quadratwurzel implementiert, da diese für die Berechnung der SPH-Formeln benötigt werden. Besonders wichtig war auch die effiziente Implementierung von Gleitkommaakkumulatoren, da alle SPH-Berechnungen über Summationsvorschriften durchgeführt werden. Mit großer Ressourcenersparnis konnten spezialisierte Operatoren entwickelt werden, welche von Randbedingungen an die Numerik profitieren. So wurde bei der Addition und Akkumulation unterschieden, ob die Operanden über ein Vorzeichen verfügen oder nur positive Beträge addiert werden. Im letzteren Fall können 30–50 % an Logikressourcen eingespart werden. Es wurden getrennte Designs für die Quadratur und Multiplikation erstellt, mit einer Ressourcenersparnis von etwa 35 % gegenüber einem Multiplizierer, wenn nur quadriert werden muss. Die Optionen, Block-Multiplizierer zu verwenden (der Xilinx Virtex-II-FPGA XC2V3000 hat z.B. 96 dieser Elemente), oder nur mit allgemeinen Logikressourcen zu arbeiten, wurden beide umgesetzt. Werden Block-Multiplizierer verwendet, können über 80 % an Logikressourcen eingespart werden. Es wurden darüber hinaus verschiedene Rundungsmodi implementiert, um eine Reduktion des Logikbedarfs um bis zu 15 % gegenüber dem Standardrundungsmodus zu ermöglichen. Die Quadratwurzel- und Divisions-Operatoren wurden über Digit-Recurrence-Methoden implementiert, mit der Freiheit die Pipelinetiefe zu variieren. Damit wurde eine direkte Einflussmöglichkeit auf den Ressourcenverbrauch und die Geschwindigkeit dieser Operatoren bereitgestellt. Alle Operatoren wurden über einen Mantissenbreitenbereich von 12 bis 24 Bit synthetisiert. Die Ergebnisse erlauben die schnelle Abschätzung des Implementierungsaufwands zukünftiger Rechenwerke für verschiedene Rechengenauigkeiten. 191 Prototypimplementierung des Rechenbeschleunigers Die Plattform für die Implementierung war das an der Universität Mannheim entwickeltes Koprozessorboard MPRACE, basierend auf einem Virtex-II-FPGA von Xilinx (XC2V3000-4). Es wurden zwei getrennte Schaltungsdesigns für den ersten und zweiten Schritt des SPH-Algorithmus implementiert. Die Schaltungsarchitektur fußt auf dem Ansatz, alle Rechenoperationen für die innersten Schleifen des SPH-Algorithmus vollständig parallel als Pipeline zu implementieren. Für den ersten Schritt mussten dazu 54 Gleitkommaoperationen zusammengesetzt werden. Es gelang eine Implementierung unter Aufwendung von 48 % der Logikressourcen für das Rechenwerk. Es wurde ein Gleitkommaformat mit 16 Mantissenbits und 8 Exponentenbits verwendet und bis auf wenige Ausnahmen mit dem Rundungsmodus Round To Nearest Integer gerechnet. Für die Interpolationskerne der SPH-Methode wurden Spezialoperatoren implementiert, um von der speziellen Form dieser Funktionen eine besonders ressourceneffiziente Implementierung ableiten zu können. Für den zweiten Schritt wurde eine ähnliche Pipeline wie für den ersten Schritt aufgebaut. Hier mussten 60 Operationen parallel implementiert werden und es folgte ein Aufwand von 49 % der Logikressourcen des FPGAs. Um die Rechenwerke in die Koprozessorplattform einzubetten, wurde eine modulare Interfacestruktur implementiert, die es gestattet, sehr einfach Portierungen auf andere FPGA-Plattformen durchzuführen. So wurde zu Evaluierungszwecken innerhalb von vier Wochen auch eine Portierung auf das japanische PROGRAPESystem durchgeführt, (es wurde in der Arbeit nicht weiter darauf eingegangen, da sich diese Plattform als zu klein für Pipelines der gewünschten Rechengenauigkeit erwies). Für die Gesamtschaltung auf dem MPRACE-Board ergab sich ein Ressourcenbedarf von etwa 53 % für Schritt 1 und 56 % für Schritt 2. Die Pipelines konnten mit der PCI-Bus-Geschwindigkeit von 66 MHz betrieben werden – mit einer Spitzenrechenleistung von 3.5 und 3.9 GFlops. Allerdings erzwang die Anbindung an den mit doppelter Taktfrequenz arbeitenden Speicher des MPRACE-Boards eine Reduzierung der Frequenz auf 50 MHz. Der Datenfluss der Prototypimplementierung führt zu einer weiteren Reduktion der Verarbeitungsgeschwindigkeit, so dass die erzielbare Dauerleistung etwa 1.5 GFlops beträgt. Diskussion der Perspektiven Durch diese Arbeit konnte gezeigt werden, dass die rechenzeitkritischen Formeln des SPH-Algorithmus auf FPGAs wesentlich schneller berechnet werden können als auf Standardprozessoren. Mit 3.9 GFlops ist die FPGA-Implementierung für die SPH-Kraftberechnung etwa um einen Faktor 20 schneller als eine moderne CPU. Es ergab sich jedoch auch, dass dieses Beschleunigungspotential derzeit nicht ausgeschöpft werden kann. Die limitierte Kommunikationsbandbreite zwischen Host und Koprozessor sowie zwischen FPGA und dem lokalen Speicher reduzieren die Rechenleistung um etwa 50 %. Auch sind die aktuellen Simulationscodes noch nicht in der Lage, den Geschwindigkeitsvorteil effizient auszunutzen. Es muss vor allem die Erzeugung der Nachbarschaftslisten optimiert werden, um sowohl die Rechenzeit dafür von derzeit etwa 30 % auf deutlich unter 10 % der Rechenzeit für SPH zu reduzieren und gleichzeitig das zum Koprozessor zu transferierende Datenvolumen zu verringern. Mit dem Ansatz, für mehrere SPH-Teilchen gemeinsame Nachbarschaftslisten zu verwenden, können diese Ziele voraussicht- 192 KAPITEL 8. ZUSAMMENFASSUNG UND DISKUSSION lich erreicht werden. Die verwendete FPGA-Plattform bietet noch einige bisher brach liegende Logikressourcen, so dass Erweiterungen der FPGA-Designs zur Unterstützung neuer Verfahren mit komprimierten Nachbarschaftslisten möglich sind. Eine genauere Analyse dieser Modifikation steht noch aus. Es müssen in jedem Fall tiefe Eingriffe in den Simulationscode erfolgen um eine neue Methode der Nachbarschaftslistengenerierung zu implementieren und das Timing verschiedener Codeteile aufeinander abzustimmen. Das einfache Anwendungsprinzip der GRAPESysteme, nur die Teilchendaten zum Beschleuniger zu schicken und alles übrige autonom auf der Beschleunigerplattform durchzuführen, lässt sich nicht auf SPH übertragen. Der Grund dafür ist die Lokalität der Wechselwirkung, was dazu führt, dass für jedes Teilchen eine individuelle Interaktionsliste abgearbeitet werden muss. Dennoch stehen die Chancen gut, durch die Koprozessorarchitektur eine Beschleunigung um den Faktor 7–10 zu erreichen. Mit diesem Speedup kann ein relativ kleines System aus Host, GRAPE und einem rekonfigurierbaren Rechensystem mit der Rechenleistung eines Supercomputers konkurrieren – bei äußerst hoher Preis-Performance. Wird diese hybride Plattform parallelisiert, wird es dann möglich sein, bereits mit etwa 32 Knoten astrophysikalische Simulationen unter Berücksichtigung der Hydrodynamik mit einer Dauerrechenleistung weit über einem TFlop durchzuführen. Tabellenverzeichnis 2.1 Entwicklung der GRAPE-Systeme . . . . . . . . . . . . . . . . . . . . . . . . . 24 4.1 ANSI/IEEE-754-Standard für Gleitkommazahlen einfacher und doppelter Genauigkeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69 6.1 6.2 6.3 6.4 6.5 6.6 6.7 6.8 6.9 6.10 6.11 6.12 6.13 6.14 6.15 6.16 6.17 6.18 6.19 Vergleich von Addierertechniken für Virtex-II-FPGA . . . . . . . . . . . . . . Ressourcenverbrauch und Geschwindigkeit von Array-Multiplizierern . . . . . Implementierungsergebnisse für Integer-Multiplizierer . . . . . . . . . . . . . Implementierungsergebnisse für Integer-Quadrierern . . . . . . . . . . . . . . Ressourcenverbrauch und Geschwindigkeit von Festkomma-Dividierern . . . . Implementierungsergebnisse für Quadratwurzel-Operatoren . . . . . . . . . . . Implementierungsergebnisse zu Shift-Bausteinen . . . . . . . . . . . . . . . . Zählen führender Nullen oder selektive Zählung von Nullen und Einsen . . . . Implementierungsergebnisse für Gleitkomma-Addierer für positive Zahlen . . . Implementierungsergebnisse für Gleitkomma-Addierer . . . . . . . . . . . . . Implementierungsergebnisse für Akkumulatoren . . . . . . . . . . . . . . . . . Implementierungsergebnisse für Gleitkomma-Multiplizierer . . . . . . . . . . Implementierungsergebnisse für Gleitkomma-Multiplizierer (ohne Block-Mult) Implementierungsergebnisse für Gleitkomma-Quadrierer . . . . . . . . . . . . Implementierungsergebnisse für Gleitkomma-Dividierer (ohne Runden) . . . . Implementierungsergebnisse für Gleitkomma-Dividierer . . . . . . . . . . . . Implementierungsergebnisse für Gleitkomma-Quadratwurzel (ohne Runden) . . Implementierungsergebnisse für Gleitkomma-Quadratwurzel . . . . . . . . . . Vergleich mit kommerziellen Produkten . . . . . . . . . . . . . . . . . . . . . 7.1 7.2 Ergebnisse für die Prototypimplementierung . . . . . . . . . . . . . . . . . . . . 185 Rechengenauigkeit der FPGA-Implementierung . . . . . . . . . . . . . . . . . . 186 193 . . . . . . . . . . . . . . . . . . . 112 116 116 120 123 126 130 131 137 143 148 154 154 156 160 161 164 165 166 194 TABELLENVERZEICHNIS Abbildungsverzeichnis 2.1 2.2 2.3 2.4 2.5 Veranschaulichung des SPH-Verfahrens . . . . . . . . . . . . Kubische Splinefunktion des Standard-Glättungskerns . . . . Simulationssystem mit GRAPE-6-Rechenbeschleuniger . . . . Architektur des GRAPE-6-Spezialrechners aus Anwendersicht Pipeline der GRAPE-6-Chips . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 13 21 22 23 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 Prinzipieller Aufbau eines FPGAs . . . . . . . . . . . . . . . . . . . . Struktureller Aufbau eines Virtex-II-FPGAs von Xilinx . . . . . . . . . Struktur einer Slice-Einheit des Virtex-II-FPGAs . . . . . . . . . . . . Halbaddierer und Volladdierer . . . . . . . . . . . . . . . . . . . . . . Volladdierer und Addier/Subtrahier-Elemente mit Virtex-II-FPGA . . . Volladdierer mit Selektion eines Eingangs mit Virtex-II-FPGA . . . . . Halbe Slice-Einheit eines Virtex-II-FPGAs . . . . . . . . . . . . . . . . Carry-Signale innerhalb einer CLB des Virtex-II-FPGAs . . . . . . . . Rechensystem aus Steuerrechner und rekonfigurierbaren Koprozessoren Grundlegende Architektur eines rekonfigurierbaren Koprozessors . . . . Der rekonfigurierbare Koprozessor MPRACE . . . . . . . . . . . . . . Schematischer Aufbau des MPRACE Koprozessors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 29 30 32 33 33 34 35 37 39 39 40 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10 4.11 4.12 4.13 4.14 Addier/Subtrahier-Operator für 1er-Komplement-Zahlen . . . . . . . . . . . Addier/Subtrahier-Operator für Zahlen in der Vorzeichen-Betrag-Darstellung Addierer für 4-Bit-Ganzzahlen als Ripple-Carry-Schaltung . . . . . . . . . . Lookahead-Carry-Generator . . . . . . . . . . . . . . . . . . . . . . . . . . Carry-Lookahead-Addierer für 16-Bit-Ganzzahlen . . . . . . . . . . . . . . Addierer für Ganzzahlen als Carry-Save-Schaltung . . . . . . . . . . . . . . Addierer für Ganzzahlen als einstufige Carry-Select-Schaltung . . . . . . . . Zweistufiger Carry-Select-Addierer . . . . . . . . . . . . . . . . . . . . . . Hardwareumsetzung der Multiplikation nach der Shift/Add-Methode . . . . . Hardwareumsetzung der Multiplikation nach der Tree-Methode . . . . . . . . Hardwareumsetzung der Multiplikation als Array-Multiplizierer . . . . . . . Detailschaltbild eines Array-Multiplizierers für 4-Bit-Zahlen . . . . . . . . . Serieller Dividierer nach der Non-Performing-Methode . . . . . . . . . . . . Detailschaltbild eines Non-Restoring Array-Dividierers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44 46 47 48 49 49 50 50 52 52 53 54 57 58 195 . . . . . . . . . . . . . . . . . . . . 196 ABBILDUNGSVERZEICHNIS 4.15 4.16 4.17 4.18 4.19 4.20 4.21 4.22 4.23 4.24 4.25 Blockschaltbild eines einfachen seriellen Dividierers nach der SRT-Methode . . Berechnungsbeispiel zur Quadratwurzel nach der Papier-und-Bleistift-Methode Detailschaltbild eines Quadratwurzel-Operators mit Non-Restoring-Verfahren . Rundungsmodi des IEEE-754-Standards für Gleitkommazahlen . . . . . . . . Maximaler relativer Fehler von Gleitkommaoperationen . . . . . . . . . . . . . Allgemeine Struktur eines Gleitkommaoperators . . . . . . . . . . . . . . . . Funktioneller Aufbau eines Addierers für Gleitkommazahlen . . . . . . . . . . Funktioneller Aufbau eines Multiplizierers für Gleitkommazahlen . . . . . . . Funktioneller Aufbau eines Dividierers für Gleitkommazahlen . . . . . . . . . Funktioneller Aufbau eines Quadratwurzeloperators für Gleitkommazahlen . . Lineare Approximation nach der Bipartite-Table-Methode . . . . . . . . . . . . . . . . . . . . . . 60 63 65 68 70 71 73 75 77 78 84 5.1 5.2 5.3 5.4 5.5 5.6 5.7 5.8 Energievergleich zur Analyse der erforderlichen Rechengenauigkeit . . . Relative Fehler der Energien für 8-Bit- und 12-Bit-Mantissen . . . . . . . Relative Fehler der Energien für 20-Bit-Mantissen . . . . . . . . . . . . . Teilchenverteilungen zur Analyse der Rechenwerke . . . . . . . . . . . . Abhängigkeit des mittleren relativen Fehlers von der Mantissenbreite – 1 . Abhängigkeit des mittleren relativen Fehlers von der Mantissenbreite – 2 . Grundlegende Hardwarearchitektur für SPH . . . . . . . . . . . . . . . . Datentransferleistung für das MPRACE-Board . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98 99 100 102 103 103 108 108 6.1 6.2 6.3 6.4 6.5 6.6 6.7 6.8 6.9 6.10 6.11 6.12 6.13 6.14 Multipliziererschaltung für 4-Bit-Integer-Zahlen . . . . . . . . . . . . . . . . . Multipliziererschaltung für 16-Bit-Integer-Zahlen . . . . . . . . . . . . . . . . Quadrierung einer 4-Bit-Zahl . . . . . . . . . . . . . . . . . . . . . . . . . . . Quadriererschaltung für 16-Bit-Integer-Zahlen . . . . . . . . . . . . . . . . . . Dividiererschaltung für 4-Bit-Festkommazahlen . . . . . . . . . . . . . . . . . Quadratwurzel für 4-Bit-Festkommazahlen . . . . . . . . . . . . . . . . . . . Verschiebeschaltung für 32-Bit-Vektor . . . . . . . . . . . . . . . . . . . . . . Verarbeitung der Exponenten bei Addierer für pos. Gleitkommazahlen . . . . . Gleitkommazahl-Addierer für positive Zahlen . . . . . . . . . . . . . . . . . . Rundung und Normalisierung bei Addition positiver Gleitkommazahlen . . . . Ressourcen für Gleitkomma-Addierern für positive Zahlen . . . . . . . . . . . Addierer für beliebige Gleitkommazahlen . . . . . . . . . . . . . . . . . . . . Normalisierung beim Gleitkommazahl-Addierer . . . . . . . . . . . . . . . . . 2er-Komplement-Bildung und Rundung beim Addierer für beliebige Gleitkommazahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ressourcen für Gleitkomma-Addierer . . . . . . . . . . . . . . . . . . . . . . Vorverarbeitung der Exponenten im Akkumulatorbaustein . . . . . . . . . . . Akkumulator für positive Gleitkommazahlen . . . . . . . . . . . . . . . . . . Ressourcenverbrauchs für die Gleitkomma-Akkumulatoren . . . . . . . . . . . Akkumulator für Gleitkommazahlen . . . . . . . . . . . . . . . . . . . . . . . Multiplizierer für Gleitkommazahlen . . . . . . . . . . . . . . . . . . . . . . . Ressourcen für Gleitkomma-Multiplizierer (ohne Block-Mult-Elemente) . . . . . . . . . . . . . . . . . 114 117 119 119 122 125 130 133 134 136 138 140 142 . . . . . . . . 142 144 146 147 149 151 153 155 6.15 6.16 6.17 6.18 6.19 6.20 6.21 . . . . . . . . . . . . . . . . 197 ABBILDUNGSVERZEICHNIS 6.22 6.23 6.24 6.25 6.26 6.27 6.28 Ressourcen für Gleitkomma-Multiplizierer . . . . . . . . . . . . . . . . . . Implementierungsergebnisse für Gleitkomma-Quadrierer . . . . . . . . . . Dividierer für Gleitkommazahlen . . . . . . . . . . . . . . . . . . . . . . . Ressourcenverbrauch für Gleitkomma-Dividierer . . . . . . . . . . . . . . Quadratwurzel-Operator für Gleitkommazahlen . . . . . . . . . . . . . . . Implementierungsergebnisse für Gleitkomma-Quadratwurzel . . . . . . . . Vergleich des Ressourcenaufwands für verschiedene Gleitkommaoperatoren . . . . . . . . . . . . . . . . . . . . . 155 157 159 161 163 165 167 7.1 7.2 7.3 7.4 7.5 7.6 7.7 7.8 Spline-Kernfunktion für SPH . . . . . . . . . . . . . Schaltung zur Berechnung der Spline-Kernfunktion . Kernfunktion Ω für SPH . . . . . . . . . . . . . . . Spezialoperator zur Berechnung der Kernfunktion Ω Blockschaltbild zur SPH-Dichteberechnung . . . . . Blockschaltbild zur Berechnung der Beschleunigung Modulares Design des Rechenbeschleunigers . . . . Datenfluss zwischen Host und Rechenbeschleuniger . . . . . . . . . . . . . . . . . . . . . . . . . 170 171 174 175 178 181 183 184 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198 ABBILDUNGSVERZEICHNIS Literaturverzeichnis [1] S. J. Aarseth, M. Henon, and R. Wielen. A comparison of numerical methods for the study of star cluster dynamics. Astron. Astrophys., 37:183–187, 1974. [2] P. Alfke. Evolution, revolution, and convolution - recent progress in field programmable logic. In Proc. of the 7th Workshop on Electronics for LHC Experiments, pages 25–31, Stockholm, Sweden, 2001. [3] H. Amano, Y. Shibata, and M. Uno. Reconfigurable systems: New activities in asia. In Proc. International Conference on Field Programmable Logic and Applications, pages 585–594, 2000. [4] D. S. Balsara. Phd thesis, University of Illinois, 1990. [5] J. Barnes and P. Hut. A Hierarchical O(N log N) Force-Calculation Algorithm. Nature, 324:446–449, 1986. [6] R. Bate, Matthew and A. Burkert. Resolution requirements for smoothed particle hydrodynamics calculations with self-gravity. Mon. Not. R. astr. Soc., 288:1060–1072, 1995. [7] J. Becker, A. Kirschbaum, F.-M. Renner, and M. Glesner. Perspectives of reconfigurable computing in research, industry and education. In Proc. International Conference on Field Programmable Logic and Applications, pages 39–48, 1998. [8] P. Belanovic and M. Leeser. A library of parameterized floating-point modules and their use. In Proc. International Conference on Field Programmable Logic and Applications, pages 657–666, Springer-Verlag Berlin, Heidelberg, 2002. [9] G. Bell and J. Gray. High performance computing: Crays, clusters and centers. what next? Technical Report MSR-TR-2001-76, ACM, 2001. [10] D. Benitez. A quantitative understanding of the performance of reconfigurable coprocessors. In Proc. International Conference on Field Programmable Logic and Applications, pages 976–986, 2002. [11] W. Benz. Smooth particle hydrodynamics: A review. The Numerical Modeling of Nonlinear Stellar Pulsations, pages 269–288, 1990. 199 200 LITERATURVERZEICHNIS [12] E. Bertschinger. Simulations of structure formation in the universe. Astron. Astrophys., 36:599–654, 1998. [13] J.-L. Beuchat and A. Tisserand. Small Multiplier-Based Multiplication and Division Operators for Virtex-II Devices. In M. Glesner, P. Zipf, and M. Renovell, editors, Proc. International Conference on Field Programmable Logic and Applications, pages 513–522, Springer Verlag Berlin, Heidelberg, 2002. [14] J. Binney and S. Tremaine. Galactic Dynamics. Princeton University Press, 1987. [15] T. Bubeck, M. Hipp, S. Hüttemann, S. Kunze, M. Ritt, W. Rosenstiel, H. Ruder, and R. Speith. Parallel SPH on Cray T3E and NEC SX-4 using DTS. In High Performance Computing in Science and Engineering. Springer Verlag, 1998. [16] J. N. Coleman and E. I. Chester. A 32-bit logarithmic arithmetic unit and its performance compared to floating-point. In Koren and Kornerup, editors, Proceedings of the 14th IEEE Symposium on Computer Arithmetic (Adelaide, Australia), pages 142–151, Los Alamitos, CA, Apr. 1999. IEEE Computer Society Press. [17] K. Compton and S. Hauck. Reconfigurable computing: A survey of systems and software. ACM Computing Surveys, 34(2):171–210, June 2002. [18] T. A. Cook, H.-R. Kim, and L. Louca. Hardware acceleration of n-body simulations for galactic dynamics. In J. Schewel, editor, Proc. Field Programmable Gate Arrays for Fast Board Development and Reconfigurable Computing (SPIE 2607), pages 115–126, Bellingham, WA, Oct. 1995. SPIE The International Society for Optical Engineering. [19] H. M. P. Couchman. Efficient algorithms for the cosmological n-body problem. Speedup, HPC Applications in Natural Science and Engineering, 12(2):22–26, Sept. 1999. [20] H. M. P. Couchman, P. A. Thomas, and F. R. Pearce. Hydra: An Adaptive-Mesh Implementation of P3 M-SPH. Astrophys. J., 452:797, 1995. [21] D. Das Sarma and D. W. Matula. Faithful Bipartite ROM Reciprocal Tables. In Proc 12th Symposium on Computer Arithmetic, pages 17–28, 1995. [22] D. Das Sarma and D. W. Matula. Faithful Interpolation in Reciprocal Tables. In Proc. 13th Symposium on Computer Arithmetic (ARITH13), pages 82–91, 1997. [23] F. de Dinechin and A. Tisserand. Some improvements on multipartite table methods. Technical Report 4059, Unité de recherche INRIA Rhône-Alpes, Montbonnot-St-Martin, France, 2000. [24] J. Dubinski. A parallel tree code. New Astronomy, 1:133–147, 1996. [25] J. Dubinski, R. Humble, C. Loken, U.-L. Pen, and P. Martin. McKenzie: A Teraflops Linux Beowulf Cluster for Computational Astrophysics. In Proc. 17th Ann. Intl. Symp. on High Performance Computing Systems and Applications (HPCS2003), May 2003. LITERATURVERZEICHNIS 201 [26] T. Ebisuzaki, J. Makino, T. Fukushige, M. Taiji, D. Sugimoto, T. Ito, and S. K. Okumura. GRAPE Project: an Overview. Publ. Astron. Soc. Japan, 45:269–278, June 1993. [27] S. Elzinga, J. Lin, and V. Singhal. Design Tips for HDL Implementation of Arithmetic Functions. XAPP215(v1.0), http://www.xilinx.com, June 2000. [28] M. D. Ercegovac, L. Imbert, D. W. Matula, J. M. Muller, and G. Wei. Improving goldschmidt division, square root, and square root reciprocal. IEEE Transactions on Comput., 49(7):759–763, July 2000. [29] G. Even and W. J. Paul. On the design of IEEE compliant floating-point units. IEEE Transactions on Comput., 49(5):398–413, May 2000. [30] B. Fagin and C. Renard. Field programmable gate arrays and floating point arithmetic. IEEE Transactions on VLSI, 2(3):365–367, 1994. [31] C. S. Frenk, S. D. White, P. Bode, J. R. Bond, G. L. Bryan, R. Cen, H. M. P. Couchman, A. E. Evrard, N. Gnedin, A. Jenkins, A. M. Khokhlov, A. Klypin, J. F. Navarro, M. L. Norman, J. P. Ostriker, J. M. Owen, F. R. Pearce, U.-L. Pen, M. Steinmetz, P. A. Thomas, J. V. Villumsen, J. W. Wadsley, M. S. Warren, G. Xu, and G. Yepes. The santa barbara cluster comparison project: A comparison of cosmological hydrodynamics solutions. Astrophys. J., 525:554, 1999. [32] A. A. Gaffar, W. Luk, P. Y. K. Cheung, N. Shirazi, and J. Hwang. Automatic customization of floating-point designs. In Proc. International Conference on Field Programmable Logic and Applications, pages 523–533, 2002. [33] A. A. Gaffar, O. Mencer, W. Luk, P. Y. K. Cheung, and N. Shirazi. Floating-point bitwidth analysis via automatic differentiation. In Proc. IEEE International Conference on FieldProgrammable Technology, pages 158–165, 2002. [34] S. Gelato, D. F. Chernoff, and I. Wasserman. An adaptive hierarchical particle-mesh code with isolated boundary conditions. Astron. J, 480:115, 1997. [35] L. Geppert. Champagne supercomputer on a beer budget. IEEE Spectrum, 36(5):19–22, 1999. [36] R. A. Gingold and J. J. Monaghan. Smoothed particle hydrodynamics: theory and application to non-spherical stars. Mon. Not. R. astr. Soc., 181:375–389, 1977. [37] D. Goldberg. What every computer scientist should know about floating-point arithmetic. ACM Computing Surveys, 23(1):5–47, Mar. 1991. [38] R. E. Goldschmidt. Applications of division by convergence, 1964. master thesis. [39] Z. Guo, W. Najjar, F. Vahid, and K. Vissers. A Quantitative Analysis of the Speedup Factors of FPGAs Over Processors. In Proc. of FPGA’04, pages 171–180, Monterey, California, USA, Feb. 2004. 202 LITERATURVERZEICHNIS [40] T. Hamada, T. Fukushige, A. Kawai, and J. Makino. PROGRAPE-1: A Programmable, Multi-Purpose Computer for Many-Body Simulations. Publ. Astron. Soc. Japan, 52:943– 954, Oct. 2000. [41] R. Hartenstein. A decade of reconfigurable computing: a visionary retrospective. In Proc. of the Conference on Design, Automation, and Test in Europe (DATE’01), pages 642–649, 2001. [42] D. C. Heggie and P. Hut. The Gravitational Million-Body Problem - A multidisciplinary approach to Star Cluster Dynamics. Cambridge Univ. Press, 2003. [43] L. Hernquist and N. Katz. Treesph: A Unification of SPH with the Hierarchical Tree Method. Astron. Astrophys. Suppl. Series, 70:419–446, June 1989. [44] M. A. Hitz and E. Kaltofen. Integer division in residue number systems. IEEE Transactions on Comput., 44(8):983–989, 1995. [45] C. H. Ho, M. P. Leong, P. H. W. Leong, J. Becker, and M. Glesner. Rapid Prototyping of FPGA based Floating Point DSP Systems. In Proc. 13th IEEE International Workshop on Rapid System Prototyping, pages 19–24, 2002. [46] C. H. Ho, K. H. Tsoi, H. C. Yeung, Y. M. Lam, K. H. Lee, P. H. W. Leong, R. Ludewig, P. Zipf, A. G. Ortiz, and M. Glesner. Arbitrary Function Approximation in HDLs with Application to the N-body Problem. In Proc. IEEE International Conference on FieldProgrammable Technology, 2003. (to appear). [47] R. Hockney and J. Eastwood. Computer Simulation Using Particles. Adam Hilger, Bristol, 1989. [48] IEEE Standard for Binary Floating-Point Arithmetic. IEEE Press, New York, 1985. (ANSI/IEEE Std 754-1985). [49] A. Jaenicke and W. Luk. Parameterised Floating-Point Arithmetic on FPGAs. In Proc. IEEE ICASSP, volume 2, pages 897–900, 2001. [50] A. Kawai, T. Fukushige, J. Makino, and M. Taiji. GRAPE-5: A Special-Purpose Computer for N-Body Simulations. Publ. Astron. Soc. Japan, 52:659–676, Aug. 2000. [51] A. Kawai, J. Makino, and T. Ebisuzaki. Performance analysis of high-accuracy tree code based on the pseudoparticle multipole method. Astrophys. J. Suppl. Series, 151:13, 2004. [52] O. Kessel-Deynet. Berücksichtigung ionisierender Strahlung im Smoothed-ParticleHydrodynamics-Verfahren und Anwendung auf die Dynamik von Wolkenkernen im Strahlungsfeld massiver Sterne. Dissertation, Ruprecht-Karls-Universität Heidelberg, 1999. [53] I. Koren. Computer arithmetic algorithms. Prentice-Hall, Englewood Cliffs, NJ, 1993. LITERATURVERZEICHNIS 203 [54] T. Kuberka et al. AHA-GRAPE: Adaptive Hydrodynamic Architecture - GRAvityPipE. In Procs. of The 1999 International Conference on Parallel and Distributed Processing Techniques and Applications (PDPTA 99), Las Vegas, USA, 1999. [55] A. Kugel. MPRACE - A PCI-64 based High Performance FPGA Co-Processor, 2003. URL: http://www-li5.ti.uni-mannheim.de/fpga/?race/. [56] U. W. Kulisch and W. L. Miranker. Computer arithmetic in theory and practice. Academic Press, New York, 1981. [57] Y. Li and W. Chu. Implementation of Single Precision Floating Point Square Root on FPGAs. In K. L. Pocek and J. Arnold, editors, Proc. of IEEE Symposium on FPGAs for Custom Computing Machines, pages 226–232, Los Alamitos, CA, USA, 1997. IEEE Computer Society Press. [58] Y. Li and W. Chu. Parallel-array implementation of a non-restoring square root algorithm. In Proc. International Conference on Computer Design (ICCD´97), pages 690–695, Austin, Texas, USA, Oct. 1997. [59] J. Liang and R. Tessier. Floating Point Unit Generation and Evaluation for FPGAs. In Proc. of IEEE Symposium on FPGAs for Custom Computing Machines, Napa, CA., 2003. [60] A. A. Liddicoat. High-Performance Arithmetic for Divison and The Elementary Functions. PhD thesis, Stanford University, 2002. [61] G. Lienhart. Beschleunigung Hydrodynamischer N-Körper-Simulationen mit Rekonfigurierbaren Rechensystemen. In Mitteilungen – Gesellschaft für Informatik e.V. ParallelAlgorithmen, -Rechnerstrukturen und -Systemsoftware (PARS), pages 9–16, 2003. ISSN 0177-0454. [62] G. Lienhart. Implementing Hydrodynamic N-Body Codes on Reconfigurable Computing Platforms. In Proc. of the International Conference on High Performance Scientific Computing, Hanoi, Vietnam, 2003. In press. [63] G. Lienhart, A. Kugel, and R. Männer. Simulation mit konfigurierbarer Hardware. In Tagungsband zum Symposium auf der 66. Physikertagung in Leipzig, Simulation in Physik, Informatik und Informationstechnik, pages 18–21, Leipzig, Germany, 2002. ISSN 09447121. [64] G. Lienhart, A. Kugel, and R. Männer. Using Floating Point Arithmetic on FPGAs for Accelerating Scientific N-Body Simulations. In Proc. of IEEE Symposium on FPGAs for Custom Computing Machines, pages 182–191, Napa Valley, CA, USA, 2002. [65] W. B. Ligon III, S. McMillan, G. Monn, K. Schoonover, F. Stivers, and K. D. Underwood. A Re-evaluation of the Practicality of Floating Point Operations on FPGAs. In K. L. Pocek and J. Arnold, editors, Proc. of IEEE Symposium on FPGAs for Custom Computing Machines, pages 206–215, Los Alamitos, CA, 1998. IEEE Computer Society Press. 204 LITERATURVERZEICHNIS [66] M. E. Louie and M. D. Ercegovac. Mapping division algorithms to field programmable gate arrays. In Proceedings of the 1992 Asilomar Conference on Signals, Systems and Computers, 1992. [67] M. E. Louie and M. D. Ercegovac. A digit-recurrence square root implementation for field programmable gate arrays. In IEEE Workshop on FPGAs for Custom Computing Machines, pages 178–183, Apr. 1993. [68] M. E. Louie and M. D. Ercegovac. On digit-recurrence division implementation for field programmable gate arrays. In E. E. Swartzlander, M. J. Irwin, and J. Jullien, editors, Proceedings of the 11th IEEE Symposium on Computer Arithmetic, pages 202–209, Windsor, Canada, June 1993. IEEE Computer Society Press, Los Alamitos, CA. [69] L. Lourca, T. A. Cook, and W. H. Johnson. Implementation of IEEE Single Precision Floating Point Addition and Multiplication on FPGAs. In Proc. of IEEE Symposium on FPGAs for Custom Computing Machines, pages 107–116. IEEE Computer Society Press, 1996. [70] L. B. Lucy. A numerical approach to the testing of the fission hypothesis. Astron. J, 82:1013–1024, 1977. [71] Z. Luo and M. Martonosi. Using delayed addition techniques to accelerate integer and floating-point calculations in configurable hardware. In J. Schewel, editor, Configurable Computing: Technology and Applications, Proc. SPIE 3526, pages 202–211, Bellingham, WA, 1998. SPIE – The International Society for Optical Engineering. [72] J. Makino. Grape-6 user’s guide. Version 0.5, 2002. [73] J. Makino and P. Hut. Performance analysis of direct n-body calculations. phys. J. Suppl. Series, 68:833–856, 1988. Astro- [74] J. Makino, E. Kokubo, and T. Fukushige. Performance evaluation and tuning of GRAPE6 – towards 40 “real” Tflops. In Tech Papers of SC2003, Phoenix, Arizona, USA, 2003. ACM. [75] J. Makino, M. Taiji, T. Ebisuzaki, and D. Sugimoto. GRAPE-4: A Massively Parallel Special-Purpose Computer for Collisional N-Body Simulations. Astrophys. J., 480:432– 446, 1997. [76] R. Matousek, M. Tichy, Z. Pohl, J. Kadlec, C. Softley, and N. Coleman. Logarithmic Number System and Floating-Point Arithmetics on FPGA. In M. Glesner, P. Zipf, and M. Renovell, editors, Proc. International Conference on Field Programmable Logic and Applications, pages 627–636, Springer Verlag Berlin, Heidelberg, 2002. [77] J. J. Monaghan. Smoothed Particle Hydrodynamics. Ann. Rev. Astron. Astrophys., 30:543– 74, 1992. LITERATURVERZEICHNIS 205 [78] J. J. Monaghan and R. A. Gingold. Shock Simulation by the Particle Method SPH. J. Comp. Phys., 52:374–389, 1983. [79] J. J. Monaghan and J. C. Lattanzio. A refined particle method for astrophysical problems. Astron. Astrophys., 149:135–143, 1985. [80] J.-M. Muller, A. Scherbyna, and A. Tisserand. Semi-logarithmic number systems. IEEE Transactions on Comput., 47(2):145–151, 1998. [81] Nallatech Limited. IEEE 754 compatible floating point cores for Virtex-II FPGAs, 2002. URL: www.nallatech.com. [82] T. Narumi, A. Kawai, and T. Koishi. An 8.61 Tflop/s Molecular Dynamics Simulation for NaCl with a Special-Purpose Computer: MDM. In Proc. of the International Conference for High-Performance Computing 2001, Denver, USA, 2001. [83] T. Narumi, R. Susukita, T. Ebisuzaki, G. McNiven, and B. Elmegreen. Molecular dynamics machine: Special-purpose computer for molecular dynamics simulations. Molecular Simulation, 21:401–415, 1999. [84] R. P. Nelson and J. C. B. Papaloizou. Variable smoothing lengths and energy conservation in smoothed particle hydrodynamics. Mon. Not. R. astr. Soc., 270:1–20, 1994. [85] S. F. Oberman. Design Issues in High Performance Floating Point Arithmetic Units. PhD thesis, Stanford University, Stanford, CA, USA, 1996. [86] S. F. Oberman. Floating Point Division and Square Root Algorithms and Implementation in the AMD-K7 Microprocessor. In Proc. 14th Symposium on Computer Arithmetic (ARITH14), pages 106–115, Apr. 1999. [87] S. F. Oberman and M. J. Flynn. Division algorithms and implementations. IEEE Transactions on Comput., 46(8):833–854, Aug. 1997. [88] C. M. Pancake. What computational scientists/engineers should know about parallelism and performance. Computer Applications in Engineering Education, 4(2):145–160, 1996. [89] B. Parhami. Computer Arithmetic – Algorithms and Hardware Designs. Oxford University Press, Inc., New York, 2000. [90] F. R. Pearce and H. M. P. Couchman. Hydra: a parallel adaptive grid code. New Astronomy, 2:411–427, 1997. [91] J.-A. Pineiro. Algorithms and Architectures for Elementary Function Computation. PhD thesis, University of Santiago de Compostela, 2003. [92] J.-A. Pineiro and J. D. Bruguera. High-speed double-precision computation of reciprocal, division, square root and inverse square root. IEEE Transactions on Comput., 52(12):1377–1388, Dec. 2002. 206 LITERATURVERZEICHNIS [93] J.-A. Pineiro, S. F. Oberman, J.-M. Muller, and J. D. Bruguera. High-speed function approximation using a minimax quadratic interpolator. Technical report, 2003. ULR: http://www.ac.usc.es/files/articulos/2003/gac2003-i01.ps. [94] QinetiQ Limited. Quixilica Floating Point FPGA Cores Data Sheet, Dec. 2002. URL: www.QinetiQ.com/quixilica. [95] J. Ramirez, U. Meyer-Bäse, A. Garcia, and A. Lloris. Design and Implementation of RNSBased Adaptive Filters. In Proc. International Conference on Field Programmable Logic and Applications, pages 1135–1138, Springer Verlag Berlin Heidelberg, 2003. [96] J. Ramirez, U. Meyer-Bäse, F. Taylor, A. Garcia, and A. Lloris. Design and Implementation of High-Performance RNS Wavelet Processors Using Custom IC Technlogies. In Journal of VLSI Processing, volume 34, pages 227–237, Kluwer Academic Publishers, The Netherlands, 2003. [97] E. Roesler and B. Nelson. Novel Optimizations for Hardware Floating-Point Units in a Modern FPGA Architecture. In M. Glesner, P. Zipf, and M. Renovell, editors, Proc. International Conference on Field Programmable Logic and Applications, pages 637– 646, Springer Verlag Berlin, Heidelberg, 2002. [98] J. K. Salmon. Parallel Hierarchical N-body Methods. Ph.d. thesis, California Institute of Technology, 1990. [99] J. K. Salmon and M. S. Warren. Skeletons from the treecode closet. J. Appl. Phys., 111(1):136–155, 1994. [100] M. J. Schulte and K. E. Wires. High-speed inverse square roots. In I. Koren and P. Kornerup, editors, Proc. 14th IEEE Symposium on Computer Arithmetic, pages 124 – 131, Apr. 1999. [101] N. R. Scott. Computer Systems and arithmetic. Prentice-Hall, Englewood Cliffs, New Jersey, 1985. [102] J. A. Sellwood. The art of n-body building. Ann. Rev. Astron. Astrophys., 25:151–186, 1986. [103] N. Shirazi, A. Walters, and P. Athanas. Quantitative Analysis of Floating Point Arithmetic on FPGA Based Custom Computing Machines. In Proc. of IEEE Symposium on FPGAs for Custom Computing Machines, pages 155–162, IEEE Computer Society Press, 1995. [104] O. Spaniol. Computer arithmetic: logic and design. Wiley, New York, 1981. [105] R. Speith. Untersuchung von Smoothed Particle Hydrodynamics anhand astrophysikalischer Beispiele. Dissertation, Eberhards-Karls-Universität zu Tübingen, 1998. LITERATURVERZEICHNIS 207 [106] V. Springel, N. Yoshida, and S. D. M. White. Gadged: A code for collisionless and gasdynamical cosmological simulations. New Astronomy, 6:79, 2001. [107] R. Spurzem. Direct n-body simulations. Journal of Computational and Applied Mathematics, 109:407–432, 1999. [108] R. Spurzem and A. Kugel. Towards the million body problem on the computer – no news since the three-body-problem? In Proc. of Molecular Dynamics on Parallel Computers, pages 264–275, Singapore, 2000. World Scientific. [109] R. Spurzem, J. Makino, T. Fukushige, G. Lienhart, A. Kugel, R. Männer, M. Wetzstein, A. Burkert, and T. Naab. Collisional stellar dynamics, gas dynamics and special-purpose computing. In Proc. Intl. Symp. Comp. Science and Engineering 2002 (ISCSE’02). JSPS, 2002. astro-ph/0204326. [110] M. Steinmetz. GRAPESPH: cosmological smoothed particle hydrodynamics simulations with the special-purpose hardware GRAPE. Mon. Not. R. astr. Soc., 278:1005–1017, 1996. [111] M. Steinmetz and E. Müller. On the capabilities and limits of smoothed particle hydrodynamics. Astron. Astrophys., 268(1):391–410, 1993. [112] J. E. Stine and M. J. Schulte. The symmetric table addition method for accurate function approximation. Journal of VLSI Signal Processing, 21:167–177, 1999. [113] D. Sugimoto, Y. Chikada, J. Makino, T. Ito, T. Ebisuzaki, and M. Umemura. A specialpurpose computer for gravitational many-body problems. Nature, 345:33, 1990. [114] E. E. Swartzlander. Computer Arithmetic, volume 1–2. IEEE Computer Society Press, Los Alamitos, CA, 1990. [115] E. E. Swartzlander and A. G. Alexpoulos. The sign-logarithm number system. IEEE Transactions on Comput., 24:1238–1242, Dec. 1975. [116] N. Takagi. Powering by a table look-up and a multiplication with operand modification. IEEE Transactions on Comput., 47(11):1216–1222, Nov. 1998. [117] R. Tessier and W. Burleson. Reconfigurable computing for digital signal processing: A survey. Journal of VLSI Signal Processing, 28(1):7–27, June 2001. [118] C. Theis and R. Spurzem. On the evolution of shape in n-body simulations. Astron. Astrophys., 341:361, 1999. [119] Top 500 web site, Sept. 2003. URL: http://www.top500.org. [120] K. Underwood. FPGAs vs. CPUs: Trends in Peak Floating-Point Performance. In Proc. of FPGA’04, pages 171–180, Monterey, California, USA, Feb. 2004. 208 LITERATURVERZEICHNIS [121] J. Wadsley. High performance computing in astrophysics: Parallel gasdynamics and gasoline. In Proc. 17th Ann. Intl. Symp. on High Performance Computing Systems and Applications (HPCS2003), May 2003. [122] M. Wannemacher. Das FPGA-Kochbuch. MITP-Verlag, 1998. ISBN 3-8266-2712-1. [123] M. S. Warren and J. K. Salmon. A parallel hashed oct-tree n-body algorithm. In Proc. of the 1993 ACM/IEEE conference on Supercomputing, pages 12–21, Portland, Oregon, Dec. 1993. [124] M. S. Warren, E. H. Weigle, and W.-C. Feng. High-density computing: a 240-processor Beowulf in one cubic meter. In Proc. of the 2002 ACM/IEEE conference on Supercomputing, pages 1–11, Baltimore, Maryland, Nov. 2002. [125] S. Waser and M. J. Flynn. Introduction to arithmetic for digital systems designers. Holt, Rinehart and Winston, CBS College Publishing, New York, 1982. [126] M. Wetzstein. Wine - a new code for astrophysical particle simulations. Diploma thesis, Ruprechts-Karls-Universität Heidelberg, 2000. [127] Xilinx. Virtex-II Data Sheet, DS031 (V1.6) . http://www.xilinx.com, 2001. [128] R. Zimmermann. Computer Arithmetic: Principles, Architectures, and VLSI Design, Mar. 1999. Danksagung Hiermit möchte ich allen danken, die mich während meiner Zeit als Doktorand unterstützt und somit das Zustandekommen dieser Arbeit ermöglicht haben. An erster Stelle möchte ich Prof. Dr. Reinhard Männer dafür danken, dass er es mir ermöglicht hat, die Arbeit durchzuführen. Ich konnte mir seiner vollen Unterstützung zu jeder Zeit sicher sein und habe mich an seinem Lehrstuhl sehr wohl gefühlt. Mein besonderer Dank gilt auch Priv. Doz. Rainer Spurzem und Prof. Dr. Andreas Burkert die das interdisziplinäre Projekt von der Seite der Astrophysik aufgebaut haben. Markus Wetzstein, Thorsten Naab und Olav Kessel-Deynet möchte ich danken für die hervorragende Zusammenarbeit in allem, was die Simulationsalgorithmen und Codes betraf. Andreas Kugel und Matthias Müller möchte ich danken für die Unterstützung in allen Belangen der Hardware und Steuerungssoftware. Bedanken möchte ich mich auch bei Harald Simmler, Holger Singpiel, Erich Krause und Christian Hinkelbein für ihre spontane Hilfe bei verschiedensten technischen Problemen. Meinen Zimmerkollegen Stefan Hezel und Oliver Brosch danke ich für ihre uneingeschränkte Hilfsbereitschaft. Zudem möchte ich mich bei allen früheren und jetzigen Mitgliedern der FPGA-Arbeitsgruppe für das positive Arbeitsklima bedanken. Klaus Lienhart und Stefan Hezel möchte ich herzlich für die vielen Stunden des Korrekturlesens danken. Danke auch an Oliver Brosch für die Durchsicht des Manuskripts. Andrea Seeger und Christiane Glasbrenner danke ich für die vorbildliche logistische Betreuung während der gesamten Zeit. Allen anderen Kollegen danke ich für das freundliche Umfeld, in dem ich arbeiten durfte. Bei meiner Familie und meiner Frau möchte ich mich für den wertvollen Rückhalt, den sie mir während der Arbeit gegeben haben, bedanken. Bedanken möchte ich mich abschließend bei allen, die mich bei meiner Arbeit unterstützt haben, die ich aber an dieser Stelle nicht namentlich nennen kann.
* Your assessment is very important for improving the work of artificial intelligence, which forms the content of this project
advertisement