Besturingssystemen/Beheer

Gebruikersbeheer

Het kunnen aanmaken van gebruikers is belangrijk, zodat iedere gebruiker zijn eigen werkomgeving kan hebben. Er zijn verschillende types van accounts: beheerders (die bv. software kunnen installeren), gewone gebruikers (die vaak geen software kunnen installeren, maar wel een eigen werkomgeving hebben) en gasten (die kunnen gebruikmaken van de pc, maar na afmelden worden instellingen en documenten vaak gewist). Aan de gebruikers kunnen ook rechten worden toegekend, zodat de ene gebruiker niet zomaar toegang heeft tot de documenten van een andere gebruiker. De controle van deze toegang gebeurt door het OS.

Multiuser is een begrip dat gebruikt wordt als een besturingssysteem of een applicatie concurrente (tezelfdertijd) toegang toelaat van meerdere gebruikers van een computer. Zo zal een databank vaak meerdere gebruikers tezelfdertijd toegang kunnen verlenen. Ook bij een multiseat of een LTSP-systeem hebben meerdere gebruikers tezelfdertijd toegang. Merk op dat bv. een “gewone” Windows XP maar één gebruiker tezelfdertijd toeliet (single-user). Verwar multi-user dus niet met het feit dat je meerdere gebruikers kan aanmaken.

Energiebeheer

Samen met de toename van toestellen die op batterijen werken, wordt het ook belangrijker om het energieverbruik onder controle te houden. Enkele mogelijkheden:

Het OS zet het scherm op zwart bij niet-gebruik.
Het OS kan het scherm dimmen.
Het OS kan de processor (of zijn kernen) onderklokken of bepaalden kernen uitschakelen/laten idlen.
Het OS zet het toestel in slaapstand (of suspend to RAM) na enkele minuten inactiviteit. De status van het toestel (oa. openstaande programma's en documenten) wordt dan in RAM bewaard, daarna wordt de stroom naar onnodige subsystemen afgesloten. Het RAM-geheugen verbruikt enkel nog net voldoende energie, om zijn inhoud niet te verliezen.
Een stapje verder is hibernation (of suspend to disk) waar de status van het toestel op permanente opslag wordt bewaard (bv. HDD of SSD). Het voordeel is dat deze permanente opslag geen energie verbruikt om zijn inhoud te bewaren. Het nadeel is dat het iets langer duurt om terug de oorspronkelijke status te krijgen, omdat permanente opslag trager is dan RAM-geheugen.
Een mengvorm is hybrid sleep (of suspend to both) waarbij zowel de slaapstand als hibernation wordt toegepast. Zolang de batterij van bv. een laptop het uithoudt is de slaapstand handig, maar als deze uiteindelijk toch leeg is, kan alsnog de status van de machine hersteld worden, dankzij hibernation.

Dit energiebeheer kan je via het OS naar de hand zetten. Je hebt er bv. onderstaande mogelijkheden, die je vaak verder kan verfijnen:

Energiebesparing: als je een harde schijf trager laat draaien of een CPU trager laat werken, dan verbruikt je systeem minder energie. Het scherm is ook een grote slokop, dus door deze te dimmen kan je ook veel besparen.
Hoge prestaties: het tegengestelde van energiebesparing.
Gebalanceerd: er wordt een evenwicht gezocht tussen het energieverbruik en de prestaties.

Multitasking en de scheduler

Een computer/besturingssysteem lijkt op één moment met alles tezelfdertijd bezig: muziek afspelen, e-mail binnenhalen, foto uploaden, klok wijzigen, updates op de achtergrond starten, een bestand opslaan, een bestand openen,... Dat is echter maar schijn: op één bepaald moment is een (single) core in theorie maar bezig met één iets (het running proces). Maar door de snelheid waarmee de processor werkt lijkt het echter dat hij veel op één moment doet. Een 3 GHz core kan zo 3 miljard "dingen" per seconde doen!

Er zijn vijf mogelijke toestanden voor de processen:

New is de toestand als een proces net wordt aangemaakt en de nodige zaken voorzien moeten worden (bv. toewijzen RAM-geheugen).
Een ready-proces is klaar om te worden uitgevoerd, maar wordt op dat eigenste moment niet uitgevoerd. Zo staan er heel wat van die ready-processen klaar.
Een running-proces is de processor nu aan het uitvoeren. Als het gaat om een systeem met maar 1 processor(kern), dan is er ook maar 1 running-proces, zelfs al staan er heel wat klaar (ready) om uitgevoerd te worden!
Een blocked-proces is niet klaar om (verder) uit te voeren, vaak omdat de processor moet wachten op randapparaten. Denk bv. aan een running-proces dat een bestand van het opslagmedium moet laden. Voor de giga-snelle processor is het wachten op dat trage opslagmedium een eeuwigheid. In plaats van niets te kunnen doen (idlen) wordt dit proces van de running-status, naar de blocked-status gebracht. De scheduler kiest dan een proces uit de ready-verzameling, zodat dit kan worden uitgevoerd (het wordt dus running). Eens het bestand is ingeladen kan het blocked-proces, de ready-status krijgen (om uiteindelijk opnieuw de running-status te verkrijgen).
Als je een proces sluit, komt het in de dead-toestand terecht. Dan wordt bv. het RAM-geheugen terug vrijgegeven.

De kunst van een goede scheduler (een soort dienstregeling) bestaat er nu in om efficiënt te wisselen tussen al die toestanden. Als bv. het ene proces te lang de running-status krijgt, dan betekent het dat andere ready-processen niet aan de beurt kunnen komen. Als eindgebruiker zou je dat zeker merken, dus moet de scheduler op tijd zorgen voor een timeout voor het running-proces, zodat een ander proces uit de ready-groep kan worden uitgevoerd (running).

De scheduler zal giga-snel wisselen tussen ready en running, zodat het voor de eindgebruiker lijkt alsof alles tezelfdertijd wordt uitgevoerd. Multitasking is een methode om één processor schijnbaar meerdere taken (programma's of delen daarvan) tegelijkertijd te laten uitvoeren. Het besturingssysteem wisselt giga-snel tussen de verschillende actieve programma's. Bij onderstaand voorbeeld wordt bij de ene core gewisseld tussen de tekstverwerker en het e-mailprogramma en bij de andere core tussen de browser en antivirus. In het echt zijn er véél meer processen waartussen gewisseld moet worden.

Multithreading

Multithreading is een programmeermodel dat een grotere taak (het proces) opsplitst in meerdere kleinere taken (de threads), op een zodanige manier dat de threads afzonderlijk van elkaar kunnen worden uitgevoerd. Threads binnen één proces delen elkaars resources (bv. het geheugen), wat bij twee afzonderlijke processen (standaard) niet zo is.

Binnen één proces (of programma) kunnen zo verschillende taken van één proces "tegelijkertijd" op meerdere cores worden uitgevoerd. Zo krijg je een snelheidswinst. Een webbrowser kan bijvoorbeeld met behulp van threads meerdere taken tegelijk uitvoeren zoals het ophalen van een webpagina van een server en het afhandelen van de acties van de gebruiker in menu's of dialoogvensters.

Hieronder merk je een gelijkaardig voorbeeld zoals bij multitasking, maar hier gaat het om één proces (i.p.v. vier afzonderlijke), met vier threads. Het proces is een meet- en controleprogramma, met daarin een thread voor het bekomen van data, een voor de gebruikersinterface, een voor de netwerkcommunicatie en een voor het loggen. Door de aanwezigheid van twee cores, kunnen twee van de vier threads tezelfdertijd worden uitgevoerd. Zonder threads kan dit programma maar aan één core worden toegekend. De Apache HTTP server maakt gebruik van thread pools: een pool van listener threads om te luisteren naar binnenkomende aanvragen en een pool van server threads voor het behandelen van die aanvragen.

Zelfs als er maar een single core is, kan er met threads snelheidswinst zijn, omdat de scheduler sneller kan wisselen tussen threads van één proces, dan tussen afzonderlijke processen (bv. omdat het geheugen tussen threads gedeeld wordt, maar niet tussen afzonderlijke processen).

Programmeurs moeten goed nadenken bij gebruik van multithreading! Threads hebben nl. toegang tot hetzelfde geheugendeel en als de ene thread iets wijzigt, waarvan de andere niet weet, kan dit fouten opleveren. Bovendien kan een crash van één thread het volledige proces laten crashen!

Multitasking en multithreading lijken wel op elkaar, maar verwijzen duidelijk naar iets anders:

Multitasking verwijst naar meerdere programma’s, elk met hun eigen bronnen (resources, zoals bv. geheugen). Het is alsof er een kookwedstrijd is, waarbij elke kok zijn eigen ingrediënten en kookboek gebruikt.
Multithreading verwijst naar delen van één programma of toepassing, waarbij de bronnen (zoals het geheugen) gedeeld worden. Het is alsof meerdere koks hetzelfde kookboek aan het lezen zijn, hun ingrediënten delen en zijn instructies volgen (niet noodzakelijk vanaf dezelfde pagina).

De geheugenbeheerder

Met betrekking tot het (RAM-)geheugen zijn er bepaalde zaken die we verwachten:

Als een programma wordt opgestart zorgt het OS dat er niet alleen geheugen is gereserveerd voor het programma zelf, maar ook voor bepaalde datastructuren. Als je je tekstverwerker opstart en vervolgens een bestand opent, dan moet voor dit alles het nodige geheugen voorzien worden.
Bij het ontwerpen van een programma is het gemakkelijk om uit te gaan van veel geheugen, netjes aaneengesloten en voor jouw programma alleen. Dit is het virtueel geheugen. Gelukkig kan je volgens dit idee programmeren, maar 'in het echt' moet het OS wel voor volgende zaken zorgen:
- Het fysieke RAM-geheugen kan te klein zijn om alle programma's te kunnen laden. In dat geval zal het OS een stuk van een ander opslagmedium (HDD, SSD,...) gebruiken als uitbreiding van het RAM-geheugen: de swap-ruimte of wisselgeheugen. Tijdelijk niet gebruikte gegevens uit het RAM-geheugen kunnen daar worden bewaard om zo meer werkgeheugen (RAM) vrij te houden voor belangrijkere zaken. Het voordeel is dat er zo kan worden verder gewerkt, het nadeel is dat het opslagmedium niet zo snel is als het RAM-geheugen.
- Het adres in dat virtueel geheugen is niet hetzelfde als het fysieke adres, dus moet er een vertaling van het ene naar het andere gebeuren. Zo kan blijken dat de fysieke plaats versnipperd is en dus niet netjes aaneengesloten is.
- Het fysieke geheugen is er niet voor één programma alleen, maar het moet gedeeld worden met andere processen, waarbij het ene proces niet zomaar toegang mag krijgen tot het geheugen van een ander proces.
Als de eindgebruiker een programma sluit, dan verwacht je dat het geheugen dat dit programma innam netjes terug wordt vrijgegeven.

Het is duidelijk dat een besturingssysteem geheugenbeheer moet voorzien, zodat alles beheersbaar kan verlopen.

Noten en referenties