1. No category

Realtidssystem
- Introduktion, jämlöpande exekvering EDA698 - Realtidssystem (Helsingborg)
Elin A. Topp
2015-08-31
Stora delar baserad på: Föreläsningsmaterial EDA040 (Klas Nilsson, Mathias Haage) samt EDA698 (Mats Lilja)
1
Om kursen
•
Upplägg:
•
•
•
7 föreläsningar (måndagar, varierande 10-12 / 13-15)
7 övningar (onsdagar, varav tre laborationsförberedande och
OBLIGATORISKA)
•
uppgifter, både teoretiska och praktiska bearbetas i övningssalen; kursledare är på
plats och besvarar frågor,
•
det förutsätts att man kommer med eget arbetsmaterial (övningshäfte) för att kunna
följa eventuella allmänna förklaringar och diskussioner!
•
laborationsförberedande övningar ska resultera i designförslag inför laboration,
godkänt design behövs inför redovisning!
3 obligatoriska laborationer (föreberedande övningar en vecka innan)
•
•
REDOVISNING: grupp 1 kl 13-15, grupp 2 kl 15-17
den schemalagda tiden räcker INTE, kom med förberedda lösningar
2
Om kursen (2)
•
ALL information på http://cs.lth.se/kurs/eda698/
•
•
•
•
•
Ex-tentor
Föreläsningsbilder
Nyheter (kolla regelbundet)
“Obligatoriskt” Kursmaterial
•
•
•
•
Allmän information, laborationsanvisningar, Eclipse-workspace
E-bok: I.C. Bertolotti & G. Manduchi, “Real-time Embedded Systems” (CRC Press, 2012)
Övningshäfte (+ lösningar)
“Multithreaded programming in Java” (Klas Nilsson / Elin A. Topp (ed) 2015-08-28)
Extra material
•
Kurskompendium “Java based Real-time programming” (Klas Nilsson, 2012-08-29)
•
Länksamling på kurshemsidan
3
Kursöversikt
•
Realtidssystem - jämlöpande processer under tidsgarantikrav (Föreläsning 1)
•
Jämlöpande exekvering, trådhantering, hantering av delade resurser
•
ömsesidig uteslutning, signalering, datahantering, trådkommunikation
semafor:
föreläsning (1), 2
övning 1, 2 laboration 1
•
monitor:
föreläsning 3 övning 3, 4
laboration 2
mailbox:
föreläsning 4 övning 5, 6
laboration 3
Tidskrav, systemhantering, schemaläggning
•
resursallokering, schemaläggning, prioritetshantering schemaläggningsanalys
dödläge:
föreläsning 5
övning 5
schemaläggning + analys
föreläsning 6, 7
övning 7
4
Dagens agenda
•
Introduktion till Jämlöpande exekvering
•
•
•
Sekventiell bearbetning i en parallel värld
Hantera olika uppgifter samtidigt - jämlöpande exekvering
Trådar, processer, parallellitet och Java
•
•
•
Pre-emption, kontextbyte
Trådar i Java
Hantera gemensamma resurser, kapplöpning, ömsesidig uteslutning
5
Dagens agenda
•
Introduktion till Jämlöpande exekvering
•
•
•
Sekventiell bearbetning i en parallel värld
Hantera olika uppgifter samtidigt - jämlöpande exekvering
Trådar, processer, parallellitet och Java
•
•
•
Pre-emption, kontextbyte
Trådar i Java
Hantera gemensamma resurser, kapplöpning, ömsesidig uteslutning
6
Den parallella världen
•
Flera “processorer”:
•
•
•
Laga mat medan en annan dukar
En kör, en läser kartan
En “processor”:
•
•
Stryka skjortor och lyssna på musik
Läsa kartan och gå mot målet
7
Jämlöpande aktiviteter
"
"
•
•
•
•
Laga mat medan en annan dukar?
En kör, en läser kartan?
✓
✓
Stryka skjortor och lyssna på musik?
✓
Läsa kartan och gå mot målet?
"25
+%%%56%$
%%2"+%5$
"##$%"$#
"25
+%%%56%$
%%2"+%5$
"##$%"$#
8
Sekventiell bearbetning
Situation 1: Utbetalning först
A: Läs 5000
A: Belopp = 5000 - 1000
A: Skriv 4000
B: Läs 4000
B: Belopp = 4000 + 10000
B: Skriv 14000
Situation 2: Inbetalning först
B: Läs 5000
B: Belopp = 5000 + 10000
B: Skriv 15000
A: Läs 15000
A: Belopp = 15000 - 1000
A: Skriv 14000
Två aktiviteter (program, trådar (threads), processer) utförs oberoende och ej
samtidigt. I båda situationer blir resultatet korrekt.
9
%
Maskinen som gjuter LEGO-klossar
2$="
Styra temperaturen i plastmassan (period) och pistongen (evenemang) samtidigt, utan att
det blir fel i en av styrningarna.
doHeat
}
On
wh
temp
~
doPush doPull
// Sta
while
wh
isEmpty
}
of
on(do
wh
}
of
isIn isOut
}
10
%
2$="
Maskinen som gjuter LEGO-klossar
I ett program:
// börja med pistongen bak
while( true) {
while( !isEmpty){
tempControl();
sleep( tsamp);
}
on( doPush);
while( !isOut) {
tempControl();
sleep( tsamp);
}
off( doPush);
on( doPull);
while( !isIn) {
tempControl();
sleep( tsamp);
}
off( doPull);
}
doHeat
temp
~
doPush doPull
isEmpty
isIn isOut
// Start
while (
whil
te
sl
}
On(d
whil
te
sl
}
off(
on(doPu
whil
te
sl
}
off(
}
"##$%"$#
Vad kan gå fel här?
11
The LEGO-brick machine – 1
Maskinen som gjuter LEGO-klossar
Mera naturligt: I två program...
// Aktivitet 1: Temperatur
while( true) {
if( temp > max)
off( doHeat);
else if( temp < min)
on( doHeat);
sleep( tsamp);
}
// Aktivitet 2: Pistong
while( true){
await( isEmpty);
on( doPush);
await( isOut);
off( doPush);
on( doPull);
await( isIn);
off( doPull);
}
%
2$="
doHeat
//
w
temp
~
doPush doPull
o
isEmpty
isIn isOut
}
"##$%"$#
12
“Real-world” objekt och aktioner
Sekventiell:
•
•
Aktioner av en enstaka aktör
Mjukvaru-exekvering
Parallellt (jämlöpande):
•
•
Fysiska processer.
Elektronisk hårdvara.
Inbyggda datorer och deras styrning (mjukvara):
Sekventiella program som körs jämlöpande (och i realtid) för att styra en parallell omgivning
Vi måste tänka både sekventiellt och parallellt när vi bygger system
13
Concurrent computing
Realtidskrav
Ett realtidssystem måste
•
•
•
•
"0
utföra alla beräkningar
logiskt korrekt
"
reagera på
inmatningar
2
jämlöpande
"
alltid ha konsistent
data att
"0"5
arbeta med
5%$
producera alla (del-)resultat
"
5+%
i tid
+1&$!
""%
+5!
0"
%3
&%2!
6$
+0"""$
För att uppnå “realtids-korrekthet”
(real-time correctness) måste mjukvaran
"##$%"$#
säkerställa, att det “jämlöpande-korrekta” (concurrency-correctness) resultatet produceras pålitligt i tid.
14
Process eller tråd (thread)
Trådar i OS-process
OS-processer
semaforer
• !
monitorer
• "#$
meddelanden i kö
• "#
%%$
•
•
•
(mailbox / event queue)
&
• sub-millisekund
•
“vårdad” av OS-process
• '&
stöd av
• (
•
•
•
programmeringsspråk
•
class “Thread”
EDA040
practice
EDA698
pipe,
socket
,
•
•
Semafor
hårdvara
eller
!
Inbyggd
minne
"#&
nätverk, fieldbus
$
"#
% • microsekunder
Inbyggda trådar
OS-Semafor
resurs
•
&
fil, fil-lås+%&
millisekund
“vårdad”
av OS / dator
•
'
“vårdad” av hårdvaran
(
classes
“System”,
• class “Thread”
“Runtime”, “Process”
,
stöd
OS / API
av,-
See EDA050
•
'
stöd av
programmeringsspråk
EDA040 con
15
Dagens agenda
•
Introduktion till Jämlöpande exekvering
•
•
•
Sekventiell bearbetning i en parallel värld
Hantera olika uppgifter samtidigt - jämlöpande exekvering
Trådar, processer, parallellitet och Java
•
•
•
Pre-emption, kontextbyte
Trådar i Java
Hantera gemensamma resurser, kapplöpning, ömsesidig uteslutning
16
Jämlöpande exekvering
av sekventiella processer
"
"
En processor måste delas av flera aktiviteter genom att dela över tid i väldigt små enheter, får
man något som ser “samtidigt” ut.
"25
+%%%56%$
%%2"+%5$
"##$%"$#
"25
+%%%56%$
%%2"+%5$
"##$%"$#
17
Exekveringstillstånd
Due to scheduler / kernel / OS
Running
Priority, time-sharing
By “this”: wait,
“synchronized” call
By other: notify,
“synchronized” return
Due to
application
Blocked
Schemaläggningstillstånd (scheduling state)
Kontext
•
•
•
•
•
•
Running
Ready
Blocked
Ready
PC (Program Counter), SP (stack pointer)
Data (beroende på tillämpning)
Registerinnehåll
18
Kontextbyte
(Context switch)
•
Kontexten av ett program / en tråd är all specifik data som tråden behöver ha med sig
•
När systemet byter från en löpande tråd till den nästa händer det alltså ett kontextbyte (context
switch), dvs all information som gäller den gamla löpande tråden sparas undan för senare
vidarebearbetning, och all data tillhörande den nya löpande tråden plockas fram.
•
I en typisk s.k. pre-emptive (“avbrytbar”) OS-kärna kan det se ut så här:
Turn off interrupts
Push PC, then CPU registers on stack
Save stack pointer in process record
Get new process record and restore stack pointer from it
Pop CPU registers, then PC from stack
Turn on interrupts
•
}
}
}
Save
Switch
Restore
Varje tråd har alltså sin egen stack, som blir allokerad vid trådens skapande.
19
Pre-emption
Det finns olika strategier för tillåtelse av kontextbyten:
•
Non-pre-emptive scheduling (“icke-avbrytbar” schemaläggning): Tråden som “kör” kan inte
avbrytas tills den släpper CPUn frivilligt
•
explicit genom att anropa yield() eller
•
implicit genom (synchronized) operationer som kan blockera.
•
Pre-emption point based scheduling (“avbrytningspunktbaserad” schemaläggning): Tråden som
“kör” kan avbrytas vid vissa punkter i programmet (definierad genom språket eller run-time
systemet)
•
Pre-emptive scheduling (“avbrytbar” schemaläggning): Tråden som “kör” kan avbrytas när som
helst av schemaläggaren (som styrs av hårdvaru-interrupts).
För att det ska bli “rätt” med schemaläggningen och väntetiderna, antar våra program att kärnan är
pre-emptive, dvs. trådar kan avbrytas vid behov och då hanterar systemet kontextbytet på ett
korrekt sätt.
20
Java? Java!
Java erbjuder abstraktionerna och den flexibiliteten och säkerheten som behövs för att kunna
bygga flexibla, komplexa system.
Med de passande tillägg gjorda på CS@LTH går det bra ändå att hantera jämlöpande trådar med
gemensam resurshantering och realtidskrav - det går också på annat sätt, men under kursen
använder vi oss av paketet:
se.lth.cs.realtime.*
21
class Thread
java.lang.Thread
•
En tråd är ett aktivt objekt, medan ett vanligt objekt med metoder som anropas inom en
sekvens kallas för passivt objekt.
•
Metoden run() utför trådens uppgifter (som i ett passivt objekt), men bara metoden start() som
anropar run() ger tråden sitt eget liv.
•
Två vägar att implementera en tråd, dvs implementera metoden run():
•
implementera interfacet Runnable eller ärva från class Thread
22
Använda Runnable
public interface Runnable {
void run();
}
...
class MyRunnableObject implements Runnable {
void run() {
/* Do loads of stuff the thread is supposed to do */
}
/* implement other stuff that is needed by the thread */
}
...
MyRunnableObject myR(...);
Thread aThread( myR);
aThread.start();
23
Använda class Thread
class MyActivity extends Thread {
public MyActivity() {
// init here, done before `start´ is called
}
public void run() {
while( true) {
// do whatever the thread should do, once it is set alive by calling
// start (which calls run, effectively)
}
}
}
...
public static void main( String[] args) {
// do / declare some stuff
MyActivity myAct1();
// ... do some stuff ...
myAct1.start();
// Vad händer här om man “bara” kör run()?
// ... do some more stuff ...
}
myAct1.join();
24
class Thread
public class Thread implements Runnable {
}
static int MAX_PRIORITY;
static int MIN_PRIORITY;
static int NORM_PRIORITY;
// Highest possible priority
// Lowest possible priority
// Default priority
Thread();
Thread( Runnable target);
// Use run in subclass
// Use run in `target´
void start();
void run();
static Thread currentThread();
// Create thread which calls `run´
// Work to be defined by subclass
// Get currently executing thread
void setPriority( int pri);
int getPriority();
// Change the priority to `pri´
// Returns this thread’s priority
static void sleep( long t);
static void yield();
// Suspend execution at least `t´ ms
// Reschedule to let others run
void interrupt();
boolean isInterrupted();
static boolean interrupted();
//
//
//
//
boolean isAlive();
void join();
void join( long t);
Set interrupt request flag
Check interrupt flag of “this” thread
Check if interrupted for currently running thread
// true if started and not dead
// Waits for this thread to die
// Try to join, but only for `t´ ms
25
"
Jämlöpande exekvering
av sekventiella processer
"25
+%%%56%$
%%2"+%5$
"##$%"$#
Varje aktivitet
(tråd) måste utföras
som ett logiskt korrekt, sekventiellt program.
Samtliga parallella aktiviteter tillsammans måste leverera korrekt beteende
jämnt och under alla omständigheter (inmatningar, händelser...).
Att testa / verifiera detta är i det närmaste omöjligt, för att pyttesmå ändringar
i hur sekvenserna “flätas samman” kan påverka mycket, och det är i princip
omöjligt att få till exakt samma flätning två gånger.
26
Kapplöpning (och “run” vs “start”)
class HelloWorld extends Thread {
class HelloWorld extends Thread {
public static void main( String[] arg) {
System.out.print( “Hello “);
new HelloWorld().run();
}
public static void main( String[] arg) {
System.out.print( “Hello “);
new HelloWorld().start();
System.out.println( “World!”);
}
public void run() {
System.out.print( “and goodbye “);
}
}
System.out.println( “World!”);
public void run() {
System.out.print( “and goodbye “);
}
}
Det behövs alltså fler egenskaper och mekanismer, samt regler för programmering av multitrådade program, än “bara” möjligheten att skapa trådar och låta dem köra samtidigt.
27
Bankkontot igen
Situation 1:
Situation 2:
A: Läs 5000
A: Läs 5000
B: Läs 5000
B: Läs 5000
B: Belopp = 5000 + 10000
B: Skriv 15000
A: Belopp = 5000 - 1000
A: Belopp = 15000 - 1000
A: Skriv 4000
B: Belopp = 5000 + 10000
A: Skriv 4000
B: Skriv 15000
Två aktiviteter (program, trådar (threads), processer) utförs samtidigt, då de
hanterar samma resurser. I båda situationer blir resultatet fel.
Här behövs det alltså någon mekanism för ömsesidig uteslutning (mutual
exclusion) för att hantera kritiska sekvenser (critical sections) och odelbara
aktioner (atomic actions).
28
Kritiska sekvenser
(Critical sections)
•
Delar av ett program (en sekvens) som behöver tillgång till en delad resurs.
•
Får inte bli avbruten av en annan programsekvens, eller av en ny upprop till sig
själv.
•
Kraven kan uppfyllas med hjälp av Semaforer, Monitorer eller
“Postlådor” (Mailboxes)
•
På låg nivå (native code) kan man också slå av interrupts (avbrott).
29
Begrepp / abstraktioner
för jämlöpande exekvering
Vad är det som ett programmeringsspråk måste stödja för att kunna erbjuda jämlöpande
exekvering?
•
Tråd - en aktivitet, programsekvens
•
Exekveringsstatus - aktiv / inaktiv, använd av en tråd eller ej; kontext + aktivitetsstatus
•
Synkronisering - hantering av gemensamma resurser
30
Dagens resultat
•
Infört begreppen jämlöpande exekvering, tråd, schemaläggning, pre-emption
(avbrytbarhet), kontext / kontextbyte, (lite) ömsesidig uteslutning
•
•
Diskuterat fällor såsom fel vid gemensam resurshantering, kapplöpning
•
Man borde kunna skriva ett litet Java-program som skapar en extra tråd, tex för att
“svara” på inmatningar i “huvudtråden (-programmet)” medan man räknar tiden och
skriver ut den i den nya tråden.
•
Lästips:
Introducerat trådar i Java
•
•
e-bok: Kap 1 ( +2).
kompendium: Kap 1 + 2
31