Exercises and selected solutions for
TDDC47
Real-time and concurrent
programming
NOTE: This is a revised version of the earlier exercise set for TDDC47
prepared by:
Mehdi Amirijoo
Jonas Elmqvist
Adapted to the English version and to conform to the new content of the
course defined in 2010, by:
Simin Nadjm-Tehrani
Jordi Cucurull
Institutionen för datavetenskap (IDA)
Linköpings universitet
Copyright © 2010 Simin Nadjm-Tehrani
TDDC47 – Real-time and concurrent programming
1. Concurrent programming
1.1
Consider the following processes where critical_section corresponds to a sequence of
statements:
process_A
repeat
...
critical_section;
...
until false;
process_B
repeat
...
critical_section;
...
until false;
process_C
repeat
...
critical_section;
...
until false;
Solve the following problems with the help of semaphores.
(a) Only one process at a time may execute in a critical section.
(b) Max two processes may be present in critical_section at any point in time.
1.2
Consider the following data structures and two processes:
integer
integer
i {initially = 0};
buffer[3];
producer
repeat
i = i + 1;
buffer[i] = funktionA;
until false;
consumer
repeat
temp = buffer[i];
i = i - 1;
until false;
We assume that a fault appears when data is being written to or read from buffer[i] when
i < 1 or i > 3.
(a) Give an example of what can happen in case the producer process and the consumer
process are not synchronized.
(b) Extend the above code with semaphores so that correct program behaviour is
obtained.
1
TDDC47 – Real-time and concurrent programming
1.3
Which problem can show up in the following program and why?
semaphore X {initially = 1};
semaphore Y {initially = 1};
process_A
repeat
...
wait(X);
wait(Y);
kritisk_sektion;
signal(X);
signal(Y);
...
until false;
process_B
repeat
...
wait(Y);
wait(X);
kritisk_sektion;
signal(Y);
signal(X);
...
until false;
1.4
Consider a system with three smoker processes and an agent process. In order to smoke a
cigarette a smoker should acquire three ingredients: tobacco, paper and matches. The
first smoker process has only paper, the second has only tobacco, and the third process
has only matches. The agent process has all three ingredients (the smokers and the agent
have an infinite amount of the ingredients they possess). The agent places two randomly
chosen ingredients on a table. These can be taken by one or more smoker processes who
need the ingredients. If a smoker process has all the three ingredients it can smoke,
whereas if it does not, it must wait. When a smoker process has smoked enough, the
agent is going to place another two ingredients on the table and the scenario is repeated
again.
(a) What can happen if the smoker processes and the agent process are not synchronized?
(b) Write a program that uses semaphores in order to synchronize the smokers and the
agent.
1.5
Consider a system consisting of four resources of the same type that are shared by three
processes. Each process needs two resources. The processes voluntarily give up the
acquired resource and a resource cannot be used by two processes at the same time. Can
the system end up in a deadlock? Why/why not?
2
TDDC47 – Real-time and concurrent programming
1.6
Consider the following view of a given system:
Allocation
A
0
1
1
0
0
P0
P1
P2
P3
P4
B
0
0
3
6
0
C
1
0
5
3
1
Max
D
2
0
4
2
4
A
0
1
2
0
0
B
0
7
3
6
6
Available
C
1
5
5
5
5
D
2
0
6
2
6
A
1
B
5
C
2
D
0
Answer the following questions using the bankers algorithm:
(a) What is the content of the matrix Need?
(b) Is the system in a ”safe” state (according to Banker terminology)?
(c) Process P1 asks for the following further resources (0,4,2,0). Can this request be
granted immediately?
1.7
Consider the following resource picture in a system:
Max
P0
P1
P2
A
0
1
2
B
0
7
3
C
1
5
5
Available
D
2
0
6
A
0
B
6
C
5
D
0
(a) Find a matrix Allocation such that the system is in an unsafe state.
(b) In the unsafe state you have created, will the system necessarily end up in a deadlock
state? In other words, is it possible that the processes complete their executions even
if the system has reached an unsafe state?
1.8
Consider the following resource allocation approach. Processes can request and release
resources at any point in time. If some request is not granted due to insufficient resources,
we can investigate whether the given resource is allocated to some process(es) which is
(are) blocked and are waiting for other resources. If this is the case we disallocate the
resource from a blocked process and give it to the process that requires it. The Need
vector of the blocked process is increased with the corresponding amount of disallocated
resource.
(a) Can the system end up in deadlock? If so give an example of such a case.
3
TDDC47 – Real-time and concurrent programming
(b) Can infinite blocking take place? That is, can a process be deprived from allocating a
resource for ever?
1.9
A system is composed of m resources of the same type that are shared by n processes.
Resources can be requested and released only one at a time. Show that the system cannot
end up in deadlock if the following condition holds:
(i) A process’s maximal need (sum of total potential requests) of resources is
between 1 and m.
(ii) The sum of all maximal need values (max requested) is less than m + n.
4
TDDC47 – Real-time and concurrent programming
2. Scheduling
2.1
Assume that the following processes are given:
Process
Period
A
B
C
10
4
2
Worst case
execution time
1
1
1
(a) Order the process priorities according to Rate Monotonic (RM) policy.
(b) Compute CPU utilisation.
(c) Show an execution trace starting at a critical time point given that RM scheduling is
used.
(d) Compute the response time for A, B och C with the help of exact analysis.
2.2
Create a scenario where you have three processes. Ensure that you set the periods and
worst case execution times so that one process misses some deadline if you use RM
scheduling, and meet all their deadlines if you schedule with earliest deadline first (EDF).
2.3
Assume that we have n processes with periods T1 ,..., Tn and that all processes have the
maximum execution time C.
(a) What is the largest C such that all processes manage their deadline given that EDF is
used to schedule the processes?
(b) For which values of C can one be sure that all processes meet their deadlines when
RM is used for scheduling the processes?
2.4
Consider the following processes where Priority-Ceiling (also called ”Original Ceiling
Priority”) protocol is used for resource management and RM is used for scheduling the
5
TDDC47 – Real-time and concurrent programming
processes. By locking time we mean the maximum duration that a process locks a given
semaphore.
Process
A
B
C
D
Period
100
40
50
1000
Process
A
B
C
D
Semafor
S1
S1
S2
S2
Max. Exec. time
10
12
6
50
Locking time
1
2
1
4
(a) Compute the priority ceiling for each resource.
(b) Compute the blocking component B in the response time for each process.
2.5
Consider the following processes where Immediate-Inheritence (also called ”Immediate
Ceiling Priority”) protocol is used for resource management and RM is used for
scheduling the processes. Locking time denotes how long the process locks the respective
semaphore. Compute the maximum blocking time and the response time for each process.
Process
A
B
C
Period
16
10
8
Max. Exec. time
4
3
2
Process
A
B
B
C
C
C
Semaphore
S1
S1
S2
S1
S2
S3
6
Max. Locking time
1
1
1
1
2
1
TDDC47 – Real-time and concurrent programming
2.6
A system consists of the four aperiodic processes P1, P2, P3 and P4. These processes
share the common resources a, b, c, and d. Consider the following resource use patterns:
Process
P1
P2
P3
P4
Execution pattern
EaabdE
EbbdddE
EbbaccE
EccaE
Priority
4
3
2
1
Release time
8
5
2
0
‘E‘ means executing without using a resource. Whereas ”a”, ”b” etc. represent execution
with the resource a, b, etc. When a resource is allocated to a process, the process is going
to retain the resource until it is not used any more. Assume that the Priority-Ceiling
protocol is used. Show the actual execution sequence based on the above patterns. Use
the attached table (see the last page) for this purpose.
7
TDDC47 – Real-time and concurrent programming
3. Real-time Communication
3.1
Consider a CAN network that consists of 3 nodes, where CSMA/CR is used. Node n1 has
ID 000…00 and sends its frames with a period of 5ms. Node n2 has ID 000…01 and
sends frames with the period 7ms. Node n3 has ID 000…10 and sends frames with the
period 10ms. Each frame is maximally 135 bits and the transmission time ( τ bit ) for a bit
is 1 x 10-6s.
(a) Describe how the nodes are going to agree on the order that the frames are going to
be sent when all nodes send simultaneously. Exemplify with the nodes n1, n2 and n3.
(b) Compute the response time for the frames sent by the nodes n1, n2 and n3 (based on
the time that it takes to send the whole frame).
3.2
Tests performed in the network described in exercise 3.1 have shown that the measured
response time is much larger than expected. One has discovered that this depends on the
scheduling of those processes that generate the frames. For the nodes n1 and n2 a frame is
ready to be sent in the worst case 5ms after the start of their respective periods, that is, the
frame is queued at the latest 5ms after the period start. For node n3 a frame becomes
ready to be sent 8ms after its period start. Consider whether this information affects the
response times, and if so, by how much.
3.3
The message ”STOPENGINE” should be sent over a CAN network. Assume that no
other nodes send for the being, and that each letter consists of 8 bits (1 byte).
(a) Compute the shortest transmission time for the message.
(b) Compute the longest transmission time for the message.
8
TDDC47 – Real-time and concurrent programming
4. Extra exercise
4.1
Compute the maximum and minimum execution time for the following C snippet:
for(y=0;y<200;y++)
{
if(test(y)==1)
{
for(x=0;x<640;x++)
{
if(image[x][y]==1)
{
int weight;
weight=calc_weight(image,x,y);
x_sum+=x*weight;
y_sum+=y*weight;
squares+=weight;
}
}
}
}
Assume that:
- assignment takes 25 cycles
- comparison takes 20 cycles
- addition takes 15 cycles
- multiplication takes 90 cycles
- to call a function takes 50 cycles
- test() takes at most 180 and at least180 cycles
- calc_weigth() takes at most 350 and at least 120 cycles.
In order to simplify we assume all jumps (conditional as well as unconditional) take 0
cycles. Note that the units are cycles in some given processor (all times are fictional).
Note also that ++ and += consist of both addition and assignment.
9
TDDC47 – Real-time and concurrent programming
Suggested solutions
1. Concurrent programming
1.1
(a)
Inför semaforen
semaphore gå_in {initially = 1};
Processernas kod ser ut som följer
process_A
repeat
...
wait(gå_in);
kritisk_sektion;
signal(gå_in);
...
until false;
process_B
repeat
...
wait(gå_in);
kritisk_sektion;
signal(gå_in);
...
until false;
process_C
repeat
...
wait(gå_in);
kritisk_sektion;
signal(gå_in);
...
until false;
(b)
Vi ändrar endast initialvärdet på semaforen, dvs. vi deklarerar gå_in enligt:
semaphore gå_in {initially = 2};
1.2
(a)
Fel uppstår om processen producent exekverar fler än tre gånger i rad, då skrivning
sker till buffer för i > 3. Det omvända gäller för processen konsument då den
exekverar fler än tre gånger i rad (i blir mindre än 1). Dessutom kan bl.a. denna sekvens
av satser ske:
producent: i = i + 1;
konsument: temp = buffer[i];
konsument: i = i - 1;
producent: buffer[i] = funktionA;
Detta innebär tex. att värdet av funktionA kommer att skrivas till fel plats i buffer.
(b)
Vi måste se till att (i) ingen skrivning sker till en redan full buffer, (ii) ingen läsning sker
från en tom buffer och (iii) endast en process kan ändra variabeln i och buffer åt
gången. Den sista punkten innebär att vi har följande kritiska sektioner:
10
TDDC47 – Real-time and concurrent programming
producent:
i = i + 1;
buffer[i] = funktionA;
konsument:
temp = buffer[i];
i = i - 1;
Vi utökar koden med följande:
integer
integer
semaphore
semaphore
semaphore
i {initially = 0};
buffer[3];
innehåller_data {initially = 0};
finns_utrymme {initially = 3};
buffer_läs_skriv {initially = 1};
producent
repeat
wait(finns_utrymme);
wait(buffer_läs_skriv);
i = i + 1;
buffer[i] = funktionA;
signal(buffer_läs_skriv);
signal(innehåller_data);
until false;
konsument
repeat
wait(innehåller_data);
wait(buffer_läs_skriv);
temp = buffer[i];
i = i - 1;
signal(buffer_läs_skriv);
signal(finns_utrymme);
until false;
1.3
Baklås (deadlock) kan uppstå då alla fyra villkor är uppfyllda:
Mutual exclusion: En semafor kan enbart ”allokeras” av en process, där allokeringen sker
med wait().
Hold & wait: En process kan allokera en semafor och sedan vänta på att allokera en
annan semafor. Tex. kan process_A allokera semafor X med wait() och vänta på att
allokera semafor Y.
11
TDDC47 – Real-time and concurrent programming
No preemption: En process ger frivilligt upp en semafor som den har allokerat genom att
anropa signal().
Circular wait: Följande cykel kan uppstå. Process_A har allokerat semafor X och vill ha
semafor Y. Process_B har allokerat semafor Y och vill ha semafor X.
1.4
(a)
Baklås kan uppstå då alla fyra villkor är uppfyllda:
Mutual exclusion: En ingrediens på bordet är en resurs som enbart kan användas av en
rökarprocess, dvs. man kan inte dela på denna resurs.
Hold & wait: En rökarprocess har en ingrediens och väntar på den andra ingrediensen.
No preemption: En ingrediens blir tillgänglig när en rökarprocess slutar röka. En
rökarprocess ger frivilligt upp resursen.
Circular wait:
P = papper, Ts= tändstickor, Tb = tobak. P1 = process 1, P2 = process 2, P3 = process 3
Agenten har inte placerat ut ingredienser ännu:
Agenten placerar ut två ingredienser på bordet och en circular wait uppstår:
12
TDDC47 – Real-time and concurrent programming
(b)
Gemensamma datastrukturer är:
semaphore ingrediens_par[3] {initially=0};
// ingrediens_par[1] = tobak_papper
// ingrediens_par[2] = tobak_tändstickor
// ingrediens_par[3] = papper_tändstickor
semaphore agent {initially=1};
Koden för agenten är:
agent_process
…
repeat
wait(agent);
sätt i till ett värde mellan 1 och 3; //välj två ingredienser
placera ingredienserna på bordet;
signal(ingrediens_par[i]);
until false;
Koden för processerna är (0<i<4):
rökar_process_i
…
repeat
wait(ingrediens_par[i]);
rök;
signal(agent);
until false;
1.5
Anta värsta fallet: varje process har allokerat en resurs. Då finns det en resurs som inte är
allokerad. Denna fria resurs kan allokeras av en av processerna som har då sina två
resurser och därmed kan avsluta. Detta medför att det nu finns två fria resurser som de
återstående processerna kan allokera och därmed kan även de avsluta. Circular wait kan
därmed inte uppstå och således kan inte systemet hamna i baklås.
13
TDDC47 – Real-time and concurrent programming
1.6
(a) Need = Max - Allocation
Need
A
0
0
1
0
0
P0
P1
P2
P3
P4
B
0
7
0
0
6
C
0
5
0
2
4
D
0
0
2
0
2
(b)
Ja. Genom att använda oss av säkerhets algoritmen (safety algorithm) kan vi hitta en
sekvens <P0,P2,P1,P3,P4> som visar att systemet är i ett säkert tillstånd.
(c)
Ja. Vi använder oss av algoritmen för hantering av resursbegäran (resource request
algorithm) för att visa detta:
(i) Request1 = (0,4,2,0) <= Need1 = (0,7,5,0)
(ii) Request1 = (0,4,2,0) <= Available = (1,5,2,0)
(iii) Efter en allokering är systemets tillstånd säkert. Sekvensen <P0,P2,P1,P3,P4> visar
att systemet befinner sig i ett säkert tillstånd.
1.7
(a) Följande system är i ett osäkert tillstånd:
Allocation
P0
P1
P2
A
0
1
1
B
0
0
3
P0
P1
P2
A
0
0
1
B
0
7
0
C
1
0
5
Max
D
2
0
4
A
0
1
2
B
0
7
3
C
1
5
5
Available
D
2
0
6
A
0
B
6
C
5
D
0
Need
C
0
5
0
D
0
0
2
(b)
P0 avslutas vilket leder till att Available = (0,6,6,2). Men P1 behöver kanske inte 7
instanser av resurs B (Max är ju trots allt vad en process behöver i västa fall) utan nöjer
sig med 6 instanser av resurs B. När P1 avslutas blir Available = (1,6,6,2), vilket betyder
att P2 kan också avslutas. Detta betyder att systemet inte behöver hamna i baklås då
tillståndet är osäkert.
14
TDDC47 – Real-time and concurrent programming
1.8
(a)
Nej, baklås kan ej ske ty processer tvingas ge upp sina resurser. Med andra ord gäller inte
voluntary release som är ett av fyra kraven för att baklås ska kunna ske.
(b)
Ja, en process kan blockeras för alltid om processens allokerade resurser blir avallokerade
genom en serie av begäran från andra processer.
1.9
Vi har följande:
(i) Max i ≥ 1
(ii)
∑ Max
i
< m+n
(iii) Need i = Maxi − Allocationi
Om baklås uppstår måste ∑ Allocation i = m . Vi visar att systemet inte kan hamna i
baklås genom motsägelsebevis. Anta att ett baklås har ägt rum, dvs. att
∑ Allocation i = m . Detta innebär då att
∑ Need + ∑ Allocation =∑ Need
i
i
i
+ m = ∑ Max i < m + n ⇒ ∑ Need i < n
Detta innebär att det existerar en process Pi sådan att Needi = 0. Med andra ord kan Pi
avsluta sin exekvering och släppa alla resurser som den har allokerat. Då Max i ≥ 1
innebär detta att Pi har åtminstone en resurs som den kan släppa. Detta innebär dock att
∑ Allocation i < m , vilket motstrider antagandet ovan. Med andra ord kan systemet inte
vara i baklås.
15
TDDC47 – Real-time and concurrent programming
2. Scheduling
2.1
(a)
Process
A
B
C
Period
10
4
2
Exekveringstid
1
1
1
Prioritet
Lägst
Mellan
Högst
(b) CPU:s utnyttjandegrad ges av
U = 1/10 + 1/4 + 1/2 = 0.85
(c)
Tiden 0 är en kritisk tidpunkt, ty alla processer har maximalt långa svarstider. Längden på
tracen måste vara minsta multipel av processernas perioder, dvs. 20.
Time
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Executing
C
B
C
A
C
B
C
Ready
A, B
A
A
C
B
C
A
C
B
C
B
B
A
B
C
B
C
B
C
B
A, B
A
16
Waiting
C
B
B, C
A
A, C
A, B
A, B, C
A
A, C
B
B, C
A
A,C
A,B
A,B, C
A
A, C
A, B
A, B, C
C
TDDC47 – Real-time and concurrent programming
(d) Vi utnyttjar följande ekvation som löses genom fixpunktsiteration:
R 
Ri = Ci + ∑∀j∈hp (i )  i C j
Tj 
Svarstiden RC: Svarstiden för C blir 1 (C:s exekveringstid) då inga processer med högre
prioritet kan avbryta, m.a.o.
RC = CC + 0 = 1
Svarstiden RB: C har högre prioritet än B och således gäller att hp(B) = C. Svarstiden RB
räknas ut med iteration tills fixpunkt uppnås. Antag initialt RB = 1 (B:s exekveringstid)
RB = C B = 1
0
RB
1
 R B0 
1
= C B +  C C = 1 +   = 1 + 1 = 2
2
 TC 
 R1 
2
2
RB = C B +  B C C = 1 +  1 = 1 + 1 = 2
2
 TC 
2
1
RB = RB = RB
Svarstiden RA: Processer B och C har högre prioritet än process A och därmed är
hp(A) = {B,C}.
RA = C A = 1
0
 R0 
 R0 
1  1 
1
R A = C A +  A C C +  A C B = 1 +  1 +  1 = 1 + 1 + 1 = 3
2 4
 TC 
 TB 
 R1 
 R1 
3 3
2
R A = C A +  A C C +  A C B = 1 +  1 +  C B = 1 + 2 + 1 = 4
2 4
 TC 
 TB 
 R2 
 R2 
4 4
3
R A = C A +  A C C +  A C B = 1 +  1 +  1 = 1 + 2 + 1 = 4
2 4
 TC 
 TB 
RA = RA = RA
3
2
17
TDDC47 – Real-time and concurrent programming
2.2
Anta att vi har tre processer och välj exekveringstider och perioder enligt:
Process
A
B
Period
3
7
Exekveringstid
1
2
C
10
3
Detta innebär att utnyttjandegraden är
C
1 2 3
U =∑ i = + +
= 0,919
Ti 3 7 10
Alla processer klarar av sina deadline med EDF då U ≤ 1. För RM kan en eller flera
processer missa sina deadlines då 0,919 ≤/ 3(21 / 3 − 1) = 0,75 . För att säkerställa huruvida
deadline kommer att missas måste vi använda oss av responstidsanalys.
Svarstiden RA: hp(A)={} och därmed är R A = 1 . Process A klarar av sin deadline.
Svarstiden RB: Endast processen A har högre prioritet än B och således har vi att
hp(B)={A}. Beräkning av responstiden ger att:
RB0 = C B = 2
 R0 
2
1
R B = C B +  B  C A = 2 +  1 = 2 + 1 = 3
3
 TA 
 R1 
3
2
R B = C B +  B C A = 2 +  1 = 2 + 1 = 3
3
 TA 
RB = RB = RB
1
2
Process B klarar av sin deadline.
Svarstiden RC: Processer A och B har högre prioritet än C och således har vi att
hp(C)={A,B}. Beräkning av responstiden ger att:
RC0 = C C = 3
 RC0 
 RC0 
3  3 
RC = C C +   C A +   C B = 3 +  1 +   2 = 3 + 1 + 2 = 6
3  7 
 TA 
 TB 
 R1 
 R1 
6 6
2
RC = C C +  C C A +  C  C B = 3 +  1 +   2 = 3 + 2 + 2 = 7
3 7 
 TA 
 TB 
1
18
TDDC47 – Real-time and concurrent programming
RC
3
RC
4
RC
5
 RC2 
 RC2 
7  7
= C C +   C A +   C B = 3 +  1 +   2 = 3 + 3 + 2 = 8
3 7
 TA 
 TB 
 R3 
 R3 
8   8 
= C C +  C C A +  C C B = 3 +  1 +   2 = 3 + 3 + 4 = 10
3  7 
 TA 
 TB 
 R4 
 R4 
10  10 
= C C +  C  C A +  C  C B = 3 +  1 +   2 = 3 + 4 + 4 = 11 > 10
3 7
 TA 
 TB 
Här ser vi att process C missar sin deadline.
2.3
(a)
EDF: För att garantera att alla processer klarar av sina deadline måste följande gälla
1
.
C≤
1
1
+ ... +
T1
Tn
(b)
RM: Genom att sätta exekveringstiden för processerna enligt
n (21 / n − 1)
C≤
1
1
+ ... +
T1
Tn
kan man garantera att alla processer klarar av sina deadline. Observera att för RM kan ett
större C användas, men att ovanstående är ett tillräckligt krav.
2.4
Prioritetstilldelning enligt RM ger
Process
A
B
C
D
Prioritet (π)
2
4
3
1
(a)
Taket på en semafor är den maximala prioriteten av alla processer som kan tänkas låsa
semaforen. Därmed har vi att
Tak ( S1) = max(π A , π B ) = 4
Tak ( S 2) = max(π C , π D ) = 3
(b)
19
TDDC47 – Real-time and concurrent programming
Vi använder oss av algoritmen för beräkning av blockering. Lås lp{Z } beteckna
mängden av processer med lägre prioritet än Z.
BD: Det finns ingen process med lägre prioritet än process D och således har vi att
lp{D} = {} . Därmed kan ingen process blockera process D och därmed är B D = 0 .
BA: Vi har att lp{ A} = {D} . Process D låser S2 och Tak ( S 2) = 3 ≥ π A = 2 och därmed
kan process D blockera process A. Detta medför att B A = t S 2, D = 4 .
BC: Vi har att lp{C} = {D, A} . Vi undersöker vilka processer som kan blockera process
C.
(i) Process D låser S2 och Tak ( S 2) = 3 ≥ π C = 3 . Process D kan blockera C.
(ii) Process A låser S1 och Tak ( S1) = 4 ≥ π C = 3 . Process A kan blockera C.
Därmed kan process C blockeras högst en gång av processerna D och A. Detta
medför att BC = max(t S 2, D , t S1, A ) = 4 .
BB: Vi har att lp{B} = {D, A, C} . Undersöker vilka processer som kan blockera process C.
(i) Process D låser S2 och Tak ( S 2) = 3 ≥/ π B = 4 . Process D kan ej blockera B.
(ii) Process A låser S1 och Tak ( S1) = 4 ≥ π B = 4 . Process A kan blockera B.
(iii) Process C låser S2 och Tak ( S 2) = 3 ≥/ π B = 4 . Process C kan ej blockera B.
Med andra ord kan B endast blockeras av A och därmed har vi att BB = t S1, A = 1 .
2.5
Prioritetstilldelning enligt RM ger
Process
A
B
C
Prioritet (π)
1
2
3
För att beräkna blockeringsfaktorn för varje process måste vi först beräkna taket på
semaforerna:
Tak ( S1) = max(π A , π B , π C ) = 3
Tak ( S 2) = max(π B , π C ) = 3
Tak ( S 3) = max(π C ) = 3
Vi använder oss av algoritmen för beräkning av blockering. Låt lp{Z } beteckna mängden
av processer med lägre prioritet än Z.
BA: Det finns ingen process med lägre prioritet än process A och således har vi att
lp{ A} = {} . Därmed kan ingen process blockera process A och därmed är B A = 0 .
20
TDDC47 – Real-time and concurrent programming
BB: Vi har att lp{B} = {A} . Process A låser S1 och Tak ( S1) = 3 ≥ π B = 2 och därmed kan
process A blockera process B. Detta medför att BB = t S1, A = 1 .
BC: Vi har att lp{C} = { A, B} . Vi undersöker vilka processer som kan blockera process C.
(i) Process A låser S1 och Tak ( S1) = 3 ≥ π C = 3 . Process A kan blockera C.
(ii) Process B låser S1 och Tak ( S1) = 3 ≥ π C = 3 . Process B kan blockera C genom
semafor S1.
(iii) Process B låser S2 och Tak ( S 2) = 3 ≥ π C = 3 . Process B kan blockera C genom
semafor S2.
Process C blockeras högst en gång av processerna A och B. Detta medför att
BC = max(t S 1, A , t S1, B , t S 2, B ) = 1 .
Vi beräknar nu svarstiderna genom att lösa följande ekvation med fixpunktsiteration:
R 
Ri = Ci + Bi + ∑∀j∈hp (i )  i C j
T j 
Svarstiden RC: hp(C)={} och därmed är RC = C1 + B1 = 2 + 1 = 3
Svarstiden RB: Endast processen C har högre prioritet än B och således har vi att
hp(B)={C}. Beräkning av responstiden ger att:
RB0 = C B + BB = 4
 R0 
R 1B = C B + B B +  B  CC = 6
 TC 
 R B1 
2
R B = C B + B B +  C C = 6
 TC 
RB = RB = RB
1
2
Svarstiden RA: Processerna B och C har högre prioritet än A och således har vi att
hp(A)={B,C}. Beräkning av responstiden ger att:
R A0 = C A + B A = 4
R0 
R0 
R 1A = C A + B A +  A  C B +  A  C C = 9
 TB 
 TC 
1
R 
 R1 
R A2 = C A + B A +  A C B +  A  C C = 11
 TB 
 TC 
2
 RA 
 R A2 
3
R A = C A + B A +  C B +  C C = 14
 TB 
 TC 
21
TDDC47 – Real-time and concurrent programming
 R3 
 R3 
R A4 = C A + B A +  A C B +  A C C = 14
 TB 
 TC 
3
4
RA = RA = RA
2.6
Process
P1
P2
P3
P4
Exekveringssekvens Prioritet
4
EaabdE
3
EbbdddE
2
EbbaccE
1
EccaE
Släpptid
8
5
2
0
Följande beteckning används:
yx
P
P
1
P
2
P
3
P
4
Betyder att processen exekverar med prioritet x och att
processen har tilldelats resurs y. Till exempel, betyder a2 att
processen har fått resurs a och att processen exekverar med
prioriteten 2.
Preemption av en process med högre prioritet.
Blockeras av en process med lägre prioritet.
E
E
E
E c
1
P c
2
b
2
P
P b
3
P P
b
3
P
P b
4
P P
P
P P
a
4
P
a
4
P
b
4
P
d
4
P
P
P
P
P
P
P
22
E
P
P d
3
P P
d
3
P
d
3
P
P
P P
P
P
E
P a
2
P P
c
2
P
c
2
P
E
P a
1
E
TDDC47 – Real-time and concurrent programming
3. Real-time communication
3.1
(a) See course literature.
(b) We have the following parameters
Nod
1
2
3
Period Ti (ms)
5
7
10
Prioritet (π)
3
2
1
The formulas required to calculate the worst-case response time of each message are the
following
 win + J j + τ bit 
where wi0 ( q ) = Bi + qCi
win +1 (q) = Bi + qCi + ∑ 
C j
Tj
∀j∈hp ( i ) 

Ri (q ) = J i + wi (q ) − qTi + Ci
Ri = max ( Ri (q ))
q =0..Qi −1
In addition, before using them, the number of possible messages, Qi, that become ready
before the end of the busy period must be calculated with the following formulas:
t
n +1
i
 t in + J j 
= Bi + ∑ 
C j
Tj 
∀j∈hep ( i ) 
where
ti0 = Ci
t + J i 
Qi =  i

 Ti 
The maximum blocking time for respective messages is B1 = B2 = 135 µs and B3 = 0 s .
Frames sent by n3 have the lowest priority, reason why their blocking factor is defined to
zero. The transmission time is given by C i = 135τ bit = 135µs .
Response time R1:
First the length of the busy period for message 1 is calculated:
t10 = C1 = 135µs
 t 0 + J1 
t11 = B1 +  1
C1 = 270µs
 T1 
23
TDDC47 – Real-time and concurrent programming
 t11 + J 1 
t = B1 + 
C1 = 270µs
 T1 
t12 = t11 = t1 = 270µs
2
1
Then the number of instances Q1 of message 1 that become ready before the end of the
busy period:
 t + J1 
Q1 =  1
 =1
 T1 
The response time must be calculated for each of the Q1 instances, in this case just one.
Since there are no messages with higher priority no iterations are required:
w10 (0) = B1 + 0C1 = 135µs
R1 (0) = J 1 + w1 (0) − 0T1 + C1 = 270µs
R1 = max( R1 (0)) = 270µs
Response time R2: We calculate the length of the busy period for message 2:
t 20 = C2 = 135µs
 t 0 + J1 
 t 20 + J 2 
t 21 = B2 +  2
C
+
 1 
C 2 = 405µs
 T1 
 T2 
 t 12 + J 1 
 t 12 + J 2 
2
t 2 = B2 + 
C1 + 
C 2 = 405µs
 T1 
 T2 
t 22 = t 12 = t 2 = 405µs
Then the number of instances Q2 that become ready:
t + J 2 
Q2 =  2
 =1
 T2 
The response time must be calculated for each of the Q2 instances:
w20 (0) = B2 + 0C 2 = 135µs
 w 0 + J 1 + τ bit 
w12 (0) = B2 + 0C 2 +  2
C1 = 270µs
T
1


1
 w + J 1 + τ bit 
w22 (0) = B2 + 0C 2 +  2
C1 = 270µs
T1


2
1
w2 = w2 = w2 = 270µs
R2 (0) = J 2 + w2 (0) − 0T2 + C 2 = 405µs
24
TDDC47 – Real-time and concurrent programming
R2 = max( R2 (0)) = 405µs
Response time R3: We calculate first the length of the busy period for message 3:
t 30 = C3 = 135µs
 t 0 + J1 
 t 30 + J 2 
 t 30 + J 3 
t 31 = B3 +  3
C
+
C
+
 1 
 2 
C3 = 405µs
T
T
T
1
2
3






1
1
1
 t + J1 
 t3 + J 2 
 t3 + J 3 
t 32 = B3 +  3
C1 + 
C 2 + 
C3 = 405µs
 T1 
 T2 
 T3 
t 32 = t 31 = t 3 = 405 µs
Then the number of instances Q3 that become ready:
t + J 3 
Q3 =  3
 =1
 T3 
The response time must be calculated for each of the Q3 instances:
w30 (0) = B3 + 0C 3 = 0 µs
 w 0 + J 1 + τ bit 
 w30 + J 2 + τ bit 
w31 (0) = B3 + 0C3 +  3
C
+
 1 
C 2 = 270µs
T1
T2




1
1
 w + J 1 + τ bit 
 w3 + J 2 + τ bit 
w32 (0) = B3 + 0C3 +  3
C1 + 
C 2 = 270µs
T1
T2




w32 = w31 = w3 = 270 µs
R3 (0) = J 3 + w3 (0) − 0T3 + C3 = 405µs
R3 = max( R3 (0)) = 405µs
3.2
In this case there is jitter:
J 1 = J 2 = 5ms and J 3 = 8ms
Then the response time for each message must be recalculated.
Response time R1: First the length of the busy period for message 1 is calculated:
t10 = C1 = 135µs
 t10 + J 1 
t = B1 + 
C1 = 405µs
 T1 
t1 + J1 
t12 = B1 +  1
C1 = 405µs
 T1 
1
1
25
TDDC47 – Real-time and concurrent programming
Then the number of instances Q1 that become ready:
 t + J1 
Q1 =  1
=2
 T1 
The response time must be calculated for each of the Q1 instances. Since there are no
messages with higher priority no iterations are required:
w10 (0) = B1 + 0C1 = 135µs
w10 (1) = B1 + 1C1 = 270µs
R1 (0) = J 1 + w1 (0) − 0T1 + C1 = 5270µs
R1 (1) = J 1 + w1 (1) − 1T1 + C1 = 405µs
R1 = max( R1 (0), R1 (1)) = 5270µs
Response time R2: We calculate the length of the busy period for message 2:
t 20 = C2 = 135µs
 t 0 + J1 
 t 20 + J 2 
t 21 = B2 +  2
C
+
 1 
C 2 = 540µs
 T1 
 T2 
t1 + J1 
 t 12 + J 2 
t 22 = B2 +  2
C
+
 1 
C 2 = 540µs
T
T
1
2




t 22 = t 12 = t 2 = 540µs
Then the number of instances Q2 that become ready:
t + J 2 
Q2 =  2
 =1
 T2 
The response time must be calculated for each of the Q2 instances:
w20 (0) = B2 + 0C 2 = 135µs
 w 0 + J 1 + τ bit 
w12 (0) = B2 + 0C 2 +  2
C1 = 405µs
T1


1
 w + J 1 + τ bit 
w22 (0) = B2 + 0C 2 +  2
C1 = 405µs
T1


2
1
w2 = w2 = w2 = 405µs
R2 (0) = J 2 + w2 (0) − 0T2 + C 2 = 5540µs
R2 = max( R2 (0)) = 5540µs
26
TDDC47 – Real-time and concurrent programming
Response time R3: We calculate first the length of the busy period for message 3:
t 30 = C3 = 135µs
 t 0 + J1 
 t 30 + J 2 
 t 30 + J 3 
t 31 = B3 +  3
C
+
C
+
 1 
 2 
C3 = 540µs
T
T
T
1
2
3






1
1
1
 t + J1 
 t3 + J 2 
 t3 + J 3 
t 32 = B3 +  3
C1 + 
C 2 + 
C3 = 540µs
 T1 
 T2 
 T3 
t 32 = t 31 = t 3 = 540 µs
Then the number of instances Q3 that become ready:
t + J 3 
Q3 =  3
 =1
 T3 
The response time must be calculated for each of the Q3 instances:
w30 (0) = B3 + 0C 3 = 0 µs
 w 0 + J 1 + τ bit 
 w30 + J 2 + τ bit 
w31 (0) = B3 + 0C3 +  3
C
+
 1 
C 2 = 405µs
T1
T2




1
1
 w + J 1 + τ bit 
 w3 + J 2 + τ bit 
w32 (0) = B3 + 0C3 +  3
C1 + 
C 2 = 405µs
T1
T2




w32 = w31 = w3 = 405 µs
R3 (0) = J 3 + w3 (0) − 0T3 + C 3 = 8540µs
R3 = max( R3 (0)) = 8540µs
3.3
(a)
Den kortaste transmissionstiden för en ram ges av C = (8n + 47 )τ bit där 0 ≤ n ≤ 8 är
antal bytes data. Meddelandet vi ska skicka är 10 bytes och således får vi dela upp
meddelandet i två ramar. Detta innebär att C = 174τ bit .
(b) På grund av bitstuffing kan antal skickade bitar ökas, vilket leder till att
transmissionstiden för en ram är maximalt

 34 + 8n − 1 
C =  8n + 47 + 
 τ bit .
4



Då vi måste dela upp meddelandet i två ramar får vi det maximala transmissionstiden
C = 210τ bit .
27
TDDC47 – Real-time and concurrent programming
4. Extra exercise
4.1
1
for(y=0;y<200;y++)
{
2
if(test(y)==1)
{
3
for(x=0;x<640;x++)
{
4
if(image[x][y]==1)
{
int weight;
5
weight=calc_weight(image,x,y);
6
x_sum+=x*weight;
7
y_sum+=y*weight;
8
squares+=weight;
}
}
}
}
Rad
1
2
3
4
5
6
7
8
Summa
MAX
MIN
25+20+200*(20+15+25)
25+20+200*(20+15+25)
200*(180+20)
200*(180+20)
200*(25+20)+200*640*(20+15+25)
0
200*640*20
0
200*640*(350+25)
200*640*(90+15+25)
200*640*(90+15+25)
200*640*(15+25)
96701045
28
0
0
0
0
52045
TDDC47 – Real-time and concurrent programming
Table for resource sharing exercises
2.6
Följande beteckning används:
yx
P
Betyder att processen exekverar med prioritet x och att
processen har tilldelats resurs y. Till exempel, betyder a2 att
processen har fått resurs a och att processen exekverar med
prioriteten 2.
Preemption av en process med högre prioritet.
Blockeras av en process med lägre prioritet.
P1
P2
P3
P4
******************
P1
P2
P3
P4
29