From 03cf86041d8ec9aaebdfb3d787a37b725854d256 Mon Sep 17 00:00:00 2001 From: Jan Altenberg Date: Fri, 19 Jun 2009 04:14:47 +0200 Subject: Added lots of content for the RT basics stuff. --- realtime/rt-basics/images/ipipe.png | Bin 0 -> 18012 bytes realtime/rt-basics/images/ipipe.svg | 185 +++++++++++++++++++++ realtime/rt-basics/images/nuclear.png | Bin 0 -> 1134159 bytes realtime/rt-basics/images/preempt_rt.png | Bin 0 -> 26716 bytes realtime/rt-basics/images/preempt_rt.svg | 254 ++++++++++++++++++++++++++++ realtime/rt-basics/images/prio_inv.png | Bin 0 -> 23132 bytes realtime/rt-basics/images/prio_inv.svg | 204 +++++++++++++++++++++++ realtime/rt-basics/images/rtai.dia | Bin 0 -> 634 bytes realtime/rt-basics/images/rtai.dia~ | Bin 0 -> 801 bytes realtime/rt-basics/images/rtai.png | Bin 0 -> 33749 bytes realtime/rt-basics/images/rtai.svg | 273 ++++++++++++++++++++++++++++++ realtime/rt-basics/images/xenomai.png | Bin 0 -> 34356 bytes realtime/rt-basics/images/xenomai.svg | 274 +++++++++++++++++++++++++++++++ 13 files changed, 1190 insertions(+) create mode 100644 realtime/rt-basics/images/ipipe.png create mode 100644 realtime/rt-basics/images/ipipe.svg create mode 100644 realtime/rt-basics/images/nuclear.png create mode 100644 realtime/rt-basics/images/preempt_rt.png create mode 100644 realtime/rt-basics/images/preempt_rt.svg create mode 100644 realtime/rt-basics/images/prio_inv.png create mode 100644 realtime/rt-basics/images/prio_inv.svg create mode 100644 realtime/rt-basics/images/rtai.dia create mode 100644 realtime/rt-basics/images/rtai.dia~ create mode 100644 realtime/rt-basics/images/rtai.png create mode 100644 realtime/rt-basics/images/rtai.svg create mode 100644 realtime/rt-basics/images/xenomai.png create mode 100644 realtime/rt-basics/images/xenomai.svg (limited to 'realtime') diff --git a/realtime/rt-basics/images/ipipe.png b/realtime/rt-basics/images/ipipe.png new file mode 100644 index 0000000..b7468fa Binary files /dev/null and b/realtime/rt-basics/images/ipipe.png differ diff --git a/realtime/rt-basics/images/ipipe.svg b/realtime/rt-basics/images/ipipe.svg new file mode 100644 index 0000000..cc7baa9 --- /dev/null +++ b/realtime/rt-basics/images/ipipe.svg @@ -0,0 +1,185 @@ + + + + + + + + + + + + + + image/svg+xml + + + + + + + + Xenomai Domain + + Linux Domain + + Interrupts + + + ..... + + + + ..... + + + + diff --git a/realtime/rt-basics/images/nuclear.png b/realtime/rt-basics/images/nuclear.png new file mode 100644 index 0000000..a434e91 Binary files /dev/null and b/realtime/rt-basics/images/nuclear.png differ diff --git a/realtime/rt-basics/images/preempt_rt.png b/realtime/rt-basics/images/preempt_rt.png new file mode 100644 index 0000000..463673f Binary files /dev/null and b/realtime/rt-basics/images/preempt_rt.png differ diff --git a/realtime/rt-basics/images/preempt_rt.svg b/realtime/rt-basics/images/preempt_rt.svg new file mode 100644 index 0000000..b186ef5 --- /dev/null +++ b/realtime/rt-basics/images/preempt_rt.svg @@ -0,0 +1,254 @@ + + + + + + + + + + + + + + image/svg+xml + + + + + + + + + + Hardware + + Linux + + IRQThread + + App + + RT App + + IRQThread + ..... + Kernel + User + + + diff --git a/realtime/rt-basics/images/prio_inv.png b/realtime/rt-basics/images/prio_inv.png new file mode 100644 index 0000000..574afb3 Binary files /dev/null and b/realtime/rt-basics/images/prio_inv.png differ diff --git a/realtime/rt-basics/images/prio_inv.svg b/realtime/rt-basics/images/prio_inv.svg new file mode 100644 index 0000000..c20b77f --- /dev/null +++ b/realtime/rt-basics/images/prio_inv.svg @@ -0,0 +1,204 @@ + + + + + + + + + + + + + + image/svg+xml + + + + + + + + + + Prio + Task 1 + Task 2 + Task 3 + + + + + blockiert + unterbrochen + Task 3 + Task 2 + + diff --git a/realtime/rt-basics/images/rtai.dia b/realtime/rt-basics/images/rtai.dia new file mode 100644 index 0000000..dedf883 Binary files /dev/null and b/realtime/rt-basics/images/rtai.dia differ diff --git a/realtime/rt-basics/images/rtai.dia~ b/realtime/rt-basics/images/rtai.dia~ new file mode 100644 index 0000000..c4024ff Binary files /dev/null and b/realtime/rt-basics/images/rtai.dia~ differ diff --git a/realtime/rt-basics/images/rtai.png b/realtime/rt-basics/images/rtai.png new file mode 100644 index 0000000..c6c21ce Binary files /dev/null and b/realtime/rt-basics/images/rtai.png differ diff --git a/realtime/rt-basics/images/rtai.svg b/realtime/rt-basics/images/rtai.svg new file mode 100644 index 0000000..39b34e4 --- /dev/null +++ b/realtime/rt-basics/images/rtai.svg @@ -0,0 +1,273 @@ + + + + + + + + + + + image/svg+xml + + + + + + + + + + Hardware + + RT Kernel + + Linux + + RT App + + RT App + + Linux App + + Linux App + + + + + + + FIFO + + + Userspace + Kernelspace + + + diff --git a/realtime/rt-basics/images/xenomai.png b/realtime/rt-basics/images/xenomai.png new file mode 100644 index 0000000..d1ff146 Binary files /dev/null and b/realtime/rt-basics/images/xenomai.png differ diff --git a/realtime/rt-basics/images/xenomai.svg b/realtime/rt-basics/images/xenomai.svg new file mode 100644 index 0000000..8f71daa --- /dev/null +++ b/realtime/rt-basics/images/xenomai.svg @@ -0,0 +1,274 @@ + + + + + + + + + + + image/svg+xml + + + + + + + + + + Hardware + + Adeos / IPIPE + + Linux + + Nucleus + + RT App + + Linux App + + + + + Userspace + Kernelspace + + RT App + + Skins + + + + + -- cgit v1.2.3 From 70f1e16d1f2994ef3c055fa914495f49f1b47700 Mon Sep 17 00:00:00 2001 From: Jan Altenberg Date: Fri, 19 Jun 2009 20:16:42 +0200 Subject: Completed RT Basics chapter --- realtime/rt-basics/images/dual_kernel.png | Bin 0 -> 43070 bytes realtime/rt-basics/images/dual_kernel.svg | 251 ++++++++++++++++++++++++++++ realtime/rt-basics/images/gpos_vs_rt.png | Bin 0 -> 124609 bytes realtime/rt-basics/images/gpos_vs_rt.svg | 134 +++++++++++++++ realtime/rt-basics/images/mar01.png | Bin 0 -> 43535 bytes realtime/rt-basics/images/mar01.svg | 122 ++++++++++++++ realtime/rt-basics/images/mar02.png | Bin 0 -> 72568 bytes realtime/rt-basics/images/mar02.svg | 158 +++++++++++++++++ realtime/rt-basics/images/mar03.png | Bin 0 -> 74787 bytes realtime/rt-basics/images/mar03.svg | 163 ++++++++++++++++++ realtime/rt-basics/images/preempt_rt.svg | 2 +- realtime/rt-basics/images/prio_inv.svg | 5 +- realtime/rt-basics/images/single_kernel.png | Bin 0 -> 34007 bytes realtime/rt-basics/images/single_kernel.svg | 234 ++++++++++++++++++++++++++ 14 files changed, 1067 insertions(+), 2 deletions(-) create mode 100644 realtime/rt-basics/images/dual_kernel.png create mode 100644 realtime/rt-basics/images/dual_kernel.svg create mode 100644 realtime/rt-basics/images/gpos_vs_rt.png create mode 100644 realtime/rt-basics/images/gpos_vs_rt.svg create mode 100644 realtime/rt-basics/images/mar01.png create mode 100644 realtime/rt-basics/images/mar01.svg create mode 100644 realtime/rt-basics/images/mar02.png create mode 100644 realtime/rt-basics/images/mar02.svg create mode 100644 realtime/rt-basics/images/mar03.png create mode 100644 realtime/rt-basics/images/mar03.svg create mode 100644 realtime/rt-basics/images/single_kernel.png create mode 100644 realtime/rt-basics/images/single_kernel.svg (limited to 'realtime') diff --git a/realtime/rt-basics/images/dual_kernel.png b/realtime/rt-basics/images/dual_kernel.png new file mode 100644 index 0000000..c58d156 Binary files /dev/null and b/realtime/rt-basics/images/dual_kernel.png differ diff --git a/realtime/rt-basics/images/dual_kernel.svg b/realtime/rt-basics/images/dual_kernel.svg new file mode 100644 index 0000000..31f80ec --- /dev/null +++ b/realtime/rt-basics/images/dual_kernel.svg @@ -0,0 +1,251 @@ + + + + + + + + + + + + + + image/svg+xml + + + + + + + Hardware + + + Micro Kernel + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/realtime/rt-basics/images/gpos_vs_rt.png b/realtime/rt-basics/images/gpos_vs_rt.png new file mode 100644 index 0000000..07a4a79 Binary files /dev/null and b/realtime/rt-basics/images/gpos_vs_rt.png differ diff --git a/realtime/rt-basics/images/gpos_vs_rt.svg b/realtime/rt-basics/images/gpos_vs_rt.svg new file mode 100644 index 0000000..7862037 --- /dev/null +++ b/realtime/rt-basics/images/gpos_vs_rt.svg @@ -0,0 +1,134 @@ + + + + + + + + + + + + + + image/svg+xml + + + + + + + RealtimeOperating System + General PurposeOperating System + + + + diff --git a/realtime/rt-basics/images/mar01.png b/realtime/rt-basics/images/mar01.png new file mode 100644 index 0000000..7f18317 Binary files /dev/null and b/realtime/rt-basics/images/mar01.png differ diff --git a/realtime/rt-basics/images/mar01.svg b/realtime/rt-basics/images/mar01.svg new file mode 100644 index 0000000..78d99db --- /dev/null +++ b/realtime/rt-basics/images/mar01.svg @@ -0,0 +1,122 @@ + + + + + + + + + + + + + + + image/svg+xml + + + + + + + + + + + diff --git a/realtime/rt-basics/images/mar02.png b/realtime/rt-basics/images/mar02.png new file mode 100644 index 0000000..f1f53a1 Binary files /dev/null and b/realtime/rt-basics/images/mar02.png differ diff --git a/realtime/rt-basics/images/mar02.svg b/realtime/rt-basics/images/mar02.svg new file mode 100644 index 0000000..3c9ac3a --- /dev/null +++ b/realtime/rt-basics/images/mar02.svg @@ -0,0 +1,158 @@ + + + + + + + + + + + + + + + + image/svg+xml + + + + + + + + + + + + RTAI / Fusion + + diff --git a/realtime/rt-basics/images/mar03.png b/realtime/rt-basics/images/mar03.png new file mode 100644 index 0000000..97ab7ba Binary files /dev/null and b/realtime/rt-basics/images/mar03.png differ diff --git a/realtime/rt-basics/images/mar03.svg b/realtime/rt-basics/images/mar03.svg new file mode 100644 index 0000000..25c40ad --- /dev/null +++ b/realtime/rt-basics/images/mar03.svg @@ -0,0 +1,163 @@ + + + + + + + + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + diff --git a/realtime/rt-basics/images/preempt_rt.svg b/realtime/rt-basics/images/preempt_rt.svg index b186ef5..a9c0ac7 100644 --- a/realtime/rt-basics/images/preempt_rt.svg +++ b/realtime/rt-basics/images/preempt_rt.svg @@ -15,7 +15,7 @@ inkscape:version="0.46" sodipodi:docname="preempt_rt.svg" inkscape:output_extension="org.inkscape.output.svg.inkscape" - inkscape:export-filename="/home/jan/work/omnicron/schulung/realtime/rt-basics/images/ipipe.png" + inkscape:export-filename="/home/jan/work/omnicron/schulung/realtime/rt-basics/images/preempt_rt.png" inkscape:export-xdpi="90" inkscape:export-ydpi="90"> + inkscape:output_extension="org.inkscape.output.svg.inkscape" + inkscape:export-filename="/home/jan/work/omnicron/schulung/realtime/rt-basics/images/prio_inv.png" + inkscape:export-xdpi="90" + inkscape:export-ydpi="90"> + + + + + + + + + + + + + image/svg+xml + + + + + + + Hardware + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + -- cgit v1.2.3 From 088976ed259b779438aad64b0997b6bdde5169d4 Mon Sep 17 00:00:00 2001 From: Jan Altenberg Date: Sat, 20 Jun 2009 00:34:08 +0200 Subject: Commit missing RT basics changes --- realtime/rt-basics/handout_rt-basics_de.tex | 168 +++++++++++++++++++++- realtime/rt-basics/hints_rt-basics_de.tex | 13 +- realtime/rt-basics/pres_rt-basics_de.tex | 210 ++++++++++++++++++++++++++-- 3 files changed, 369 insertions(+), 22 deletions(-) (limited to 'realtime') diff --git a/realtime/rt-basics/handout_rt-basics_de.tex b/realtime/rt-basics/handout_rt-basics_de.tex index 4c391b2..8576b7d 100644 --- a/realtime/rt-basics/handout_rt-basics_de.tex +++ b/realtime/rt-basics/handout_rt-basics_de.tex @@ -1,17 +1,173 @@ -\documentclass{article} +\documentclass{lxarticle} \usepackage{german} \usepackage[utf8]{inputenc} +\usepackage{lxheaders} +\usepackage{lxextras} \begin{document} -\section*{Titel} +\section*{Realtime Linux} -\subsection*{Abschnitt1} +\subsection*{Grundlagen} -Text +\subsubsection*{Was ist Echteit?} +Vor der Betrachtung verschiedener Ansätze, Linux echtzeitfähig zu machen, ist es +notwendig einige grundlegende Begrifflichkeiten zur erläutern: +\begin{itemize} +\item Echtzeit: +Zur Definition eines Echtzeitsystems kann man folgende Aussagen Treffen: Auf +einem Echtzeitsystem hängt die Korrektheit einer Berechnung nicht nur von deren +logischen Korrektheit, sondern auch von der Ausführung zum korrekten Zeitpunkt +ab. Das Nichteinhalten eines bestimmten Zeitrahmens resultiert in einem Fehler. +\item Latenzzeit: Unter Latenzzeit versteht man den Zeitraum zwischen dem +Auftreten eines Events und der Reaktion auf dieses Event. +\item Jitter: Mit Jitter bezeichnet man die Varianz der Latenzzeit. +\end{itemize} -\subsection*{Abschnitt2} +\subsubsection*{Anwendungsbereiche} +Die wohl gängigsten Anwendungsbereiche für Echtzeitsysteme sind die +Steuerungs- und Automatisierungstechnik, Multimediasysteme und die Luft- und +Raumfahrttechnik. Ein weiteres interessantes Einsatzgebiet stellt die +Finanzdienstleistung dar. Hier geht es insbesondere um die zeitgenaue, +zuverlässige Abwicklung von Finanztransaktionen über hochverteilte Systeme. -Text +\subsubsection*{Anforderungen an ein Echtzeitsystem} +Ein Echtzeitsystem muß in der Lage sein, in einem garantierten Zeitrahmen auf +ein Ereignis zu reagieren. Es muß also möglich sein, in möglichst kurzer Zeit +von einer niederprioren Task auf eine hochpriore Task umzuschalten, falls diese +Rechenzeit benötigt. Das System muß also möglichst ''feingranular'' +unterbrechbar sein. +Doch allein die Unterbrechbarkeit kann kein deterministisches Zeitverhalten +garantieren. So kann eine niederpriore Task Resourcen blockieren, die von einer +hochprioren Task benötigt werden. Wird die niederpriore Task nun unterbrochen, +kommt es zur ''Prioritätsinversion / priority inversion'', da die hochpriore Task +auf die Freigabe der Resource wartet, diese aber erst wieder dann freigegeben +wird, wenn die niederpriore Task wieder Rechenzeit bekommt. +Gelöst werden kann dieses Problem durch ''prioriy inheritance'' und ''priority ceiling''. +\begin{itemize} +\item Prioritätsvererbung / priority inheritance: Hier wird die Priorität der +niederprioren Task angehoben, um zu erreichen, daß die blockierte Resource +freigegeben kann. +\item Prioritätsgrenzen / priority ceiling: Hier wird für jede Resource eine +Prioritätsgrenze festgelegt. Jede Task, die die Resource belegt, wird auf die +Prioritätsgrenze der Resource angehoben. +\end{itemize} + +\subsection*{Realtime Linux Varianten} +\subsubsection*{Historisches zu Echtzeitlinux} +Im Gegensatz zu traditionellen Echtzeitsystem wurde Linux ursprünglich nicht als +solches designt. Als General Purpose Operating System wurde Linux auf Fairness +und Durchsatz optimiert. Linux echtzeitfähig zu machen, bedeutet also, ein +Standardbetriebssystem um Echtzeitfunktionen bzw. entsprechende Sonderfälle zu +erweitern. Mit dieser Tatsache lassen sich die zwei technischen Ansätze für +Realtime Linux erklären. +\begin{itemize} +\item Dual Kernel Ansatz: Hier koexistieren ein Echtzeitkernel, der für alle +zeitkritischen Dinge zuständig ist, und ein Standard Linux Kernel. Dieser Ansatz +setzt voraus, daß alle externen Events zuerst vom Echtzeitkernel bearbeitet +werden, bevor Sie an den Linux Kernel weitergereicht werden können. Die +bekanntesten Vertreter dieser Technik sind RTAI und Xenomai. +\item In-Kernel Ansatz: Diese Methode macht Linux an sich zu einem +Echtzeitsystem. Dieser Ansatz wird mit dem Realtime Preemption Patch verfolgt +und ist die Variante, die von den Linux Entwicklern zur Integration in den +Hauptzweig von Linux abgenickt wurde. +\end{itemize} + +\subsubsection*{RTAI} +Das Realtime Application Interface (RTAI) ist eine Entwicklung der Technischen +Universität Mailand und entstand unter der Schirmherrschaft von Professor Paolo +Mantegazza. Oberstes Designziel von RTAI ist und war es, die kleinstmöglichen +Latenzzeiten auf einer gegebenen Hardwareplattform zu erzielen. Dieses +Designziel bedingt diverse Einschränkungen für RTAI Applikationen. Weiterhin +wird nur eine recht kleine Anzahl an Zielplattormen unterstützt (derzeit x86, +x86\_64 und diverse ARM Plattformen). +\begin{figure}[h] +\centering +\includegraphics[height=0.5\textwidth]{images/rtai.png} +\caption{Technischer Aufbau von RTAI} +\label{img:rtai} +\end{figure} +RTAI ist ein typischer Vertreter des Dual Kernel Ansatzes. Abbildung +\ref{img:rtai} zeigt die Funktionsweise von RTAI. + +\subsubsection*{Xenomai} +Das Xenomai Projekt wurde im Jahre 2001 gegründet. Im Gegensatz zu RTAI erlaubt +Xenomai auch Echtzeit im Userpace (RTAI erlaubt dies nur sehr eingeschränkt). +Die Besonderheit von Xenomai sind die sogenannten Skins, die es vereinfachen sollen, +Applikationen von proprietären Echtzeitsystemen nach Xenomai zu portieren. +Xenomai Skins bilden die API dieser Systeme ab. Xenomai unterstützt derzeit +folgende Architekturen: PowerPC32, PowerPC64, x86, x86\_64, Blackfin, ARM und +ia64). Die zentralen Begriffe im Designkonzept von Xenomai stellen Xenomai +Nucleus, die Interrupt Pipeline (IPIPE), Hardware Abstraction Layer (HAL) und +System Abstraction Layer (SAL) dar. +IPIPE kann bildlich als virtueller Interruptkontroller betrachtet werden. +Sie organisiert das System in verschiedenen Domains. Interrupts werden von +IPIPE entgegengenommen und an die einzelnen Domains verteilt. +Nucleus beeinhaltet die Xenomai Core Funktionalität. Dieser ist zuständig dafür, +alle notwendigen Resourcen, die Skins benötigen, um die Funktionalität von +RTOSsen nachzubilden. Der Hardware Abstraction Layer beinhaltet den Plattform +und CPU abhängigen Code. Alle darüberliegenden Layer (darunter auch Nucleus) +bauen darauf auf. HAL ist kombiniert mit dem System Abstraction Layer. Dieser +soll die darüberliegenden Layer, wie z.B. Nucleus, noch portierbarer machen. +Abbildung \ref{img:xenomai} zeigt das technische Zusammenspiel der Xenomai +Komponenten. Abbildung \ref{img:ipipe} zeigt die Funktionsweise von IPIPE. +\begin{figure}[h] +\centering +\includegraphics[height=0.5\textwidth]{images/xenomai.png} +\caption{Technischer Aufbau von Xenomai} +\label{img:xenomai} +\end{figure} +\begin{figure}[h] +\centering +\includegraphics[height=0.5\textwidth]{images/ipipe.png} +\caption{Technische Funktionsweise von IPIPE} +\label{img:ipipe} +\end{figure} + +\subsubsection*{Preempt RT} +Der Realtime Preemption Patch entstand ursprünglich aus Arbeiten von Ingo Molnar +und Thomas Gleixner. Beide sind bis zum heutigen Zeitpunkt die treibenden Kräfte +bei der Entwicklung von Preempt RT. +Im Gegensatz zu RTAI und Xenomai macht Preempt RT den Linux Kernel an sich +echtzeitfähig. Dies wird im Besonderen durch folgende Mechanismen erreicht: +\begin{itemize} +\item Sleeping Spinlocks: Spinlocks werden durch RT Mutexe ersetzt. Raw +Spinlocks ersetzen die Eigenschaft der ursprünglichen Spinlocks. +\item Threaded Interrupt Handlers: Interrupt Handler laufen per Default nicht im +harten Interruptkontext, sondern als Kernelthread. +\end{itemize} +Viele Mechanismen, die ursprünglich in Preempt RT entwickelt wurden, haben +bereits Ihren Weg in den Mainline Linuxzweig gefunden: High Resolution Timer +(Hochauflösende Timer unabhängig vom Scheduler Tick), Priority Inheritance, +generisches Interrupthandling für alle Architekturen und mit 2.6.30 nun auch die +Threaded Interrupt Handler. +Weiterhin hat sich die Linux Entwicklergemeinde bereits 2006 darauf geeinigt, +daß Preempt RT in den Linux Kernel integriert wird. Weiterhin bietet der +Realtime Preempton Patch den großen Vorteil, daß Echtzeitapplikationen als POSIX +Realtime Applikationen geschrieben werden. Es wird keine spezielle API +verwendet. Preempt RT Unterstützt eine Vielzahl von Architekturen (PowerPc, x86, +x86\_64, MIPS, ARM, ...). +\begin{figure}[h] +\centering +\includegraphics[height=0.5\textwidth]{images/preempt_rt.png} +\caption{Überblick Preempt RT} +\label{img:preempt_rt} +\end{figure} +Wie Abbildung \ref{img:preempt_rt} zeigt, integriert Preempt RT die +Echtzeitfunktionalität ''natlos'' in den Linux Kernel. Auch die Entwickler +anderer Projekte haben die Vorzüge von Preempt RT bereits erkannt. Die Roadmap +für Xenomai 3 sieht Preempt RT Support vor. Dies würde den Einsatz von Xenomai +Skins auf Preempt RT Kerneln ermgöglichen. + +\subsection*{Kontrollfragen} + +\begin{enumerate} +\item Was sind die wichtigsten Anforderungen an ein Echtzeitsystem? +\item Welche beiden Ansätze gibt es, um Linux echtzeitfähig zu machen? +\item Was sind die bekanntesten Vertreter für Echtzeitlinux und welchen der oben +beschriebenen Ansätze verfolgen Sie? +\item Wird für das Schreiben einer Echtzeitapplikation mit Preempt RT eine +spezielle API benötigt? +\end{enumerate} \end{document} diff --git a/realtime/rt-basics/hints_rt-basics_de.tex b/realtime/rt-basics/hints_rt-basics_de.tex index fd15c6e..11c5c34 100644 --- a/realtime/rt-basics/hints_rt-basics_de.tex +++ b/realtime/rt-basics/hints_rt-basics_de.tex @@ -1,17 +1,18 @@ -\documentclass{article} +\documentclass{lxarticle} \usepackage{german} \usepackage[utf8]{inputenc} +\usepackage{lxheaders} +\usepackage{lxextras} \begin{document} -\section*{Block \lq Grundlagen Realtime\rq} +\section*{Block \lq Was ist Linux?\rq} \subsection*{Lernziele} \begin{itemize} -\item Kennenlernen der verschiedenen Ansätze (RTAI, Xenomai, RT-Preempt) -\item Kennenlernen der Funktion von RT-Preempt -\item Verstehen, wie der RT-Preempt-Patch beschafft und angewendet werden kann -\item Anwendungen, Grenzen, Geschichte von RT-Preempt +\item Lernziel 1 +\item Lernziel 2 +\item Lernziel 3 \end{itemize} \subsection*{Unterrichts-Ablauf} diff --git a/realtime/rt-basics/pres_rt-basics_de.tex b/realtime/rt-basics/pres_rt-basics_de.tex index 07db328..c60f8a5 100644 --- a/realtime/rt-basics/pres_rt-basics_de.tex +++ b/realtime/rt-basics/pres_rt-basics_de.tex @@ -1,24 +1,214 @@ -\documentclass{article} +\documentclass{beamer} +\usetheme{linutronix} \usepackage{german} \usepackage[utf8]{inputenc} +\usepackage{pgf} +\usepackage{graphicx} +\usepackage{lxextras} + +\title{Block \lq Realtime Linux\rq} +\institute{Linutronix GmbH} \begin{document} -\section*{Block \lq Was ist Linux?\rq} +\maketitle + + +% ----- Slide ------------------ +\begin{frame} +\frametitle{Was ist Echtzeit?} +\begin{itemize} +\item Korrektheit bedeutet auch Ausführung zum korrekten Zeitpunkt +\item Nicht Einhalten des korrekten Zeitrahmens führt zu einem Fehler +\end{itemize} +\end{frame} + +\begin{frame} +\frametitle{Echtzeit ''anschaulich''} +\begin{overprint} +\onslide<1> +\begin{alertblock}{Wir erinnern uns} +Nicht Einhalten des korrekten Zeitrahmens führt zu einem Fehler! +\end{alertblock} +\onslide<2> +\begin{figure}[h] +\centering +\includegraphics[height=0.5\textwidth]{images/nuclear.png} +\end{figure} +\end{overprint} +\end{frame} + +\begin{frame} +\frametitle{Anwendungsbereiche} +\begin{itemize} +\item Steuerungs- / Automatisierungstechnik +\item Multimediasysteme +\item Luft- und Raumfahrttechnik +\item Finanzdienstleistung +\item ... +\end{itemize} +\end{frame} + +\begin{frame} +\frametitle{Anforderungen} +\begin{itemize} +\item Deterministisches Zeitverhalten +\item Unterbrechbarkeit +\item Priority Inheritance / Priority Ceiling +\end{itemize} +\end{frame} + +\begin{frame} +\frametitle{Priority Inversion} +\begin{figure}[h] +\centering +\includegraphics[width=0.8\textwidth]{images/prio_inv.png} +\end{figure} +\end{frame} + +\begin{frame} +\frametitle{Linux und Echtzeit} +\begin{figure}[h] +\centering +\includegraphics[height=0.5\textwidth]{images/gpos_vs_rt.png} +\end{figure} +\end{frame} -\subsection*{Lernziele} +\begin{frame} +\frametitle{Ansätze} \begin{itemize} -\item Lernziel 1 -\item Lernziel 2 -\item Lernziel 3 +\item Dual-Kernel +\item In-Kernel / Single Kernel \end{itemize} +\end{frame} -\subsection*{Unterrichts-Ablauf} +\begin{frame} +\frametitle{Dual-Kernel} +\begin{figure}[h] +\centering +\includegraphics[height=0.5\textwidth]{images/dual_kernel.png} +\end{figure} +\end{frame} -Hinweise zur Präsentation, Zeitplanung, etc. +\begin{frame} +\frametitle{Single-Kernel} +\begin{figure}[h] +\centering +\includegraphics[height=0.5\textwidth]{images/single_kernel.png} +\end{figure} +\end{frame} + +\begin{frame} +\frametitle{RTAI} +\begin{itemize} +\item Prof. Paolo Mantegazza, Universität Mailand +\item Dual-Kernel Ansatz +\item Echtzeit im Kernelspace +\item Userspace Echtzeittasks nur eingeschränkt möglich +\item Oberstes Designziel: Möglichst niedrige Latenzzeiten +\item Unterstützte Plattformen: x86, x86\_64, einige ARM Plattformen +\end{itemize} +\end{frame} + +\begin{frame} +\frametitle{RTAI} +\begin{figure}[h] +\centering +\includegraphics[height=0.5\textwidth]{images/rtai.png} +\end{figure} +\end{frame} + +\begin{frame} +\frametitle{Xenomai} +\begin{itemize} +\item Gegründet 2001 +\item Echtzeit im Userpace +\item Skins bilden API verschiedenster RTOSse nach +\item Dual-Kernel Ansatz +\item Unterstützte Plattformen: x86, x86\_64, PowerPC, ARM, ia64 +\end{itemize} +\end{frame} + +\begin{frame} +\frametitle{Xenomai} +\begin{figure}[h] +\centering +\includegraphics[height=0.5\textwidth]{images/xenomai.png} +\end{figure} +\end{frame} + +\begin{frame} +\frametitle{Xenomai / IPIPE} +\begin{figure}[h] +\centering +\includegraphics[height=0.5\textwidth]{images/ipipe.png} +\end{figure} +\end{frame} + +\begin{frame} +\frametitle{Drum prüfe, wer sich ewig bindet...} +\begin{overprint} +\onslide<1> +\begin{figure}[h] +\centering +\includegraphics[width=0.8\textwidth]{images/mar01.png} +\end{figure} +\onslide<2> +\begin{figure}[h] +\centering +\includegraphics[height=0.5\textwidth]{images/mar02.png} +\end{figure} +\onslide<3> +\begin{figure}[h] +\centering +\includegraphics[height=0.5\textwidth]{images/mar03.png} +\end{figure} +\end{overprint} +\end{frame} + +\begin{frame} +\frametitle{Preempt RT} +\begin{itemize} +\item Thomas Gleixner, Ingo Molnar +\item In-Kernel Ansatz +\item Große Entwicklergemeinde +\item Viele Funktionen bereits nach ''Mainline'' Linux übernommen +\item POSIX Realtime +\item Hohe Akzeptanz, vollständige Integration in Linux 2006 beschlossen +\end{itemize} +\end{frame} + +\begin{frame} +\frametitle{Preempt RT und Mainline} +\textit{''Controlling a laser with Linux is crazy, but everyone in this room is +crazy in his own way. So if you want to use Linux to control an an industrial +welding laser, I have no problem with your using Preempt RT''} - Linus Torvalds +auf dem Kernel Summit 2006 +\end{frame} + +\begin{frame} +\frametitle{Wie macht Preempt RT Linux echtzeitfähig?} +\begin{overprint} +\onslide<1> +\begin{alertblock}{Wir erinnern uns...} +Unterbrechbarkeit ist eine zentrale Anforderung an ein Echtzeitsystem +\end{alertblock} +\onslide<2> +\begin{itemize} +\item Locking Primitiven: Spinlocks werden durch RT Mutexe ersetzt, die schlafen +können. Raw Spinlocks ersetzen die ursprüngliche Spinlock +\item Interrupt Handler laufen per default in einem Kernelthread +\end{itemize} +\end{overprint} +\end{frame} -\subsection*{Übungen bei vorhandener Hardware} +\begin{frame} +\frametitle{Preempt RT} +\begin{figure}[h] +\centering +\includegraphics[height=0.5\textwidth]{images/preempt_rt.png} +\end{figure} +\end{frame} -Hinweise zu Übungen, Zeitlimit dazu. \end{document} -- cgit v1.2.3 From d3835cbfea3bbc19b386f31c4972d4bc37b9347b Mon Sep 17 00:00:00 2001 From: "Hans J. Koch" Date: Sat, 20 Jun 2009 03:00:55 +0200 Subject: Added Makefiles in each folder to allow make all or make clean from top level directory --- Makefile | 6 ++++++ application-devel/Makefile | 6 ++++++ kernel-devel/Makefile | 6 ++++++ linux-basics/Makefile | 6 ++++++ realtime/Makefile | 7 +++++++ 5 files changed, 31 insertions(+) create mode 100644 application-devel/Makefile create mode 100644 kernel-devel/Makefile create mode 100644 linux-basics/Makefile create mode 100644 realtime/Makefile (limited to 'realtime') diff --git a/Makefile b/Makefile index 4929de1..494db82 100644 --- a/Makefile +++ b/Makefile @@ -1,3 +1,5 @@ +SUBDIRS = kernel-devel linux-basics realtime application-devel + latex-install: mkdir -p /usr/share/texmf-texlive/tex/latex/linutronix cp latex/lxarticle/lxarticle.cls /usr/share/texmf-texlive/tex/latex/linutronix/ @@ -10,3 +12,7 @@ latex-install: cp latex/latex-beamer/*vf /usr/share/texmf/fonts/vf/linutronix texhash +all clean:: + for dir in $(SUBDIRS) ; do \ + (cd $$dir && make $@); \ + done diff --git a/application-devel/Makefile b/application-devel/Makefile new file mode 100644 index 0000000..d62fe78 --- /dev/null +++ b/application-devel/Makefile @@ -0,0 +1,6 @@ +SUBDIRS = app-debugging compile-tools devel-best-practices devel-environment embedded-devel + +all clean:: + for dir in $(SUBDIRS) ; do \ + (cd $$dir && make $@); \ + done diff --git a/kernel-devel/Makefile b/kernel-devel/Makefile new file mode 100644 index 0000000..f325edd --- /dev/null +++ b/kernel-devel/Makefile @@ -0,0 +1,6 @@ +SUBDIRS = char-device driver-basics kernel-basics kernel-best-practices kernel-build uio-driver + +all clean: + for dir in $(SUBDIRS) ; do \ + (cd $$dir && make $@); \ + done diff --git a/linux-basics/Makefile b/linux-basics/Makefile new file mode 100644 index 0000000..ab3b327 --- /dev/null +++ b/linux-basics/Makefile @@ -0,0 +1,6 @@ +SUBDIRS = boot-process filesystem-structure important-tools linux-processes sh-programming what-is-linux + +all clean:: + for dir in $(SUBDIRS) ; do \ + (cd $$dir && make $@); \ + done diff --git a/realtime/Makefile b/realtime/Makefile new file mode 100644 index 0000000..fa8db4f --- /dev/null +++ b/realtime/Makefile @@ -0,0 +1,7 @@ +SUBDIRS = rt-app-basics rt-basics rt-specialties + +all clean:: + for dir in $(SUBDIRS) ; do \ + (cd $$dir && make $@); \ + done + -- cgit v1.2.3 From 3ed5b5306f5fa4ee95bcb5a57733bd116ce008e3 Mon Sep 17 00:00:00 2001 From: Jan Altenberg Date: Sat, 20 Jun 2009 03:36:56 +0200 Subject: Adding one more missing rt-basic file --- realtime/rt-basics/images/mar03.svg | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'realtime') diff --git a/realtime/rt-basics/images/mar03.svg b/realtime/rt-basics/images/mar03.svg index 25c40ad..71e98ae 100644 --- a/realtime/rt-basics/images/mar03.svg +++ b/realtime/rt-basics/images/mar03.svg @@ -16,7 +16,7 @@ inkscape:version="0.46" sodipodi:docname="mar03.svg" inkscape:output_extension="org.inkscape.output.svg.inkscape" - inkscape:export-filename="/home/jan/work/omnicron/schulung/realtime/rt-basics/images/mar02.png" + inkscape:export-filename="/home/jan/work/omnicron/schulung/realtime/rt-basics/images/mar03.png" inkscape:export-xdpi="90" inkscape:export-ydpi="90"> Date: Sat, 20 Jun 2009 03:38:22 +0200 Subject: rt-specialties chapter --- realtime/rt-specialties/Makefile | 9 + .../rt-specialties/handout_rt-specialties_de.tex | 295 ++++++++++++++++++++- .../rt-specialties/hints_rt-specialties_de.tex | 18 +- realtime/rt-specialties/images/g4894.png | Bin 0 -> 12196 bytes realtime/rt-specialties/images/menu_rt_001.png | Bin 0 -> 30735 bytes realtime/rt-specialties/images/menu_rt_002.png | Bin 0 -> 32309 bytes realtime/rt-specialties/images/menu_rt_003.png | Bin 0 -> 32025 bytes realtime/rt-specialties/images/menu_rt_004.png | Bin 0 -> 23627 bytes realtime/rt-specialties/images/pitfall.png | Bin 0 -> 32291 bytes realtime/rt-specialties/images/pitfall.svg | 121 +++++++++ realtime/rt-specialties/images/thumb.png | Bin 0 -> 12196 bytes realtime/rt-specialties/images/thumb.svg | 86 ++++++ realtime/rt-specialties/pres_rt-specialties_de.tex | 227 +++++++++++++++- 13 files changed, 732 insertions(+), 24 deletions(-) create mode 100644 realtime/rt-specialties/Makefile create mode 100644 realtime/rt-specialties/images/g4894.png create mode 100644 realtime/rt-specialties/images/menu_rt_001.png create mode 100644 realtime/rt-specialties/images/menu_rt_002.png create mode 100644 realtime/rt-specialties/images/menu_rt_003.png create mode 100644 realtime/rt-specialties/images/menu_rt_004.png create mode 100644 realtime/rt-specialties/images/pitfall.png create mode 100644 realtime/rt-specialties/images/pitfall.svg create mode 100644 realtime/rt-specialties/images/thumb.png create mode 100644 realtime/rt-specialties/images/thumb.svg (limited to 'realtime') diff --git a/realtime/rt-specialties/Makefile b/realtime/rt-specialties/Makefile new file mode 100644 index 0000000..e80961b --- /dev/null +++ b/realtime/rt-specialties/Makefile @@ -0,0 +1,9 @@ +all: + pdflatex pres_rt-specialties_de.tex + pdflatex hints_rt-specialties_de.tex + pdflatex handout_rt-specialties_de.tex + pdflatex handout_rt-specialties_de.tex + +clean: + rm -f *.aux *.log *.pdf *.log *.snm *.toc *.vrb *.nav *.out + diff --git a/realtime/rt-specialties/handout_rt-specialties_de.tex b/realtime/rt-specialties/handout_rt-specialties_de.tex index 4c391b2..372aa25 100644 --- a/realtime/rt-specialties/handout_rt-specialties_de.tex +++ b/realtime/rt-specialties/handout_rt-specialties_de.tex @@ -1,17 +1,300 @@ -\documentclass{article} +\documentclass{lxarticle} \usepackage{german} \usepackage[utf8]{inputenc} +\usepackage{lxheaders} +\usepackage{lxextras} \begin{document} -\section*{Titel} +\section*{Anwendung des Preempt RT Patches} +\subsection*{Besorgen und Anwenden des Patches} +Preempt RT wird als Patch gegen den Mainline Linux Kernel gepflegt. +Unter:\newline +http://www.kernel.org/pub/linux/kernel/projects/rt sind die aktuellsten Patche +für Preempt RT zu finden. Im Unterverzeichnis older/ sind ältere Patche +archiviert. Das Vorbereiten eines Kerneltrees mit Preempt RT ist denkbar +einfach: +\begin{lstlisting} +# Vanilla Kernel +wget http://www.kernel.org/pub/linux/kernel\ +/v2.6/linux-2.6.29.5.tar.bz2 -\subsection*{Abschnitt1} +# Preempt RT Patch +wget http://www.kernel.org/pub/linux/kernel\ +/projects/rt/patch-2.6.29.5-rt21.bz2 -Text +# Extract the kernel tree +tar xjvf linux-2.6.29.5.tar.bz2 +# Patch the kernel tree +cd linux-2.6.29.5 +bzcat ../patch-2.6.29.5-rt21.bz2 | patch -p1 +\end{lstlisting} +Mit Steven Rostedt's Version des Pythonskripts ''ketchup'' geht es sogar noch einfacher (Steven +Rostedt's ketchup Version steht unter:\newline +http://people.redhat.com/srostedt/rt/tools/ketchup-0.9.8-rt3 zum Download +bereit): +\begin{lstlisting} +mkdir linux-2.6.29.5-rt21 +cd linux-2.6.29.5-rt21 +ketchup -f --no-gpg 2.6.29.5-rt21 +\end{lstlisting} -\subsection*{Abschnitt2} +\subsection*{Konfigurieren und Übersetzen eines Preempt RT Kernels} +Die Konfiguration und das Übersetzen machen keinen Unterschied zu Linux ohne +Preempt RT Patch: +\begin{lstlisting} +# external build directory +mkdir ../build +# base build on existing config +cp /boot/config-x-x-x ../build/.config +make O=../build oldconfig +\end{lstlisting} +Für ein Echtzeitsystem müssen verschiedene Kerneloptionen aktiviert werden: +\begin{lstlisting} +make O=../build menuconfig +\end{lstlisting} +Die wichtigsten Optionen befinden sich unter dem Menupunkt ''Kernel features'' +bzw. ''Processor type and features''. +\begin{figure}[ht!] +\centering +\includegraphics[height=0.5\textwidth]{images/menu_rt_001.png} +\end{figure} +Dort müssen folgende Optionen aktiviert werden: +\begin{itemize} +\item High Resolution Timer Support +\item Preemption Mode (Complete Preemption (Real-Time)) +\end{itemize} +\begin{figure}[ht!] +\centering +\includegraphics[height=0.5\textwidth]{images/menu_rt_002.png} +\end{figure} +\begin{figure}[ht!] +\centering +\includegraphics[height=0.5\textwidth]{images/menu_rt_003.png} +\end{figure} +\begin{figure}[ht!] +\centering +\includegraphics[height=0.5\textwidth]{images/menu_rt_004.png} +\end{figure} +Das Übersetzen des Kernels erfolgt nun wie üblich mit +\begin{lstlisting} +make O=../build +make O=../build modules +make O=../build install +make O=../build modules_install +\end{lstlisting} +\section*{Testen eines Preempt RT Systems} +\subsection*{RT Tests} +Die RT Tests sind eine Sammlung von Programmen, zur Validierung der +Eigenschaften von Echtzeitsystemen. Die RT Tests umfassen folgende Tools: +\begin{itemize} +\item cyclictest: High Resolution Timer Testsoftware. +\item hwlatdetect: Python Script, zur Steuerung des Kernelmoduls zur Erkennung +von System Management Interrupts (hwlat\_detector). +\item pi\_stress: Stresstest für Mutexe mit Priority Inheritance Attribut +\item signaltest: Benchmark, bei dem Signale zwischen Tasks ausgetauscht werden. +\end{itemize} +Die Sourcen der RT Tests werden in einem GIT Tree verwaltet. +\begin{lstlisting} +# Checkout RT Tests +git-clone git://git.kernel.org/pub/scm/linux/kernel\ +/git/clrkwllms/rt-tests.git -Text +# Compile RT Tests +cd rt-tests +make +\end{lstlisting} +\subsection*{Cyclictest} +Cyclictest ist die wohl meistgenutzte Testsoftware auf Preempt RT Systemen. Mit +Cyclictest kann eine bestimmte Anzahl von Timertasks mit einem definierten +Interval aufgesetzt werden. Für diese Tasks wird kontinuierlich die Abweichung +zum gewünschten Interval gemessen und hierfür die Maximale und Durchschnittliche +Abweichung aufgezeichnet. Die wichtigsten Parameter für Cyclictest sind die +Anzahl und die Priorität der gewünschten Timertasks, die Art des zu verwendenden +Timers und das gewünschte Timerinterval: +\begin{lstlisting} +# 4 Timertasks (2000 , 2500, 3000, 3500us) +# -i options tells us the interval of the first task +# the interval of all other tasks will be increased +# by 500us +# The -p options tells us the priority of the first task +# the priorities of all other tasks will be decremented by 1 +# -n = using nanosleep +zi:~# cyclictest -p80 -n -t4 -i2000 +0.32 0.30 0.12 1/56 2124 +T: 0 ( 2121) P:80 I:2000 C: 1258 Min: 62 Act: 99 Avg: 83 Max: 161 +T: 1 ( 2122) P:79 I:2500 C: 1007 Min: 47 Act: 76 Avg: 77 Max: 130 +T: 2 ( 2123) P:78 I:3000 C: 841 Min: 54 Act: 76 Avg: 82 Max: 136 +T: 3 ( 2124) P:77 I:3500 C: 723 Min: 67 Act: 95 Avg: 96 Max: 177 +\end{lstlisting} +\subsection*{Lastszenarien} +Um eine Aussage über das Echtzeitverhaltens treffen zu können, interessiert in +der Hauptsache das Verhalten in Worst-Case Szenarien (hohe CPU Laste, hohe +Interruptlast). Ein ausgezeichnetes Werkzeug, um CPU Last zu erzeugen, ist +''hackbench''. Hackbench wurde ursprünglich als Schedulerbenchmark entwickelt. +Es erzeugt eine bestimme Anzahl an Prozessgruppen von Clients und Servern, die +über Sockets miteinander kommunizieren:\newline +http://people.redhat.com/mingo/cfs-scheduler/tools/hackbench.c + +Interruptlast, läßt sich hervorragend mit einem Floodping von einem entfernten +Rechner erzeugen. Ein Floodping schickt eine große Anzahl von ICMP Paketen in +kurzer Zeit. Dies erzeugt eine hohe Anzahl von Netzwerkinterrupts. Um Floodpings +zu generieren muß das Programm ping mit Rootrechten und mit der Option -f +ausgeführt werden. +\subsection*{Pitfall} +Ein sehr häufig gemeldetes Phänomen bei Testläufen von Cyclictest mit einem +Floodping als Lastszenario, sind extrem große Ausreißer in der Größenordnung von +50ms. Dies ist auf ein ''Feature'' aktueller Preempt RT Kernel zurückzuführen. +Da Preempt RT auch auf vielen Desktops eingesetzt wird, auf denen Low Latency +Anwendungen betrieben werden (z.B. Multimedia Anwendungen), häuften sich +Fehlerberichte, die letztendlich nicht auf ein Kernelproblem zurückzuführen +waren, sondern auf eine Realtime Applikation, die den Rest des Systems +aushungerte. Daher wurde eine Option eingeführt, die die Laufzeit von Realtime +Tasks beschränken kann. Überschreiten die Realtime Tasks dieses Zeitlimit, +werden diese für einen bestimmten Zeitraum nicht mehr geschedult. Die +Standardeinstellung liegt bei 950ms. Bei Überschreiten der 950ms werden die +Echtzeittasks für 50ms suspendiert. Dieser Wert kann durch Schreiben des +gewünschten Wertes nach /proc/sys/kernel/sched\_rt\_runtime\_us angepaßt werden. +Zum Deaktivieren dieser Funktion muß folgendes getan werden: +\begin{lstlisting} +echo -1 > /proc/sys/kernel/sched_rt_runtime_us +\end{lstlisting} +\section*{Erstellen einer Realtime Task für Preempt RT} +\subsection*{Schedulingklassen / Prioritäten} +Eine Realtime Applikation auf Preempt RT ist eine POSIX Realtime Applikation. +POSIX sieht für Echtzeitapplikationen folgende Schedulingstrategien vor: +\begin{itemize} +\item SCHED\_FIFO: Scheduling mit statischen Prioriäten +\item SCHED\_RR: Round Robin mit Prioritäten +\end{itemize} +Echtzeitpriorität bekommt eine Applikation nur dann, wenn dies explizit +gewünscht wird. Hierzu ist die Funktion sched\_setscheduler() vorgesehen. +\subsection*{Beispiel einer Echtzeitapplikation} +Das folgende Beispiel zeigt eine einfache POSIX Realtimeapplikation: +\begin{lstlisting} +/* + * POSIX Realtime Example + * based on the example on http://rt.wiki.kernel.org + / +#include +#include +#include +#include +#include +#include + +#define MAX_SAFE_STACK (8*1024) /* The maximum stack size which is + guranteed safe to access without + faulting */ + +void stack_prefault(void) { + + unsigned char dummy[MAX_SAFE_STACK]; + + memset(&dummy, 0, MAX_SAFE_STACK); + return; +} + +int main(int argc, char* argv[]) +{ + struct sched_param param; + + /* Declare ourself as a real time task */ + param.sched_priority = 80; + if(sched_setscheduler(0, SCHED_FIFO, ¶m) == -1) { + perror("sched_setscheduler failed"); + exit(-1); + } + + /* Lock memory !!!*/ + if(mlockall(MCL_CURRENT|MCL_FUTURE) == -1) { + perror("mlockall failed"); + exit(-2); + } + + /* Pre-fault our stack */ + stack_prefault(); + + while(1) { + [...] + } +} +\end{lstlisting} +Die oben aufgelistete Applikation zeigt sehr schön, was notwendig ist, um eine +Applikation mit deterministischem Zeitverhalten zu erzeugen: +\begin{itemize} +\item RT Scheduling Policy und Priorität festlegen +\item Speicher locken, um zu vermeiden, um undeterministisches Zeitverhalten +durch Pagefaults auszuschliessen. +\item ''Stack Pre-Faulting'', um zu zu vermeiden, daß Stackfaults +undeterministisches Zeitverhalten verursachen +\end{itemize} +Eine Ausgezeichnete Einführung zum Erstellen von Echtzeitapplikation und zur +Verwendung von Preempt RT, findet sich unter:\newline +http://rt.wiki.kernel.org +\subsection*{Tracing / Latenzen aufspüren} +\subsubsection*{FTrace} +Ein hervorragendes Werkzeug, um kernelseitige Codepfade aufzuspüren, die lange +Latenzzeiten verursachen, ist Ftrace. Ftrace wird über DebugFS, einem virtuellen +Dateisystem, gesteuert und platziert dort auch seine Ausgaben. Die einfachste +Methode, FTrace zu verwenden ist Cyclictest. Cyclictest biete bereits einige +Optionen, um FTrace zu verwenden. Die Option -f schällt Cyclictests Ftrace +Support an, -b veranlaßt Cyclictest, bei Überschreiten einer +maximalen Latenzzeit, abzubrechen und einen Trace zu triggern. +\subsubsection*{Kerneloptionen für FTrace} +Um FTrace verwenden zu können, müssen beim Konfigurieren des Kernel einige +unter dem Menupunkt ''Kernel hacking-->Tracers'' einige Optionen aktiviert werden: +\begin{itemize} +\item Kernel Function Tracer +\item Optional: Beliebige Optionen, die mit Trace beginnen (der zu verwendende +Tracetyp kann cyclictest über die Commandline mitgegeben werden, siehe +cyclictest -h. Default ist der +Event Tracer) +\end{itemize} +\subsubsection*{Beispiel eines Traces} +Das Erstellen eines Traces mit cyclictest läßt sich am Besten mit einem Beispiel +erläutern: +\begin{lstlisting} +# mount DebugFS +mkdir -p /mnt/debugfs +mount -t debugs debugfs /mnt/debugfs + +# list available tracers +zi:~# cat /mnt/debugfs/tracing/available_tracers +wakeup_rt wakeup preemptoff function sched_switch nop + +# start trace +cyclictest -p80 -n -f -b 100 + +zi:~# less /mnt/debugfs/tracing/trace +# tracer: function +# +# TASK-PID CPU# TIMESTAMP FUNCTION +# | | | | | +IRQ-129-772 [000] 4154503386.851178: __rt_mutex_adjust_prio<-t +IRQ-129-772 [000] 4154503386.851186: __rt_mutex_adjust_prio<-t +IRQ-129-772 [000] 4154503386.851189: task_setprio<-__rt_mutex_ +IRQ-129-772 [000] 4154503386.851192: task_rq_lock <-task_setpr +IRQ-129-772 [000] 4154503386.851195: sched_clock <-sched_clock +IRQ-129-772 [000] 4154503386.851199: dequeue_task <-task_setpr +IRQ-129-772 [000] 4154503386.851202: dequeue_task_fair <-deque +IRQ-129-772 [000] 4154503386.851206: update_curr <-dequeue_tas +IRQ-129-772 [000] 4154503386.851217: enqueue_task_rt <-task_se +IRQ-129-772 [000] 4154503386.851221: dequeue_rt_stack<-enqueue +IRQ-129-772 [000] 4154503386.851226: switched_to_rt <-task_set +IRQ-129-772 [000] 4154503386.851234: timer_interrupt<-ret_from +[...] +\end{lstlisting} + +\subsection*{Kontrollfragen} +\begin{itemize} +\item Welche Optionen sollten beim Übersetzen eines Preempt RT Kernels +mindestens gesetzt sein? +\item Wozu dient das Tool cyclictest? +\item Welchen bekannten ''Pitfall'' gibt es bzgl. hoher Latencies mit Floodping +als Lastszenario? Wie kann dieser behoben werden? +\item Welche 3 Schritte sind notwendig, um das deterministische Zeitverhalten +einer Applikation zu garantieren? +\end{itemize} \end{document} diff --git a/realtime/rt-specialties/hints_rt-specialties_de.tex b/realtime/rt-specialties/hints_rt-specialties_de.tex index b8b74bc..e07f25a 100644 --- a/realtime/rt-specialties/hints_rt-specialties_de.tex +++ b/realtime/rt-specialties/hints_rt-specialties_de.tex @@ -1,25 +1,27 @@ -\documentclass{article} +\documentclass{lxarticle} \usepackage{german} \usepackage[utf8]{inputenc} +\usepackage{lxheaders} +\usepackage{lxextras} \begin{document} -\section*{Block \lq Realtime-Besonderheiten\rq} +\section*{Block \lq Was ist Linux?\rq} \subsection*{Lernziele} \begin{itemize} -\item Verstehen, warum Kernel-Treiber SMP-fest sein müssen -\item Kennenlernen der Grundregeln für korrektes Locking im Kernel -\item Kennenlernen von Möglichkeiten zum Test der RT-Funktionalität - (lockdep, cyclictest) +\item Beschaffen und anwenden des Preempt RT Patches +\item Konfigurieren und Kompilieren eines Preempt RT Kernels +\item Testen des Preempt RT Kernels \end{itemize} \subsection*{Unterrichts-Ablauf} -Hinweise zur Präsentation, Zeitplanung, etc. +Vortrag + Übungen (insgesamt 90 - 120 Minuten) \subsection*{Übungen bei vorhandener Hardware} -Hinweise zu Übungen, Zeitlimit dazu. +RT Kernel für das Entwicklungssystem. Testen des RT Kernels und dessen +Echtzeitverhaltens auf dem Entwicklungssystem. \end{document} diff --git a/realtime/rt-specialties/images/g4894.png b/realtime/rt-specialties/images/g4894.png new file mode 100644 index 0000000..6b9f247 Binary files /dev/null and b/realtime/rt-specialties/images/g4894.png differ diff --git a/realtime/rt-specialties/images/menu_rt_001.png b/realtime/rt-specialties/images/menu_rt_001.png new file mode 100644 index 0000000..27f26cd Binary files /dev/null and b/realtime/rt-specialties/images/menu_rt_001.png differ diff --git a/realtime/rt-specialties/images/menu_rt_002.png b/realtime/rt-specialties/images/menu_rt_002.png new file mode 100644 index 0000000..c4dd8dc Binary files /dev/null and b/realtime/rt-specialties/images/menu_rt_002.png differ diff --git a/realtime/rt-specialties/images/menu_rt_003.png b/realtime/rt-specialties/images/menu_rt_003.png new file mode 100644 index 0000000..8449d80 Binary files /dev/null and b/realtime/rt-specialties/images/menu_rt_003.png differ diff --git a/realtime/rt-specialties/images/menu_rt_004.png b/realtime/rt-specialties/images/menu_rt_004.png new file mode 100644 index 0000000..21045c8 Binary files /dev/null and b/realtime/rt-specialties/images/menu_rt_004.png differ diff --git a/realtime/rt-specialties/images/pitfall.png b/realtime/rt-specialties/images/pitfall.png new file mode 100644 index 0000000..a083003 Binary files /dev/null and b/realtime/rt-specialties/images/pitfall.png differ diff --git a/realtime/rt-specialties/images/pitfall.svg b/realtime/rt-specialties/images/pitfall.svg new file mode 100644 index 0000000..bdfc4de --- /dev/null +++ b/realtime/rt-specialties/images/pitfall.svg @@ -0,0 +1,121 @@ + + + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + diff --git a/realtime/rt-specialties/images/thumb.png b/realtime/rt-specialties/images/thumb.png new file mode 100644 index 0000000..6b9f247 Binary files /dev/null and b/realtime/rt-specialties/images/thumb.png differ diff --git a/realtime/rt-specialties/images/thumb.svg b/realtime/rt-specialties/images/thumb.svg new file mode 100644 index 0000000..9dd0510 --- /dev/null +++ b/realtime/rt-specialties/images/thumb.svg @@ -0,0 +1,86 @@ + + + + + + + + + + + + image/svg+xml + + + + + + + + + + + diff --git a/realtime/rt-specialties/pres_rt-specialties_de.tex b/realtime/rt-specialties/pres_rt-specialties_de.tex index 07db328..e7e3d1d 100644 --- a/realtime/rt-specialties/pres_rt-specialties_de.tex +++ b/realtime/rt-specialties/pres_rt-specialties_de.tex @@ -1,24 +1,231 @@ -\documentclass{article} +\documentclass{beamer} +\usetheme{linutronix} \usepackage{german} \usepackage[utf8]{inputenc} +\usepackage{pgf} +\usepackage{graphicx} +\usepackage{lxextras} + +\title{Block \lq Anwendung des Preempt RT Patches\rq} +\institute{Linutronix GmbH} \begin{document} -\section*{Block \lq Was ist Linux?\rq} +\maketitle + + +% ----- Slide ------------------ +\begin{frame}[fragile] +\frametitle{Besorgen und Anwenden des Preempt RT Patches} +\begin{lstlisting} +# Vanilla Kernel +wget http://www.kernel.org/pub/linux/kernel\ +/v2.6/linux-2.6.29.5.tar.bz2 + +# Preempt RT Patch +wget http://www.kernel.org/pub/linux/kernel\ +/projects/rt/patch-2.6.29.5-rt21.bz2 + +# Extract the kernel tree +tar xjvf linux-2.6.29.5.tar.bz2 +# Patch the kernel tree +cd linux-2.6.29.5 +bzcat ../patch-2.6.29.5-rt21.bz2 | patch -p1 +\end{lstlisting} +\end{frame} + +\begin{frame}[fragile] +\frametitle{Besorgen und Anwenden des Preempt RT Patches} +\begin{lstlisting} +mkdir linux-2.6.29.5-rt21 +cd linux-2.6.29.5-rt21 +ketchup -f --no-gpg 2.6.29.5-rt21 +\end{lstlisting} +\end{frame} -\subsection*{Lernziele} +\begin{frame}[fragile] +\frametitle{Konfigurieren und Übersetzen eines Preempt RT Kernels} +\begin{overprint} +\onslide<1> +\begin{lstlisting} +# external build directory +mkdir ../build +# base build on existing config +cp /boot/config-x-x-x ../build/.config +make O=../build oldconfig +\end{lstlisting} +\onslide<2> +\begin{lstlisting} +make O=../build menuconfig +\end{lstlisting} +\onslide<3> +\begin{figure}[ht!] +\centering +\includegraphics[height=0.5\textwidth]{images/menu_rt_001.png} +\end{figure} +\onslide<4> +\begin{figure}[ht!] +\centering +\includegraphics[height=0.5\textwidth]{images/menu_rt_002.png} +\end{figure} +\onslide<5> +\begin{figure}[ht!] +\centering +\includegraphics[height=0.5\textwidth]{images/menu_rt_003.png} +\end{figure} +\onslide<6> +\begin{figure}[ht!] +\centering +\includegraphics[height=0.5\textwidth]{images/menu_rt_004.png} +\end{figure} +\onslide<7> +\begin{lstlisting} +make O=../build +make O=../build modules +make O=../build install +make O=../build modules_install +\end{lstlisting} +\end{overprint} +\end{frame} + +\begin{frame} +\frametitle{Testen eines Preempt RT Systems} +RT Tests: \begin{itemize} -\item Lernziel 1 -\item Lernziel 2 -\item Lernziel 3 +\item cyclictest +\item hwlatdetect +\item pi\_stress +\item signaltest \end{itemize} +\end{frame} -\subsection*{Unterrichts-Ablauf} +\begin{frame} +\frametitle{Cyclictest} +\begin{itemize} +\item Ursprünglich entwickelt von Thomas Gleixner für Preempt RT Testing +\item High Resolution Timer Testsoftware +\item Setzt beliebige Anzahl von Realtime Tasks mit unterschiedlicher Priorität +und unterschiedlichen Intervallen auf +\item Viele Debuggingmöglichkeiten +\item Sehr Aussagekräftig, um echtzeitverhalten auf einer bestimmten Plattform +zu beurteilen. +\end{itemize} +\end{frame} -Hinweise zur Präsentation, Zeitplanung, etc. +\begin{frame} +\frametitle{Lastszenarien} +Geeignete Lastszenarien, um Worst-Case Situationen nachstellen /provozieren zu +können: +\begin{itemize} +\item CPU Last: ''hackbench'', ursprünglich als Scheduler Benchmark geschrieben. +\item Interrupt Last: Floodping (''ping -F'') +\end{itemize} +\end{frame} + +\begin{frame}[fragile] +\frametitle{Pitfall!} +\begin{lstlisting} +cat /proc/sys/kernel/sched_rt_runtime_us +\end{lstlisting} +\begin{figure}[l!] +\centering +\includegraphics[height=0.4\textwidth]{images/pitfall.png} +\end{figure} +\end{frame} + +\begin{frame} +\frametitle{Echtzeitapplikationen mit Preempt RT} +\begin{columns} +\column[r]{7cm} +\begin{figure}[l!] +\centering +\includegraphics[height=0.4\textwidth]{images/thumb.png} +\end{figure} +\column[l]{8cm} +\huge +POSIX! +\end{columns} +\end{frame} + +\begin{frame} +\frametitle{Schedulingstrategien} +\begin{itemize} +\item SCHED\_FIFO: Static priority +\item SCHED\_RR: Round Robin mit Prioritäten +\end{itemize} +\end{frame} + +\begin{frame}[fragile] +\frametitle{Aufbau einer RT Applikation} +\begin{overprint} +\onslide<1> +Schedulingstrategie / Priorität +\begin{lstlisting} +struct sched_param param; + +param.sched_priority = 80; +if(sched_setscheduler(0, SCHED_FIFO, ¶m) + == -1) { + perror("sched_setscheduler failed"); + exit(-1); +} +\end{lstlisting} +\onslide<2> +Lock memory: +\begin{lstlisting} +if(mlockall(MCL_CURRENT|MCL_FUTURE) == -1) { + perror("mlockall failed"); + exit(-2); +} +\end{lstlisting} +\onslide<3> +''Stack prefaulting'' +\begin{lstlisting} +void stack_prefault(void) { + unsigned char dummy[MAX_SAFE_STACK]; + memset(&dummy, 0, MAX_SAFE_STACK); + return; +} +\end{lstlisting} +\end{overprint} +\end{frame} + +\begin{frame}[fragile] +\frametitle{Tracing / Latency hunting} +\begin{itemize} +\item FTrace +\item Cyclictest unterstützt Traces mittels FTrace +\item Unterschiedliche Tracer (müssen im Kernel aktiviert sein) +\item Kommunikation mit FTrace über Debugfs +\end{itemize} +\end{frame} -\subsection*{Übungen bei vorhandener Hardware} +\begin{frame}[fragile] +\frametitle{Cyclictest + FTrace} +\begin{lstlisting}[basicstyle=\ttfamily\fontsize{8}{10}\selectfont] +# mount DebugFS +mkdir -p /mnt/debugfs +mount -t debugs debugfs /mnt/debugfs -Hinweise zu Übungen, Zeitlimit dazu. +# list available tracers +zi:~# cat /mnt/debugfs/tracing/available_tracers +wakeup_rt wakeup preemptoff function sched_switch nop +\end{lstlisting} +\end{frame} +\begin{frame}[fragile] +\frametitle{Cyclictest + FTrace} +\begin{lstlisting}[basicstyle=\ttfamily\fontsize{8}{10}\selectfont] +cyclictest -p80 -n -f -b 100 +zi:~# less /mnt/debugfs/tracing/trace +# tracer: function +# +# TASK-PID CPU# TIMESTAMP FUNCTION +# | | | | | +IRQ-129-772 [000] 4154503386.851178: __rt_mutex_adjust_prio +IRQ-129-772 [000] 4154503386.851186: __rt_mutex_adjust_prio +IRQ-129-772 [000] 4154503386.851189: task_setprio<-__rt_mut +[...] +\end{lstlisting} +\end{frame} \end{document} -- cgit v1.2.3 From 4f259a1216b52bf0341ec30544e068e49cec4895 Mon Sep 17 00:00:00 2001 From: Jan Altenberg Date: Sat, 20 Jun 2009 12:10:29 +0200 Subject: RT basics fixes --- realtime/rt-basics/handout_rt-basics_de.tex | 22 +++++++++++----------- realtime/rt-basics/pres_rt-basics_de.tex | 2 +- 2 files changed, 12 insertions(+), 12 deletions(-) (limited to 'realtime') diff --git a/realtime/rt-basics/handout_rt-basics_de.tex b/realtime/rt-basics/handout_rt-basics_de.tex index 8576b7d..8d98ccc 100644 --- a/realtime/rt-basics/handout_rt-basics_de.tex +++ b/realtime/rt-basics/handout_rt-basics_de.tex @@ -10,13 +10,13 @@ \subsection*{Grundlagen} -\subsubsection*{Was ist Echteit?} +\subsubsection*{Was ist Echtzeit?} Vor der Betrachtung verschiedener Ansätze, Linux echtzeitfähig zu machen, ist es -notwendig einige grundlegende Begrifflichkeiten zur erläutern: +notwendig, einige grundlegende Begrifflichkeiten zur erläutern: \begin{itemize} \item Echtzeit: Zur Definition eines Echtzeitsystems kann man folgende Aussagen Treffen: Auf -einem Echtzeitsystem hängt die Korrektheit einer Berechnung nicht nur von deren +einem Echtzeitsystem hängt die Korrektheit einer Berechnung nicht nur von ihrer logischen Korrektheit, sondern auch von der Ausführung zum korrekten Zeitpunkt ab. Das Nichteinhalten eines bestimmten Zeitrahmens resultiert in einem Fehler. \item Latenzzeit: Unter Latenzzeit versteht man den Zeitraum zwischen dem @@ -47,7 +47,7 @@ Gelöst werden kann dieses Problem durch ''prioriy inheritance'' und ''priority \begin{itemize} \item Prioritätsvererbung / priority inheritance: Hier wird die Priorität der niederprioren Task angehoben, um zu erreichen, daß die blockierte Resource -freigegeben kann. +freigegeben werden kann. \item Prioritätsgrenzen / priority ceiling: Hier wird für jede Resource eine Prioritätsgrenze festgelegt. Jede Task, die die Resource belegt, wird auf die Prioritätsgrenze der Resource angehoben. @@ -94,7 +94,7 @@ RTAI ist ein typischer Vertreter des Dual Kernel Ansatzes. Abbildung Das Xenomai Projekt wurde im Jahre 2001 gegründet. Im Gegensatz zu RTAI erlaubt Xenomai auch Echtzeit im Userpace (RTAI erlaubt dies nur sehr eingeschränkt). Die Besonderheit von Xenomai sind die sogenannten Skins, die es vereinfachen sollen, -Applikationen von proprietären Echtzeitsystemen nach Xenomai zu portieren. +Applikationen von anderen Echtzeitsystemen nach Xenomai zu portieren. Xenomai Skins bilden die API dieser Systeme ab. Xenomai unterstützt derzeit folgende Architekturen: PowerPC32, PowerPC64, x86, x86\_64, Blackfin, ARM und ia64). Die zentralen Begriffe im Designkonzept von Xenomai stellen Xenomai @@ -104,9 +104,9 @@ IPIPE kann bildlich als virtueller Interruptkontroller betrachtet werden. Sie organisiert das System in verschiedenen Domains. Interrupts werden von IPIPE entgegengenommen und an die einzelnen Domains verteilt. Nucleus beeinhaltet die Xenomai Core Funktionalität. Dieser ist zuständig dafür, -alle notwendigen Resourcen, die Skins benötigen, um die Funktionalität von -RTOSsen nachzubilden. Der Hardware Abstraction Layer beinhaltet den Plattform -und CPU abhängigen Code. Alle darüberliegenden Layer (darunter auch Nucleus) +alle notwendigen Resourcen bereitzustellen, die Skins benötigen, um die Funktionalität +von RTOSsen nachbilden zu können. Der Hardware Abstraction Layer beinhaltet +den Plattform und CPU abhängigen Code. Alle darüberliegenden Layer (darunter auch Nucleus) bauen darauf auf. HAL ist kombiniert mit dem System Abstraction Layer. Dieser soll die darüberliegenden Layer, wie z.B. Nucleus, noch portierbarer machen. Abbildung \ref{img:xenomai} zeigt das technische Zusammenspiel der Xenomai @@ -143,7 +143,7 @@ generisches Interrupthandling für alle Architekturen und mit 2.6.30 nun auch di Threaded Interrupt Handler. Weiterhin hat sich die Linux Entwicklergemeinde bereits 2006 darauf geeinigt, daß Preempt RT in den Linux Kernel integriert wird. Weiterhin bietet der -Realtime Preempton Patch den großen Vorteil, daß Echtzeitapplikationen als POSIX +Realtime Preemption Patch den großen Vorteil, daß Echtzeitapplikationen als POSIX Realtime Applikationen geschrieben werden. Es wird keine spezielle API verwendet. Preempt RT Unterstützt eine Vielzahl von Architekturen (PowerPc, x86, x86\_64, MIPS, ARM, ...). @@ -154,7 +154,7 @@ x86\_64, MIPS, ARM, ...). \label{img:preempt_rt} \end{figure} Wie Abbildung \ref{img:preempt_rt} zeigt, integriert Preempt RT die -Echtzeitfunktionalität ''natlos'' in den Linux Kernel. Auch die Entwickler +Echtzeitfunktionalität ''nahtlos'' in den Linux Kernel. Auch die Entwickler anderer Projekte haben die Vorzüge von Preempt RT bereits erkannt. Die Roadmap für Xenomai 3 sieht Preempt RT Support vor. Dies würde den Einsatz von Xenomai Skins auf Preempt RT Kerneln ermgöglichen. @@ -164,7 +164,7 @@ Skins auf Preempt RT Kerneln ermgöglichen. \begin{enumerate} \item Was sind die wichtigsten Anforderungen an ein Echtzeitsystem? \item Welche beiden Ansätze gibt es, um Linux echtzeitfähig zu machen? -\item Was sind die bekanntesten Vertreter für Echtzeitlinux und welchen der oben +\item Was sind die bekanntesten Vertreter für Echtzeitlinux und welche der oben beschriebenen Ansätze verfolgen Sie? \item Wird für das Schreiben einer Echtzeitapplikation mit Preempt RT eine spezielle API benötigt? diff --git a/realtime/rt-basics/pres_rt-basics_de.tex b/realtime/rt-basics/pres_rt-basics_de.tex index c60f8a5..128b115 100644 --- a/realtime/rt-basics/pres_rt-basics_de.tex +++ b/realtime/rt-basics/pres_rt-basics_de.tex @@ -181,7 +181,7 @@ Nicht Einhalten des korrekten Zeitrahmens führt zu einem Fehler! \begin{frame} \frametitle{Preempt RT und Mainline} \textit{''Controlling a laser with Linux is crazy, but everyone in this room is -crazy in his own way. So if you want to use Linux to control an an industrial +crazy in his own way. So if you want to use Linux to control an industrial welding laser, I have no problem with your using Preempt RT''} - Linus Torvalds auf dem Kernel Summit 2006 \end{frame} -- cgit v1.2.3 From a3dd8a86b6e4c60630141721c7f4cb4adb73b043 Mon Sep 17 00:00:00 2001 From: Jan Altenberg Date: Sat, 20 Jun 2009 12:39:37 +0200 Subject: RT speciality fixes --- .../rt-specialties/handout_rt-specialties_de.tex | 41 ++++++++++++---------- realtime/rt-specialties/pres_rt-specialties_de.tex | 4 +-- 2 files changed, 25 insertions(+), 20 deletions(-) (limited to 'realtime') diff --git a/realtime/rt-specialties/handout_rt-specialties_de.tex b/realtime/rt-specialties/handout_rt-specialties_de.tex index 372aa25..33dc9b6 100644 --- a/realtime/rt-specialties/handout_rt-specialties_de.tex +++ b/realtime/rt-specialties/handout_rt-specialties_de.tex @@ -89,7 +89,7 @@ Die RT Tests sind eine Sammlung von Programmen, zur Validierung der Eigenschaften von Echtzeitsystemen. Die RT Tests umfassen folgende Tools: \begin{itemize} \item cyclictest: High Resolution Timer Testsoftware. -\item hwlatdetect: Python Script, zur Steuerung des Kernelmoduls zur Erkennung +\item hwlatdetect: Python Script zur Steuerung des Kernelmoduls zur Erkennung von System Management Interrupts (hwlat\_detector). \item pi\_stress: Stresstest für Mutexe mit Priority Inheritance Attribut \item signaltest: Benchmark, bei dem Signale zwischen Tasks ausgetauscht werden. @@ -108,10 +108,10 @@ make Cyclictest ist die wohl meistgenutzte Testsoftware auf Preempt RT Systemen. Mit Cyclictest kann eine bestimmte Anzahl von Timertasks mit einem definierten Interval aufgesetzt werden. Für diese Tasks wird kontinuierlich die Abweichung -zum gewünschten Interval gemessen und hierfür die Maximale und Durchschnittliche +zum gewünschten Intervall gemessen und hierfür die Maximale und Durchschnittliche Abweichung aufgezeichnet. Die wichtigsten Parameter für Cyclictest sind die Anzahl und die Priorität der gewünschten Timertasks, die Art des zu verwendenden -Timers und das gewünschte Timerinterval: +Timers und das gewünschte Timerintervall: \begin{lstlisting} # 4 Timertasks (2000 , 2500, 3000, 3500us) # -i options tells us the interval of the first task @@ -130,7 +130,7 @@ T: 3 ( 2124) P:77 I:3500 C: 723 Min: 67 Act: 95 Avg: 96 Max: 177 \end{lstlisting} \subsection*{Lastszenarien} Um eine Aussage über das Echtzeitverhaltens treffen zu können, interessiert in -der Hauptsache das Verhalten in Worst-Case Szenarien (hohe CPU Laste, hohe +der Hauptsache das Verhalten in Worst-Case Szenarien (hohe CPU Last, hohe Interruptlast). Ein ausgezeichnetes Werkzeug, um CPU Last zu erzeugen, ist ''hackbench''. Hackbench wurde ursprünglich als Schedulerbenchmark entwickelt. Es erzeugt eine bestimme Anzahl an Prozessgruppen von Clients und Servern, die @@ -154,9 +154,15 @@ aushungerte. Daher wurde eine Option eingeführt, die die Laufzeit von Realtime Tasks beschränken kann. Überschreiten die Realtime Tasks dieses Zeitlimit, werden diese für einen bestimmten Zeitraum nicht mehr geschedult. Die Standardeinstellung liegt bei 950ms. Bei Überschreiten der 950ms werden die -Echtzeittasks für 50ms suspendiert. Dieser Wert kann durch Schreiben des -gewünschten Wertes nach /proc/sys/kernel/sched\_rt\_runtime\_us angepaßt werden. -Zum Deaktivieren dieser Funktion muß folgendes getan werden: +Echtzeittasks für 50ms suspendiert. +Da Interrupts unter Preempt RT als Kernelthread mit Echtzeitprioriät laufen +und durch den Floodping eine hohe Anzahl an Netzwerkinterrupts +(einschliesslich der zugehörigen Softinterrupts) erzeugt wird, nehmen Realtime +Tasks im System einen Großteil der Resourcen ein. Somit kann es passieren, daß +dieses Zeitlimit überschritten wird. +Das Limit für die Rechenzeit kann durch Schreiben des gewünschten Wertes nach +/proc/sys/kernel/sched\_rt\_runtime\_us angepaßt werden. +Zum Deaktivieren dieser Funktion muß Folgendes getan werden: \begin{lstlisting} echo -1 > /proc/sys/kernel/sched_rt_runtime_us \end{lstlisting} @@ -225,13 +231,13 @@ Die oben aufgelistete Applikation zeigt sehr schön, was notwendig ist, um eine Applikation mit deterministischem Zeitverhalten zu erzeugen: \begin{itemize} \item RT Scheduling Policy und Priorität festlegen -\item Speicher locken, um zu vermeiden, um undeterministisches Zeitverhalten -durch Pagefaults auszuschliessen. -\item ''Stack Pre-Faulting'', um zu zu vermeiden, daß Stackfaults +\item Speicher locken, um undeterministisches Zeitverhalten durch +Pagefaults auszuschliessen. +\item ''Stack Pre-Faulting'', um zu vermeiden, daß Stackfaults undeterministisches Zeitverhalten verursachen \end{itemize} -Eine Ausgezeichnete Einführung zum Erstellen von Echtzeitapplikation und zur -Verwendung von Preempt RT, findet sich unter:\newline +Eine Ausgezeichnete Einführung zum Erstellen von Echtzeitapplikationen und zur +Verwendung von Preempt RT findet sich unter:\newline http://rt.wiki.kernel.org \subsection*{Tracing / Latenzen aufspüren} \subsubsection*{FTrace} @@ -239,18 +245,17 @@ Ein hervorragendes Werkzeug, um kernelseitige Codepfade aufzuspüren, die lange Latenzzeiten verursachen, ist Ftrace. Ftrace wird über DebugFS, einem virtuellen Dateisystem, gesteuert und platziert dort auch seine Ausgaben. Die einfachste Methode, FTrace zu verwenden ist Cyclictest. Cyclictest biete bereits einige -Optionen, um FTrace zu verwenden. Die Option -f schällt Cyclictests Ftrace +Optionen, um FTrace zu steuern. Die Option -f schällt Cyclictests Ftrace Support an, -b veranlaßt Cyclictest, bei Überschreiten einer maximalen Latenzzeit, abzubrechen und einen Trace zu triggern. \subsubsection*{Kerneloptionen für FTrace} -Um FTrace verwenden zu können, müssen beim Konfigurieren des Kernel einige +Um FTrace verwenden zu können, müssen beim Konfigurieren des Kernels einige unter dem Menupunkt ''Kernel hacking-->Tracers'' einige Optionen aktiviert werden: \begin{itemize} \item Kernel Function Tracer -\item Optional: Beliebige Optionen, die mit Trace beginnen (der zu verwendende +\item Beliebige Optionen, die mit Trace beginnen (der zu verwendende Tracetyp kann cyclictest über die Commandline mitgegeben werden, siehe -cyclictest -h. Default ist der -Event Tracer) +cyclictest -h. Default ist der Event Tracer) \end{itemize} \subsubsection*{Beispiel eines Traces} Das Erstellen eines Traces mit cyclictest läßt sich am Besten mit einem Beispiel @@ -293,7 +298,7 @@ IRQ-129-772 [000] 4154503386.851234: timer_interrupt<-ret_from mindestens gesetzt sein? \item Wozu dient das Tool cyclictest? \item Welchen bekannten ''Pitfall'' gibt es bzgl. hoher Latencies mit Floodping -als Lastszenario? Wie kann dieser behoben werden? +als Lastszenario? Wie kann dieser umgangen werden? \item Welche 3 Schritte sind notwendig, um das deterministische Zeitverhalten einer Applikation zu garantieren? \end{itemize} diff --git a/realtime/rt-specialties/pres_rt-specialties_de.tex b/realtime/rt-specialties/pres_rt-specialties_de.tex index e7e3d1d..046521d 100644 --- a/realtime/rt-specialties/pres_rt-specialties_de.tex +++ b/realtime/rt-specialties/pres_rt-specialties_de.tex @@ -107,14 +107,14 @@ RT Tests: \item Setzt beliebige Anzahl von Realtime Tasks mit unterschiedlicher Priorität und unterschiedlichen Intervallen auf \item Viele Debuggingmöglichkeiten -\item Sehr Aussagekräftig, um echtzeitverhalten auf einer bestimmten Plattform +\item Sehr Aussagekräftig, um Echtzeitverhalten auf einer bestimmten Plattform zu beurteilen. \end{itemize} \end{frame} \begin{frame} \frametitle{Lastszenarien} -Geeignete Lastszenarien, um Worst-Case Situationen nachstellen /provozieren zu +Geeignete Lastszenarien, um Worst-Case Situationen nachstellen / provozieren zu können: \begin{itemize} \item CPU Last: ''hackbench'', ursprünglich als Scheduler Benchmark geschrieben. -- cgit v1.2.3