Thomas Vandermeiren

2TI6
Besturingssystemen
02-05-2012
baci
1.1) A listing of your revised code; highlight the parts of your revised code that
are
different from the original.
//Global Variable Declarations //
binarysem b = 1;
void add (int lower, int upper)
//Adds numbers in the range lower to upper inclusive to total
{
int i;
for (i=lower;i<=upper;i++)
{
wait(b);
total = total + i;
signal(b);
}
}
void initialize ()
//Initializes all global variables and data structures
{
initialsem(b,1);
total = 0;
}
1.2) A brief explanation of why the original program gives incorrect results.
Het proces zou juist gebeuren als het serieel werd uitgevoerd. Indien het parallel
gebeurt voert men de processen uit maar krijgt men een fout. Ik zal deze fout
even uitleggen met 2 processen. Het 1
ste
proces doet zijn berekening, het 2
de

proces doet zijn berekening. Deze berekening word opgeslagen en dan pakt het
1
ste
proces deel 2 de opgeslagen berekening en werkt hiermee voort maar deze
berekening wordt niet opgeslagen en het 2
de
deel van het 2
de
proces begint met
de opgeslagen berekening van deel 1, hiermee krijgt men verlies en telt men
bepaalde dingen niet op.
//aanpassen
1.3) A brief explanation of how your solution corrects this. (What is the correct
answer?)
We initialiseren een semafoor, met deze semafoor kunnen we processen op
wacht zetten en hierna terug verdergaan met het process. We kiezen met welk
proces we verdergaan random een proces op te wekken. Hierdoor beschermen
we het getal en krijgen we geen verlies en kunnen we ons proces makkelijk
hervatten.
//aanpassen
Oefening 2
2.1) A listing of your revised code; highlight the parts of your revised code that
are different from the original.
const int number= 5;
const int true = 1;
const int false= 0;
const int none = -1;
semaphore f;
semaphore fork[number];
int hasfork[number];
int dinerseaten[number];
----
void initialize ()
//YOU CAN ADD ANY INITIALIZATIONS HERE//
{
int count;
for (count=0; count<number; count++)
{
dinerseaten[count] = false; //no diners have eaten yet//
hasfork[count] = none; //nobody has forks yet//
initialsem(fork[count],1); //only one diner per fork at once//

}
initialsem(f, number-1);
}
-----
void dine(int diner)
//This procedure is started concurrently for each diner //
//This version of program occaisionally deadlocks //
{
wait(f);
takefork (left(diner), diner);
takefork(right(diner), diner);
eat(diner);
replacefork(left(diner), diner);
replacefork(right(diner), diner);
signal(f);
} //dine//
2.2) A brief explanation of why the original program deadlocks, and also an
explanation of how the diners sometime do manage to eat in this program.
Als iedereen een vork pakt kan niemand eten. Dus dan loopt het programma vast
(dit is een Deadlock). Als 1 iemand in het begin 2 vorken kan bemachtigen kan
hij alles opeten en kan hij zijn vorken terug neerleggen als hij zijn vorken
neerlegt kan iemand anders zijn vorken pakken. Hierdoor kan geen deadlock
meer optreden en kan iedereen eten.
2.3) A brief explanation of how your solution correct the problem discussed in 2.,
emphasizing why your solution never deadlocks.
We laten gewoon iemand buitenstaan als de eerste 4 aan het eten zijn. Als er
iemand gedaan heeft dan kan de persoon die buiten staat gaan eten. Zo kan er
geen deadlock meer voorkomen.
2.4) An illustration of the results from 50 executions, which shows that your
solution never deadlocks. (You can add a for-loop to the main program outside
the cobegin to help make this data collection easier.)
for i in `seq 1 50`; do ./bainterp diners.pco ; done
Diner # 0has eaten
Diner # 2has eaten
Diner # 4has eaten
Diner # 1has eaten
Diner # 3has eaten
SUCCESS
Diner # 3has eaten
Diner # 2has eaten
Diner # 1has eaten
Diner # 0has eaten
Diner # 4has eaten
SUCCESS
Diner # 2has eaten
Diner # 1has eaten
Diner # 0has eaten
Diner # 4has eaten
Diner # 3has eaten
SUCCESS
Enz
2.5) Show the results from your 50-executions when you change your program
to 4 dining philosophers and then to 3 dining philosophers. The only parts of the
code that should change for these different executions is the number of calls to
dine() in the cobegin block.
for i in `seq 1 50`; do ./bainterp diners.pco ; done
Diner # 4has eaten
Diner # 3has eaten
Diner # 2has eaten
Diner # 1has eaten
FAILURE
Enz
Met 3 diners
for i in `seq 1 50`; do ./bainterp diners.pco ; done
Diner # 3has eaten
Diner # 2has eaten
Diner # 1has eaten
FAILURE
Je krijgt altijd een FAILURE
2.6) A brief explanation of the following two questions:
a. Is your algorithm robust against deadlock when the number of diners
change? Explain.
Nee wanneer je het aantal diners verandert krijg je een deadlock want het
aantal calls bij dine() in de cobeginblock moet je ook veranderen.
//BIJZETTEN
//
***********************************************************
***//
// main program //
// DO NOT CHANGE THIS PROGRAM EXCEPT TO CHANGE NUMBER OF
DINERS //
main ()
{
int i;
initialize();
cobegin
{
for(i = 0; i < number; i++)
{
dine(i);
}
//add/delete more lines if number of diners changes...//
//note baci can only handle about 10 threads at a time//
}
success();
b. Is your algorithm fair in the sense that every diner has a chance to be
the first to eat? Explain.
Ja elke diner heeft e
}en kans om eerst te eten.