Laufzeitmessung für SCCharts auf Lego...

Laufzeitmessung für SCCharts aufLego Mindstorms

Dirk Sommerfeld

Bachelorarbeit2015/16

Prof. Dr. Reinhard von HanxledenReal-Time and Embedded Systems group

Department of Computer ScienceKiel University

Advised byDipl.-Inf. Ass. iur. Insa Fuhrmann

Eidesstattliche Erklärung

Hiermit erkläre ich an Eides statt, dass ich die vorliegende Arbeit selbstständig verfasstund keine anderen als die angegebenen Quellen und Hilfsmittel verwendet habe.

Kiel,

iii

Zusammenfassung

Diese Bachelorarbeit beschäftigt sich mit der Messung der Laufzeit von SCCharts auf LEGOMindstorms. SCCharts sind eine Modelliersprache für sicherheitskritische reaktive Systeme.Die LEGO Mindstorms sind programmierbare Systeme, die beispielsweise in einen Roboteroder eine Maschine aus speziellen LEGO Bauteilen eingebettet werden können. KIELERist ein Forschungsprojekt der Arbeitsgruppe Echtzeitsysteme und Eingebettete Systemeder Christian-Albrechts-Universität zu Kiel. Durch das Projekt KIELER kann man mitSCCharts ein reaktives System modellieren und es für eine Ausführung auf den LEGOMindstorms übersetzen. Reaktive Systeme sind zyklisch aufgebaut. Sie lesen Eingaben,berechnen daraus eine Reaktion und erzeugen Ausgaben. Für einen fehlerfreien Ablaufist es typischerweise wichtig, dass die Laufzeitanforderung der Verarbeitungsschritteeingehalten wird. Es wurde ein Mechanismus entwickelt, um bei der Ausführung aufden Mindstorms die Laufzeit zu messen. Das funktioniert mit Zeitstempeln, welche beider Ausführung gesetzt werden. Im Laufe der Arbeit wurden mehrere Methoden zurGenerierung von Zeitstempeln betrachtet und ihre Verwendbarkeit für eine Messungbeurteilt. Dann wurde ein Mechanismus zur Laufzeitmessung auf LEGO Mindstorms inKIELER integriert.

v

Inhaltsverzeichnis

1 Einleitung 11.1 Worst-case execution time . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.2 Analyse von SCCharts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.3 Problemstellung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31.4 Aufbau der Arbeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

2 Verwandte Arbeiten 72.1 Joint Test Action Group Interface . . . . . . . . . . . . . . . . . . . . . . . . . 72.2 Übersicht über Laufzeitanalysewerkzeuge . . . . . . . . . . . . . . . . . . . . 8

3 Verwendete Technologien 113.1 Eclipse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113.2 Kiel Integrated Environment for Layout Eclipse RichClient . . . . . . . . . . 11

3.2.1 Kieler Compiler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123.2.2 Project Management in KIELER . . . . . . . . . . . . . . . . . . . . . 123.2.3 Timing Program Points . . . . . . . . . . . . . . . . . . . . . . . . . . 13

3.3 LEGO Mindstorms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

4 Entwurf und Aufbau des Messverfahrens 194.1 Betrachtung der Mindstorms und der Betriebssysteme . . . . . . . . . . . . 19

4.1.1 Betriebssysteme des Lego Mindstorms NXT . . . . . . . . . . . . . . 204.1.2 Lego Mindstorms EV3 . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

4.2 Methoden zur Zeitmessung des EV3 . . . . . . . . . . . . . . . . . . . . . . . 224.3 Struktureller Aufbau des Messverfahrens . . . . . . . . . . . . . . . . . . . . 24

4.3.1 Beschreibung der timing-analyse-Datei und assumption-Datei . . . 254.3.2 Erstellung der Tick-Datei . . . . . . . . . . . . . . . . . . . . . . . . . 264.3.3 Erstellung der Main-Datei und des Headers . . . . . . . . . . . . . . 27

5 Implementierung in KIELER 31

6 Evaluation 356.1 Basisbeispiel SCChart robot . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356.2 Einfluss der Messung auf die Laufzeit . . . . . . . . . . . . . . . . . . . . . . 376.3 Ersetzung von Hostcode-Aufrufen . . . . . . . . . . . . . . . . . . . . . . . . 396.4 Messung von größeren SCCharts . . . . . . . . . . . . . . . . . . . . . . . . . 41

vii

Inhaltsverzeichnis

7 Fazit 437.1 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 437.2 Ausblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

A Robot 45

Bibliography 57

viii

Abbildungsverzeichnis

1.1 EV3-Brick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31.2 SCChart mit Laufzeitanalyse und Hotspot Highlighting . . . . . . . . . . . 4

2.1 Geöffneter NXT mit Modifikation für JTAG Interface . . . . . . . . . . . . . 7

3.1 SCChart ABO mit generiertem C-Code . . . . . . . . . . . . . . . . . . . . . 153.2 Mindstorms RCX und NXT . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163.3 Gyro-Boy, ein Roboter aus einem EV3 . . . . . . . . . . . . . . . . . . . . . . 17

4.1 SCChart secure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274.2 Tickfunktion des SCCharts secure . . . . . . . . . . . . . . . . . . . . . . . . . 28

5.1 Struktur des Messverfahrens . . . . . . . . . . . . . . . . . . . . . . . . . . . 325.2 KIELER . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

6.1 SCChart robot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356.2 SCChart secure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376.3 SCChart print . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 396.4 SCChart FunParc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

ix

Quellcodeverzeichnis

A.1 Textual SCChart (.sct) des Robots . . . . . . . . . . . . . . . . . . . . . . . . . 45A.2 Timing Analysis Datei des Robots . . . . . . . . . . . . . . . . . . . . . . . . 46A.3 Main-Datei des Robots . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47A.4 Tick-Datei des Robots . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

xi

Tabellenverzeichnis

6.1 Gesamtlaufzeit robot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 366.2 Gesamtlaufzeit von secure verschiedener TPP-Anzahlen . . . . . . . . . . . . 396.3 Messungen des SCCharts print . . . . . . . . . . . . . . . . . . . . . . . . . . 40

A.1 Messergebnisse robot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54A.1 Messergebnisse robot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55A.1 Messergebnisse robot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

xiii

Abkürzungsverzeichnis

Brick programmierbarer Baustein eines LEGO Mindstorms

KiCo KIELER Compiler

KIELER Kiel Integrated Environment for Layout Eclipse RichClient

Prom Project Management in KIELER

SCCharts Sequentially Constructive Charts

TPP Timing Programm Point

WCET worst-case execution time

xv

Kapitel 1

Einleitung

Im Bereich der eingebetteten Systeme befasst man sich mit Computern oder Software,welche fest in Geräte eingebaut und an eine bestimmte Funktion angepasst sind. Die Gerätereagieren meist auf Steuerbefehle und Sensoren, um dann Aktoren wie Motoren anzusteu-ern und werden oft im Dauerbetrieb eingesetzt. Deshalb ist bei der Entwicklung darauf zuachten, dass die Systeme fehlerfrei und ohne Abstürze arbeiten. Die Ausführungszeit derProgramme ist dabei sehr entscheidend. Dabei gilt nicht „schneller ist besser“, sonderndass das System im richtigen Moment angemessen reagiert. Die Ausführungszeit hängtvon vielen Faktoren ab. Die verwendete Hardware bestimmt, wie schnell ein einzelnerBefehl ausgeführt wird und wie hoch der Durchsatz an Befehlen ist. Sie bestimmt auch dieBefehle, die das System versteht. Diese sind in einem Instruktionssatz niedergeschrieben.Auch die umgebende Software, insbesondere das verwendete Betriebssystem, sowie dieArt, wie ein Stück Code zur Ausführung gebracht wird oder wie hoch die Auslastung desSystems ist, sind Faktoren, die die Ausführungszeit beeinflussen können.

1.1 Worst-case execution time

Der Begriff Worst-Case Execution Time (WCET) bezeichnet die längst mögliche Ausfüh-rungszeit eines Codeabschnitts. Eine exakte Berechnung der WCET kann sehr aufwendigwerden, in einigen Fällen ist es sogar praktisch unmöglich. Deshalb setzt man Technikenein, die die WCET annähernd bestimmen. Es gibt zwei große Teilgebiete von Techniken, dieWCET zu bestimmen[WEE+]. Das eine Gebiet umfasst statische Analysen. Ein verbreitetesVerfahren dafür ist das Arbeiten auf einem Kontrollflussgraphen des Programms. Dabeistellt man die Verzweigung eines Programms in einem Graphen dar und berechnet bei-spielweise den längsten Pfad des Graphen. Das zweite Gebiet sind messbasierte Verfahren.Das Ausführen auf der Zielhardware verbunden mit einem Messmechanismus ist hierfüreine Möglichkeit. Alle Verfahren haben Vor- und Nachteile. Bei einer statischen Analysedes Programms kann es schwierig werden, das restliche System einzubeziehen. Im Systemkönnen beispielsweise Caches verbaut sein, deren zeitliches Verhalten nicht oder nurschwierig vorhersagbar ist. Beim Ausführen auf der Zielhardware ist es im Allgemeinenunmöglich alle Fälle zu testen. Deshalb kommt es oft zur Unterschätzung der WCET, dadie längste Ausführungszeit nicht in der Testmenge liegen muss. Ein Vorteil von statischen

1

1. Einleitung

Analysen, im Vergleich zu Messmethoden, ist, dass die Zielhardware für die Berechnungnicht direkt eingesetzt werden muss.

Bei eingebetteten Systemen handelt es sich meist um reaktive Systeme. Das System liesteine Eingabe, berechnet eine Reaktion für diese und produziert entsprechende Ausgaben.Die Systeme lesen meist in regelmäßigen Abständen Eingaben ein. Dieser Zyklus wirdTick genannt. Bei der Berechnung der WCET müssen der Zustand und die Eingaben desProgramms berücksichtigt werden. So kann die Dauer des längstmöglichen Tickintervallsberechnet werden. Mit dieser Information kann eine sichere Taktung des Systems bestimmtwerden.

Die Sequentially Constructive Charts (SCCharts) [HDM+14] bilden eine grafische, syn-chrone Programmiersprache für sicherheitskritische Systeme. Ein SCChart ist typischer-weise ein reaktives Programm. Es hat Eingaben, Ausgaben und verschiedene Zustände.Das SCChart kann zu einer Tickfunktion kompiliert werden. Bei der Berechnung desWCETs für ein SCChart wird die erzeugte Tickfunktion betrachtet. Es wird die langsamsteAusführungszeit dieser Funktion, unter der Berücksichtigung des Zustandsraums und dermöglichen Eingaben des SCCharts, gesucht.

1.2 Analyse von SCCharts

Das Kiel Integrated Environment for Layout Eclipse RichClient (KIELER) ist ein Forschungs-projekt zur Verbesserung von grafischer, modellbasierter Entwicklung von komplexenSystemen. An der Christian-Albrechts-Universität zu Kiel wird die Modellierung voneingebetteten Systemen mittels SCCharts und der KIELER Entwicklungsumgebung aufLEGO Mindstorms gelehrt. Die LEGO Mindstorms werden außerdem am Lehrstuhl fürEchtzeitsysteme und Eingebettete Systeme als Forschungsobjekt eingesetzt. Ein wesentli-cher Aspekt von Echtzeit-Systemen ist die Einhaltung von Laufzeitanforderungen. Deshalbist man an einer Laufzeitanalyse von SCCharts auf LEGO Mindstorms interessiert.

Ein aktiver Bereich der Forschung in KIELER ist das Hotspot Highlighting. Dabei wer-den Elemente des SCCharts hervorgehoben, die im langsamsten Tick besonders viel Zeitverbrauchen, die sogenannten Hotspots (Siehe Abbildung 1.2). Um ein solches Highligh-ting anzubieten, wird eine Analyse der Laufzeit benötigt. In KIELER wurde das HotspotHighlighting mit einer Analyse des Analysewerkzeugs KTH‘s Time-aware Analyzer (KTA)des Royal Institute of Technology (KTH) in Schweden implementiert. Der Kieler Compilerkann ein SCChart unter anderem in die Sprache C übersetzen. Das Analysewerkzeuganalysiert das SCCharts indem es bei dem generieten C-Code eine erschöpfende Sucheeinsetzt und eine Ausführung auf einem MIPS 32 Prozessor simuliert. Man möchte das

2

1.3. Problemstellung

Abbildung 1.1. LEGO Mindstorms EV3 mit Sensoren und Aktoren1

Hotspot Highlighting auch für LEGO Mindstorms einsetzen. Dafür benötigt man dieWCET des SCCharts auf diesem System.

Ein zusätzlicher Verwendungszweck einer Laufzeitanalyse auf LEGO Mindstorms isteinen Vergleich zwischen Hotspots eines SCCharts, erzeugt vom KTA für den MIPS 32Prozessor und den Hotspots des SCCharts auf den LEGO Mindstorms machen zu können.

1.3 Problemstellung

In KIELER soll es möglich sein, eine Laufzeitanalyse von SCCharts auf LEGO Mindstormszu erstellen. Dafür habe ich einen Mechanismus entwickelt, der aus der kompiliertenTickfunktion für das SCChart unter Zuhilfenahme von Informationen über die Zuständeund Eingaben des SCCharts ein lauffähiges Programm erstellt und es auf dem LEGOMindstorms ausführt. Bei der Ausführung werden Informationen über die Laufzeit erstelltund in einer Datei abgespeichert. Es werden alle Kombination aus Zuständen und Belegungvon Eingaben gemessen und die Messergebnisse gespeichert. Das Messen der Laufzeitist in die Software integriert und nicht beispielsweise über eine externe Schnittstelle der

1 Quelle: https://entwickler.de/wp-content/uploads/2015/07/loewenstein_robotik2_2.jpg

3

https://entwickler.de/wp-content/uploads/2015/07/loewenstein_robotik2_2.jpg

1. Einleitung

Abbildung 1.2. SCChart mit Laufzeitanalyse und Hotspot Highlighting

Hardware realisiert, damit die Messung ohne Modifizierung des Mindstorms möglich ist.Innerhalb der Ausführung werden Zeitstempel gesetzt. Hierfür wurden die verfügbarenMethoden zur Generierung von Zeitstempeln geprüft und eine Methode verwendet, diemöglichst genau ist und wenig Einfluss auf das System hat. Dieser Mechanismus wurdedann in KIELER implementiert. In der Tickfunktion gibt es Variablen, die beschreiben, inwelchem Zustand sich das SCChart befindet. Die Anzahl und Belegung der Variablen hängtdabei vom einzelnen SCChart ab. Meistens sind bei der Ausführung des SCCharts nurbestimmte Belegungen der Variablen gültig. Wenn keine Informationen über die gültigenBelegungen vorhanden sind, werden alle Belegungen der Variablen als gültig angenommen,um eine Messung durchzuführen. In der Implementierung dieser Arbeit werden nacheiner Messung die ermittelten Laufzeiten in tabellarischer Form zur Verfügung gestellt.Eine Interpretation der Laufzeiten wurde nicht implementiert.

1.4 Aufbau der Arbeit

Im folgenden Kapitel wird auf verwandte Arbeiten eingegangen, die sich mit der Bestim-mung von WCET beschäftigen oder eine Analyse der Hardware von LEGO Mindstormsliefern. In Kapitel 3 werden Technologien vorgestellt, auf welchen das Messverfahrenaufbaut oder die es verwendet. Kapitel 4 behandelt den Aufbau und die Struktur desMessverfahrens. Bevor das Messverfahren entwickelt werden konnte, musste zunächst einpassendes System und eine angemessene Methode zur Zeitmessung gefunden werden.Wie der strukturelle Aufbau des gewählten Messverfahrens dann in KIELER umgesetztist, wird in Kapitel 5 beschrieben. In Kapitel 6 werden dann einige Ergebnisse der Mes-

4

1.4. Aufbau der Arbeit

sung präsentiert und analysiert. Im letzten Kapitel werden die Ergebnisse der Arbeitzusammengefasst und zukünftige Verwendungszwecke sowie offene Aufgabenstellungenvorgestellt.

5

Kapitel 2

Verwandte Arbeiten

In diesem Kapitel werden andere Arbeiten vorgestellt, die sich mit Laufzeitanalysen be-schäftigen. Es wird eine Methode zur Messung der Laufzeit vorgestellt, welche über externeHardware den Prozessor steuert. Danach wird auf verschiedene Techniken zur Laufzeit-analyse eingegangen und ein paar Werkzeuge analysiert, welche für die Bestimmung vonstatischen Laufzeitanalysen entwickelt wurden.

2.1 Joint Test Action Group Interface

Im Paper „Ada user guide for LEGO MINDSTORMS NXT” [BPZ11] wird beschrieben, wieman die LEGO Mindstorms NXT mit der Programmiersprache Ada verwenden kann. Dazuwird auch erklärt, wie man Debugging über ein externes Interface durchführt. Es handeltsich um ein Joint Test Action Group Interface (JTAG) und wurde 1985 für Test- und De-buggingzwecke entwickelt. An dieses Interface schließt man einen Test Access Port (TAP)Adapter an. Um dieses zu ermöglichen, muss man den Brick öffnen und die Leitung für dasInterface auf der Hauptplatine verlöten (Abbildung 2.1, links). Danach ist man in der Lage,über den TAP Adapter den Mindstorm zu steuern. Dabei kann man nicht nur den Speichermanipulieren und Programme starten, sondern auch systeminterne Zustände auslesen.Man kann beispielsweise den Prozessor anhalten, seine Register auslesen und sogar neusetzen und anschließend die Ausführung fortsetzen. Über dieses Interface könnte man bei-spielsweise die Prozessorzyklen mitzählen, welche ein Programm zur Ausführung benötigt.

Abbildung 2.1. Geöffneter NXT mit Modifikation für JTAG Interface1

7

2. Verwandte Arbeiten

In dieser Bachelorarbeit soll eine Methode entwickelt werden, die bei der Entwicklungvon Modellen, wenig Zusatzaufwand für die Durchführung der Laufzeitanalyse benötigt.Um das JTAG Interface nutzen zu können, wird zusätzliche Hardware in Form einesAdapters benötigt. Für die Verdrahtung des Adapters muss der Brick geöffnet, das In-terface verlötet und nach außen geführt werden. Schließlich muss die Software für dasAnsteuern des Interfaces auf dem Rechner konfiguriert werden, mit dem der Mindstormangesteuert werden soll. Da es nicht abschätzbar ist, wie gut die vorhandene Software aneine Laufzeitmessung anpassbar ist und die Hardware modifiziert werden müsste, wurdedieser Ansatz in dieser Arbeit nicht weiter verfolgt.

2.2 Übersicht über Laufzeitanalysewerkzeuge

Das Paper „The Worst-Case Execution Time Problem - Overview of Methods and Surveyof Tools”[WEE+] beschreibt allgemein das Vorgehen vieler Analysewerkzeuge und stellteinige Analysewerkzeuge vor. Es werden drei grundsätzliche Herangehensweisen an dieAnalyse beschrieben, beispielsweise ob eine Analyse direkt auf dee ganzen Ausführungoder nur auf Teilbereichen des Systems oder des Programms arbeitet. Die beiden Berei-che statische und messbasierte Methoden zur Laufzeitanalyse, welche in Abschnitt 1.1beschrieben sind, werden in 5 Unterkategorien eingeteilt und diese genauer beschrieben.Beispielsweise die Simulation von Ausführungen eines Programms ist nicht klar in einenBereich einteilbar. Die Vorteile und Nachteile verschiedener Analysetechniken werdenvorgestellt und ein Vergleich zwischen statischen und messbasierten Analysen gezogen.Danach werden verschiedene Werkzeuge zur Laufzeitanalyse vorgestellt.

Unter anderen auch „aiT WCET Analyzers” von AbsInt2. Dieses Werkzeug wurde imVerlauf der Recherche dieser Arbeit auch betrachetet, um zu ermitteln, ob sich diese füreine Analyse von SCCharts auf einem LEGO Mindstorms eignet. Das Werkzeug unterstütztdie Prozessoren der LEGO Mindstorms NXT und EV3. Es soll die WCET eines Programmsfür diese Architekturen berechnen können. Von der Verwendung in meiner Arbeit habeich jedoch abgesehen, da es sich um ein kommerzielles Werkzeug handelt.

Das Werkzeug „Open Toolbox for Adaptive WCET Analysis”3 (OTAWA) ist im Rahmeneines Forschungsprojektes an der University of Toulouse, Frankreich, entstanden. Im Paper„OTAWA: An open toolbox for adaptive WCET analysis”[BCR+10] werden die Elementeund Funktionen von OTAWA vorgestellt. Der Vorteil dieses Werkzeugs ist, dass es durchAbstraktion auf verschiedene Hardware anpassbar ist. Man kann über ein Interface eine

1 Quelle: Ada user guide for LEGO MINDSTORMS NXT [BPZ11]2 http://www.absint.com/3 http://www.otawa.fr/

8

2.2. Übersicht über Laufzeitanalysewerkzeuge

Beschreibung des Prozessors an das Werkzeug übergeben und damit die WCET-Analyseauf diesen Prozessor ausweiten. Damit könnte man OTAWA auf die LEGO Mindstormsanpassen. Ein mögliches Problem ist die Anpassung des Werkzeugs an die Eigenschafteneines SCCharts. OTAWA verwendet Bibliotheken, um verschiedene Analysetechnikenanbieten zu können. Inwieweit diese für SCChart verwendbar bzw. erweiterbar sind,wurde im Rahmen dieser Arbeit nicht betrachtet, da das Hauptziel der Bachelorarbeit eineMessung auf der Hardware ist. Ein weiteres Problem ist, dass für SCCharts das Messen voneinzelnen Codeabschnitten möglich sein soll und in OTAWA berechnet man die Laufzeitvon Funktionen.

9

Kapitel 3

Verwendete Technologien

Dieses Kapitel beschreibt Technologien, welche bei der Messung benötigt oder verwendetwerden. Dazu gehört die Softwarearchitektur KIELER, in welche der Mechanismus zurZeitmessung integriert wurde. Des Weiteren wird die Hardware beschrieben, die für eineMessung in Betracht gezogen wurde. Dabei handelt es sich um verschiedene Versionender LEGO Mindstorms.

3.1 Eclipse

Eclipse1 ist eine iä.ntegrierte Entwicklungsumgebung (IDE). Sie wurde von IBM bis 2001unter dem Namen „IBM Visual Age for Java 4.0“ entwickelt. Danach wurde der Quellcodeoffengelegt und Eclipse als frei verfügbare Software weiterentwickelt. 2004 wurde dieEclipse Foundation2 gegründet, eine Open-Source-Gemeinschaft, die es sich zur Aufgabegemacht hat, Eclipse zu betreuen. Eclipse wurde ursprünglich als Java Entwicklungsumge-bung entwickelt, mittlerweile gibt es allerdings eine Vielzahl von Anwendungsgebieten.Durch einen modularen Aufbau kann man die Funktionalität von Eclipse erweitern, dafürwurde eine Plug-in-Architektur umgesetzt. Durch Plug-ins kann man die vorhandeneFunktionalität erweitern oder neue Funktionen hinzufügen. Es ist dadurch auch möglich,eine eigene Sprache mit einem Editor in Eclipse umzusetzen.

3.2 Kiel Integrated Environment for Layout Eclipse RichClient

Das Forschungsprojekt Kiel Integrated Environment for Layout Eclipse RichClient3 (KIE-LER) beschäftigt sich mit der Verbesserung von graphischen Modellierungen für dieEntwicklung von eingebetteten und sicherheitskritischen Systemen. Dafür wurde auf Basisvon Eclipse eine Entwicklungsumgebung aufgebaut. Diese kann zur Modellierung vonSCCharts[HDM+14] verwendet werden. Das SCChart wird in einer textuellen Form mo-delliert. Zu diesem Modell wird dann automatisch eine visuelle Repräsentation generiert.Das erleichtert nicht nur den Modellierungsprozess, sondern unter anderem auch das

1 https://eclipse.org/2 https://eclipse.org/org/foundation/3 http://rtsys.informatik.uni-kiel.de/confluence/KIELER/

11

https://eclipse.org/

https://eclipse.org/org/foundation/

http://rtsys.informatik.uni-kiel.de/confluence/KIELER/

3. Verwendete Technologien

Verstehen von unbekannten SCCharts. In KIELER ist nicht nur die Modellierung vonSCCharts möglich, darüber hinaus es gibt noch weitere Funktionen für die Entwicklungvon komplexen Systemen. Diese Funktionen sind in KIELER in Projekte aufgeteilt. Andieser Stelle werden Projekte von KIELER vorgestellt, die für die Implementierung derLaufzeitmessung relevant sind.

3.2.1 Kieler Compiler

Der Kieler Compiler (KiCo)[MSH14] wurde in KIELER für die Übersetzung von SCChartsentwickelt. Er funktioniert mit dem Single-Pass Language-Driven Incremental Compilation(SLIC) Prinzip. Das bedeutet, dass der Compiler in einzelne Transitionen untergliedert ist.Diese Transitionen übersetzen immer ein Element einer Sprache. Dadurch ist der Compilermodular in einzelne Transformationen aufgebaut und kann um weitere Transformationenerweitert werden. Für jede Transformation wird angegeben, welche Eingaben in diesermöglich sind und welche Ausgabe produziert wird. Dadurch kann man KiCo für verschie-dene Zielplattformen einsetzen und Zwischenschritte der Kompilierung ersetzen oderweitere einfügen. Beim Aufruf von KiCo wird dabei in einem Context übergeben, welcheTransformationsschritte benutzt werden sollen. Man kann KiCo unter anderem auch dafürverwenden, aus einem SCChart eine Tickfunktion zu erstellen. Die Tickfunktion kann dannin der Sprache C oder Java erzeugt werden.

3.2.2 Project Management in KIELER

In der Entwicklungsumgebung KIELER ist die Entwicklung von Systemen in Projekteeingeteilt. Um diese Projekte für die Modellierung von SCCharts vorzubereiten und einebestimmte Zielplattform zu wählen, wurde die Erweiterung Project Management in KIE-LER (Prom)[Sta15] entwickelt.

Prom dient dazu das Projekt zu initialisieren, den benötigten Context für KiCo zu konfi-gurieren und die Tickfunktion des SCCharts in ein Programm einzubetten. Dafür mussein Environment für diese Plattform vorhanden sein und bei der Erstellung des Projektsausgewählt werden. Es folgt die Benennung des Projekts. Optional können noch vieleweitere Einstellungen vorgenommen werden. Zu diesen zählen zum einem die Einstellungvon Prom und zum anderen die Konfigurationsmöglichkeiten, welche Eclipse für Projektebietet. Passend für das entsprechende Environment gibt es Snippets und eine Vorlagefür das Programm, in welches die Tickfunktion eingebettet wird. In den Snippets stehenCodeabschnitte, die die Eingaben und Ausgaben des SCCharts verarbeiten können. Mankann anschliend über Annotationen im SCChart den Snippets die nötigen Informationenzukommen lassen, um bestimmte Abschnitte für das Programm zu verwenden. Bei derAusführung des SCCharts wird ein vollständiges Programm mit Hilfe von KiCo aus der

12

3.2. Kiel Integrated Environment for Layout Eclipse RichClient

Vorlage und den Snippets erstellt. Prom übernimmt die Einstellung von KiCo, erstelltdie Dateien und startet entweder Kommandozeilenbefehle oder einen launch shortcut. DieEinstellungen dafür können auch über das Environment übergeben werden. Der launchshortcut ist ein Mechanismus in Eclipse, um aus einem Editor oder der Workbench Pro-gramme zu starten. Ein solcher launch shortcut wird beispielsweise vom Eclipse Plug-inleJOS angeboten. Mit diesem kann man Java Programme automatisch übersetzen lassenund auf den, mit leJOS Firmware bestückten Brick, hochladen. Um einen launch shortcutzu erstellen wird von Eclipse ein Interface bereitgestellt.

Um es zu ermöglichen, in Prom weitere Environments hinzuzufügen, wird ein Interfaceangeboten. Man kann in einem Projekt in KIELER dieses Interface implementieren. Dazuwerden die Einstellungen für das Environment übergeben und die Programmvorlage undSnippets erstellt.

3.2.3 Timing Program Points

Das Projekt „Interactive Timing Analysis“[FBS+14] beschäftigt sich mit der Darstellungder Laufzeit eines SCCharts bei der Entwicklung von Systemen. Eine experimentelle Ent-wicklung, die daraus hervorgegangen ist, ist das Hotspot Highlighting. Um ein solchesHighlighting anzubieten, wurde eine Infrastruktur implementiert, die eine Analyse desSCCharts möglich macht.

Das Tracing[Sch14] ist eine Erweiterung von KIELER, mit der man Beziehungen zwi-schen Modellelementen vor und nach einer Modelltransformation herstellen kann. In demProjekt „Interactive Timing Analysis“ wurde eine Methode entwickelt, die aus dem Tracingeine Zuordnung von Elementen des SCCharts zu Abschnitten der Tickfunktion berechnet.Dabei wird die Tickfunktion so strukturiert, dass eine Zuordnung der Abschnitte zuRegionen des SCCharts möglich ist. Mit dieser Methode wurde dann eine Transition fürKiCo entwickelt, die in einem Zwischenschritt sogenannte Timing Program Points (TPP) indie Tickfunktion einfügt.

Die Timing Program Points sind durchnummeriert und werden als Markierung in derTickfunktion eingearbeitet. Diese Punkte trennen Abschnitte in der Tickfunktion von-einander. Wenn man nun die Laufzeit zwischen den TPPs kennt, kann man daraus dieanteilige Laufzeit der Regionen des SCCharts berechnen. Ein Beispiel für eine Übersetzungvon einem SCChart mit den TPPs ist in Abbildung 3.1 illustriert, dabei wird aus demSCChart C-Code generiert. Die drei TPPs in Zeile 9, 17 und 25 teilen die Tickfunktionin vier Abschnitte. Diese Abschnitte sind verschiedenen Regionen des SCChart zugeordnet.

Damit man eine Laufzeitanalyse durchführen kann, werden neben den TPPs in der

13


Tickfunktion noch weitere Informationen zum SCChart benötigt. Das sind zum einenInformationen über die Verwendung von Variablen in der Tickfunktion, also ob sie als Ein-oder Ausgaben genutzt werden oder ob sie für die Speicherung des Zustands des SCChartszuständig sind. Zum anderen benötigt man Informationen, welche Zustände des SCChartsgültig sind. Um diese Informationen zu erstellen, gibt es im Projekt eine Funktion, welche ineiner Datei die Information erstellt. Diese Datei heißt timing-analysis-Datei (.ta-Datei). DieFunktion erstellt einen Teil der Daten aus der Übersetzung des SCCharts und den anderenTeil aus einer assumption-Datei (.asu-Datei). Die assumption-Datei enthält die gültigen Zu-stände des SCCharts und es können über sie Laufzeiten von Hostcode-Aufrufen integriertwerden. Diese geben für eine Laufzeitanalyse die Möglichkeit, Hostcode-Aufrufe durchDummies zu ersetzen und trotzdem für die Aufrufe Laufzeiten berechnen zu können. EineLaufzeitanalyse eines SCCharts kann dann mit der passenden .ta-Datei und der generiertenTickfunktion, in der bei der Übersetzung die TPPs eingefügt wurden, durchgeführt werden.

Das Hotspot Highlighting ist eine mögliche Verwendung einer Laufzeitanalyse. In derAnalyse wird der längste Tick des SCCharts berechnet, die anteiligen Laufzeiten derRegionen im SCChart durch die TPPs des Ticks bestimmt und diese Information in einHighlighting wie in Abbildung 1.2 umgesetzt.

14

3.2. Kiel Integrated Environment for Layout Eclipse RichClient

(a) Das SCChart ABO

1 void tick(){

2

3 {

4 g0 = _GO;

5 if(g0){

6 O1 = 0;

7 O2 = 0;

8 }

9 TPP(1);

10 g4 =(PRE_g3);

11 g2 =((g4&&A)||(_GO&&A));

12 if(g2){

13 B = 1;

14 O1 = 1;

15 }

16 g3 =((_GO&&(!(A))) ||

(g4&&(!(A))));

17 TPP(2);

18 g7 =(PRE_g6);

19 g7b = g7;

20 g6 =(_GO||(g7b&&(!(B))));

21 g8 =(g7b&&B);

22 if(g8){

23 O1 = 1;

24 }

25 TPP(3);

26 g8_e2 =(!(g6));

27 g2_e1 =(!(g3));

28 g9 =((g2_e1||g2) &&

(g8_e2||g8) &&

(g2||g8));

29 if(g9){

30 O1 = 0;

31 O2 = 1;

32 }

33 g11 =(PRE_g10);

34 g10 =(g9||g11);

35 }

36 PRE_g3 = g3;

37 PRE_g6 = g6;

38 PRE_g10 = g10;

39 _GO = 0;

40

41 return;

42 }

(b) C-Code von ABO mit TPPs

Abbildung 3.1. Ein SCChart mit generiertem C-Code

15


(a) Der Mindstorms RCX4(b) Der Mindstorms NXT5

Abbildung 3.2. Die ersten Mindstorms

3.3 LEGO Mindstorms

Die LEGO Mindstorms Produktserie besteht aus drei programmierbaren Bausteinen. Diesogenannten Bricks werden in Paketen verkauft, welches neben Aktoren und Sensorenauch andere Legosteine enthalten. Die Aktoren sind beispielsweise Motoren und Lampen.Bei den Sensoren gibt es Taster oder Geräte zur Umgebungserkennung, wie Ultraschall-sensoren, für Entfernungsmessung oder Gyrosensoren um Drehungen zu erkennen. Mankann aus diesen Paketen verschiedenste Roboter oder Maschinen bauen und zur Steue-rung Programme erstellen und auf den Brick hochladen. Der Brick besitzt Buchsen zumAnschließen von Aktoren und Sensoren.

Der erste Brick, mit dem Namen RCX (Robotics Command System), ist 1998 erschienen.Sein Hauptprozessor hat eine 8-Bit Architektur. Basierend auf diesem System wurde daszweite System mit dem Namen LEGO Mindstorms NXT im Jahr 2006 entwickelt. DerBrick besitzt drei RJ12-Anschlüsse für Aktoren und vier RJ12-Anschlüsse für Sensoren.Die Aktoren des NXT bestehen aus Glühlampen und Servomotoren. In die Servomotorensind Rotationssensoren integriert, wodurch man den Motor gradgenau ansteuern kann.Die Sensoren bestehen aus einem Abstandsmesser auf Ultraschallbasis, einem Lichtsensor,der Helligkeit erkennt, einem Schallsensor, der Geräusche erkennt und Tastern, welchebetätigt oder als Kontaktsensor verwendet werden können. Im Inneren des Bricks ist einAtmel AT91SAM7S256 Mikroprozessor verbaut. Der Prozessor gehört in die ARM7TDMIFamilie. Die Prozessorfamilie benutzt je nach Version einen anderen Instruktionssatz. ImFall des AT91SAM7S256 ist es der ARMv4T Instruktionssatz.

4 Quelle : http://vignette2.wikia.nocookie.net/herofactory/images/5/57/LEGO_RCX.png/revision/latest?cb=201101182213265 Quelle : https://entwickler.de/wp-content/uploads/2015/07/loewenstein_robotik2_2.jpg

16

http://vignette2.wikia.nocookie.net/herofactory/images/5/57/LEGO_RCX.png/revision/latest?cb=20110118221326

https://entwickler.de/wp-content/uploads/2015/07/loewenstein_robotik2_2.jpg

3.3. LEGO Mindstorms

Der aktuellste Brick, der im Jahr 2013 erschienen ist, heißt EV3. Er besitzt vier RJ12-Anschlüsse für Aktoren und vier RJ12-Anschlüsse für Sensoren. Die Anschlussgerätedes NXT sind mit dem EV3 kompatibel. In dieser Version gibt es neben allen Sensorenund Aktoren, welche auch für den NXT zur Verfügung stehen, noch einen kleinen Motorund einen Gyrosensor, welcher Drehungen erkennen kann. Der Lichtsensor kann nebenHell und Dunkel auch Farben erkennen. Zur Steuerung des Bricks sind sechs Knöpfeangebracht. Die Micro-USB-Buchse dient als Kommunikationsschnittstelle. An der Seitehat der Brick eine USB-Buchse und ein Einschubfach für Micro-SD-Karten. Die Buchsekann verwendet werden, um weitere USB Geräte an den Mindstorm anzuschließen, wiebeispielsweise einen WLAN-Empfänger. Das Einschubfach ist zur Erweiterung des Spei-chers des Bricks gedacht. Dabei kann man eine SD-Karte bis zu der Größe von 32 GBverwenden. In Abbildung 3.3 ist ein Roboter abgebildet, der aus einem EV3 gebaut wurde.An der Seite des Bricks sieht man die USB- und SD-Kartenschnittstelle.

Abbildung 3.3. Der Gyro-Boy, ein Roboter aus einemEV36

Im Inneren des Ev3 ist, wiebei den Vorgängern auch, ein Ein-Chip-System (System on a Chip)eingebaut. Beim Ev3 ist es dervon Texas Instruments hergestell-te AM1808. Der Hauptprozessorauf diesem Chip gehört in dieARM9 Architektur-Familie. Es ist derARM926EJ-S Kern mit einem Taktvon 300 MHz (3 1/3 ns pro Pro-zessorzyklus). Er benutzt einen 32-Bit ARMv5 Instruktionssatz. DieserInstruktionssatz ist 2003 erschienen.Der Ev3 hat einen Arbeitsspeichervon 64 MB RAM, sowie einen in-ternen Speicher mit 16 MB Flash-Speicher und kann per SD-Karteum bis zu 32 GB erweitert wer-den.

Der EV3 unterstützt, neben demvon LEGO entwickelten Betriebssystem LEGO EV3 Firmware, auch noch weitere Betriebs-systeme. Es ist nicht nötig die Firmware auf dem Brick zu überschreiben, denn er ist so

6 Quelle: http://mms.businesswire.com/bwapps/mediaserver/ViewMedia?mgid=352951&vid=5

17

http://mms.businesswire.com/bwapps/mediaserver/ViewMedia?mgid=352951&vid=5


konfiguriert, dass ein passendes bootbares Betriebssystem per SD-Karte eingesteckt werdenkann. Der Brick priorisiert das Betriebssystem von der SD-Karte. Der Ev3 unterstützt unteranderem ein Linux-Debian-Kernel. Der in dieser Arbeit verwendete Kernel heißt ev3dev.Er bietet eine Netzwerkschnittstelle über den Micro-USB-Anschluss, mit der man denBrick per SSH ansteuern kann. Es gibt auch die Möglichkeit, den Brick per Bluetooth oderWLAN anzusprechen. Für WLAN muss man allerdings einen WLAN-Empfänger an dieintegrierte USB-Schnittstelle anschließen. Wenn der EV3 mit einem Rechner verbunden ist,kann er sich über diesen Rechner mit dem Internet verbinden, um beispielsweise Updatesherunterzuladen. Der Kernel ev3dev ist kompatibel mit allen Programmen, die für ARMunter Linux zur Verfügung stehen. Außerdem gibt es einen Crosscompiler, der für allegängigen Betriebssysteme bereit steht. Mit diesem Compiler können C-Programme für denKernel übersetzt werden. So ist es nicht nötig Programme auf dem Brick zu kompilieren.Das Programm kann auf einem System übersetzt und auf den Ev3 hochgeladen werden.

18

Kapitel 4

Entwurf und Aufbau des Messverfahrens

In diesem Kapitel wird beschrieben, wie das Messverfahren aufgebaut ist. Dazu wirderklärt, welche Methoden zur Laufzeitmessung im Laufe der Arbeit betrachtet wurden.Die Laufzeitmessung soll auf LEGO Mindstorms durchgeführt werden, dafür wurdenverschiedene Betriebssysteme analysiert. Danach werden für das eingesetzte Betriebssystemverschiedene Methoden für die Erstellung von Zeitstempeln vorgestellt. Der Ablauf derMessung wird im letzten Abschnitt beschrieben.

4.1 Betrachtung der Mindstorms und der Betriebssysteme

Für die Zeitanalyse sollte nach Möglichkeit ein Zielsystem gewählt werden, das Program-me in einer Sprache versteht, die sich gut für eine Analyse eignet. Eine weit verbreiteteSprache für Analysen ist C, da sie hardware-nah übersetzt werden kann und wenigeHintergrundprozesse benötigt, um ausgeführt zu werden. In dieser Arbeit wurde derLEGO Mindstorms EV3 verwendet und als Betriebssystem ein Linux-Kernel. In Verlauf derArbeit wurden noch weitere Betriebssysteme betrachtet. Diese stelle ich im folgenden vor.

LEGO Firmware: Für die vom Hersteller auf den Bricks installieren Betriebssystemegibt es keine Möglichkeit ein SCChart auszuführen. Diese Betriebssysteme können nurProgramme ausgeführen, welche mit der LEGO Software erstellt wurden. Dabei wird einegrafische Programmiersprache verwendet, die auf LabVIEW bassiert.

leJOS: leJOS ist ein Java-Betriebssystem. Es ist für die Programmierung mit Javaausgelegt. leJOS wurde sowohl für den EV3, wie auch für den NXT entwickelt. Java bietetbei der Entwicklung von Programmen den großen Vorteil der Plattformunabhängigkeit.Der Code wird in einer virtuellen Maschine ausgeführt, die für die Plattform angepasstsein muss. Ein weiterer Vorteil ist, dass man bei der Entwicklung von Programmen denSpeicher nicht selbst verwalten muss. Die Verwaltung des Arbeitsspeichers ist in Javaautomatisiert. Ein daraus entstehender Nachteil ist, dass ein sogenannter Garbage Collectorbenötigt wird. Dabei handelt es sich um ein Programm, welches im Hintergrund läuft undSpeicherbereiche bereinigt, wenn diese nicht mehr referenziert werden. Der Garbage Col-lector und die virtuelle Maschine sind schwer berechenbar und können bei einer Messung

19

4. Entwurf und Aufbau des Messverfahrens

die Ausführungszeit erheblich beeinflussen. Aufgrund dieser Nachteile wurde von einerVerwendung von Java für die Messung abgesehen.

4.1.1 Betriebssysteme des Lego Mindstorms NXT

Für den LEGO Mindstorms NXT gibt es eine Reihe von Betriebssystemen. Um das Betriebs-system zu wechseln, muss der Brick geflasht werden. Beim Flashen werden alle Daten aufdem Brick gelöscht und es muss ein neues Betriebssystem aufgespielt werden. Um einneues Betriebssystem auf den Brick zu schreiben, benötigt man einen Rechner, bei dem derTreiber für den Mindstorms eingerichtet ist. Der Brick muss mit diesem Rechner über einMicro-USB Kabel verbunden sein. Der LEGO Mindstorms NXT bietet kein Betriebssystem,welches C-Code verarbeitet und sich für die Messung eignet. Aber es gibt Betriebssystemefür den NXT welche C-ähnlichen Code benutzen, dazu gehören brickOS und nxtOSEK.

brickOS: Das Betriebssystem brickOS ist für eine Messung zu aufwendig. Es wird dafürein Rechner benötigt, auf dem das „Bricx Command Center“ installiert ist. Die Einrichtungdieser Software ist für einige Systeme schwierig. So konnte bei einem Test für Linux dieSoftware zwar gestartet werden, aber sie hat den Brick, welcher über USB verbunden war,nicht erkannt. Für Programme wird dann nicht die Sprache C verwendet, sondern dieProgrammiersprache „Not eXactly C“. Des Weiteren würde man einen speziellen Compilerfür diese Programme benötigen.

nxtOSDEK: Ein weiteres Betriebssystem, das betrachtet wurde, ist nxtOSEK. Diesesbietet gegenüber brickOS den Vorteil, dass es eine GNU-ARM-Compiler-Chain (GCC) be-nutzt. Die Bedeutung von GCC hat sich im Laufe der Zeit sehr gewandelt. Die allgemeinsteBedeutung ist GNU-Compiler-Collection. Ursprünglich wurde der GCC als C-Compilerfür Linux-Systeme entwickelt. Mittlerweile kann er eine Vielzahl von Sprachen übersetzen.Er ist auch für die Benutzung verschiedener Zielplattformen und Architekturen erweitertworden. Bei der Installation von nxtOSEK traten einige Probleme mit der Einrichtung desBricks auf, da die Firmware nur als Quellcode vorliegt. Dieser muss zur Benutzung erstübersetzt werden. Zum Zeitpunkt dieser Bachelorarbeit konnte die Firmware auf einemaktuellen Ubuntu der Version 15.10 nicht kompiliert werden. Es werden nur Ubuntu 11.10und Ubuntu 10.8 als verwendbare Betriebssysteme angegeben, um die Kompilierketteaufzubauen. Da es sich abzeichnete das nxtOSEK eine erhebliche Konfigurierungszeitdes Entwicklungsrechners benötigt, wurde von einer Verwendung für die Zeitmessungabgesehen.

20

4.1. Betrachtung der Mindstorms und der Betriebssysteme

4.1.2 Lego Mindstorms EV3

Der LEGO Mindstorms EV3 kann flexibler mit verschiedenen Betriebssystemen umgehen.Es ist möglich das Betriebssystem zu wechseln, ohne den Brick neu beschreiben zu müssen.Man erstellt eine SD-Karte mit einem bootbaren Betriebssystem und steckt diese vor demStarten des Bricks ein. Wenn man den EV3 dann startet erkennt er das Betriebssystem aufder SD-Karte und startet es anstelle der Firmware, welche intern im Brick installiert ist. Da-bei wird das Betriebssystem im Flashspeicher nicht überschrieben. Stattdessen arbeitet derBrick von der SD-Karte aus. Für den EV3 gibt es auch verschiedene Betriebssysteme. Unteranderem gibt es eine Version von ROBOTC. Neu im Vergleich zu dem NXT ist, dass derEV3 mit einem Linux-Kernel kompatibel ist. Da sich heraus stellte, dass ein Linux-Kernelalle Kriterien für eine Messung erfüllt, wurden keine weiteren Betriebssysteme betrachtet.

ev3dev: Ev3dev ist ein Debian-Linux basiertes Betriebssystem und wurde speziellfür den EV3 entwickelt. Durch die Benutzung von Linux stehen alle Programme zurVerfügung, welche sich für die ARM-Architektur kompilieren lassen. Außerdem kannder Cross-Compiler1 (GNU C Compiler for armel architecture) verwendet werden. EinCross-Compiler ist eine Übersetzungsmaschine, welche den Quellcode eines Programmsin ein ausführbares Programm übersetzen kann und dabei nicht auf der Zielhardwareausgeführt werden muss. Der LEGO Mindstorms EV3 ist ein eingebettetes System und fürseinen Verwendungszweck leistungsstark, aber er ist nicht für komplexe Berechnungenausgelegt. Der Rechner, der für die Entwicklung genutzt wird, ist im Allgemeinen deutlichleistungsfähiger als der eingesetzte EV3. Der Brick muss für die Messung das Programmlediglich ausführen. Der Compiler muss für eine Messung auf dem Entwicklungsrechnerinstalliert sein und für KIELER zugänglich gemacht werden. Dafür muss man die Umge-bungsvariable setzen, damit KIELER weiß, wo sich der Compiler befindet. Dadurch kanndas Programm vollständig auf dem Rechner übersetzt werden. Es ist möglich, über einMicro-USB-Kabel das Gerät mit einem anderen Rechner zu verbinden. Dann wird per USBeine Netzwerkverbindung aufgebaut. Im ev3dev läuft eine Software, welche über dieseSchnittstelle eine Kommunikation per Secure Shell (SSH) ermöglicht. Man benötigt zurSteuerung des Bricks nur einen Client, der SSH unterstützt. Diese Clients sind in Linuxstandardmäßig installiert und es stehen auch Clients für Windows und MAC zur Verfü-gung. Die Messung benötigt also nur einen Rechner mit einem gängigen Betriebssystemund einem SSH-Client, welcher als kostenlose Software für alle zur Verfügung steht.

1https://launchpad.net/gcc-arm-embedded

21


4.2 Methoden zur Zeitmessung des EV3

Um eine Messung der Laufzeit durchführen zu können, sind in die Tickfunktion „TimingProgram Points“ eingearbeitet. Zwischen diesen TPPs soll die vergangene Zeit gemessenwerden. Dafür benötigt man eine Methode um Zeitstempel an den TPPs zu generieren. Eswerden nun verschiedene Methoden vorgestellt, welche im Verlauf der Arbeit betrachetetwurden. Dabei hat sich die Methode Timer als geeignet herausgestellt und wird in derLaufzeitmessung dieser Arbeit eingesetzt.

Beim Testen verschiedener Methoden war es erforderlich, den Kernel des EV3 zumodifizieren. Gründe dafür waren zum einen, dass Funktionen betrachtet wurden, die nurdem Kernel zugänglich sind, zum anderen war zum Ausführen bestimmter Befehle eineBerechtigungsstufe erforderlich. Diese Befehle kann man entweder in einem Modul desKernels ausführen oder in einer Kernelfunktion aufrufen. Um einem Linux-Betriebssystemein neues dynamisches Modul hinzuzufügen, gibt es das Dynamic Kernel Module Support(DKMS) Framework. Um es zu benutzen, installiert man das dkms package und fügt demKernel die passenden Header hinzu. Da der ev3dev kein Standard-Kernel ist, kann mandie Header nicht über den package manager beziehen. Man kann die Header im Git2 vonev3dev finden und dem Kernel hinzufügen. Es war dennoch nicht möglich, auf demKernel neue dynamschine Module zu installieren. Zur Modifikation des Kernels musste erneu kompiliert werden. Dafür gibt es im Git vom ev3dev den kompletten Quellcode undBuildscripts zur Erstellung des Kernels. Diese kann man unter Ubuntu verwenden. Mankann den Quellcode des Kernels um weitere Module oder Systemfunktionen erweiternund ihn dann kompilieren. Es gibt zwei Methoden, den modifizierten Kernel zum Einsatzzu bringen. Man kann ein komplett neues Image vom Betriebssystem erstellen und diesesauf eine SD-Karte kopieren. Das hat den Nachteil, dass der Kernel sich beim ersten Startenneu initialisieren muss und alle Daten gelöscht werden. Die zweite Methode besteht darin,ein Updatepackage für das ev3dev zu erstellen. Dieses Package installiert man auf demEV3. Dabei werden die Module und Systemfunktionen angepasst.

Bibliotheken: Die geläufigste Methode, um in einem Linux-Kernel einen Zeitstempelzu erhalten, ist die Funktion gettimeofday(struct timeval *tv, struct timezone *tz). Das structtimeval besteht aus zwei Variablen. In der einen werden Sekunden und in der anderenMillisekunden gespeichert. Dieses struct wird von der Bibliothek time.h zur Verfügunggestellt. Beim Aufruf der Funktion werden die Sekunden und Millisekunden gespeichert,die seit dem 1.1.1970 vergangen sind. Diese Methode ist auch der Standard-Zeitstempelder Programmiersprache Java. Für eine Messung ist diese Methode ungeeignet, da sie nurMillisekunden genau messen kann, was für eine Messung zu grob ist. Ein weiteres struct

2https://github.com/ev3dev

22

4.2. Methoden zur Zeitmessung des EV3

in dieser Bibliothek ist timespec. Es speichert Sekunden und Nanosekunden. Man setzteinen Zeitstempel in timespec mit der Funktion clock_gettime(clockid_t, struct timespec *). AlsParameter dieser Funktion übergibt man einen Pointer auf ein timespec struct und die Artdes Zeitstempels, den man speichern will. Beispielweise gibt es als Art CLOCK_MONOTI-NIC. Damit bekommt man einen Zeitstempel von einem Zähler, der einen undefiniertenStartpunkt hat und nicht gesetzt werden kann. Dadurch, dass man ihn nicht setzen kann,ist sichergestellt, dass niemand ihn zurücksetzen kann. Diese Methode ist nicht für eineMessung geeignet, da es sich bei Tests herausgestellt hat, dass der Jitter dieser Methode zugroß ist. Die gemessende Zeit zwischen zwei Zeitstempeln schwankte bei Wiederholungder Ausführung um mehr als fünf Millisekunden.

Neben der Möglichkeit, die Ausführungszeit über die Zeit zu messen, kann man dieProzessorzyklen zählen, welche ein Programm bei der Ausführung braucht. Dafür brauchtman eine Unterstützung der Hardware, wie ein Register, welches bei jedem Prozessorzy-klus inkrementiert wird. Außerdem muss sichergestellt sein, dass sich die Zyklen in eineLaufzeit umrechnen lassen. Bei einer Ausführung auf mehreren Prozessoren oder wennder Prozessor einen variablen Takt hat, ist eine Berechnung der Laufzeit schwer oder garunmöglich. Der EV3 besitzt nur einen Prozessor mit einem festen Takt von 300 Mhz.

In Linux gibt es eine Bibliothek, die Funktionen enthält, mit denen man die verbrauch-ten Prozessorzyklen eines Programms messen können soll. Bei Versuchen diese Bibliothekzu verwenden, stellte sich heraus, dass diese Bibliothek auf dem EV3 nicht funktionierte.Diese Bibliothek wird erst ab der ARMv6 Architektur unterstützt, wärend der EV3 eineARMv5 Architektur benutzt.

Assembler: Unter x86 gibt es einen Standard-Assembler Befehl, mit dem man einenZähler auslesen kann, der Prozessorzyklen zählt. Für ARM-Architekturen gibt es auchso einen Befehl. Es ist MRC p15, 0, <Rd>, c9, c13, 0. Dabei gibt das Schlüsselwort MRCan, dass man etwas aus dem Co-Prozessor bei ARM-Chips in ein Register des Hauptpro-zessors kopieren will. Das <Rd> ist das Zielregister im Hauptprozessor, die restlichenOptionen beschreiben, welches Register man aus dem Co-Prozessor kopieren möchte. Esgibt mehrere MRC-Befehle, auch für die ARMv5-Architektur, aber der Befehl MRC p15, 0,<Rd>, c9, c13, 0 funktioniert nur für ARM Cortex-A8- und Cortex-A9-Architekturen. Dadies aber nicht gleich ersichtlich war, habe ich diesen Befehl auf dem EV3 ausprobiert. Umdiesen Befehl ausführen zu dürfen, muss man sich im Kernelspace befinden. Ich habe überein Modul ein Programm für den Kernel geschreiben, da sonst ein Fehler ausgegeben wirdund das Betriebssystem die Ausführung des Befehls beendet. Nachdem die Erweiterungdem Kernel hinzugefügt wurde und der Befehl ausgeführt wird, wird das Programmbeendet, weil die Hardware den Befehl nicht versteht.

23


Timer: Im Kernel des EV3 gibt es Mechanismen, welche mit einem Zeitstempel arbeiten.Aus den Informationen dieser Mechanismen wurde die Methode zur Generierung desZeitstempels erstellt. Ein wichtiges Element des Kernels ist das Scheduling. Der Schedulerarbeitet dafür auf Basis eines Timers. Ich habe dem Kernel eine Erweiterung geschrie-ben, um das Verhalten dieses Timers zu analysieren. Dabei wurde festgestellt, dass derScheduler auf einem „general purpose timer“ des Chips arbeitet. Er ist als 32-Bit-Zählerkonfiguriert und läuft mit einer Frequenz von 24 MHz. Das bedeutet, ein hochgezähltesBit in diesem Timer entspricht einer vergangenen Zeit von 41 2/3 Nanosekunden. DerZähler hat einen Überlauf nach 178.956.969.942 Nanosekunden (Das entspricht etwa 2Minuten und 58 Sekunden). Diese Konfigurierung ist für eine Zeitmessung geeignet.Die Schritteinheit ist klein genug, um die Messung einzelner Codeabschnitte zu ermög-lichen. Zudem ist der Überlauf des Zählers groß genug, damit er nicht innerhalb derMessung eines Ticks mehrfach überläuft. Damit man auf den Timer zugreifen kann, ist erauf einer Speicheradresse hinterlegt. In der allgemeinen technischen Dokumentation derAM1808/AM18103 wird beschrieben, wie der Timer aufgebaut ist. Beispielsweise wie dieFunktionen der einzelnen Register des Timers sich zusammensetzen. In der technischenDokumentation des AM18084 wird dann beschrieben, dass der Timer an der Hex-Adresse0x1c20010 im Speicher liegt. Um den Timer zu konfigurieren, müssen die Einstellungen indie passenden Register des Timers geschrieben werden. In der Implementierung wird derschon konfigurierte Timer verwendet, welchen auch der Scheduler nutzt. Dabei wird demProgramm ein lesender Zugriff auf den Teil des Speichers zugänglich gemacht, in dem derTimer liegt. Es ist also nicht möglich, den Timer zu setzen, um Fehler im Betriebssystem zuvermeiden. Der Timer wird im Betriebssystem auch von weiteren Funktionen verwendet.Der Vorteil dieser Methode ist, dass es nicht nötig ist den Kernel ev3dev zu modifizieren,um einen Timer zu konfigurieren und eine Messung durchzuführen.

4.3 Struktureller Aufbau des Messverfahrens

In diesem Teil wird nun beschrieben, wie die einzelnen Elementen des Messverfahrenszusammengefügt werden. Wir beginnen mit den SCChart, konstruieren daraus ein Pro-gramm und führen es auf dem Mindstorms aus. Aus dem SCChart muss zunächst dieTickfunktion erstellt werden. Dafür wird der Kieler Compiler verwendet. KiCo wird dafür sokonfiguriert, dass die Tickfunktion in der Sprache C erzeugt wird und die Timing ProgramPoints in der Tickfunktion enthalten sind.

3http://www.ti.com/lit/ug/spruh82a/spruh82a.pdf4http://www.ti.com/lit/ds/symlink/am1808.pdf

24

4.3. Struktureller Aufbau des Messverfahrens

4.3.1 Beschreibung der timing-analyse-Datei und assumption-Datei

Für die Laufzeitmessung eines SCCharts wird nicht nur eine einzelne Ausführung der Tick-funktion durchgeführt. Sie wird mit verschiedenen Eingaben und Zuständen aufgerufen.Die Information über Zustände und Eingaben werden durch eine Datei übergeben. In dersogenannten timing-analysis-Datei (.ta-Datei) werden die nötigen Daten für die Zeitanalysegeliefert. In der Datei werden die Informationen durch Schlüsselwörter markiert. Es gibtfolgende Schlüsselwörter:

� Funktion <Funktionsname> : Die hier benannte Funktion ist diejenige, die analysiertwerden soll. Typischerweise ist das die Tickfunktion.

� InitFunction <Funktionsname> : Die Funktion setzt das SCChart auf den initialenZustand zurück.

� State <Variablenname>: Alle Variablen, in denen der Zustand des SCCharts gespeichertwird, werden mit dem Schlüsselwort State markiert.

� GlobalVar <Variablenname> <Wertebereich>: Mit diesem Schlüsselwort ordnet man denEingaben des SCCharts einen Wertebereich zu. Es werden alle Werte aus diesem Bereichgemessen. In der aktuellen Implementierung kann man Boolean mit dem Wertebereich0. . .1 angeben und Integer mit beispielsweile 3..67.

� FunctionWCET <Hostcode-Aufrufsname> <Wert>: Durch dieses Schlüsselwort kannman für Hostcode-Aufrufe eine Abschätzung der Laufzeit angeben.

� Combination: Nach diesem Schlüsselwort wird in den folgenden Zeilen eine gültigeBelegung der Zustandsvariablen beschrieben. Die Zeilenanzahl entspricht dabei der An-zahl der durch State gekennzeichneten Variablen. In jeder Zeile steht ein Variablennameund der Wert dieser Variable.

� FWCET <Wert1> <Wert2>: Dieses Schlüsselwort beschreibt zwischen welchen TPPs dieZeit gemessen werden soll.

� WCP <Wert1> <Wert2>: Damit wird der Laufzeitanalyse mitgeteilt, dass man den Pfadzwischen Wert1 und Wert2 im längsten Tick wissen möchte.

Die meisten dieser Einstellungen können durch das KIELER Projekt Interactive TimingAnalysis aus dem Result von KiCo erstellt werden. Zusätzlich zum Result wird noch eineassumption-Datei (.asu-Datei) eingelesen. Darin sind die restlichen Einstellungen gespei-chert. Dazu gehören die Abschätzungen der Laufzeiten von Hostcode-Aufrufen, welcheunter dem Schlüsselwort FunctionWCET zu finden sind und die gültigen Belegungen derZustandvariablen mit dem Schlüsselwort Combination.

25


Die Informationen der assumption-Datei sind nicht immer vorhanden. Für Hostcode-Aufrufe gilt, dass sie nicht ersetzt werden, wenn keine Information über ihre Laufzeitvorhanden ist. Sie werden also normal ausgeführt und ihre Laufzeit mitgemessen. Wennkeine gültigen Kombinationen für die Belegung der Zustandsvariablen gegeben werden,werden alle Kombinationen als gültig angesehen. Es wird dann das Kreuzprodukt derZustandsvariablen gebildet und gemessen.

4.3.2 Erstellung der Tick-Datei

Nun haben wir die Tickfunktion in C-Code und der timing-analysis-Datei. Aus denCombinations werden dann Setfunktionen erstellt. Diese funktionieren ähnlich wie dieInitFunktion. Sie setzen das SCChart nur nicht auf den Startzustand, sondern in einenZustand der analysiert werden soll. Hostcode-Aufrufe, deren Laufzeiten bekannt sind,werden in der Tickfunktion ersetzt. Dafür werden Variablen von Typ Integer angelegtund auf 0 initialisiert. Im Namen der Variablen ist der Hostcode-Aufruf und der Codeab-schnitt codiert, in dem der Hostcode-Aufruf enthalten ist. Wenn der Aufruf in mehrerenCodeabschnitten vorkommt, werden mehrere Variablen angelegt. Anstelle des Aufrufes inder Tickfunktion wird dann die entsprechende Variable inkrementiert. Damit ist späternachvollziehbar, wie oft die Hostcode-Funktion aufgerufen wurde. Damit der GCC dasInkrement wie einen Funktionsaufruf behandelt, also keine Optimierung an dieser Stelledurchführt, wird vor und nach dem Inkrement eine Barriere errichtet.

Eine Barriere besteht aus den Befehl asm volatile( ::: "memory"). Es ist ein leererAssembler-Befehl, d.h. an der Ausführung des Programms ändert sich nichts, aber durchdie Schlüsselwörter volatile und memory beeinflusst man den Compiler. Wenn man einAssembler-Befehl als volatile deklariert, optimiert der Compiler nicht über diesen Befehlhinweg, er behält also die Reihenfolge des Quellcodes an dieser Stelle bei. Steht bei einemAssembler-Befehl die Option memory, nimmt der Compiler an, dass sich die Variablen imSpeicher durch den Assembler-Befehl geändert haben können und liest alle Variablen fürdie weitere Benutzung neu ein.

In der Tickfunktion müssen noch die TPPs durch den Zeitstempel ersetzt werden.Um den ersten und letzten Codeabschnitt messen zu können, müssen noch TPPs amAnfang und am Ende der Tickfunktion eingefügt werden. Dann wird pro TPP eine Variableangelegt. In der Tickfunktion wird dann der TPP ersetzt durch eine Zuweisung in derentsprechenden Variable. Die Zuweisung entspricht dem Wert des Zählregistes vom Timer.Damit sich die einzelnen Codeabschnitte nicht durch Optimierung mischen, werden auchhier Barrieren vor und nach dem Aufruf eingefügt. Zur Veranschaulichung habe ich fürein SCChart secure (Abbildung 4.1) modelliert. In Abbildung 4.2 ist die Tickfunktion vor

26


Abbildung 4.1. SCChart des Beispiels Abbildung 4.2

und nach der Bearbeitung dargestellt.

4.3.3 Erstellung der Main-Datei und des Headers

Als nächstes wird die Mainfunktion erstellt. In der Mainfunktion wird zunächst der Pointerfür den Zeitstempel initialisiert. Dafür wird ein lesender Zugriff auf den Speicherbereichangefordert, in dem der Timer liegt. Der Timer wird in Abschnitt 4.2 vorgestellt. Es wird einPointer auf den Zähler des Timers gesetzt. Danach werden die Variablen für die Messunginitialisiert. Für jede Eingabe, in der .ta-Datei gekennzeichnet durch GlobalVar, wird einSchleifenzähler und ein Array angelegt. Das Array enthält die Werte, die im Wertebereichangegeben sind. Es wird noch eine Zählvariable für die Schleife angelegt, die den Zustanddes SCCharts setzt. Des Weiteren wird ein Puffer für die Messergebnisse angelegt. DieGröße des Puffers ist so gewählt, dass die Messergebnisse eines Durchlaufes hinein passen.Da das SCChart vor jedem Aufruf in den passenden Zustand gesetzt wird, kann man außer-halb der Tickfunktion, in der Mainfunktion die Verwaltung für die Messung durchführen.Dazu gehören ineinander geschachtelte Schleifen, um die Tickfunktion für die Messungvorzubereiten. Die erste Schleife setzt dabei einen Zustand der Tickfunktion. Dann wirdfür jede Eingabe des SCCharts eine Schleife erstellt. Damit wird ein Kreuzprodukt ausden Zuständen und allen Belegungen der Eingaben gebildet. Da es sich um eine Messunghandelt, werden für jede Konfiguration des SCCharts zehn Messungen durchgeführt. ImInneren der Schleifen befindet sich der eigentliche Tick-Aufruf. Nach dem Tick-Aufrufwerden die Konfiguration und Zeitstempel des Ticks in eine Datei geschrieben, bevor dernächste Tick-Aufruf vorbereitet wird.

Damit ein Austausch von Variablen in C zwischen der Mainfunktion und der Tick-funktion funktioniert, wird eine Header-Datei erstellt. In der Header-Datei stehen der

27


1

2

3 char left;

4 char right;

5

6

7

8

9 char _GO;

10 char g0;

11 char g2;

12 char PRE_g2;

13 char g3;

14 char g4;

15 char g6;

16 char PRE_g6;

17 char g7;

18 char g8;

19 char g9;

20 char g4_e1;

21 char g8_e2;

22

23 void tick(){

24

25

26 {

27 g0 = _GO;

28 TPP(1);

29 g3 =(PRE_g2);

30 g2 =(_GO||(g3&&(!(left))));

31 g4 =(g3&&left);

32 TPP(2);

33 g7 =(PRE_g6);

34 g6 =((g7&&(!(right)))||_GO);

35 g8 =(g7&&right);

36 TPP(3);

37 g4_e1 =(!(g3));

38 g8_e2 =(!(g7));

39 g9 =((g4_e1||g4) &&

(g8_e2||g8) &&

(g4||g8));

40 if(g9){

41 working();

42 }

43 }

44 PRE_g2 = g2;

45 PRE_g6 = g6;

46 _GO = 0;

47

48

49 return;

50 }

(a) Die originale Tickfunktion

1 #define TPP(LABEL) asm volatile("" ::: "memory");

timingTPP##LABEL = *systemTimer; asm volatile(""

::: "memory")

2

3 char left;

4 char right;

5

6 unsigned long timingTPPStart, timingTPPEnd,

timingTPP1, timingTPP2, timingTPP3;

7 int working_timing_exit = 0;

8

9 char _GO;

10 char g0;

11 char g2;

12 char PRE_g2;

13 char g3;

14 char g4;

15 char g6;

16 char PRE_g6;

17 char g7;

18 char g8;

19 char g9;

20 char g4_e1;

21 char g8_e2;

22

23 void tick(){

24 TPP(entry);

25

26 {

27 g0 = _GO;

28 TPP(1);

29 g3 =(PRE_g2);

30 g2 =(_GO||(g3&&(!(left))));

31 g4 =(g3&&left);

32 TPP(2);

33 g7 =(PRE_g6);

34 g6 =((g7&&(!(right)))||_GO);

35 g8 =(g7&&right);

36 TPP(3);

37 g4_e1 =(!(g3));

38 g8_e2 =(!(g7));

39 g9 =((g4_e1||g4) && (g8_e2||g8) && (g4||g8));

40 if(g9){

41 asm volatile("" ::: "memory");

working_timing_exit++; asm volatile("" :::

"memory");

42 }

43 }

44 PRE_g2 = g2;

45 PRE_g6 = g6;

46 _GO = 0;

47

48 TPP(exit);

49 return;

50 }

(b) Die modifizierte Tickfunktion

Abbildung 4.2. Überarbeitete Tickfunktion des SCCharts secure

28


Pointer auf den Zählers des Timers, die Variablen der Zeitstempel und der Eingaben desSCCharts. Die Mainfunktion und Tickfunktion importieren diesen Header. Damit kanndie Mainfunktion die Eingaben der Tickfunktion setzen und nach dem Tickaufruf dieZeitstempel aus der Tickfunktion auslesen.

Nun wird aus dem generierten Programm ein ausführbares Programm mit dem GCCerstellt. Danach wird es dann per SSH auf den Mindstorms hochgeladen und gestartet.Nachdem alle Messungen abgeschlossen sind, wird die Datei mit den Ergebnissen zu-rückkopiert. Die Ergebnisse sind als Tabelle aufgebaut. Dabei entspricht eine Zeile in derTabelle einem Tick des SCCharts. In der ersten Zeile der Tabelle wird beschrieben, wasdie einzelnen Spalten bedeuten. Die erste Spalte beschreibt welche Setfunktion benutztwurde, um den Zustand des SCCharts zu setzen. Weiterhin gibt es für jede Eingabe desSCCharts eine Spalte in der beschrieben wird, mit welchem Wert die Eingabe beim Tickbelegt ist. Es folgt für jeden TPP eine Spalte. Der Wert in dieser Spalte ist der gemesseneZeitstempel, der bei der Ausführung des Ticks gesetzt wurde. Danach können noch weitereSpalten folgen. Diese Spalten gehören zu den ersetzten Hostcode-Aufrufen. Dabei wirdgezählt, wie oft ein Hostcode-Aufruf in einem Codeabschnitt aufgerufen werden würde.Es wird für einen Hostcode-Aufruf, der in einem Codeabschnitt vorkommt, eine Spalteerstellt. Durch die Abschätzung in der timing-analysis-Datei ist dann die Berechnung derAusführungszeit des Ticks möglich ohne das die Funktion ausgeführt werden muss.

29

Kapitel 5

Implementierung in KIELER

In diesem Kapitel wird beschrieben, wie das Messverfahren aus Kapitel 4 in KIELERumgesetzt ist. KIELER wurde dafür um das Plug-in ev3timing erweitert. Durch diesesPlug-in ist eine Laufzeitmessung von SCCharts auf dem LEGO Mindstorms EV3 möglich.In Abbildung 5.1 sind die Dateien dargestellt, die für eine Messung erstellt werden undwelche Projekte diese verarbeiten.

Die Erweiterung „Project Management in KIELER“ wird in Kapitel 3.2.2 vorgestellt. DieVerwaltung des Projektes für die Laufzeitanalyse wird von Prom übernommen. Das Projektkann mit Hilfe von Prom erstellt werden. Nachdem das SCChart im Projekt modelliertwurde, kann es über „KiCo Compilation“ ausgeführt werden. In Abbildung 5.2 ist eineMöglichkeit dargestellt, wie nach der Modellierung das Programm gestartet werden kann.Prom erstellt die Tickfunktion und startet den launch shortcut, welcher von ev3timing bereitgestellt wird. Einen launch shortcut erstellt man über das Interface ILaunchShortcut. Eserlaubt, in der Entwicklungsumgebung aus dem Editor oder der Workbench das Pro-gramm zu starten. Dabei wird die entsprechende Implementierung des launch shortcutsaufgerufen und das Programm übergeben. An dieser Stelle soll das Plug-in ev3timingeinsetzen und den restlichen Ablauf der Messung übernehmen. Wie Prom vorgehen muss,wird in einem Environment festgehalten. Das „EV3 Timing” Environment wird im Plug-inev3timing über das Interface, welches Prom anbietet, erstellt. Bei der Erstellung des Envi-ronments übergibt man die Einstellungen, die dann im Projekt in KIELER gesetzt werdensollen.

Zu den Einstellung für das Environment gehört die Konfiguration von KiCo. KiCowird aufgerufen, um aus dem SCChart die Tickfunktion in C mit eingefügten TPP zuerstellen. Dafür setzt man als targetLanguage im Environment die Zielsprache und zu-sätzliche Transformationen zum einfügen der TPPs. Die Transformation, welche die TPPseinfügt, setzt voraus, dass im Context von KiCo zwei Properties gesetzt wurden. Zum einenmuss das Tracing eingeschaltet werden. Das geschieht indem man die boolesche PropertyTracing.ACTIVE_TRACING auf „True” setzt. Zum anderen muss in der Property Timin-gAnalysis.INPUT_SCCHART das Modell des SCCharts übergeben werden. Das Tracingerzeugt bei Transformationen in KiCo Hilfsinformationen. Die Hilfsinformationen enthalteneine Zuordnung zwischen Elementen vor und nach einer Transformation. Daraus wird

31

5. Implementierung in KIELER

eine Zuordnung von Elementen vom Anfang bis zum Ende der Kompilierung berechnet.Mit dieser kann man dann ein Mapping für Regionen des SCCharts erstellen. Aus diesemMapping erkennt man die Positionen an denen die TPPs eingefügt werden müssen. DieseProperties sind vorläufig auf dem Branch in Plug-in Prom gesetzt. Damit Prom flexibelbleibt, sollte das Interface zur Erzeugung eines Environments um die Benutzung vonProperties erweitert werden.

tick.c

KiCo

.asu

.ta

timing analysis

editedTick.cmain.c

ev3timing

ev3timing

header

.out

GCC

.csvMindstorms

Abbildung 5.1. Erstellung der Programmdateien

Im Environment wird auch derlaunch shortcut gesetzt, welchervon Prom nach der Generierungder Tickfunktion aufgerufen wird.Für die Messung ist im Plug-inev3timing ein Shortcut erstellt undals associated launch shortcut zumEnvironment hinzugefügt worden.Der erste Schritt für die Laufzeit-messung ist Aufruf der FunktiongenerateTimingRequestFile(String co-de, State scchart, String uriString,int highestInsertedTPPNumber) ausdem Plug-in tsccharts. Die Funkti-on liest dann die Assumptions ein,wenn welche im Projekt vorhandensind und erstellt dann die timing-analysis-Datei, welche die Informa-tionen für die Messung enthält. Fürdiesen Aufruf werden Informatio-nen aus dem Result von KiCo so-wie das Modell des SCCharts be-nötigt. Prom übergibt dem launchshortcut nur die Main-Datei, wie esdurch das Interface ILaunchShort-cut vorausgesetzt wird. Aus diesemGrund ist dieser Aufruf vorläufigin Plug-in Prom implementiert. Ei-ne Möglichkeit, diesen Aufruf ausProm zu lösen und in das Plug-in ev3timing zu übertragen, wä-re einen angepassten launch short-cut anzubieten, der neben dem Pro-

32

Abbildung 5.2. KIELER

gramm noch das Modell und das Result übergibt.

Nach der Erstellung der Informationen für die Messung wird eine Funktion inev3timing benutzt, um das Programm zu erstellen. Dazu gehört das Editieren der Tick-funktion, das Erstellen der Setfunktionen, Mainfunktion und des Headers. Die Detailsdazu wurden in Kapitel 4 vorgestellt. Danach wird der ARM-Cross-Compiler aufgerufen,welcher das C-Programm zu einem ausführbaren Programm übersetzt. Damit das möglichist, muss die GCC-ARM-Embedded-Toolchain1 installiert sein und eine Umgebungsvaria-ble für KIELER darauf gesetzt sein. Danach wird das Programm auf den EV3 hochgeladen.Die Bibliothek Java Secure Channel wird verwendet, um eine SSH-Verbindung zum EV3herzustellen. Der EV3 ist dabei per USB-Kabel mit dem Rechner verbunden. Danach wirdgewartet bis die Ausführung der Messung auf dem EV3 beendet ist und die Ergebnisseder Messung vorliegen. Die Datei, welche die Ergebnisse enthält, wird zum Abschluss,wieder per SSH, in das Projekt zurückkopiert.

1https://launchpad.net/gcc-arm-embedded

33

Kapitel 6

Evaluation

In diesem Kapitel wird der Ablauf einer Messung anhand eines Beispiels präsentiert unddie Messergebnisse von verschiedenen SCCharts gezeigt und analysiert. Dabei werden dieVor- und Nachteile der Messung verdeutlicht.

6.1 Basisbeispiel SCChart robot

Abbildung 6.1. SCChart des Robots1

Das SCChart robot wurde in dieser Arbeit als Grundbeispiel verwendet, um die Messung zuentwickeln. Basierend auf diesem Beispiel wurde schon einmal eine Analyse durchgeführt2,wodurch die gültigen Belegungen der Zustandsvariablen vorliegen. Es sind in diesemFall drei Variablen, die den Zustand des SCCharts speichern. Es sind _GO, PRE_g1 undPRE_g4. Die Variable _GO gibt an ob es sich um den ersten Tick handelt und die Variablen

1Quelle : http://rtsys.informatik.uni-kiel.de/confluence/download/attachments/14516356/robot-synchron1.png?version=

1&modificationDate=1452692490000&api=v22http://rtsys.informatik.uni-kiel.de/confluence/display/KIELER/Interactive+Timing+Analysis

35

http://rtsys.informatik.uni-kiel.de/confluence/download/attachments/14516356/robot-synchron1.png?version=1&modificationDate=1452692490000&api=v2

http://rtsys.informatik.uni-kiel.de/confluence/download/attachments/14516356/robot-synchron1.png?version=1&modificationDate=1452692490000&api=v2

http://rtsys.informatik.uni-kiel.de/confluence/display/KIELER/Interactive+Timing+Analysis

6. Evaluation

PRE_g1 und PRE_g4 speichern, die Belegung der Variablen g1 und g4 im letzten Tick.Als sogenannte guards werden die Variablen g1 und g4 bezeichnet, welche Bedingungen

von Transitionen und aktive Zustände des SCCharts beschreiben. Von den acht (23) da-durch möglichen Kombinationen sind nur drei Kombinationen für das SCChart gültig. InAbbildung 6.1 ist das SCChart dargestellt. Im SCChart kann man die drei Zustände wieder-erkennen, die gespeichert werden müssen. Diese sind der Init Zustand, der StartE Zustandund der Start Zustand. Die Zustände Emergency und Normal schließen sich gegenseitigaus. Die restlichen Zustände werden im gleichen Tick verlassen, in dem sie betreten werden,da sie ausgehende unbedinge immediate Transition haben oder Endzustände sind. DerQuellcode für das SCChart, also das SCChart textual, ist im Anhang A.1 enthalten. Für dieLaufzeitanalyse ist in Abbildung A.2 auch die timing-analysis-Datei abgebildet. Aus derassumption-Datei werden die Daten mit den Schlüsselwörtern FunctionWCET und Combi-nation importiert. Dann wird daraus die Mainfunktion (A.3) und Tickfunktion (A.4) erstellt.Danach wird das Programm ausgeführt und dabei die Laufzeit in eine „comma-separatedvalues” Tabelle eingetragen. Eine Messung ist in Tabelle A.1 abgebildet. Man erkennt inden rechten Spalten die Anzahl der Aufrufe von den Hostcodefunktionen, welche für dieMessung ersetzt wurden. Wenn durch die assumption-Datei Laufzeiten der Funktionenbekannt sind, können diese mit entsprechender Ausführungsanzahl eingerechnet werden.

SetNr bumper accelerator Gesamtzeit in ns errorLog writeLog getImage

0 0 0 8351 1 0 00 0 1 8269 1 0 00 1 0 8425 1 0 00 1 1 8302 1 0 01 0 0 8171 0 2 01 0 1 8099 0 1 11 1 0 8064 0 2 01 1 1 8269 0 1 12 0 0 8417 0 0 02 0 1 8339 0 0 02 1 0 8269 0 0 02 1 1 8380 0 0 0

Tabelle 6.1. Gesamtlaufzeit robot

Aus der Tabelle mit den Messergebnissen habe ich exemplarisch eine vereinfachteVersion in Tabelle 6.1 erstellt. Dafür wurde ein Durchschnittswert der gemessenen Zei-ten berechnet und dargestellt. Dabei wurden Werte, welche extrem abweichen, ignoriert.

36

6.2. Einfluss der Messung auf die Laufzeit

Für die Hostcode-Aufrufe ist die Häufigkeit der Aufrufe in dem Tick aufgelistet. DieGesamtzeit ist dabei ohne die Hostcode-Aufrufe berechnet. Dieses ist nur eine beispielhaf-te Interpretation zur Veranschaulichung. In dieser Arbeit wird keine Interpretation derMessung durchgeführt, dieses ist Teil der offenen Aufgabenstellung dieser Arbeit.

In dieser Messung gibt es beispielsweise 3 Werte die deutlich erhöht sind. Es wurdeinsgesamt 120 Ticks gemessen (3 Zustaende � 22 Eingabenbelegungen � 10 Messung).Den Wert 98.250 ns für einen Tick erhält man aus der Zeile: SetNr = 0, bumper = 1 undaccelerator = 1 und von dieser Konfiguration die 8. Messung. Dieser Wert ist deutlich vonden neun Vergleichswerten zu unterscheiden, da diese nur etwa 8000 ns brauchen. Einemögliche Ursache dafür ist, dass es durch den Scheduler einen Kontextwechsel gegebenhat. Ein Überlauf des Timers ist ausgeschlossen, da der gesamte Ablauf der Messung nurwenige Sekunden gedauert hat und der Timer ungefähr drei Minuten für einen Überlaufbenötigt. Wenn man die Zeit zwischen dem ersten und dem letzten Zeitstempel berechnetergibt sich eine verbrauchte Zeit der Messung von 142.569.125 ns (0,1 Sekunden). Wennder Zähler nach 232 Bit auf 0 zurückspringt, erkennt man es durch eine negativen Laufzeiteines Ticks. Für diese Berechung gilt dann (232

� Endpunkt + Startpunkt).

6.2 Einfluss der Messung auf die Laufzeit

Abbildung 6.2. SCChart des secure Beispiels

Um den Einfluss der Messung auf die Laufzeit zu demonstrieren, wurde das SCChartsecure mit unterschiedlicher Anzahl von TPPs durchgemessen. Für die Laufzeitanalyse sind

37

6. Evaluation

3 TPPs im Programm enthalten. Dazu kommen noch die impliziten TPPs, am Anfang undam Ende des Programmes. In der Tabelle 6.2 ist die Gesamtlaufzeit eines Ticks abgebildet.Die Anzahl der TPPs wird im Programm variiert. Somit kann man erkennen, dass dieAnzahl der TPPs eine Rolle spielt. Die Laufzeit wird durch die TPPs erhöht. Dies erfolgtlinear zur Anzahl der TPPs. Damit kann man über eine untere Schranke den Einfluss derTPPs ausgleichen.

SetNr left right nur entry und exit 1 TPP 2 TPP 3 TPP

0 0 0 5477 6223 6778 70390 0 1 5473 5990 6756 70350 1 0 5391 5963 6664 72470 1 1 5481 6177 6646 69781 0 0 5522 5727 6662 69331 0 1 5694 5690 6531 69061 1 0 5608 5740 6564 70021 1 1 5678 5838 6519 70272 0 0 5002 5908 6367 68282 0 1 4940 5879 6428 68882 1 0 5416 6018 6445 68792 1 1 5469 6113 6469 70423 0 0 5248 5735 6375 67563 0 1 5223 5785 6432 69823 1 0 5682 5793 6482 69413 1 1 5703 5932 6564 69864 0 0 5174 6166 6658 71294 0 1 5383 5973 6678 70114 1 0 5166 6178 6547 69334 1 1 5298 5973 6609 68835 0 0 5514 6006 6601 71055 0 1 5543 5887 6535 69945 1 0 5384 5885 6601 70235 1 1 5507 5826 6551 69376 0 0 4895 5842 6301 66926 0 1 4891 5879 6309 69606 1 0 5194 5986 6650 70026 1 1 5330 5920 6523 69087 0 0 5186 5764 6211 67447 0 1 5100 5781 6207 69377 1 0 5481 6043 6551 7084

38

6.3. Ersetzung von Hostcode-Aufrufen

SetNr left right nur entry und exit 1 TPP 2 TPP 3 TPP

7 1 1 5667 5899 6564 6863

Tabelle 6.2. Gesamtlaufzeit von secure verschiedener TPP-Anzahlen

6.3 Ersetzung von Hostcode-Aufrufen

Abbildung 6.3. Beispiel print

Ein weiteres Beispiel stellt das Ersetzen der Hostcode-Aufrufe dar. Dabei werden zweiMessungen mit der Linux-Systemfunktion printf() durchgeführt und zwei Messungen,bei denen der Aufruf mit Hilfe einer assumption-Datei ersetzt wurde. Jede Messungbesteht aus 10 Aufrufen, dabei wird das SCChart immer zurückgesetzt. Das SCChart ist sominimal gehalten, dass es keine weitere Funktion besitzt, deshalb ist auch nur ein Zustandrelevant. In der Tabelle 6.3 sind die vier Messungen abgebildet. Dabei ist deutlich derNachteil von Systemfunktionen zu erkennen. Sie haben beim ersten Aufruf eine sehr hoheLaufzeit. Dazu schwankt ihre Laufzeit bei wiederholtem Aufruf immer noch deutlich.Bei den ersetzten Ergebnissen gibt es diesen Overhead nicht und man kann über dieassumption-Datei angeben, mit welcher Laufzeit für den Aufruf gerechnet werden soll.

2. Messungmit printf


2. Messungmit ersetz-tem printf


767889 574082 1886 180420787 20992 1681 172219639 19188 1845 155819270 24354 1681 155819844 20254 1681 155817917 19311 1640 155818737 18819 1845 1558

39

6. Evaluation





18737 19434 1845 155818286 19270 1845 172217302 19557 1845 1558

Tabelle 6.3. Messungen des SCCharts print, mit Hostcodeaufrufen und Ersetzungen für die Hostco-deaufrufe

40

6.4. Messung von größeren SCCharts

6.4 Messung von größeren SCCharts

Abbildung 6.4. SCChart des FunParcs

Um die Skalierbarkeit zu demonstrieren, wurde das SCChart FunParc auf dem EV3 eineMessung durchgeführt. Das SCChart besitzt neun Variablen, welche den Zustand speichern,und fünf boolsche Eingaben. Jede Konfiguration wird zehnmal durchgemessen. Darausergibt sich eine Testmenge von 163.840 Ticks (29 Zustaende � 25 Eingabenbelegungen �

10 Messung), da keine Informationen über die gültigen Zustande des SCCharts vorlie-

41

6. Evaluation

gen. Die gesamte Durchführung der Messung dauerte 7 Minuten und 15 Sekunden. DieTestmenge für die Messung eines SCCharts verdoppelt sich mit jeder weitere boolsche Zu-standsvariable oder Eingabe. Allerdings kann man durch Informationen über die gültigenKombination die Testmenge stark einschränken. In der Tickfunktion des FunParcs sind 50TPPs enthalten und einige dieser TPPs sind nur in bestimmten Zuständen erreichbar. Daserkennt man daren, dass für alle zehn Messticks dieser Konfiguration der entsprechendeTPP den Wert 0 hat.

42

Kapitel 7

Fazit

7.1 Zusammenfassung

In dieser Arbeit wurde eine Methode entwickelt, um die Laufzeit von Ticks eines SCChartszu bestimmen. Die Methode sollte einen geringen Aufwand zur Durchführung einerMessung haben. Für eine Messung wird automatisch aus dem SCChart ein Programmgeneriert und auf der Zielplattform, einem der LEGO Mindstorms ausgeführt. Im Laufeder Arbeit wurden verschiedene Mindstorms und Betriebssysteme betrachtet und beurteiltwie gut sie sich für eine Laufzeitmessung eignen. Der EV3 mit einem Debian-Linux erfülltalle Vorraussetzung, die für die Arbeit vorgegeben waren. Für komplexe Systeme können,ohne das SCChart zu verändern, im Programm Aufrufe ersetzt werden. Dadurch benötigtman nur ein USB-Kabel und den Brick des EV3s mit einer SD-Karte, um die Laufzeitmes-sung durchzuführen. Um die Zeitmessung durchzuführen wird ein general purpose timerverwendet, welcher schon vorkonfiguriert ist. Diese Methode wurde dann anschließend inKIELER implementiert. Dabei wurden die vorhandenen Strukturen erweitert und derenAnpassung beschrieben. KIELER ist damit in der Lage, die Laufzeit eines SCCharts aufeinem LEGO Mindstorms EV3 zu messen.

7.2 Ausblick

Für eine Messung benötigt man die gültigen Zustände des SCCharts. Der Zustand einesSCCharts wird in Variablen gespeichert. Welche Belegungen dieser Variablen im SCCharterreichbar sind, kann bisher nicht automatisch generiert werden. Um die Messung dahinge-hend automatisieren zu können, wird ein Algorithmus benötigt, der diese Kombinationenerzeugen kann. Ein breites Feld, dass ebenfalls nicht in dieser Arbeit abgedeckt wird,ist die Weiterverarbeitung der Messdaten. Aus den Messergebnissen könnte man denlängsten Tick bestimmen und die anteiligen Laufzeiten dieses Ticks berechnen, um dieLaufzeitmessung beispielsweise für das Hotspot Highlighting einzusetzen. Eine andereVerwendungsmöglichkeit der Laufzeitmessung wäre es, einen Vergleich zwischen verschie-denen Methoden zur Laufzeitanalyse zu erstellen, sofern weitere Techniken vorhanden sind.Man kann die Messdaten auch dafür verwenden, die Laufzeit verschiedener Prozessorenzu vergleichen.

43

Anhang A

Robot

1 scchart robot {

2 input bool bumper;

3 input bool accelerator;

4 output bool motor;

5

6 region Main:

7

8 initial state Init

9 --> Emergency immediate with bumper

10 --> Normal immediate;

11

12 state Emergency {

13 region HandleEmergency:

14 initial state StartE

15 --> DoneE with / ’errorLog()’; motor = false;

16 final state DoneE;

17 }

18 >-> Done;

19

20 state Normal {

21

22 region HandleMotor:

23

24 initial state Start

25 --> Stop with accelerator / ’getImage()’; motor = true

26 --> Stop with / ’writeLog()’; motor = false;

27

28 final state Stop;

29

30 }

31 >-> Done with / ’writeLog(fin)’;

32

33 final state Done;

34 }

Quellcodeverzeichnis A.1. SCCharttextual des Robots

45

A. Robot

1 Function tick

2 InitFunction reset

3 State _GO

4 State PRE_g1

5 State PRE_g4

6 HighestTPPNumber 5

7 GlobalVar bumper 0..1

8 GlobalVar accelerator 0..1

9

10 FunctionWCET errorLog 800

11 FunctionWCET writeLog 1800

12 FunctionWCET getImage 2000

13

14 Combination

15 _GO 1

16 PRE_g1 1

17 PRE_g4 0

18

19 Combination

20 _GO 1

21 PRE_g1 0

22 PRE_g4 1

23

24 Combination

25 _GO 0

26 PRE_g1 0

27 PRE_g4 0

28

29 FWCET entry 1

30 FWCET 1 2

31 FWCET 2 3

32 FWCET 3 4

33 FWCET 4 5

34 FWCET 5 exit

35 WCP entry exit

Quellcodeverzeichnis A.2. Timing Analysis Datei desRobots

46

Mainfunktion

1 #include "robot.c"

2 #include "robot.h"

3

4 #include <time.h>

5 #include <sys/time.h>

6 #include <stdlib.h>

7 #include <stdio.h>

8 #include <stdlib.h>

9 #include <fcntl.h>

10 #include <sys/mman.h>

11 #include <unistd.h>

12

13 unsigned long *systemTimer = 0;

14 int run = 1;

15 int main(){

16

17

18

19 //Address to timing register in Memory

20 off_t offset = 0x1c20010;

21 size_t len = 8;

22 size_t pagesize = sysconf(_SC_PAGE_SIZE);

23 off_t page_base = (offset / pagesize) * pagesize;

24 off_t page_offset = offset - page_base;

25

26 int fd = open("/dev/mem", O_SYNC);

27 unsigned char *mem = mmap(NULL, page_offset + len, PROT_READ , MAP_SHARED, fd,

page_base);

28

29 if (mem == MAP_FAILED) {

30 perror("Can’t map memory");

31 return -1;

32 }

33

34 //Pointer to the 32Bit timing register

35 systemTimer = mem + page_offset + 4;

36

37 //write header of csv

38 FILE *fp;

39 fp = fopen("./result.csv", "w+");

40 fprintf(fp, "SetNr, bumper, accelerator, TPP(start), TPP(1), TPP(2), TPP(3), TPP(4),

TPP(5), TPP(end), errorLog_timing_2, writeLog_timing_3, writeLog_timing_4,

getImage_timing_3\n");

47

A. Robot

41 fclose( fp );

42

43 char buf[108];

44 int bufNeed = 0;

45 int currBufIndex = 0;

46 int stateLoopcount;

47 int bumperLoopcount;

48 int bumperArr[2] = {0, 1};

49 int acceleratorLoopcount;

50 int acceleratorArr[2] = {0, 1};

51 int rerun = 0;

52

53 for(stateLoopcount = 0; stateLoopcount < 3; stateLoopcount++){

54

55 for(bumperLoopcount = 0; bumperLoopcount < 2; bumperLoopcount++) {

56

57 bumper = bumperArr[bumperLoopcount];

58

59 for(acceleratorLoopcount = 0; acceleratorLoopcount < 2; acceleratorLoopcount++) {

60

61 accelerator = acceleratorArr[acceleratorLoopcount];

62 rerun = 10;

63

64 while(rerun){

65

66 reset();

67 if(stateLoopcount == 0){

68 set0();

69 }

70


72 set1();

73 }

74


76 set2();

77 }

78

79

80

81 tick();

82

83 bufNeed = sprintf (&buf[currBufIndex], "\%u", stateLoopcount);

84 currBufIndex = currBufIndex + bufNeed;

85 buf[currBufIndex] = ’,’;

48

86 currBufIndex ++;

87 bufNeed = sprintf (&buf[currBufIndex], "\%d", bumperLoopcount);



90 currBufIndex ++;

91 bufNeed = sprintf (&buf[currBufIndex], "\%d", acceleratorLoopcount);



94 currBufIndex ++;

95 bufNeed = sprintf (&buf[currBufIndex],"\%lu",timingTPPStart);



98 currBufIndex ++;

99 bufNeed = sprintf (&buf[currBufIndex],"\%lu",timingTPP1);



102 currBufIndex ++;

















119 bufNeed = sprintf (&buf[currBufIndex],"\%lu",timingTPPEnd);




123 bufNeed = sprintf (&buf[currBufIndex], "\%u", errorLog_timing_2);




127 bufNeed = sprintf (&buf[currBufIndex], "\%u", writeLog_timing_3);




49

A. Robot

131 bufNeed = sprintf (&buf[currBufIndex], "\%u", writeLog_timing_4);




135 bufNeed = sprintf (&buf[currBufIndex], "\%u", getImage_timing_3);


137 buf[currBufIndex] = ’\n’;


139

140 errorLog_timing_2 = 0;

141 writeLog_timing_3 = 0;

142 writeLog_timing_4 = 0;

143 getImage_timing_3 = 0;

144 rerun--;

145

146 buf[currBufIndex] = ’\0’;

147 fp = fopen("./result.csv", "a");

148 fputs(buf , fp);

149 fclose( fp );

150 currBufIndex = 0;

151

152 }

153

154

155 }

156 }

157 }

158 return 0;

159 }

Quellcodeverzeichnis A.3. Main-Datei des Robots

50

Tickfunktion

1 /* Im edit the generated TickFunction */

2 /* It now ready to timing */

3 #include "robot.h"

4

5

6 #define TPP(LABEL) asm volatile("" ::: "memory"); timingTPP##LABEL = *systemTimer; asm

volatile("" ::: "memory")

7

8 /*****************************************************************************/

9 /* G E N E R A T E D C C O D E */

10 /*****************************************************************************/

11 /* KIELER - Kiel Integrated Environment for Layout Eclipse RichClient */

12 /* */

13 /* http://www.informatik.uni-kiel.de/rtsys/kieler/ */

14 /* Copyright 2014 by */

15 /* + Kiel University */

16 /* + Department of Computer Science */

17 /* + Real-Time and Embedded Systems Group */

18 /* */

19 /* This code is provided under the terms of the Eclipse Public License (EPL).*/

20 /*****************************************************************************/

21 char bumper;

22 char accelerator;

23 char motor;

24

25 unsigned long timingTPPStart, timingTPPEnd, timingTPP1, timingTPP2, timingTPP3,

timingTPP4, timingTPP5;

26 int errorLog_timing_2 = 0;

27 int writeLog_timing_3 = 0;

28 int writeLog_timing_4 = 0;

29 int getImage_timing_3 = 0;

30

31 char _GO;

32 char g0;

33 char g1;

34 char PRE_g1;

35 char g2;

36 char g3;

37 char g4;

38 char PRE_g4;

39 char g5;

40 char g6;

41 char g7;

51

A. Robot

42 char g8;

43

44 void set0(){

45 _GO = 1;

46 PRE_g1 = 1;

47 PRE_g4 = 0;

48 }

49 void set1(){

50 _GO = 1;

51 PRE_g1 = 0;

52 PRE_g4 = 1;

53 }

54 void set2(){

55 _GO = 0;

56 PRE_g1 = 0;

57 PRE_g4 = 0;

58 }

59

60 void reset(){

61 _GO = 1;

62 PRE_g1 = 0;

63 PRE_g4 = 0;

64 return;

65 }

66 void tick(){

67 TPP(Start);

68

69 {

70 g0 = _GO;

71 TPP(1);

72 g1 =(_GO&&bumper);

73 g2 =(PRE_g1);

74 if(g2){

75 asm volatile("" ::: "memory"); errorLog_timing_2++; asm volatile("" ::: "memory");

76 motor = 0;

77 }

78 TPP(2);

79 g5 =(PRE_g4);

80 g6 =(g5&&accelerator);

81 if(g6){

82 asm volatile("" ::: "memory"); getImage_timing_3++; asm volatile("" ::: "memory");

83 motor = 1;

84 }

85 g8 =(g5&&(!(accelerator)));

86 if(g8){

52

87 asm volatile("" ::: "memory"); writeLog_timing_3++; asm volatile("" ::: "memory");

88 motor = 0;

89 }

90 TPP(3);

91 g7 =(g6||g8);

92 if(g7){

93 asm volatile("" ::: "memory"); writeLog_timing_4++; asm volatile("" ::: "memory");

94 }

95 g3 =(g2||g7);

96 TPP(4);

97 g4 =(_GO&&(!(bumper)));

98 TPP(5);

99 }

100 PRE_g1 = g1;

101 PRE_g4 = g4;

102 _GO = 0;

103

104 TPP(End);

105 return;

106 }

Quellcodeverzeichnis A.4. Tick-Datei des Robots

53

A. RobotR

obot

mes

serg

ebni

sse

Tabe

lle

A.1

.Mes

serg

ebni

sse

robo

t

SetN

rbu

mpe

rac

cele

rato

rTP

P(st

art)

TPP(

1)TP

P(2)

TPP(

3)TP

P(4)

TPP(

5)TP

P(en

d)er

rorL

og_t

imin

g_2

wri

teLo

g_t

imin

g_3

wri

teLo

g_t

imin

g_4

getI

mag

e_t

imin

g_3

00

039

3994

977

3939

9500

339

3995

044

3939

9510

439

3995

152

3939

9517

839

3995

198

10

00

00

039

4038

645

3940

3867

139

4038

708

3940

3877

139

4038

813

3940

3883

939

4038

859

10

00

00

039

4203

134

3942

0316

039

4203

197

3942

0325

739

4203

305

3942

0333

039

4203

350

10

00

00

039

4249

288

3942

4930

939

4249

346

3942

4940

839

4249

455

3942

4948

139

4249

501

10

00

00

039

4271

907

3942

7192

239

4271

959

3942

7201

639

4272

059

3942

7208

539

4272

105

10

00

00

039

4293

959

3942

9397

439

4294

011

3942

9407

239

4294

115

3942

9414

139

4294

161

10

00

00

039

4316

405

3943

1642

039

4316

457

3943

1651

439

4316

561

3943

1658

639

4316

606

10

00

00

039

4341

082

3943

4109

739

4341

134

3943

4119

139

4341

234

3943

4126

039

4341

280

10

00

00

039

4365

743

3943

6575

839

4365

795

3943

6585

639

4365

903

3943

6592

839

4365

948

10

00

00

039

4393

465

3943

9348

039

4393

517

3943

9357

939

4393

627

3943

9365

339

4393

673

10

00

00

139

4418

326

3944

1834

139

4418

378

3944

1843

539

4418

478

3944

1850

439

4418

527

10

00

00

139

4443

188

3944

4320

339

4443

240

3944

4329

739

4443

345

3944

4337

139

4443

391

10

00

00

139

4489

831

3944

8985

139

4489

888

3944

8994

939

4489

992

3944

9001

839

4490

038

10

00

00

139

4512

608

3945

1262

739

4512

668

3945

1272

539

4512

768

3945

1279

439

4512

814

10

00

00

139

4535

501

3945

3551

639

4535

553

3945

3561

039

4535

653

3945

3567

939

4535

699

10

00

00

139

4557

732

3945

5774

739

4557

784

3945

5784

139

4557

889

3945

5791

539

4557

935

10

00

00

139

4582

974

3945

8298

939

4583

026

3945

8308

339

4583

126

3945

8315

139

4583

171

10

00

00

139

4607

519

3946

0753

439

4607

571

3946

0762

839

4607

671

3946

0769

739

4607

717

10

00

00

139

4655

973

3946

5599

939

4656

041

3946

5610

139

4656

148

3946

5617

339

4656

193

10

00

00

139

4681

478

3946

8149

339

4681

533

3946

8158

939

4681

636

3946

8166

239

4681

682

10

00

01

039

4727

567

3947

2758

739

4727

632

3947

2768

839

4727

731

3947

2775

639

4727

776

10

00

01

039

4750

272

3947

5028

739

4750

324

3947

5038

139

4750

424

3947

5045

039

4750

470

10

00

01

039

4773

621

3947

7363

639

4773

677

3947

7373

739

4773

784

3947

7381

039

4773

830

10

00

01

039

4796

224

3947

9623

939

4796

276

3947

9633

339

4796

376

3947

9640

239

4796

426

10

00

01

039

4821

934

3948

2194

939

4821

986

3948

2204

839

4822

099

3948

2212

539

4822

145

10

00

01

039

4846

927

3948

4694

239

4846

979

3948

4704

139

4847

083

3948

4710

939

4847

129

10

00

01

039

4875

270

3948

7528

539

4875

322

3948

7537

939

4875

426

3948

7545

239

4875

472

10

00

01

039

4900

227

3949

0024

239

4900

279

3949

0033

639

4900

384

3949

0041

039

4900

430

10

00

01

039

4925

798

3949

2581

339

4925

850

3949

2590

739

4925

954

3949

2598

039

4926

000

10

00

01

039

4971

715

3949

7174

139

4971

778

3949

7183

939

4971

882

3949

7190

839

4971

928

10

00

01

139

4995

100

3949

9512

039

4995

157

3949

9521

739

4995

259

3949

9528

539

4995

305

10

00

01

139

5017

244

3950

1725

939

5017

296

3950

1735

339

5017

401

3950

1742

639

5017

446

10

00

01

139

5039

850

3950

3986

539

5039

902

3950

3995

939

5040

006

3950

4003

239

5040

052

10

00

01

139

5064

900

3950

6492

039

5064

957

3950

6501

439

5065

061

3950

6508

739

5065

107

10

00

01

139

5092

902

3950

9291

739

5092

956

3950

9301

339

5093

056

3950

9308

239

5093

102

10

00

01

139

5117

943

3951

1795

839

5117

995

3951

1805

239

5118

103

3951

1812

939

5118

149

10

00

01

139

5143

581

3951

4359

639

5143

633

3951

4369

039

5143

738

3951

4376

839

5143

788

10

00

01

139

5168

426

3951

6844

139

5168

478

3951

6853

839

5170

736

3951

7076

439

5170

784

10

00

01

139

5215

291

3952

1531

839

5215

359

3952

1542

139

5215

468

3952

1549

439

5215

514

10

00

01

139

5237

823

3952

3783

839

5237

879

3952

3793

539

5237

977

3952

3800

339

5238

023

10

00

10

039

5260

892

3952

6091

139

5260

947

3952

6100

139

5261

044

3952

6107

039

5261

090

01

10

10

039

5283

190

3952

8320

539

5283

244

3952

8329

839

5283

346

3952

8337

239

5283

392

01

10

10

039

5308

684

3953

0869

939

5308

735

3953

0879

539

5308

838

3953

0886

339

5308

883

01

10

10

039

5335

678

3953

3569

339

5335

729

3953

3578

739

5335

835

3953

3586

139

5335

881

01

10

10

039

5361

132

3953

6114

739

5361

183

3953

6123

939

5361

287

3953

6131

239

5361

332

01

10

10

039

5386

036

3953

8605

139

5386

087

3953

8614

139

5386

184

3953

8621

039

5386

230

01

10

10

039

5432

459

3954

3247

939

5432

515

3954

3257

439

5432

621

3954

3264

639

5432

666

01

10

54

Tabe

lle

A.1

.Mes

serg

ebni

sse

robo

t

SetN

rbu

mpe

rac

cele

rato

rTP

P(st

art)

TPP(

1)TP

P(2)

TPP(

3)TP

P(4)

TPP(

5)TP

P(en

d)er

rorL

og_t

imin

g_2

wri

teLo

g_t

imin

g_3

wri

teLo

g_t

imin

g_4

getI

mag

e_t

imin

g_3

10

039

5463

353

3954

6336

839

5463

408

3954

6346

239

5463

505

3954

6353

039

5463

550

01

10

10

039

5486

151

3954

8616

639

5486

202

3954

8625

839

5486

301

3954

8632

639

5486

346

01

10

10

039

5507

656

3955

0767

139

5507

707

3955

0776

239

5507

812

3955

0783

839

5507

858

01

10

10

139

5529

217

3955

2923

239

5529

268

3955

2932

339

5529

374

3955

2940

039

5529

420

00

11

10

139

5554

405

3955

5442

039

5554

459

3955

5661

739

5556

660

3955

5668

639

5556

706

00

11

10

139

5580

820

3955

8083

539

5580

871

3955

8093

139

5580

974

3955

8099

939

5581

019

00

11

10

139

5605

325

3956

0534

039

5605

376

3956

0543

139

5605

474

3956

0550

039

5605

520

00

11

10

139

5632

019

3956

3203

439

5632

079

3956

3213

839

5632

181

3956

3220

739

5632

227

00

11

10

139

5675

455

3956

7547

539

5675

515

3956

7557

039

5675

613

3956

7563

939

5675

659

00

11

10

139

5699

180

3956

9919

539

5699

231

3956

9929

039

5699

333

3956

9935

939

5699

379

00

11

10

139

5721

892

3957

2190

739

5721

947

3957

2200

239

5722

049

3957

2207

539

5722

095

00

11

10

139

5743

784

3957

4379

939

5743

835

3957

4389

039

5743

933

3957

4396

139

5743

981

00

11

10

139

5766

148

3957

6616

339

5766

199

3957

6625

439

5766

302

3957

6632

839

5766

348

00

11

11

039

5790

547

3957

9056

239

5790

598

3957

9065

639

5790

699

3957

9072

539

5790

745

01

10

11

039

5817

955

3958

1797

039

5818

006

3958

1806

139

5818

108

3958

1813

339

5818

153

01

10

11

039

5859

570

3958

5959

639

5859

638

3958

5969

639

5859

743

3958

5976

939

5859

789

01

10

11

039

5885

309

3958

8532

939

5885

365

3958

8541

939

5885

466

3958

8549

239

5885

512

01

10

11

039

5930

834

3959

3085

439

5930

890

3959

3094

839

5930

991

3959

3101

739

5931

037

01

10

11

039

5953

589

3959

5360

439

5953

640

3959

5369

439

5953

745

3959

5377

139

5953

791

01

10

11

039

5975

255

3959

7527

439

5975

310

3959

7536

439

5975

412

3959

7543

739

5975

457

01

10

11

039

5997

456

3959

9747

139

5997

507

3959

9756

139

5997

604

3959

9762

939

5997

649

01

10

11

039

6021

934

3960

2194

939

6021

985

3960

2204

039

6022

083

3960

2210

839

6022

132

01

10

11

039

6047

021

3960

4703

639

6047

072

3960

4712

739

6047

170

3960

4719

539

6047

215

01

10

11

139

6074

080

3960

7409

539

6074

131

3960

7419

139

6074

241

3960

7426

739

6074

287

00

11

11

139

6116

365

3961

1638

539

6116

421

3961

1648

039

6116

527

3961

1655

339

6116

573

00

11

11

139

6159

897

3961

5991

739

6159

953

3961

6001

339

6160

060

3961

6008

839

6160

108

00

11

11

139

6184

123

3961

8413

839

6184

174

3961

8423

439

6184

281

3961

8430

639

6184

326

00

11

11

139

6205

808

3962

0582

339

6205

859

3962

0591

439

6205

957

3962

0598

239

6206

002

00

11

11

139

6228

174

3962

2818

939

6228

225

3962

2828

039

6228

323

3962

2834

939

6228

369

00

11

11

139

6249

615

3962

4963

039

6249

666

3962

4972

339

6249

766

3962

4979

239

6249

812

00

11

11

139

6276

631

3962

7664

639

6276

686

3962

7674

139

6276

784

3962

7681

039

6276

830

00

11

11

139

6300

867

3963

0088

239

6300

918

3963

0097

239

6301

015

3963

0104

139

6301

061

00

11

11

139

6325

636

3963

2565

139

6325

687

3963

2574

239

6325

792

3963

2581

839

6325

838

00

11

20

039

6352

573

3963

5258

839

6352

624

3963

5268

039

6352

730

3963

5275

639

6352

776

00

00

20

039

6396

001

3963

9602

139

6396

057

3963

9611

839

6396

168

3963

9619

439

6396

214

00

00

20

039

6420

161

3964

2017

639

6420

212

3964

2027

339

6420

319

3964

2034

439

6420

364

00

00

20

039

6442

671

3964

4268

639

6442

722

3964

4277

939

6442

825

3964

4285

139

6442

871

00

00

20

039

6464

440

3964

6445

539

6464

491

3964

6454

839

6464

594

3964

6462

039

6464

640

00

00

20

039

6486

698

3964

8671

339

6486

749

3964

8680

639

6486

851

3964

8687

639

6486

896

00

00

20

039

6510

921

3965

1093

639

6510

972

3965

1103

839

6511

083

3965

1110

939

6511

129

00

00

20

039

6537

736

3965

3775

139

6537

787

3965

3784

439

6537

894

3965

3792

039

6537

940

00

00

20

039

6561

774

3965

6179

039

6561

826

3965

6188

739

6561

937

3965

6196

339

6561

987

00

00

20

039

6586

574

3965

8658

939

6586

625

3965

8871

839

6588

768

3965

8879

439

6588

814

00

00

20

139

6631

584

3966

3159

939

6631

637

3966

3169

839

6631

744

3966

3177

039

6631

790

00

00

20

139

6656

567

3966

5658

239

6656

618

3966

5667

739

6656

727

3966

5675

339

6656

773

00

00

20

139

6678

740

3966

7875

839

6678

795

3966

7885

639

6678

902

3966

7892

839

6678

948

00

00

20

139

6701

380

3967

0139

539

6701

431

3967

0148

839

6701

534

3967

0156

039

6701

580

00

00

20

139

6723

424

3967

2344

039

6723

476

3967

2353

339

6723

578

3967

2360

439

6723

624

00

00

20

139

6748

665

3967

4868

039

6748

716

3967

4877

739

6748

823

3967

4884

939

6748

869

00

00

20

139

6781

785

3967

8180

039

6781

836

3967

8189

639

6781

942

3967

8196

739

6781

987

00

00

20

139

6809

594

3968

0960

939

6809

645

3968

0970

239

6809

748

3968

0977

339

6809

793

00

00

20

139

6833

724

3968

3373

939

6833

779

3968

3383

539

6833

880

3968

3390

639

6833

926

00

00

55

A. RobotTa

bell

eA

.1.M

esse

rgeb

niss

ero

bot

SetN

rbu

mpe

rac

cele

rato

rTP

P(st

art)

TPP(

1)TP

P(2)

TPP(

3)TP

P(4)

TPP(

5)TP

P(en

d)er

rorL

og_t

imin

g_2

wri

teLo

g_t

imin

g_3

wri

teLo

g_t

imin

g_4

getI

mag

e_t

imin

g_3

20

139

6877

140

3968

7716

039

6877

196

3968

7725

339

6877

299

3968

7732

439

6877

344

00

00

21

039

6900

900

3969

0092

039

6900

956

3969

0101

339

6901

059

3969

0108

439

6901

104

00

00

21

039

6923

169

3969

2318

939

6923

225

3969

2328

239

6923

328

3969

2335

439

6923

376

00

00

21

039

6944

770

3969

4478

539

6944

821

3969

4487

839

6944

924

3969

4495

039

6944

970

00

00

21

039

6967

213

3969

6722

839

6967

264

3969

6732

039

6967

366

3969

6739

239

6967

412

00

00

21

039

6992

072

3969

9209

239

6992

128

3969

9218

439

6992

230

3969

9225

539

6992

275

00

00

21

039

7019

896

3970

1991

139

7019

947

3970

2000

439

7020

053

3970

2007

939

7020

099

00

00

21

039

7061

551

3970

6157

739

7061

615

3970

6167

639

7061

730

3970

6175

639

7061

776

00

00

21

039

7090

595

3970

9061

539

7090

651

3970

9071

139

7090

763

3970

9078

939

7090

809

00

00

21

039

7134

552

3971

3457

239

7134

611

3971

3467

439

7134

720

3971

3474

639

7134

766

00

00

21

039

7157

050

3971

5706

539

7157

101

3971

5715

839

7157

208

3971

5723

439

7157

254

00

00

21

139

7178

692

3971

7870

839

7178

744

3971

7880

139

7178

847

3971

7887

539

7178

895

00

00

21

139

7200

864

3972

0087

939

7200

915

3972

0097

239

7201

018

3972

0104

439

7201

064

00

00

21

139

7224

924

3972

2493

939

7224

975

3972

2503

239

7225

078

3972

2510

339

7225

123

00

00

21

139

7251

753

3972

5176

939

7251

805

3972

5186

139

7251

911

3972

5193

739

7251

957

00

00

21

139

7276

345

3972

7636

039

7276

396

3972

7645

339

7276

499

3972

7652

739

7276

547

00

00

21

139

7301

288

3973

0130

839

7301

344

3973

0140

439

7301

457

3973

0148

339

7301

503

00

00

21

139

7325

686

3973

2570

139

7325

737

3973

2579

439

7325

840

3973

2586

639

7325

886

00

00

21

139

7372

050

3973

7206

539

7372

103

3973

7216

439

7372

210

3973

7223

639

7372

256

00

00

21

139

7394

284

3973

9429

939

7394

335

3973

9439

639

7394

444

3973

9447

039

7394

490

00

00

21

139

7416

671

3974

1668

739

7416

723

3974

1678

539

7416

830

3974

1685

639

7416

876

00

00

56

Literatur

[BCR+10] Clément Ballabriga, Hugues Cassé, Christine Rochange und Pascal Sainrat.„Otawa: an open toolbox for adaptive wcet analysis“. In: Software Technologiesfor Embedded and Ubiquitous Systems. Springer, 2010, S. 35–46.

[BPZ11] Peter Bradley Valdenebro, Juan Antonio de la Puente Alfaro und Juan RafaelZamorano Flores. „Ada user guide for lego mindstorms nxt“. In: Ada UserJournal 32.3 (2011), S. 194–203.

[FBS+14] Insa Fuhrmann, David Broman, Steven Smyth und Reinhard von Hanxleden.Towards interactive timing analysis for designing reactive systems. ReconcilingPerformance and Predictability (RePP’14), satellite event of ETAPS’14. Alsoas technical report: EECS Department, University of California, Berkeley,UCB/EECS-2014-26, April 2014. Apr. 2014.

[HDM+14] Reinhard von Hanxleden, Björn Duderstadt, Christian Motika, Steven Smyth,Michael Mendler, Joaquín Aguado, Stephen Mercer und Owen O’Brien. „SC-Charts: Sequentially Constructive Statecharts for safety-critical applications“.In: Proc. ACM SIGPLAN Conference on Programming Language Design and Imple-mentation (PLDI’14). Long version: Technical Report 1311, Christian-Albrechts-Universität zu Kiel, Department of Computer Science, December 2013, ISSN2192-6274. Edinburgh, UK: ACM, Juni 2014.

[MSH14] Christian Motika, Steven Smyth und Reinhard von Hanxleden. „Compilingsccharts - a case-study on interactive model-based compilation“. In: Levera-ging Applications of Formal Methods, Verification and Validation. Technologies forMastering Change. Springer, 2014, S. 461–480.

[Sch14] Alexander Schulz-Rosengarten. „Framework zum tracing von emf-modell-transformationen“. Bachelor Thesis. Kiel University, Maerz 2014.

[Sta15] Andreas Achim Stange. „Comfortable sccharts modeling for embedded sys-tems“. Bachelor Thesis. Kiel University, Okt. 2015.

[WEE+] Reinhard Wilhelm, Jakob Engblom, Andreas Ermedahl, Niklas Holsti, StephanThesing, David Whalley, Guillem Bernat, Christian Ferdinand, ReinholdHeckmann, Tulika Mitra u. a. „The worst-case execution time problem -overview of methods and survey of tools“. In: ().

57

Laufzeitmessung für SCCharts auf Lego...

Documents

Transcript of Laufzeitmessung für SCCharts auf Lego...