Eckdaten

Zu den Werkzeugen für die Software-Entwicklung gehören nicht nur Emulationssysteme, die eine schnelle Ausführung von RTL-Designs ermöglichen, um Software lange vor der Verfügbarkeit des Siliziums oder eines Entwicklungs-Boards zu validieren, sondern auch schnelle transaktions-basierte Co-Modellierungs-Kanäle, die den Emulator mit Software-Entwicklungswerkzeugen, die auf einer Workstation installiert sind, verbinden sowie eine Software-Debug-Umgebung mit den von den Software-Entwicklern geforderten Eigenschaften. Mentor Graphics bietet die Werkzeuge und notwendige Integration, die eine erfolgreiche Entwicklung ermöglichen und einen Wettbewerbsvorteil bieten.

Bei der Entwicklung von Software für ein bisher nicht vorhandenes Produkt benötigt der Programmierer als erstes eine Umgebung, auf der Software-Code ablaufen kann. Angefangen mit einem einfachen Stub-Code und dessen Weiterentwicklung mittels immer detaillierterer und vollständigerer Hardware-Modelle ist es möglich, die Software vor dem Erhalt des physikalischen Siliziums zu validieren. Dabei sollte der Entwickler so lange wie möglich in der leistungsfähigsten und am einfachsten zu debuggenden Umgebung bleiben und bei Bedarf detaillierte Modelle zur Validierung von Systemaspekten nutzen, die anders nicht zu überprüfen sind. Für eine nahtlose Übergabe von einer Umgebung in die andere benötigt der Entwickler eine gemeinsame Umgebung für Aufbau, Ausführung und Debugging. Diese Umgebung muss sich bis zum endgültigen Silizium erstrecken, da am Ende mit dem realen Seriengerät ein abschließender Test durchgeführt werden muss. Sobald der physikalische Prototyp vorliegt, muss jetzt nur noch eine finale Überprüfung seiner Funktion erfolgen. Das schwierige Hardware-Software-Zusammenspiel wurde bereits viel früher in der Designphase mit abstrakten Modellen der Hardware und späteren Takt-genauen RTL-Modellen der Hardware ausgearbeitet. Das reduziert erheblich die für die Software-Entwicklung erforderliche Zeit, wenn der physikalische Prototyp verfügbar ist.

Mentors Enterprise-Verification-Platform kombiniert moderne Simulationslösungen, Emulations-Technologie und eine leistungsfähige Debug-Umgebung in einer global zugänglichen hochleistungsfähigen Datenzentrums-Ressource.

Mentors Enterprise-Verification-Platform kombiniert moderne Simulationslösungen, Emulations-Technologie und eine leistungsfähige Debug-Umgebung in einer global zugänglichen hochleistungsfähigen Datenzentrums-Ressource.Mentor Graphics

Anspruchsvolle Modelle der neuen Hardware erstellen

Mit einem virtuelle Prototyping-System wie Vista von Mentor Graphics können anspruchsvolle Modelle der neuen Hardware erstellt werden. Diese Modelle laufen in der Regel schnell genug, damit die Software komfortabel ausgeführt werden kann. Falls das Hardware-Team die Modelle für den virtuellen Prototypen erstellt hat, so lässt sich, wenn die Software darauf abläuft, verifizieren, ob der Blick des Softwareteams auf das Design mit dem Blick des Hardware-Teams übereinstimmt. Normalerweise gibt es einige Diskrepanzen zwischen diesen beiden Ansichten. Das frühe Entdecken dieser Differenzen erspart später im Designzyklus eine Menge Ärger. Ein Werkzeug, mit dem sich Hard- und Software leichter debuggen lassen, verbessert das Debuggen erheblich.

Ein virtueller Prototyp enthält ein vollständig funktionales Modell der Peripherie, für die die Hardware entwickelt werden soll. Der Entwickler kann seine Software auf dieselbe Weise wie für das endgültige Zielsystem programmieren und auf die Register der Peripheriegeräte zugreifen, als ob sie auf echter Hardware laufen würden. Zusätzlich gewährt der virtuelle Prototyp einen direkten, nicht-intrusiven Blick in die Peripherieregister. Dies vereinfacht das Debugging. Der Entwickler ist damit in der Lage, seine Treiber vollständig zu schreiben und deren Funktion zu validieren. Er kann sogar grobe Zeitprobleme lösen. Für die detaillierte Timing-Verifikation benötigt er jedoch ein Modell, das die Hardware detaillierter beschreibt.

Detaillierte Timing-Verifikation

Ein virtueller Prototyp ist aber keine reale Hardware, er ist ein Modell. Ein Modell (in der Form eines Programms), das von einem Menschen geschrieben wurde. Leider weisen derartige Programme gelegentlich Fehler auf. Eine andere Sache, die im Auge behalten werden muss ist, dass die Hardware auf einer sehr abstrakten Ebene modelliert ist. Dies kann zu subtilen, aber erheblichen Differenzen mit der tatsächlichen Hardware führen. Selbst wenn die Treiber vollständig mit virtuellen Prototypen überprüft wurden, ist die Sache noch nicht erledigt. Es muss immer noch eine Validierung mit einer detaillierteren Hardware-Beschreibung erfolgen.

Sobald der Nutzen von Stub-Code und eventuell verfügbaren virtuellen Prototypen erschöpft ist, folgt als nächster Schritt die Validierung des Codes mit einem genauen Hardware-Modell, insbesondere RTL. Der beste Weg damit zu beginnen, ist eine Kombination der virtuellen Maschine mit dem RTL-Modell der Hardware, die entweder in der Simulation oder Emulation läuft. Virtuelle Maschinen beinhalten QEMU, einen Open-Source-Systememulator. Dieser modelliert bereits eine Vielzahl von ARM-Boards und zwei virtuelle ARM-Plattformen – das ARM-Fast-Modell (AFM) und das Foundation-Modell, eine kostenlose Version des AFM.

Validierung des Codes mit einem genauen Hardware-Modell

Mentor Graphics verfügt über ein Produkt namens Warpcore, das dies ermöglicht. Es kombiniert eine virtuelle Maschine mit einer RTL-Ausführungsumgebung und nutzt den RTL-Simulator oder -Emulator nur, wenn auf RTL zugegriffen wird. Die Kombination einer virtuellen Maschine mit Simulation, die mit wenigen Hundert Hertz läuft, mag verrückt erscheinen, ist aber machbar, wenn der Entwickler die Hardware nicht zu sehr stresst. Dies funktioniert sehr gut, wenn die Hardware mit weniger als einer Millionen Takte läuft. Der Simulator ist in der Regel einfacher einzurichten, zu debuggen und es lässt sich einfacher auf ihn zugreifen. Sobald mehr Taktzyklen auf der Hardware-Seite erforderlich sind, muss der Entwickler auf ein Emulationssystem wechseln, um eine vernünftige Leistung zu erzielen.

Das Kombinieren von virtueller Maschine und Emulation – einige Anbieter bezeichnen dies als Hybrid-Emulation – erlaubt es dem Entwickler, seine Software schnell und einfach mit einem Taktzyklen-genauen Modell der Hardware ablaufen zu lassen. Die typische Performance dieser Konfiguration liegt bei ungefähr 100 MHz. Das ist keine Echtzeit, aber schnell genug, um einen vollständigen Software-Stack ablaufen zu lassen und zu debuggen.

Emulation ist viel mehr als nur beschleunigte Simulation.

Emulation ist viel mehr als nur beschleunigte Simulation.
Mentor Graphics

Für die Peripheriekomponenten können einige einfache Tests angewendet werden. Um einen Treiber jedoch vollständig zu validieren, muss die Peripheriekomponente mehr machen als nur einen Loop-Back ausführen. Das heißt, sie muss mit der Außenwelt verbunden werden. Dies geschieht entweder über I/O-Kabel des Emulators oder virtuell mit einem Modell oder Host-Interface auf dem Computer, der mit dem Emulator verbunden ist. Im Emulationssystem von Mentor wird dies als Co-Model-Host bezeichnet. Eine schnelle und effiziente Verbindung zwischen Emulation-Co-Model-Host und dem Emulator ist für eine hohe Leistungsfähigkeit essenziell.

Detaillierte Leistungsanalysen

In dieser Konfiguration ist nicht das vollständige Design auf RTL. Das bedeutet, dass das System zwar korrekt funktioniert, aber nicht die gleichen Leistungscharakteristiken wie das Endprodukt aufweist. Es gibt einige Leistungsaspekte, die in dieser Konfiguration beobachtet werden können, zum Beispiel der Traffic zwischen bestimmten Komponenten. Detaillierte Leistungsanalysen erfordern jedoch eine genauere Darstellung des Systems.

Wird das gesamte Design auf RTL dargestellt, hat der Entwickler ein Taktzyklen-genaues Modell des vollständigen Systems. Dies kann für detaillierte Timing-Analysen oder Schlussfolgerungen über Durchsatz, Latenz und Reaktionszeiten verwendet werden. Um das System effektiv ablaufen zu lassen, muss es mit einem Emulations-System oder FPGA-Prototyp betrieben werden. Ein vollständiges System einschließlich einer realistischen Software-Last lässt sich mit Software-basierter Simulation praktisch nicht modellieren. Es gilt zu bedenken, dass selbst die Emulation im einstelligen MHz-Bereich läuft. Dies ist zwar viel schneller als Software-basierte Simulation, aber erheblich langsamer als Echtzeit.

Während der Emulation des Designs muss der Entwickler in der Lage sein, die auf dem Embedded-Prozessor laufende Software zu debuggen. Üblicherweise wird das mit den auf dem System vorhandenen Hardware-Schnittstellen wie JTAG gemacht. Dabei gibt es jedoch ein Problem. Während sich JTAG ideal zum Debuggen von funktionalen Aspekten eignet, lässt es sich nur schwer zum Debuggen der Performance- und Timing-Aspekte verwenden. Da der Entwickler mithilfe des „Hybrids“ aus virtueller Maschine und Emulation eine sehr viel höhere Performance erreicht, will er alle funktionalen Aspekte dort debuggen. Offen bleiben dann nur die zeitabhängigen Bugs und Performance-Probleme.

Alle Fähigkeiten eines traditionellen Software-Debuggers

Mit Codelink bietet Mentor Graphics ein Produkt, mit dem der Entwickler eine Fehlerprotokollierung des emulierten Designs durchführen und mit diesem Protokoll einen traditionellen Software-Debugger steuern kann. Im Wesentlichen erhält er so alle Fähigkeiten eines traditionellen Software-Debuggers – Einzelschrittverarbeitung des Codes, Setzen von Break-Points, Betrachten von Speicher und Variablen. Dies erfolgt ohne störende Nebenwirkungen unter Beibehaltung der Taktzyklen-genauen Emulation des Systems. Der Entwickler bekommt auch eine vollständig simultane Sichtbarkeit auf mehrere Prozessorkerne und die Möglichkeit, das System vor- und zurücklaufen zu lassen. Viele Performance-Probleme sind auf Source-Level nur schwer zu debuggen, häufig muss die Zeitachse der Prozessoraktivitäten im Design Seite an Seite mit den Hardware-Aktivtäten dargestellt werden. Das von Codelink erstellte Fehlerprotokoll lässt sich in Mentors Systemanalysewerkzeug integrieren, das diese Leistungsdaten zusammen mit Hardware-Daten anzeigen kann. Dies ist wahrscheinlich der beste Weg, um die Performance- und Timing-Aspekte darzustellen, die der Entwickler in diesem Entwicklungsstadium diagnostizieren möchte.