Besturingssystemen: verschil tussen versies

Ga naar: navigatie, zoeken
Regel 200: Regel 200:
  
 
[[Categorie:1bi]]
 
[[Categorie:1bi]]
 +
[[Categorie:2bi]]
 
[[Categorie:Aoi]]
 
[[Categorie:Aoi]]

Versie van 20 feb 2008 om 20:26

BartDemoen.jpg

De curus en het examen

Tijdens het jaar krijg je een permanente evaluatie op 3 punten: 3 keer een glossary (begrippenlijst) indienen van een deel van het boek. Dit wordt niet streng gequoteerd, maar dit moet ervoor zorgen dat je het boek al volledig gelezen hebt tegen de examens. Negeer dit niet, het zijn 3 punten die gemakkelijk verdiend zijn, en je zal het je beklagen als je dit vak niet bekeken hebt voor de blok.

Het examen is goed te doen. Je krijgt een aantal vragen die je goed moet bespreken, en een oefening. Je krijgt 1,5 uur om voor te bereiden, en dat is goed te doen, en daarna word je zo'n 20 minuten ondervraagd. Wat je opschrijft maakt niet uit, hij kijkt totaal niet naar je papieren, het is wat je vertelt dat belangrijk is. Hij stelt ook redelijk wat bijvragen, maar laat je niet van je stuk brengen.

Slides

De prof heeft geen slides meer voorzien, dus komen hier de slides van de vorige prof (Bart De Decker): Category:Besturingssystemen/Slides


Examenvragen

2007

vr 31 aug 2007 (vm)

Identiek dezelfde vragen als vr 19 jan 2007

Do 1 feb 2007 (namiddag)

  1. Beschrijf hoe bestanden kunnen beschermd worden tegen ongeoorloofde operaties, of omgekeerd, hoe selectief toelating tot bepaalde operaties kan verleend worden. Op welk niveau gebeurt de controle?
  2. Wat is het belangrijkste verschil tussen de notie buffer en de notie van cache? Welke buffers kunnen gebruikt worden tussen een schijf en een gebruikersprogramma bij een leesoperatie? Op welke manier kan een cache nuttig zijn?
  3. Bespreek bedreigingen van programma's en van het systeem - in het bijzonder het Trojaanse paard, de achterdeur, de stack-overflow, de worm, het virus en de "denial of service"
  4. Oefening: De volgende code (uit het handboek) zorgt dat een aantal readers en een writer gesynchroniseerd worden door de writer te laten wachten tot geen enkele reader meer bezig is, en dan kan de writer zijn ding doen. Dat is dus een oplossing voor wat het handboek noemt: het eerste readers-writers probleem. Het kan leiden tot verhongering van de writer. Toon eerst aan dat onderstaande code niet toelaat dat een lezer en een schrijver tegelijkertijd lezen en schrijven. Pas vervolgens de code aan zodat op het ogenblik de writer wil schrijven, die writer nog moet wachten tot er een nieuwe reader zich aanmeldt: dan moet de writer wel voorgaan. Het idee is dat het moet de moeite zijn om iets te schrijven.
 semaphore mutex, wrt; // initieel 1 
 int readcount; // initieel 0
 Structuur van de writer:
 
 do {
    wait(wrt);
    ...
    // hier wordt writing gedaan
    ...
    signal(wrt);
 } while (TRUE);
 Structuur van een reader:
 
 do {
    wait(mutex);
    readcount++;
    if (readcount == 1)
       wait(wrt);
    signal(mutex);
    ...
    // hier wordt reading gedaan
    ...
    wait(mutex);
    readcount--;
    if (readcount == 0)
       signal(wrt);
    signal(mutex);
 } while (TRUE);

vr 26 jan 2007 (namiddag)

  1. Bespreek process scheduling met prioriteiten. Geef een redelijke manier om prioriteiten aan een process toe te kennen. Zijn er processen die niet mogen onderbroken worden? Waarom? Hoe wordt dat gedaan? Hoe zorg je dat een process met laga prioriteit toch ooit uitgevoerd wordt?
  2. Leg uit wat demand paging juist is. In die context bespreek je eventueel ook swapping, de swapruimte, de prestaties van demand paging, trashing en de keuze van een slachtofferpagina.
  3. Oefening: De volgende code (uit het handboek) zorgt dat een aantal readers en een writer gesynchroniseerd worden door de writer te laten wachten tot geen enkele reader meer bezig is, en dan kan de writer zijn ding doen. Dat is dus een oplossing voor wat het handboek noemt: het eerste readers-writers probleem. Het kan leiden tot verhongering van de writer. Toon eerst aan dat onderstaande code toelaat dat meerdere readers tegelijkertijd lezen. Pas vervolgens de code aan zodat hoogstens 4 readers tegelijkertijd lezen(ook als er meer dan 4 readers willen lezen). Kan een reader verhongeren in je oplossing ? Hoe kan je dat verhinderen?
 semaphore mutex, wrt; // initieel 1 
 int readcount; // initieel 0
 Structuur van de writer:
 
 do {
    wait(wrt);
    ...
    // hier wordt writing gedaan
    ...
    signal(wrt);
 } while (TRUE);
 Structuur van een reader:
 
 do {
    wait(mutex);
    readcount++;
    if (readcount == 1)
       wait(wrt);
    signal(mutex);
    ...
    // hier wordt reading gedaan
    ...
    wait(mutex);
    readcount--;
    if (readcount == 0)
       signal(wrt);
    signal(mutex);
 } while (TRUE);

Zoals lucie zei, vragen zijn goed te doen, maar uiteindelijk beslist em op het mondeling zelf wel of ge het kent ofnie :-)


vr 19 jan 2007 ('s morgens)

  1. Beschrijf hoe mbv overlays een programmeur een programma dat te groot is voor het fysieke (of logische?) geheugen toch kan uitvoeren. Leg daarna de link naar paginatie en swapping. Helpen die om de fysieke beperkingen op te heffen, of de logische?
  2. Bespreek 4 condities om te kunnen spreken van een deadlock, manieren om die condities te ontdekken en te verhinderen. Wat kan je doen als de deadlock toch optreed?
  3. een oefening: je kreeg de code van een oplossing van het writer/readerproblem met 2 semaforen, er stond bij dat het uit het boek gekopiëerd was, en je moest daaruit de fouten halen en verbeteren.
 semaphore mutex, wrt; // geïnitialiseerd op 1
 int readcount = 0;  

structuur van een writer

 do{
   if(readcount>0)
      wait (wrt);
   ....
   //writing
   ...
   if(readcount >0)
      signal(wrt);
 }while (TRUE)

structuur van een reader

 do{
    wait(mutex);
    readcount++;
    wait(wrt);
    signal(mutex);
    ...
    //reading
    ...
    wait(mutex);
    readcount--;
    signal(wrt);
    signal(mutex);
 }while(TRUE)

De vragen waren te doen vond ik, maar Demoen is wel streng tijdens het mondeling, en hij vraagt echt wel door, dus zie maar dat je het kent!!Lucie

vr 19 jan 2007 (namiddag)

  1. Wat zijn threads ? Wat zijn de verschillende manieren op threads te implementeren ? Welke ondersteuning van het besturingssysteem is nodig of nuttig ? Hoe worden signalen van de kernel naar een thread doorgegeven ? Bespreek ook het verschil tussen user- en kernelthreads? Hoe worden threads gecreeerd en beindigd ?
  2. Welke interne datastructuren moet een besturingssysteem aanpassen wanneer het een bestand opent? Worden er ook processtructuren aangepast ? Hoe vind het besturingssysteem het begin van het bestand op schijf ? Geef de opeenvolgende acties die gebeuren bij een lees()-operatie.
  3. Laaste opgave is een oefening op het lezer/schrijver probleem (met code gegeven), toon aan dat tegelijk meerdere lezers kunnen lezen.

Pas de code aan zodat slechts 4 lezers tegelijk kunnen lezen. Komt er in je oplossing verhongering voor ? Zo ja, hoe vermijd je dat.

--bijvragen: threadscheduling en paging, memorymapped bestanden

2006

bij de burgies, van de vorige prof

  1. segmentation, extra hardware en software, hoe gebeurt adresvertaling, wat bij grote logische adresruimten, wat is voordeel van segmentatie op andere technieken?
    1. toegangsmatrix: hoe kun je dynamische wijzigingen beschermen?
    2. welke cpu-sched algs zijn toepasbaar bij job-sched? tabel maken met beschrijving, voordelen, nadelen, afzwakken van nadelen als kolommen
    3. monitor van een casino, waar een max aantal spelers binnenmogen, en waar de deur pas opengaat als er een minimum-aantal personen binnen is, of als de som van de mensen binnen plus de wachtenden buiten gelijk is aan datzelfde minimum
      1. plus er is ook nog een geldkoerier die als hij aankomt om geld op te halen voorrang krijgt op alle spelers maar enkel binnengaat als de zaal leeg is en vanaf dan mogen er dus geen spelers meer binnen
      2. methodes: wil_binnen_in_zaal(boolean speler) en is_buiten()

2005

ma 16 jan 2005 (13u/14u) (vorige prof)

  1. Soms wordt paginatie en segmentatie gecombineerd. Wat zijn de voordelen daarvan? Welke nadelen levert het op? Stel dat je kan kiezen tussen verschillende frame-groottes. Welke argumenten laten je eerder kiezen voor kleine frames en welke voor grote? Op basis waarvan zal je uiteindelijk kiezen voor een bepaalde grootte? Maak een oordeelkundige afweging voor "gepagineerde segmentatie"
  2. Beantwoord bondig de volgende vragen:
    • Stel dat een aparte schijf voorzien is voor archivering. Het besturingssysteem verplaatst alle bestanden die op andere schijven al meer dan een half jaar niet meer gebruikt zijn naar de archiveringsschijf. Welk allocatie-algoritme kan je hiervoor best gebruiken? Kan je deze "optimisatie" in het gebruik van schijfgeheugen altijd toepassen?
    • Een cineast gebruikt zijn PC voor het maken van tekenfilms. Hij gebruikt de PC voor twee doeleinden: het genereren van (complexe) beelden en het monteren (bekijken, knippen en plakken) van de films. Het genereren van beelden kan erg rekenintensief zijn. Welke CPU-scheduling algoritme raad je aan? Welk raad je zeker af?
  3. Oefening over monitors: Je kon kiezen tussen een monitor (met conditions) of een oplossing in java (zonder conditions, maar met wait, notify en notifyAll). De opgave was een restaurant waar elke tafel werd bediend door een robot. De klanten zijn beleefd en wachten met eten tot iedereen aan de tafel bediend is. De klanten staan pas op als iedereen aan de tafel gedaan heeft met eten. Klanten mogen niet gaan zitten aan een tafel waar mensen aan het eten zijn. De code die de klant uitvoert is als volgt:
tafel.neem_plaats()
klant gaat zitten
tafel.bestel_schotel()
klant eet zijn bord leeg
tafel.verlaat_tafel()

De code die de robot uitvoert is als volgt:

while (true){
  tafel.wacht_op_bestelling();
  ga schotel halen
  tafel.opgediend();
}

ma 16 jan 2005 (8u/9u) (vorige prof)

  1. Geef de berkingen voor de programmeur,het operating system, de bronnen & het proces bij de verschillende deadlock algoritmes. Geef ook een evaluatie van elk algoritme met de voor en nadelen. Doe dit aan de hand van een tabel.
  2. Beantwoord bondig de volgende vragen:
    • Een programmeur voert expirimenten uit op zijn pc, uiteindelijk komen de resultaten in 1 bestand terecht. Naast de zware expirmenten schrijft de programmeur nog programmeercode,hij compileert deze en test zijn programma uit. Welke CPU-scheduling algoritme raad je aan? Welk raad je zeker af?
    • Disk cache: leg uit, wat als disk cache vol zit.
    • Welke manier van geheugenbeheer heeft het meeste problemen met interne fragmentatie? Welk het minste?
  3. Oefening over monitors: Je kon kiezen tussen een monitor (met conditions) of een oplossing in java (zonder conditions, maar met wait, notify en notifyAll). vergelijkbaar met "lange smalle brug" probleem uit de oefenzitting, maar met treinen & moeilijker. Maximum aantal treinen op het spoor tegelijk, indien er een wachtrij aan de andere kant is mogen er maar x-aantal treinen meer over, en nog een aantal aanpassing zoals de wissels die moeten juist staan.

vrij 27 jan 2005 (8u/9u) (vorige prof)

  1. Deadlock prevention. (6ptn)
    1. Leg uit
    2. Voor & nadelen tov deadlock avoidance, detection, ..
  2. Hoe kun je een toegangsmatrix aanpassen zodat het zichzelf beschermt? en waarom wordt die soms gecombineert met een capability? (en nog 2 vraagskes diek ni just nimeer weet) (4ptn)
  3. Waar of niet waar? (3ptn)
    • SJF heeft de kortste gemiddelde verblijftijd? (das dus blijkbaar ni hetzelfde als wachttijd)
    • Een 2-level paging gebruikt meestal minder memory dan een 1-level paging. (en das een strikvraag wan dees is wel waar, aangezien een volledige blok van invalid bits in de 1-level pt ni aangerekent wordt in de 2-level pt.)
    • Een veilige toestand kan een onveilige toestand worden als een proces resources aanvraagt die niet beschikbaar zijn.
  1. Synchronisatie oefening: (de volle 2 blz tekst >.>) (7ptn)
    • Je moest een monitor maken dat een sluis beheert, die boten liet oversteken op een verval. Boten in de sluis moeten altijd eerst naar buiten gaan vooraleer andere boten der in mogen. De boot roept de volgende sequentie op:
    sluis.toegelaten()
    // vaart in de sluis
    sluis.binnenWilBuiten()
    // vaart naar buiten
    sluis.buiten()
    // boot is buiten
    • Functies die je mocht gebruiken: wijzig(laag....hoogwater)
    • Zijn er deadlocks in jouw oplossing, is het eerlijk ?