From b208259c74504385c2f9b90d892785c55cc9aff5 Mon Sep 17 00:00:00 2001 From: Jan Altenberg 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/rt-specialties') 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 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/rt-specialties') 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