QNX Momentics Tool Suite

Assistenten

Die QNX Momentics Tool Suite erlaubt die automatische Projekterzeugung mittels geführter Assistenten. Entwickler können:

• Zwischen C, C++, Makefile und QNX-Multiplattform-Projekten wählen
• Mit einer Schritt-für-Schritt-Anleitung Projekte für eine beliebige Kombination von Zielsystemen erzeugen
• Projekte automatisch mit Build-Verzeichnissen, Dependency-Files und initialem Quellcode versehen
• Das gesamte Projekt automatisch zu ausführbaren Dateien übersetzen lassen

Projekt-Assistent

Der Projekt-Assistent hilft beim Anlegen neuer Projekte.

Die Quellcodeeditoren der QNX Momentics Tool Suite bieten eine Vielzahl hilfreicher und zeitsparender Features wie z.B. Undo, automatische Block-Kommentierung, Highlighting, sprachspezifische Einrückung und benutzerdefinierte Einstellungen.

Die IDE kann mit internen und externen Editoren verwendet werden. Öffnet ein Anwender eine Datei, startet die IDE den mit dem Dateityp verknüpften internen Editor. Ist kein interner Editor vorhanden, so wird ein passender externer Editor gestartet.

Kontexthilfe

Entwickler werden von einem kontextabhängigen Hilfssystem unterstützt, welches Autovervollständigung beherrscht, Funktionsbeschreibungen und Parameterlisten einblendet, die benötigten Header auflistet und die dafür notwendigen "include"-Anweisungen selbstständig einfügen kann.

Content Assist

Die Content Assist Funktion vervollständigt Funktionsnamen, zeigt Informationen an und ergänzt Parameter und Headerdateien.

Code Folding

Entwickler können Bereiche des Quellcodes ausblenden, wenn sie aktuell nicht damit arbeiten. Dazu gehört auch eine Mischform, bei der man Unterbereiche festlegen kann, die auch dann sichtbar bleiben, wenn der umgebende Codebereich ausgeblendet wird.

Code Templates

Mit einem einfachen Tastendruck kann sich ein Entwickler häufig benötigte Quellcodeblöcke generieren lassen, z.B. Code zur Behandlung von Exceptions oder eine "for"-Schleife. Jeder Editor bietet vordefinierte Templates, die nach Belieben angepasst oder kopiert werden können.

Markierungen

Die Editoren zeigen für die geladene Datei relevante Markierungen an, u.a. Breakpoints und Fehlermeldungen des Compilers. Ein Klick auf eine solche Markierung zeigt die problematische Zeile. Daneben können Entwickler selbst Markierungen zur Erinnerung an offene Aufgaben (To-Do) oder als Lesezeichen setzen.

Quellcode-Navigation

Der Quellcode-Navigator erlaubt die kontextabhängige Suche nach Referenzen und Definitionen, bietet eine Outline-View für die schnelle Navigation in Source- und Headerfiles und springt direkt zur Deklaration von Funktionen und Prototypen.

Änderungshistorie

Der Editor der IDE speichert die lokale Historie einer Datei und erleichtert somit temporäre Änderungen beim Debuggen. Anwender können die Editor-Einstellungen so wählen, dass mehrere Versionen der bearbeiteten Datei automatisch gespeichert, Versionen verglichen und gemerged werden können und Änderungen nachträglich zurückgenommen werden können.

Die IDE erlaubt Entwicklern freie Wahl der Build-Tools für die Entwicklung ihrer Embedded-Systeme. Sie können exakt identische Binaries und Ergebnisse auf folgende Arten erzielen:

• Command-Line Tools, die aus der IDE heraus gestartet werden
• IDE-Tools
• Command-Line und IDE-Tools

Kontrolle des Build-Prozesses

Die IDE erlaubt Entwicklern die interaktive Konfiguration des Build-Prozesses, wie z.B. Optionen für Compiler und Linker oder für zusätzliche Includes und Bibliotheken.

Multiprozessor-Makefiles

Die IDE macht Schluss mit der Notwendigkeit, Makefiles für Multiprozessor-Umgebungen selbst schreiben zu müssen. Mit einer einfach zu bedienenden Oberfläche kann die für die verschiedenen, auch parallel genutzten Zielsystem-CPU-Typen benötigte rekursive Makefile-Struktur generiert werden. Einstellungen werden von der IDE in das konventionelle Makefile-Format übertragen.

Wiederverwendung und Portierung

Entwickler können bestehende, auf Makefiles aufbauende Projekte weiterverwenden, aber auch Projekte portieren, die eine von "make" abweichende Build-Technologie verwenden.

Startkonfigurations-Assistent

Damit man für Build, Start und Debugging jeweils nur einen Klick braucht, gibt es den Startkonfigurations-Assistenten. Mittels der „Launch Configurations“ kann angegeben werden, welches Programm auf welchem Board mit welchen Debugger-Einstellungen gestartet werden soll.

Die IDE unterstützt außerdem Start-Gruppen, womit man mehrere Anwendungen sowohl gleichzeitig auf das Zielsystem laden und starten kann, als auch in einer vom Entwickler festgelegten Sequenz. Die IDE merkt sich die Einstellungen für diese Gruppen, so dass nachfolgende Starts einfach und schnell von der Hand gehen.

Die IDE erlaubt die Verwaltung des gesamten Quellcodes in einer Umgebung. Unterstützt werden:

• Subversion zur Integration mit darauf basierenden Repositories
• CVS-Versionskontrolle mit Unterstützung für Remote "PServer"-Lösungen und sicherem SSH-Zugriff auf Repositories
• Viele weitere Integrationen mit Versionsverwaltungen mittels Eclipse Plug-Ins: ClearCase, Perforce, SCWI, usw.

Integriertes Versions- und Konfigurationsmanagement

Versions- und Konfigurationsmanagement wurden direkt in das IDE-Framework integriert und erlauben die gesamte Quellcodeverwaltung innerhalb der IDE. Zudem können Entwickler in einem heterogenen Umfeld von Versionskontrollen arbeiten und verschiedene Lösungen für unterschiedliche Projekte einsetzen - auch für unterschiedliche Dateien in einem Projekt.

Versionsverwaltung, Vergleich und Merging

Wichtige Quellcode-Verwaltungsfeatures der IDE:

• Versionsmanagement bei Änderungen am Quellcode
• Steuerung der Freigabe von Änderungen an Teammitglieder
• Änderungshistorie zur Nachvollziehbarkeit der Änderungen anderer Programmierer
• Graphischer Vergleich von Dateiversionen
• Interaktiver Merge-Mechanismus zur Auflösung von Konflikten durch konkurrierende Änderungen an einer Datei

Konfigurationsmanagement

Mit dem Konfigurationsmanagement kann der Entwickler einstellen, welche Programme auf welchen Zielsystemen mit welchen Debug-Optionen ausgeführt werden sollen.

Im Debugger können Views von jedem anderen Werkzeug geöffnet werden, um so umfassende Informationen zum Zustand der Anwendung und einzelner Daten zu erhalten. Weitere Fähigkeiten des Debuggers:

• Gleichzeitiges Debugging mehrerer C oder C++ Anwendungen
• Debugging vom Multi-Thread-Anwendungen: Jeder Thread kann individuell überwacht werden und die Interaktion zwischen Threads ist nachvollziehbar
• Debugging von mehreren Prozessen, die auf unterschiedlichen CPUs laufen (bzw. auf unterschiedlichen Cores bei einer Multicore-CPU) mit Nachverfolgung des Wechsels der Programmausführung zwischen CPUs
• Dynamisches Attach des Debuggers an laufende Prozesse
• Post-Mortem-Analyse von Core-Dump-Dateien

Das QNX® Neutrino® Embedded-Betriebssystem enthält eine instrumentierte Version des QNX-Microkernels mit hochentwickelten Tracing- und Profiling-Mechanismen für das Echtzeit-Monitoring auf Einzelprozessor- und Multiprozessor-Systemen. Von der IDE aus kann man Trace-Events und Modi konfigurieren und anschließend die Log-Files zur Auswertung automatisch übertragen lassen.

Performance

Der instrumentierte Kernel verursacht nur einen sehr geringen Overhead. Er benötigt nur ca. 30 Kilobyte zusätzlichen Speicher und erreicht im Betrieb ohne Logging ca. 98% der Leistung des nicht instrumentierten Kernels.

Dank des geringen Overheads und der guten Performance verwenden viele Nutzer den instrumentierten Kernel nicht nur während der Entwicklung, sondern auch im fertig ausgelieferten Produkt und verbessern somit die Debugging- und Diagnosemöglichkeiten nach Produktauslieferung enorm.

Wenig Aufwand, hoher Nutzen

Um den instrumentierten Kernel zu nutzen, müssen keine Eingriffe am Quellcode vorgenommen werden, um die Interaktion des Programms mit dem Kernel nachvollziehen zu können.

Events filtern

Entwickler können bei der QNX® Momentics® Tool Suite die Menge der Daten filtern, die vom instrumentierten Kernel erfasst und gespeichert werden, um sich so ganz auf die für die Problemlösung relevanten Informationen konzentrieren zu können:

• Konfiguration der Bedingungen für die Auslösung von Trace-Events
• Einstellung von vordefinierten Filtern im Kernel zur dynamischen Anpassung von Trace-Events
• Implementierung von kundendefinierten Trace-Event-Handlern für eine sehr spezifische Filterung der erfassten und gespeicherten Daten.

Mit dem QNX® Momentics® Application Profiler können Entwickler die gesamte Performance eines Programms beurteilen, egal wie groß und komplex es ist, ohne jede einzelne Codezeile betrachten zu müssen. Bereiche mit häufig ausgeführtem Code können unmittelbar für Debugging, Performance-Analysen und zielgerichtete Optimierung identifiziert werden:

• Live-Profiling mittels Anbindung des Profilers an Software, die bereits auf dem Zielsystem läuft
• Identifizierung der Zeilen im Quellcode, die die meisten CPU-Zyklen verbrauchen
• Analyse der CPU-Auslastung durch Prozesse und Shared Libraries
• Aufzeichnung umfassender Laufzeitinformation mittels Kompilierung einer für den Profiler vorbereiteten Version der Software
• Postmortem-Profiling und -Analyse durch das Laden von statistischen Daten in den Profiler

Profiling ohne Beeinflussung

Der Application Profiler zeichnet in regelmäßigen Intervallen auf, in welchen Funktionen sich das laufende Programm gerade befindet, um so Entwicklern zu helfen, ineffiziente Teile in Programmen oder Shared Libraries zu finden. Diese Methode verursacht nur geringen Overhead, denn sie benötigt keine Instrumentierung oder Änderungen am Quellcode und stellt damit sicher, dass der Profiler die Daten, die er sammelt, nicht beeinflusst. Die Aufzeichnung kann ohne Neustart der Anwendung zurückgesetzt werden, so dass Entwickler Ergebnisse bei unterschiedlicher Last miteinander vergleichen können.

Instrumentiertes Profiling

Um exakte Angaben über die Häufigkeit von Funktionsaufrufen zu bekommen, kann der Compiler den übersetzten Code für den Application Profiler instrumentieren. Dieser zusätzliche Code informiert über Funktionsaufrufe und Aufrufpaare (aufrufende und aufgerufene Funktion). Sobald man die kritischen Bereiche anhand der Aufrufzahlen und Ausführungsstatistiken identifiziert hat, kann man anhand des navigierbaren Call-Graphs die Aufrufer einer Funktion finden und von da aus deren übergeordnete Funktionen – eine hervorragende Hilfe zur effizienten Optimierung des Codes.

QNX Application Profiler

Mit dem Application Profiler kann der Entwickler schnell herausfinden, wo sich eine Optimierung des Codes lohnt.

Multicore-Optimierung

Nach der Portierung auf ein Multi-Core-System können Entwickler Analysen des Application Profilers verwenden, um sehr schnell Codeteile für parallele Ausführung zu identifizieren. Angenommen eine CPU-intensive Routine zur Signalverarbeitung sticht im Profiling-Vorgang heraus, so teile man die Berechnung auf mehrere Multi-Threaded-Routinen auf, um auf einem Multi-CPU-System im SMP-Betrieb eine parallele Ausführung zu erreichen.

Der QNX® Momentics® System Profiler arbeitet Hand in Hand mit dem instrumentierten Kernel, um Einblicke in die Ereignisse und Aktivitäten des Betriebssystems zu ermöglichen. Wie der Application Profiler hilft der System Profiler bei der systemweiten Identifizierung von Bereichen, die womöglich Verbesserung benötigen:

• Bottlenecks in der Interprozesskommunikation - durch die Beobachtung des Nachrichtenflusses zwischen Threads
• Ressourcenkonflikte - durch die Beobachtung von Zustandsänderungen von Threads
• Cache-Kohärenz in Multicore Systemen - durch die Beobachtung von Threads, die von einer CPU auf eine andere wechseln

Multicore-System-Profiling

Der System Profiler arbeitet sowohl auf Singlecore- als auch auf Multicore-Systemen, die symmetrisches Multiprozessing (SMP) verwenden. Das Multicore-System-Profiling bietet für eine CPU oder das gesamte System u.a. folgende Features:

• Aktive Threads werden in unterschiedlichen Farben dargestellt, um anzuzeigen, auf welcher CPU der jeweilige Thread läuft.
• Die CPU-Migrationsübersicht zeigt, wie häufig das Scheduling einen Thread zwischen Prozessoren wechseln lässt und hilft bei der Identifizierung von Cache Thrashing
• Überblick über das Inter-Core Messaging, um zu zeigen, wie viel Nachrichtenverkehr zwischen den Cores stattfindet

QNX System Profiler

Der System Profiler nutzt eine instrumentierte Version des Microkernels, um das Zeitverhalten des Systems zu analysieren und Optimierungspotential zu finden.

Snapshots, Zusammenfassungen, Statistiken und mehr

Der System Profiler enthält verschiedene Werkzeuge, um Entwickler in die Lage zu versetzen, genau zu verstehen, was ihr System macht, wie sie Probleme lösen und die Performance optimieren können.

• Daten des instrumentierten Kernels werden grafisch aufbereitet, um Interaktionen zwischen Komponenten darzustellen
• Thread-State-Snapshots stellen den Zustand jedes einzelnen Threads zu einer bestimmten Zeit dar
• Das “Why Running?”-Tool listet alle Events auf, die zum aktuellen Zustand eines Threads geführt haben.
• Benutzerdefinierte Filter beschränken das Tracing auf die gerade interessanten Ereignisse und reduzieren somit das Datenvolumen für eine einfachere Analyse.
• Client/Server-Statistiken zeigen die direkt von einem Client benötigte Zeit und zusätzlich die Zeit, die dieser in von ihm verwendeten Server-Prozessen in Anspruch nimmt.
• Export von Trace-Daten an den Application Profiler für die Performance-Analyse von kritischen Systeminteraktionen

Die QNX® Momentics® Tool Suite beinhaltet ein integriertes Code Coverage Werkzeug, mit dem Entwickler während ihrer Tests nicht ausgeführte Codeteile identifizieren können. Somit können sie entweder den Test so ändern, dass der Code zur Ausführung gebracht wird – oder den Code löschen, falls er nicht mehr benötigt werden sollte. Features des Code Coverage Tools:

• Start einer Code Coverage Session zur unmittelbaren Beobachtung einer Anwendung
• Live-Darstellung der Resultate von Binärcode-Coverage bis hinunter zu einzelnen Blöcken (Branch Path)
• Einbindung des Quellcode-Editors, um sofort nachvollziehen zu können, welche Codezeilen abgedeckt wurden
• Nutzung der Navigations- und Referenz-Werkzeuge für die Analyse der Daten
• Darstellung des Fortschritts der Code-Abdeckung über mehrere Starts der Anwendung hinweg
• Generierung von Reports für weitere Analysen

QNX Code Coverage

Mit Code Coverage stellt der Entwickler sicher, dass bei Tests bestimmter Code wirklich vollständig ausgeführt wird. Das Tool erstellt bei Bedarf auch entsprechende Reports.

Code Coverage ist eine essenzielle Methodik für Umgebungen, die belastbares und vollständiges Testen erfordern. Es kann auch von großen Nutzen sein, wenn Bugfixing und Wartung von Teams durchführt werden, die nicht an der ursprünglichen Entwicklung des Codes beteiligt waren und womöglich an unterschiedlichen Standorten arbeiten.

Mudflap bietet eine Überprüfung von Pointern zur Laufzeit und ist in den GNU C/C++ Compiler (GCC) integriert. Verwendet man die QNX Momentics Tool Suite, benötigt man keine zusätzlichen Tools für Mudflap und erhält folgende Features:

• Ein Werkzeug zur Integration in den Build Prozess, der Mudflap als eine Build Variante anbietet.
• Ein Werkzeug erlaubt Entwicklern, von Mudflap entdeckte Fehler einzusehen und auszuwerten – beispielsweise Buffer-Overflows, unzulässige Heap-Zugriffe oder dereferenzierte Null-Pointer.

QNX Mudflap Unterstützung

Die QNX Momentics Tool Suite hat integrierte Mudflap-Unterstützung. Damit findet der Entwickler schnell Probleme mit Zeigerarithmethik.

Der System Builder vereinfacht das Erstellen von Betriebssystem-Images für Embedded-Systeme und spart den Entwicklern unzählige Arbeitsstunden, wenn sie Boot-Images oder Images für Flash-Dateisysteme erstellen müssen. Features des System-Builders:

• Automatische BSP-Projekt-Erstellung
• Entwickler können eine vorgefertigte Target-Image-Definition aus einem BSP importieren oder neu bauen
• Browser für Target-Images, mit dem Entwickler schnell und einfach Binärdateien, DLLs und Bibliotheken für das Image auswählen können
• Tracking von Library-Abhängigkeiten
• Es wird sichergestellt, dass das Image bei C/C++ Projekten immer aktuelle Builds enthält
• Optionale Verringerung des Speicherverbrauchs, indem nicht benötigte Funktionalität aus Shared Libraries entfernt wird.

QNX Embedded System Builder

Der QNX System Builder ermöglicht die visuelle Erstellung und Anpassung des Boot-Image Layouts.

Laden eines Boot-Images auf das Zielsystem

Für die Übertragung des Images auf das Zielsystem verwendet der System Builder entweder das eingebaute serielle Terminal, das mit einem ROM-Monitor auf dem Embedded-System kommuniziert, oder einen Transfer via TFTP oder BOOTP.

Sobald das Zielsystem betriebsbereit ist, können Entwickler auf eine Vielzahl von Möglichkeiten für Entwicklung und Dateitransfer zurückgreifen. Beispielsweise können sie den File-Browser in der IDE verwenden, um Dateien direkt auf dem Zielsystem bearbeiten zu können.

Die QNX Momentics Tool Suite kommt mit einem Target-Agent für das Embedded-Zielsystem, mit dem eine Vielzahl von Tool-Interaktionen ermöglicht wird, beispielsweise Programmstart, Debugging, Profiling oder Sammeln von Informationen.

Der Target-Agent ermöglicht jedem Tool in der IDE, mit dem Target zu kommunizieren. Sobald das Hostsystem einen Service aktiviert, lädt der Target-Agent das korrespondierende Modul auf dem Zielsystem. Wird der Service nicht länger benötigt, wird dieser vom Target-Agent wieder beendet, um so den Ressourcenverbrauch minimal zu halten.

Wie jeder QNX-Treiber kann der Target-Agent nach Bedarf jederzeit dynamisch gestartet oder gestoppt werden.

Die IDE enthält einen Navigator für das Target-Dateisystem, um eine einheitliche Sicht auf Zielsysteme zu erhalten. Entwickler können den Target-Navigator für eine Vielzahl von Aufgaben verwenden:

• Definition von Zielsystemen und Verbindungsaufbau
• Assoziation eines Standardprojektes, beispielsweise eines System-Images, mit einem bestimmten Zielsystem
• Überprüfung der Verfügbarkeit aller Target-Boards und Geräte
• Auswahl eines bestimmten Targets für eine Aktion, z.B. dem Start einer Telnet-Session
• Anzeige von Informationen zur Verbindung, Malloc, Speicher, Prozessen und Signalen

Neue Werkzeuge können den Navigator für das Target-Dateisystem als Erweiterungsansatzpunkt verwenden und eigene Aktionen zum Kontextmenü des Zielsystems hinzufügen. Beispiele für solche Aktionen könnten das Generieren eines Signals für einen Prozess oder ein Attach des Debuggers an einen laufenden Prozess sein.

QNX Target Navigator

Mit dem Target Navigator kann der Entwickler u.a. Dateien per Drag and Drop vom und zum Zielsystem transferieren.

Die IDE verfügt über ein Zielsystem-Informationswerkzeug, das eine Menge an Live- und Post-Mortem-Daten über das Zielsystem zur Verfügung stellt:

• Identifizierung von Bereichen mit hohem Ressourcenverbrauch – Speicherverbrauch, CPU-Auslastung und die Anzahl der offenen Interprozess-Verbindungen
• Hilft bei der Entdeckung und Auflösung potentieller Deadlock-Situationen – Grafische Anzeige der Abhängigkeiten von Prozessen
• Bearbeitung von Dateien auf dem Zielsystemen genau so, als wären sie lokal verfügbar
• Transfer neuer Dateien auf das Zielsystem, die dort direkt mit der IDE bearbeitet werden können
• Direkte Programmausführung: Ausführbare Dateien auf dem Target können durch einfachen Doppelklick gestartet werden

QNX System Information

Das QNX System Information Tool präsentiert dem Entwickler verschiedene Sichten auf das Embedded-System, vom Überblick über laufende Prozesse über Speicherverbrauch bis hin zu detaillierten Thread-Eigenschaften.         

Überblick und Detailinformationen

Die Target System Information bietet dem Entwickler einen High-Level-Überblick über das gesamte Zielsystem und auf Wunsch Detailinformationen über alle Prozesse und Threads. Im High-Level Überblick können Entwickler z.B. feststellen, welche Prozesse aktiv sind und welche Eigenschaften diese haben, dann kann der CPU- und Speicherverbrauch für das Gesamtsystem und für jeden Prozess einzeln betrachtet werden. Zudem können sie immer tiefer gehen und die Attribute von Threads (Status, Scheduling-Policy, CPU-Verbrauch, Größe des Stacks), den Status von Signalen, die Speicherbelegung von Programmen, File-Deskriptoren usw. untersuchen.