Realtidssystem. - Introduktion, jämlöpande exekvering - EDAF85 - Realtidssystem (Helsingborg) Elin A. Topp. Föreläsning 1

Realtidssystem - Introduktion, jämlöpande exekvering - EDAF85 - Realtidssystem (Helsingborg) Elin A. Topp Föreläsning 1 Kursens innehåll motsvarar tidigare omgångar under beteckning EDA698 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 4 övningar / frågestunder uppgifter, både teoretiska och praktiska, delvis från gamla tentor, 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! laborationsuppgifterna kan tas upp och börjar bearbetas (design) 3 obligatoriska laborationer laborationsförberedande övningar ska avslutas med redovisning av skriftlig designförslag, godkänt design behövs inför praktisk redovisning! FÖRBEREDELSE: grupp 1 kl 10-12, grupp 2 kl 13-15 (med undantag lv 6) 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/ Allmän information, laborationsanvisningar, Eclipse-workspace Ex-tentor Föreläsningsbilder Nyheter (kolla regelbundet) Obligatoriskt Kursmaterial 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) 08/2017) 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

Innehåll 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

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 8

Jämlöpande aktiviteter Laga mat medan en annan dukar? 8

Jämlöpande aktiviteter Laga mat medan en annan dukar? En kör, en läser kartan? 8

Jämlöpande aktiviteter Laga mat medan en annan dukar? En kör, en läser kartan? Stryka skjortor och lyssna på musik? 8

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? 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 Styra temperaturen i plastmassan (period) och pistongen (evenemang) samtidigt, utan att det blir fel i en av styrningarna. doheat temp ~ dopush dopull isempty isin isout 10

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 ~ dopush dopull isin isout Vad kan gå fel här? temp isempty 11

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); doheat ~ temp // Aktivitet 2: Pistong while( true){ await( isempty); on( dopush); await( isout); off( dopush); on( dopull); await( isin); off( dopull); dopush dopull isin isout isempty 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

Realtidskrav Ett realtidssystem måste utföra alla beräkningar logiskt korrekt reagera på inmatningar jämlöpande alltid ha konsistent data att arbeta med producera alla (del-)resultat i tid 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 semaforer monitorer meddelanden i kö (mailbox / event queue) OS-processer OS-Semafor resurs fil, fil-lås pipe, socket Inbyggda trådar Semafor eller hårdvara Inbyggd minne nätverk, fieldbus sub-millisekund millisekund microsekunder vårdad av OS-process stöd av programmeringsspråk class Thread vårdad av OS / dator stöd av OS / API classes System, Runtime, Process vårdad av hårdvaran stöd av programmeringsspråk class Thread EDAF85 15

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. 17

Exekveringstillstånd Due to scheduler / kernel / OS Running Priority, time-sharing Ready Due to application By this : wait, synchronized call Blocked By other: notify, synchronized return Schemaläggningstillstånd (scheduling state) Running Ready Blocked Kontext PC (Program Counter), SP (stack pointer) Data (beroende på tillämpning) Registerinnehåll 18

Kontextbyte (Context switch) 19

Kontextbyte (Context switch) Kontexten av ett program / en tråd är all specifik data som tråden behöver ha med sig 19

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. 19

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 19

Pre-emption 20

Pre-emption Det finns olika strategier för tillåtelse av kontextbyten: 20

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. 20

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) 20

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). 20

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! 21

Java? Java! Java erbjuder abstraktionerna och den flexibiliteten och säkerheten som behövs för att kunna bygga flexibla, komplexa system. 21

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: 21

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 22

class Thread java.lang.thread 22

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. 22

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. 22

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(): 22

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(); //... do some more stuff... myact1.join(); 24

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; Thread(); Thread( Runnable target); void start(); void run(); static Thread currentthread(); void setpriority( int pri); int getpriority(); static void sleep( long t); static void yield(); void interrupt(); boolean isinterrupted(); static boolean interrupted(); boolean isalive(); void join(); void join( long t); // Highest possible priority // Lowest possible priority // Default priority // Use run in subclass // Use run in `target // Create thread which calls `run // Work to be defined by subclass // Get currently executing thread // Change the priority to `pri // Returns this thread s priority // Suspend execution at least `t ms // Reschedule to let others run // 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 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 ) 27

Kapplöpning (och run vs start ) class HelloWorld extends Thread { public static void main( String[] arg) { System.out.print( Hello ); new HelloWorld().run(); System.out.println( World! ); public void run() { System.out.print( and goodbye ); 27

Kapplöpning (och run vs start ) class HelloWorld extends Thread { public static void main( String[] arg) { System.out.print( Hello ); new HelloWorld().run(); class HelloWorld extends Thread { public static void main( String[] arg) { System.out.print( Hello ); new HelloWorld().start(); System.out.println( World! ); System.out.println( World! ); public void run() { System.out.print( and goodbye ); public void run() { System.out.print( and goodbye ); 27

Kapplöpning (och run vs start ) class HelloWorld extends Thread { public static void main( String[] arg) { System.out.print( Hello ); new HelloWorld().run(); class HelloWorld extends Thread { public static void main( String[] arg) { System.out.print( Hello ); new HelloWorld().start(); System.out.println( World! ); System.out.println( World! ); public void run() { System.out.print( and goodbye ); 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: A: Läs 5000 B: Läs 5000 A: Belopp = 5000-1000 B: Belopp = 5000 + 10000 A: Skriv 4000 B: Skriv 15000 A: Läs 5000 Situation 2: B: Läs 5000 B: Belopp = 5000 + 10000 B: Skriv 15000 A: Belopp = 15000-1000 A: Skriv 4000 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 30

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? 30

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 30

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 30

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

Sammanfattning 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 Introducerat trådar i Java 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: e-bok: Kap 1 ( +2). kompendium: Kap 1 (Introduction) + 2-1 (Threads) 31