RTP

RTP
Real-Time Programmatuur
hoofdstuk 7:
concurrent
programming
Yolande Berbers
Programmatuur voor real-time controle
slide 1
RTP
kenmerken van een RTS
(copie van slide van H1)

verschillende software componenten zijn gelijktijdig actief
 de apparaten in de omgeving werken gelijktijdig
 deze gelijktijdigheid wordt het best gerealiseerd door
gelijktijdig uitvoerende software componenten
 meer en meer real-time systemen zijn gedistribueerde systemen
 dit vraagt ondersteuning van programmeertalen en/of systemen
Yolande Berbers
Programmatuur voor real-time controle
slide 2
RTP

gelijktijdigheid: inleiding
Multiprogrammatie
 gelijktijdige processen
 processen: onafhankelijk of samenwerkend

Monoprocessor
 multiplexing van de CPU

Multiprocessor
 processen voeren echt gelijktijdig uit
Yolande Berbers
Programmatuur voor real-time controle
slide 3
RTP

samenwerkende processes
samenwerkende processen:
 elke proces wordt beïvloed door of beïnvloed andere processen
 ze delen informatie (gegevens, toestandsinformatie, …)
 veronderstelt “communicatie mechanisme”

voordelen:
 modulariteit
 versnelling
monoprocessor: als ene moet wachten kan andere verder
 multiprocessor: werkelijk in parallel

Yolande Berbers
Programmatuur voor real-time controle
slide 4
RTP


communicatie mechanismen
gedeeld geheugen (zie H8)
booschappen (zie H9)
 zenden - ontvangen

sturen van events (zie H11)
 asynchroon
Yolande Berbers
Programmatuur voor real-time controle
slide 5
RTP



gedeeld geheugen
processen delen stuk van geheugen
besturingssyst.oproepen voor export / import geheugen
communicatie zonder tussenkomst besturingssysteem
Yolande Berbers
Process A
Process B
Import
Export
Store Ri,xyz
Load Rj,xyz
Programmatuur voor real-time controle
slide 6
RTP


communicatie met boodschappen
geen gedeeld geheugen
besturingssysteemoproepen voor zenden / ontvangen
van boodschappen
Process A
Send
Yolande Berbers
besturingssysteem
Process B
Receive
Programmatuur voor real-time controle
slide 7
RTP


events (zie H11)
vergelijkbaar met interrupts
besturingssyst.oproep voor signaleren van event (kill) /
voor aanduiden van handler (signal)
(volgt het resumptionmodel)
Process A
Kill
Yolande Berbers
Process B
Signal
Programmatuur voor real-time controle
slide 8
RTP concurrent programming: inleiding

concurrent programming = notaties en technieken voor
 uitdrukken van potentieel parallellisme
 oplossen van synchronisatie en communicatie

concurrent programming biedt
 abstractiemechanismen om parallellisme te beschrijven
 onafhankelijk van de implementatiedetails

de implementatie van parallellisme
 onderwerp van computersystemen (hardware en software)
 is onafhankelijk van concurrent programming
Yolande Berbers
Programmatuur voor real-time controle
slide 9
RTP

seq. vs concurrent prog. talen
sequentiële prog.talen: Pascal, C, C++, Fortran, COBOL
 programma’s hebben slechts 1 controledraad (Engels: thread)
 ze voeren uit, bevel per bevel, totdat het programma eindigt
 het pad door het programma kan variëren al naar gelang de
invoer, maar bij gelijke invoer heb je een gelijk pad

‘concurrent’ programmeertalen (programmeertalen voor
gelijklopende onderdelen) bevatten de notie van proces
 elke proces heeft (tenminste) 1 controledraad
 implementatie van processen:
uitvoering op 1 enkele processor (multiprogrammatie)
 uitvoering op multiprocessor (met gedeeld geheugen)
 uitvoering op multicomputer (met gescheiden geheugen)
 concurrent slaat op potentieel parallellisme

Yolande Berbers
Programmatuur voor real-time controle
slide 10
RTP
een proces en zijn levencyclus
niet bestaand
niet bestaand
Proces
Code
PC
Data
+ Stack
gecreëerd
initialiserend
beëindigd
uitvoerbaar
Yolande Berbers
Programmatuur voor real-time controle
slide 11
RTP

seq. vs concurrent prog. talen
RTSS (run-time support system)
 heeft de taak van het creëren en initialiseren van een proces
 eventueel ook van het schedulen van de verschillende
controledraden
 wordt meestal door de compiler gegenereerd

alternatief voor concurrent programmeertalen
 gescheiden processen schrijven met een sequentiële taal
 de mogelijkheden van het besturingssysteem gebruiken om
gelijktijdige uitvoering te bekomen
Yolande Berbers
Programmatuur voor real-time controle
slide 12
RTP

proces, controledraad
processen
 worden voorzien in alle besturingssystemen
 elke proces voert uit in een eigen virtuele machine, zonder
interferentie van andere processen (logisch gezien alsof ze het
enige proces zijn)

controledraden (threads)
 soort subproces binnen een klassiek proces
 alle controledraden hebben toegang tot hele virtuele machine
 de programmeur en de taal moeten de controledraden voor
elkaar beschermen
Yolande Berbers
Programmatuur voor real-time controle
slide 13
RTP
Threads
Process
Threads
Code
Code
PC
PC
PC
PC
Data
+ Stack
Data
+ Stack
Thread, LWP (Lightweight Process)
Yolande Berbers
Programmatuur voor real-time controle
slide 14
RTP
Threads
Process
Process
Registers
Registers
Registers
PC
Code
Data
Registers
Registers
Registers
Other state ...
Stack
PC
Code
Data
Other state ...
PC
Stack
Stack
Registers
Registers
Registers
Other state ...
Resources
Resources
Yolande Berbers
Programmatuur voor real-time controle
slide 15
RTP

Threads
Thread
 own state
IC, registers, CC, …, stack (+ SP)
 code, data, other resources: shared

Disadvantage
 no protection between threads of 1 task

Advantages:
 context switch = less overhead
 thread creation / termination = cheap
Yolande Berbers
Programmatuur voor real-time controle
slide 16
RTP
Threads
Implementation
User-Level Threads
Supported by OS

Library Routines

SVC CREATE-THREAD

Switching = Fast!

More Overhead

Blocking SVC!
  threads blocked!

Blocking SVC
 other threads still run

Scheduling (process)

Scheduling (thread)

E.g. Unix

E.g. OS/2, Solaris, ...
Yolande Berbers
Programmatuur voor real-time controle
slide 17
RTP
Threads
Client
Server
Client
Client
Server
Client
Yolande Berbers
Programmatuur voor real-time controle
slide 18
RTP
Kernel
Threads
Switch
Blocking
SVC
Sched.
Multi-CPU
Overhead
Switch
thread
by kernel:
Fair (?)
# in Parallel
Lib.
Fast!
Routine
(user level)
Yolande Berbers
Wait (block Progr. (do
process)
it yourself)
Programmatuur voor real-time controle
Max. 1
slide 19
RTP

Threads
Kernel (OS):
 single-threaded vs multi-threaded
 single-thread:
at most 1 process active in kernel
 multi-thread:
many processes active in kernel
 synchronization! (shared data structures)
Yolande Berbers
Programmatuur voor real-time controle
slide 20
RTP

seq. vs concurrent prog. talen
discussie: op welk niveau moet concurrency aangeboden
worden: door de taal of door het besturingssysteem ?
 Ada en Java bieden concurrency in de taal
 C en C++ niet
Yolande Berbers
Programmatuur voor real-time controle
slide 21
RTP

seq. vs concurrent prog. talen
voordelen van concurrent programmeertalen
 beter leesbare en onderhoudbare code
 draagbaarder over meerdere besturingssystemen heen
 soms is er geen besturingssysteem op een real-time systeem
 de compiler kan op een aantal zaken testen

voordelen combinatie sequentiële taal + besturingssyst
 gemakkelijker om programma's geschreven in verschillende
talen te combineren
 op sommige besturingssystemen is het moeilijk om sommige
concurrent taalmodellen te implementeren
 omdat er standaarden zijn voor besturingssystemen, zijn de
programma's draagbaarder
Yolande Berbers
Programmatuur voor real-time controle
slide 22
RTP

constructies voor concurrent programmeren
3 fundamentele faciliteiten
 uitdrukken van gelijktijdig uitvoeren (door de notie van proces)
 synchronisatie tussen processen
 communicatie tussen processen

3 verschillende soorten relaties
 onafhankelijk
 samenwerkend
 in competitie
Yolande Berbers
Programmatuur voor real-time controle
slide 23
RTP

gelijktijdig uitvoeren
verschillen tussen procesmodellen
 structuur
 niveau
 granulariteit
 initialisatie
 beëindiging
 relaties tussen gecreëerd proces en andere
 voorstelling
Yolande Berbers
Programmatuur voor real-time controle
slide 24
RTP

gelijktijdig uitvoeren
structuur
 statisch
aantal processen is vast
 dit aantal is gekend tijdens compilatie
 dynamisch
 aantal processen kan variëren van uitvoering tot uitvoering


niveau
 vlak
processen enkel gedefinieerd op hoogste niveau
 genest
 processen kunnen een hiërarchie vormen: processen
kunnen andere processen starten (vader/kind)

Yolande Berbers
Programmatuur voor real-time controle
slide 25
RTP

gelijktijdig uitvoeren
granulariteit
 fijn
het is ‘goedkoop’ om processen te creëren
 in een typisch programma worden er veel gecreëerd voor
telkens een hele kleine taak
 grof
 het is ‘duur’ om een proces te creëren
 er worden geen grote aantallen processen gecreëerd


initialisatie
 parameters doorgeven
 expliciete communicatie na creatie
Yolande Berbers
Programmatuur voor real-time controle
slide 26
RTP

gelijktijdig uitvoeren
beëindiging
 beëindigen van de code
 door uitvoering van een specifiek ‘zelfmoord’ bevel
 expliciete moord door een ander proces
 uitvoering van een niet-opgevangen uitzondering
 nooit (oneindige lus)
 wanneer niet meer nodig (geen communicatie meer mogelijk)

relatie tussen gecreëerd proces en andere
 vader/kind: vader (creërend proces) wacht tot het kind
gecreëerd en geïnitialiseerd is
 hoeder/afhankelijke: hoeder kan niet het blok verlaten waarin de
afhankelijke is gecreëerd, voordat de afhankelijke beëindigd is
 vader en hoeder kunnen maar hoeven niet zelfde proces te zijn
Yolande Berbers
Programmatuur voor real-time controle
slide 27
RTP
Process States
niet bestaand
niet bestaand
gecreëerd
wacht op
init kind
Yolande Berbers
initialiserend
beëindigd
uitvoerbaar
wacht op
afhank. einde
Programmatuur voor real-time controle
slide 28
RTP

gelijktijdig uitvoeren
terminologie bij object-georiënteerde systemen
 elke proces is een object (maar niet omgekeerd)
 actieve objecten: nemen spontaan acties
 reactieve objecten
reageren enkel op invocaties
(= operaties die uitgevoerd worden op een object)
 bv resources (hulpmiddelen)
 passieve objecten
 reactieve objecten waarvan de operaties altijd kunnen
uitgevoerd worden
 beschermde resource: beschermd door passieve entiteit
 server: resource waarbij de controle actief is (proces is nodig)

Yolande Berbers
Programmatuur voor real-time controle
slide 29
RTP

gelijktijdig uitvoeren
voorstelling: 4 basis mechanismen
 co-routines
 fork/join
 cobegin/coend
 expliciete procesdeclaratie
Yolande Berbers
Programmatuur voor real-time controle
slide 30
RTP

procesvoorstelling: co-routines
controle wordt expliciet doorgegeven
(sleutelwoord resume): er is geen return-bevel

relatie is symmetrisch

een routine A voert ‘resume B’ uit
 routine A stopt uitvoeren
 routine B voert uit vanaf het punt waar het vroeger gestopt was
 routine A bewaart alle statusinformatie, zodat het later op
hetzelfde punt kan verder gezet worden
Yolande Berbers
Programmatuur voor real-time controle
slide 31
RTP
procesvoorstelling: co-routines
Co-routine A
1
6
Co-routine B
2
3
resume B
7
resume B
12 11
Co-routine C
4
resume C
8
10
5
resume A
9
resume A
6
13
14
12
resume B
15
resume C
Yolande Berbers
Programmatuur voor real-time controle
slide 32
RTP

procesvoorstelling: fork en join
methode:
 C := fork F
 join C;

een nieuw proces start de uitvoering van F
oproepend proces gaat ook verder
oproepend proces wacht op einde F
gebruikt in POSIX
 bij fork kun je parameters doorgeven
 met wait wacht je, 1 waarde keert terug
 flexibel maar niet erg gestructureerd
geven gemakkelijk aanleiding tot fouten
 hoeder moet bv expliciet wachten op al zijn kinderen

Yolande Berbers
Programmatuur voor real-time controle
slide 33
RTP
procesvoorstelling: fork en join
tijdsas
fork
fork
P
F
P
F
join
join
vaderproces voert
join uit voordat kind
beëindigd is
Yolande Berbers
kindproces heeft
gedaan voordat vader
join uitvoert
Programmatuur voor real-time controle
slide 34
RTP procesvoorstelling: cobegin/coend

na cobegin (of parbegin) staan een aantal blokken die in
parallel uitgevoerd worden (ze worden allemaal samen
opgestart)

het vaderproces wacht, of voert 1 van de blokken uit

bij coend (of parend) wordt er gewacht tot alle blokken
beëindigd zijn
Yolande Berbers
Programmatuur voor real-time controle
slide 35
RTP procesvoorstelling: cobegin/coend
tijdsas
cobegin
coend
Yolande Berbers
Programmatuur voor real-time controle
slide 36
RTP

procesvoorstelling: ex-/impliciete procesdeclaratie
expliciete procesdeclaratie
 routines geven tekstueel aan of ze door een apart proces
uitgevoerd worden (modula 1)
 het is niet meer de oproeper van de routine die aangeeft dat
een nieuw proces gecreëerd moet worden

impliciete procesdeclaratie
 alle processen die gedeclareerd worden binnen een blok
beginnen in parallel uit te voeren bij begin van het blok (Ada)
Yolande Berbers
Programmatuur voor real-time controle
slide 37
RTP

gelijktijdige uitvoering in Ada
benaming voor sequentieel proces: task
 kan gedeclareerd worden
 wordt gecreëerd wanneer declaratie zichtbaar wordt: impliciet
 procedure eenvoudige_taak eindigt niet voordat task A eindigt
procedure eenvoudige_taak is
task A;
task body A is
-- lokale declaraties
begin
-- bevelen van de taak A
end A;
begin
... -- taak A begint met uitvoeren voor het eerste bevel in dit blok
end eenvoudige_taak;
Yolande Berbers
Programmatuur voor real-time controle
slide 38
RTP


gelijktijdige uitvoering in Ada
het is mogelijk een task-type te definiëren
maakt het mogelijk om een rij van taken te declareren
task type T;
type Long is array (1..100) of T;
L: Long;
task body T is
-- lokale declaraties
begin
-- bevelen van de taak T
end T;
Yolande Berbers
Programmatuur voor real-time controle
slide 39
RTP

gelijktijdige uitvoering in Ada
parameters kunnen doorgegeven worden bij initialisatie
procedure Main is
type Dimension is (Xplane, Yplane);
task type Control (Dim: Dimension);
C1: Control(Xplane);
C2: Control(Yplane);
task body Control is
-- lokale declaraties
begin
-- bevelen van de taak Control (zie in boek)
end Control;
begin
null;
end Main;
Yolande Berbers
Programmatuur voor real-time controle
slide 40
RTP

gelijktijdige uitvoering in Ada
uitzonderingen
 bij initialisatie: de creërende taak krijgt de uitzondering
‘Tasking_error’
 tijdens uitvoering:


de nieuwe taak mag de uitzonderingen opvangen

niet opgevangen uitzondering: nieuwe taak wordt beëindigd
beëindiging van een taak
 de taak beëindigt zijn uitvoering (normaal of door uitzondering)
 de taak voert het bevel ‘terminate’ uit (zie later)
 de taak is gestopt door een andere taak (via abort)
Yolande Berbers
Programmatuur voor real-time controle
slide 41
RTP gelijktijdige uitvoering in POSIX

twee mechanismen
 voor processen
fork() creëert een exacte copie van het oproepende proces
 met wait() kan het oproepende proces wachten op het
gecreëerde
 voor threads
 allerhande routines voor creatie en beheer van threads
 vaak met veel parameters
 nogal complex


beide mechanismen situeren zich op het niveau van het
besturingssysteem (zijn dus niet in een taal geïntegreerd)
Yolande Berbers
Programmatuur voor real-time controle
slide 42
RTP gelijktijdige uitvoering in POSIX

threads in POSIX
 alle threads hebben attributen (vb stack size)

attribute object om deze attributen te manipuleren
typedef … pthread_t;
typedef … pthread_attr_t;
int pthread_attr_init (pthread_attr_t *attr);
/* initializes a thread attribute pointed at by attr to default values */
int pthread_setstacksize (pthread_attr_t *attr, size_t stacksize);
/* set the stack size of a thread attributed */
int pthread_attr_setstrackaddr (pthread_attr_t *attr, void *stackaddr);
/* set the stack address of a thread attribute */
Yolande Berbers
Programmatuur voor real-time controle
slide 43
RTP gelijktijdige uitvoering in POSIX

threads in POSIX
 alle threads hebben een identifier, uniek in het proces

thread kan deze identifier bekomen via pthread_self
typedef … pthread_t;
pthread pthread_self (void);
/* return the thread_id of the calling thread */
int pthread_equal (pthread_t t1, pthread_t t2);
/* compare two thread ids */
Yolande Berbers
Programmatuur voor real-time controle
slide 44
RTP gelijktijdige uitvoering in POSIX

threads in POSIX
 thread is klaar om uit te voeren na creatie

pthread_create, 4 argumenten: thread identifier, attributes,
functie met de code, parameters die doorgegeven moeten
worden
int pthread_create (pthread_t *thread,
const pthread_attr_t *attr,
void * (*start_routine) (void*),
void *arg);
/* create a new thread with the given attributes and call the
given start_routine with the given argument */
Yolande Berbers
Programmatuur voor real-time controle
slide 45
RTP gelijktijdige uitvoering in POSIX

threads in POSIX
 thread kan eindigen
door oproep van pthread_exit
 bij ontvangst van een signal (zie hoofdstuk 10)
 gestopt door pthread_cancel

int pthread_exit (void *value_ptr);
/* terminate the calling thread and make the pointer value_ptr
available to any joining thread */
Yolande Berbers
Programmatuur voor real-time controle
slide 46
RTP gelijktijdige uitvoering in POSIX

threads in POSIX
 wachten op het einde van een andere thread: pthread_join
int pthread_join (pthread_t thread, void **value_ptr);
/* suspends the calling thread until the named thread has
terminated, and returned values are pointed at by
value_ptr */
Yolande Berbers
Programmatuur voor real-time controle
slide 47
RTP gelijktijdige uitvoering in POSIX

threads in POSIX
 opkuisen na uitvoering en vrijgave van geheugen:
bij join
 met detach attribute: geen join nodig

int pthread_attr_setdetachstate (pthread_attr_t *attr,
int *detachstate);
/* set the detach state of the attribute */
int pthread_detach (pthread_t thread);
/* the storage space associated with the given thread may be
reclaimed when the thread terminates */
Yolande Berbers
Programmatuur voor real-time controle
slide 48
RTP
Robot Arm in C/POSIX
#include <pthread.h>
pthread_attr_t attributes;
pthread_t xp, yp, zp;
typedef enum {xplane, yplane, zplane} dimension;
int new_setting(dimension D);
void move_arm(int D, int P);
void controller(dimension *dim)
{
int position, setting;
position = 0;
while (1) {
setting = new_setting(*dim);
position = position + setting;
move_arm(*dim, position);
};
/* note, process does not terminate */
}
Yolande Berbers
Programmatuur voor real-time controle
slide 49
int main() {
dimension X, Y, Z;
void *result;
Need JOIN as when a process terminates,
all its threads are forced to terminate
X = xplane,
Y = yplane;
Z = zplane;
PTHREAD_ATTR_INIT(&attributes);
/* set default attributes */
PTHREAD_CREATE(&xp, &attributes, (void *)controller, &X);
PTHREAD_CREATE(&yp, &attributes, (void *)controller, &Y);
PTHREAD_CREATE(&zp, &attributes, (void *)controller, &Z);
PTHREAD_JOIN(xp, &result);
/* need to block main program */
exit(-1); /* error exit, the program should not terminate */
}
SYS_CALL style indicates a call to
sys_call with a check for error returns
RTP

Threads in Java
Two techniques:
 subclassing Thread and overriding run
 Implementing Runnable Interface

for classes that extend another class

no multiple inheritence
Yolande Berbers
Programmatuur voor real-time controle
slide 51
RTP
Threads in Java
class FirstThread extends Thread {
public FirstThread (String str) { super(str); }
public void run ()
{ … what the thread should do … }
}
class SecondThread extends Thread {
public SecondThread (String str) { super(str); }
public void run () { … what this thread should do … }
}
public class TwoThreadsTest {
public static void main (String [] args) {
new FirstThread(“First”).start();
new SecondThread(“Second”).start();
}
Yolande Berbers
Programmatuur voor real-time controle
slide 52
RTP
Threads in Java
class Name extends Whatever implements Runnable {
public Name (...) { ... }
public void run ()
{ … what the thread should do … }
}
public class ThreadsTest {
public static void main (String [] args) {
Name obj = new Name (…);
Thread objThread = new Thread(obj, “NameThread”);
objThread.start();
}
}
Yolande Berbers
Programmatuur voor real-time controle
slide 53
RTP

Threads in Java
Lifecycle of a thread
yield( )
start( )
new Thread
Runnable
block on I/O
sleep( millisec )
wait for a condition
Not Runnable
run() terminates
Dead
Yolande Berbers
Programmatuur voor real-time controle
slide 54
RTP
Robot Arm Example
public class UserInterface
{
public int newSetting (int Dim) \{ ... \}
...
}
public class Arm
{
public void move(int dim, int pos) \{ ... \}
}
UserInterface UI = new UserInterface();
Arm Robot = new Arm();
Yolande Berbers
Programmatuur voor real-time controle
slide 55
RTP
Robot Arm Example
public class Control extends Thread
{
private int dim;
public Control(int Dimension) // constructor
{
super();
dim = Dimension;
}
public void run()
{
int position = 0;
int setting;
while(true)
{
Robot.move(dim, position);
setting = UI.newSetting(dim);
position = position + setting;
}
Yolande Berbers}
Programmatuur voor real-time controle
slide 56
RTP
Robot Arm Example
final int xPlane = 0;
final int yPlane = 1;
final int zPlane = 2;
// final indicates a constant
Control C1 = new Control(xPlane);
Control C2 = new Control(yPlane);
Control C3 = new Control(zPlane);
C1.start();
C2.start();
C3.start();
Yolande Berbers
Programmatuur voor real-time controle
slide 57
RTP
Alternative Robot Control
public class Control implements Runnable
{
private int dim;
public Control(int Dimension)
{
dim = Dimension;
}
// constructor
public void run()
{
int position = 0;
int setting;
while(true)
{
Robot.move(dim, position);
setting = UI.newSetting(dim);
position = position + setting;
}
}
Yolande
} Berbers
Programmatuur voor real-time controle
slide 58
RTP
Alternative Robot Control
final int xPlane = 0;
final int yPlane = 1;
final int zPlane = 2;
Control C1 = new Control(xPlane); // no thread created yet
Control C2 = new Control(yPlane);
Control C3 = new Control(zPlane);
// constructors passed a Runnable interface and threads created
Thread X = new Thread(C1);
Thread Y = new Thread(C2);
Thread Z = new Thread(C2);
X.start(); // thread started
Y.start();
Z.start();
Yolande Berbers
Programmatuur voor real-time controle
slide 59
RTP
Java Thread States
non-existing
Create thread object
new
start
executable
run method exits
stop, destroy
blocked
Yolande Berbers
dead
Programmatuur voor real-time controle
slide 60
RTP






Points about Java Threads
Java allows dynamic thread creation
Java (by means of constructor methods) allows arbitrary data
to be passed as parameters
Java allows thread hierarchies and thread groups to be
created but there is no master or guardian concept; Java
relies on garbage collection to clean up objects which can no
longer be accessed
The main program in Java terminates when all its user threads
have terminated (see later)
One thread can wait for another thread (the target) to
terminate by issuing the join method call on the target's
thread object.
The isAlive method allows a thread to determine if the
target thread has terminated
Yolande Berbers
Programmatuur voor real-time controle
slide 61
RTP


A Thread Terminates:
when it completes execution of its run method either
normally or as the result of an unhandled exception;
via its stop method — the run method is stopped and the
thread class cleans up before terminating the thread
(releases locks and executes any finally clauses)
 the thread object is now eligible for garbage collection.
 if a Throwable object is passed as a parameter to stop,
then this exception is thrown in the target thread; this allows
the run method to exit more gracefully and cleanup after itself
 stop is inherently unsafe as it releases locks on objects and
can leave those objects in inconsistent states; the method is
now deemed obsolete (depreciated) and should not be used

by its destroy method being called -- destroy terminates the
thread without any cleanup (never implemented in JVM)
Yolande Berbers
Programmatuur voor real-time controle
slide 62
RTP





Daemon Threads
Java threads can be of two types: user threads or
daemon threads
Daemon threads are those threads which provide general
services and typically never terminate
When all user threads have terminated, daemon threads
can also be terminated and the main program terminates
The setDaemon method must be called before the
thread is started
(Daemon threads provide the same functionality as the
Ada ``or terminate'' option on the select statement)
Yolande Berbers
Programmatuur voor real-time controle
slide 63
RTP

Thread Exceptions
IllegalThreadStateException is thrown when:
 start method is called and thread has already been started
 the setDaemon method has been called and the thread has
already been started

SecurityException is thrown by security manager when:
 a stop or destroy method has been called on a thread for
which the caller does not have the correct permissions for the
operation requested

NullPointerException is thrown when:
 A null pointer is passed to the stop method

InterruptException is thrown if a thread which has
issued a join method is woken up by the thread being
interrupted rather than the target thread terminating
Yolande Berbers
Programmatuur voor real-time controle
slide 64
RTP


Ada, Java and C/POSIX
Ada and Java provide a dynamic model with support for
nested tasks and a range of termination options.
POSIX allows dynamic threads to be created with a flat
structure; threads must explicitly terminate or be killed.
Yolande Berbers
Programmatuur voor real-time controle
slide 65
RTP een eenvoudig real-time systeem



aflezen van temperatuur en aanpassen van verwarming
aflezen van druk en aanpassen van pomp
telkens de waarden ook op het scherm printen
thermokoppel
T
drukmeter
P
verwarming
S
pomp
scherm
Yolande Berbers
Programmatuur voor real-time controle
slide 66
RTP een eenvoudig real-time systeem

3 implementatiemethoden
 1 sequentieel programma
houdt geen rekening met het feit dat T, P en S logisch gezien
gelijktijdig en onafhankelijk van elkaar zijn
 vraagt geen ondersteuning van het run-time- of
besturingssysteem
 3 sequentiële programma's
 T, P en S zijn geschreven in een sequentiële taal
 met primitieven van het besturingssysteem worden 3
processen hiervoor gecreëerd
 1 concurrent programma
 T, P en S zijn 3 threads
 run-time ondersteuning is nodig

Yolande Berbers
Programmatuur voor real-time controle
slide 67
RTP een eenvoudig real-time systeem
 1 sequentieel programma, houdt geen rekening met feit dat T, P
en S logisch gezien gelijktijdig en onafhankelijk van elkaar zijn
procedure Controller is
TR : Temp_Reading;
PR : Pressure_Reading;
HS : Heater_Setting;
PS : Pressure_Setting;
begin
loop
Read(TR); Temp_Convert(TR, HS); Write(HS); Write(TR);
Read(PR); Pressure_Convert(PR, PS); Write(PS); Write(PR);
end loop;
end Controller;
Yolande Berbers
Programmatuur voor real-time controle
slide 68
RTP een eenvoudig real-time systeem

1 sequentieel programma: bespreking
 temperatuurmetingen en drukmetingen gebeuren met gelijke
intervallen (misschien hoeft dat niet in de praktijk)

mogelijke oplossing: een aantal if-then-else bevelen toevoegen
 wanneer het programma bezig is met temperatuur kan er geen
aandacht gegeven worden aan de druk en vice-versa
 als probleem met lezen van 1 van de 2 metingen blokkeert het geheel
(dus ook het deel dat daar niets mee te maken heeft)

mogelijke oplossing: testen of er kan gelezen worden (p. 195)

nadeel is hier wel dat men test via ‘polling’ (busy waiting)

dit vraagt veel processortijd
 belangrijkste opmerking: geen weerspiegeling van werkelijkheid, waar
temperatuur en druk volledig onafhankelijke subsystemen zijn
Yolande Berbers
Programmatuur voor real-time controle
slide 69
RTP een eenvoudig real-time systeem
 3 sequentiële programma's (met primitieven van het
besturingssysteem worden 3 processen hiervoor gecreëerd)
package Operating_System_Interface is
type Thread_Id is private;
type Thread is access procedure;
function Create_Thread (Code: Thread) return Thread_Id;
...
end Operating_System_Interface;
package processes is
procedure Temp_Controller;
procedure Pressure_Controller;
end processes;
package body processes is ...
Yolande Berbers
Programmatuur voor real-time controle
slide 70
RTP een eenvoudig real-time systeem
 3 sequentiële programma's (met primitieven van het
besturingssysteem worden 3 processen hiervoor gecreëerd)
procedure Controller is
TC, PS: Thread_Id;
begin
TC := Create_Thread (Temp_Controller’Access);
PC := Create_Thread (Pressure_Controller’Access);
end Controller;

bespreking
 doordat de taal geen ondersteuning biedt is dit moeilijk te
schrijven en te onderhouden (zeker voor grotere systemen)
 bv niet erg duidelijk uit de code welke procedures nu gewone
zijn en welke bedoeld zijn om als proces uit te voeren
Yolande Berbers
Programmatuur voor real-time controle
slide 71
RTP een eenvoudig real-time systeem
 1 concurrent programma waarbij T, P en S 3 threads zijn
procedure Controller is
task Pressure_Controller;
task Temp_Controller;
task body Temp_Controller is
begin
loop
Read(TR); Temp_Convert(TR, HS); Write(HS); Write(TR);
end loop;
end Temp_Controller ;
task body Pressure_Controller is ...
begin
null;
end Controller ;
Yolande Berbers
Programmatuur voor real-time controle
slide 72
RTP een eenvoudig real-time systeem

1 concurrent programma: bespreking
 de logica van de toepassing is mooi zichtbaar in de code
 dit maakt het geheel leesbaar en onderhoudbaar

probleem dat telkens genegeerd werd: synchronisatie
van de data die naar het scherm gestuurd worden
(zie hoofdstuk 8)
Yolande Berbers
Programmatuur voor real-time controle
slide 73
RTP

seq. vs concurrent prog. talen
voordelen van concurrent programmeertalen
 beter leesbare en onderhoudbare code
 draagbaarder over meerdere besturingssystemen heen
 soms is er geen besturingssysteem op een real-time systeem
 de compiler kan op een aantal zaken testen

voordelen combinatie sequentiële taal + besturingssyst
 gemakkelijker om programma's geschreven in verschillende
talen te combineren
 op sommige besturingssystemen is het moeilijk om sommige
concurrent taalmodellen te implementeren
 omdat er standaarden zijn voor besturingssystemen, zijn de
programma's draagbaarder

Ada/Java: voordelen groter dan nadelen
Yolande Berbers
Programmatuur voor real-time controle
slide 74