Besturingssystemen

Start Omhoog Computersystemen Besturingssystemen Processen Threads Gelijktijdigheid: Wederzijdse uitsluiting Gelijktijdigheid: deadlock en utisterving Geheugenbeheer Virtueel geheugen Uniprocessor planning Multiprocessor en real-time planning Bestandsbeheer I/O beheer en schijfplanning Bash Powershell Begrippen

2.1. Doelen en functies

  • Gemakkelijk
    Het besturingssysteem maakt de computer makkelijker in het gebruik.
  • EfficiŽnt
    Het besturingssysteem laat toe dat de systeembronnen efficiŽnt worden gebruikt.
  • Mogelijkheid om uit te breiden
    Een besturingssysteem moet zo worden ontworpen dat het toelaat effectieve ontwikkeling, testen en het introduceren van nieuwe systeemfuncties kunnen worden doorgevoerd zonder onderbreking van de service.
  • Voorbeelden van operating systemen:

  • UNIX
  • Windows
  • Solaris
  • Linux
  • Android
  • IOS
  • 2.1.1. User / Computer Interface

    De user / computerinterface is gemakkelijk en gebruiksvriendelijk en biedt eventueel een GUI (Graphical User Interface).

    Doel:

  • Afschermen hardware gebruiker

  • Toegang via applicaties of services

  • Programma ontwikkeling
    OS voorziet programmeur van allerlei hulpprogramma's zoals editors en debuggers. Deze zijn strikt genomen geen kerntaak van het OS.

  • Programma uitvoering
    OS regelt initialisatie van I/O apparaten, bestanden die moeten worden geÔnitialiseerd en andere bronnen die moeten worden voorbereid.

  • Toegang tot I/O apparaten
    Uniforme interface waarin gebruikers apparaten kunnen benaderen met simpele read/writes.

  • Gecontroleerde toegang tot bestanden
    OS regelt benadering van type I/O apparaat, data indeling op het opslagmedium en kan eventueel toegangsprotectie tot de bestanden regelen.

  • Systeem toegang
    Biedt functies tot beschermde toegang van bronnen, zoals afscherming niet-geautoriseerde gebruikers.

  • Fout detectie en reactie
    Het OS biedt antwoord op interne en externe hardware fouten (geheugenfouten), apparaat fouten, softwarefouten (divide by zero) en zal het probleem proberen op te lossen met de minst mogelijke impact op het systeem.

  • Administratie
    De gebruiksstatistieken van diverse bronnen en prestatie parameters zoals responstijd kan worden gebruikt om het systeem beter af te stellen en de performance te verbeteren. In een multiuser systeem kan dit worden gebruikt voor facturering.

  • Sleutel interfaces in een typisch computersysteem:

  • Instruction Set Architecture (ISA)
  • Application Binary Interface (IBA)
  • Application Programming Interface (API)
  • 2.1.2. Bronnenbeheerder

    Een computersysteem is verzameling van bronnen voor de verplaatsing, opslag en verwerking van data en de controle van deze functies. Het OS is verantwoordelijk voor het beheer van deze bronnen.

    Wat is een bron?

  • Bestand
  • Printer
  • Geheugen
  • Het besturingssysteem is best onafhankelijk van de bronnen die het moet beheren. (zie boek pagina 70)

    Regelt het OS de verplaatsing, opslag en verwerking van data?

    NEEN

  • OS functioneert op dezelfde manier als andere programmaís
  • OS geeft regelmatig de controle uit handen aan de processor
  • Wat doet het OS dan wel?

  • Bepaalt hoe de CPU andere bronnen toewijst
  • Planning van de bronnen
  • Planning uitvoeren van verschillende programmaís
  • Wat is er nodig?

  • Wisselwerking OS ⇔ CPU (interrupts)
  • Leveren programmacode
  • Welke 3 niveaus belangrijk bij gebruik bronnen/programmaís?

  • Ruimte
    Voldoende plaats in geheugen

  • Tijd
    Genoeg CPU tijd voorzien

  • I/O
    Zijn de I/O apparaten beschikbaar

  • 2.1.3. Evolutie

    Waarom evolueert een operating system?

  • Hardware verbeteringen en nieuwe typen van hardware
  • Nieuwe diensten
  • Bugs oplossen
  • 2.2. Evolutie

    Om de kernbenodigdheden van een operating systeem te kunnen begrijpen is het handig om te weten hoe besturingssystemen zijn geŽvolueerd door de jaren heen.

    2.2.1. SeriŽle of enkelvoudige verwerking

    Op de eerste computers werd de computer hardware rechtstreeks bestuurd door de programmeur, omdat er nog geen OS was.

    De computer werd bediend via een console van displaylichten, tuimelschakelaars, en een of andere vorm van invoerapparaat en een printer.

    Programma's in machinetaal werden geladen via een invoerapparaat (b.v. ponskaarten.)

    Foutmeldingen werden zichtbaar gemaakt via lichten op het consolebord.

    Vroegere systemen kenden twee hoofdproblemen:

  • Planningsregeling
    Een gebruiker kreeg een bepaalde tijd toegewezen en zijn tijd stopte ook al was het werk niet af.
  • Opstarttijd
    Een enkelvoudig programma, c.q. Job omvatte:
  • laden van de compiler samen met het high-level language programma (broncode) in het geheugen
  • opslaan van het gecompileerd programma (objectcode)
  • Laden en linken van de objectcode en algemene functies
  • Andere nadelen:

  • SeriŽle verwerking betekende slechts ťťn programma per keer
  • Bijna onmogelijk te debuggen. Fouten enkel door uitvoer via lichtjes of printer zichtbaar
  • Elk van deze stappen had betrekking met het koppelen of ontkoppelen van tapes of het opzetten van ponskaarten (card decks). Een fout resulteerde dat je wee van voor af aan kan starten.

    2.2.1.1. Werking IBM 1620

  • Geheugen vorige sessie wissen

  • Ponskaarten met de compiler SW laden

  • Ponskaarten met eigen programmacode laden

  • Compilatie genereert nieuwe set ponskaarten (intermediate set). Eventuele fouten in de compilatie worden weergegeven door alarmlichtjes

  • Leegmaken geheugen en inladen van de linker programmatuur via ponskaarten

  • De intermediate set ponskaarten laden

  • Het linkproces genereert een nieuwe set ponskaarten (executable set)

  • Geheugen wissen

  • Executable set ponskaarten inladen + alle nodige libraries inladen

  • 2.2.2. Eenvoudige batchverwerking

    Omdat computers in het begin zeer kostbaar waren, was het belangrijk om de computertijd zo efficiŽnt mogelijk te benutten. De verloren plannings- en opstarttijd waren onacceptabel.

    Om aan dit probleem tegemoet te komen, werd het eerste batch OS midden jaren 1950 ontwikkeld. Dit was ontwikkeld door General Motors voor gebruik op IBM machines.

    2.2.2.1. Monitor

    Het centrale idee achter de eenvoudige batchverwerking is het gebruik van een programma de zogenoemde monitor. Met dit type OS had de gebruiker niet langer meer directe toegang tot de processor. In plaats daarvan moest de gebruiker de job aanleveren via punch-kaarten of tapes aan de computeroperator die deze sequentieel samenvoegde tot een aaneengesloten groep die dit compleet geheel ook weer via punch-kaarten of tapes inlaadde voor gebruik door de monitor.

    Om te begrijpen hoe dit schema werkt bekijken we dit langs twee kanten: de kant van de monitor en dat van de processor.

    Kant monitor:

  • Grootst mogelijke deel zit altijd in het intern geheugen (IG). Dit wordt ook wel de residentiŽle monitor genoemd.

  • Hulpprogramma's en gemeenschappelijke functies welke worden geladen aan het begin van een job indien nodig.

  • Stappen in een batch

  • Job inlezen

  • Plaatsen in de User Program Area (UPA)

  • Monitor bepaalt wanneer job wordt uitgevoerd

  • Monitor geeft controle aan job

  • Job uitvoeren

  • Job geeft uitvoer door aan printer

  • Job geeft controle terug aan monitor

  • Monitor laadt volgende job

  • Kant processor:

  • Voert instructies uit van delen van het hoofdgeheugen waar de monitor zich bevindt

  • Job wordt ingelezen in een ander deel van het interne geheugen

  • Na het inlezen geeft de monitor de processor een executiesprong naar het begin van het gebruikersprogramma

  • Processor blijft instructies uitvoeren tot het einde van het programma, een fout of interrupt (eerste modellen hadden nog geen interrupts)

  • De monitor of batch OS is eenvoudig een computerprogramma. Het steunt op het vermogen van de processor om instructies op te halen uit verschillende delen van het hoofdgeheugen om vervolgens deze te claimen en weer los te laten. Bepaalde hardware mogelijkheden zijn wenselijk:

  • Geheugen beveiliging
    In het geval dat een gebruikersprogramma een deel van het geheugen probeert te wijzigen waar de monitor zich bevindt, moet de processor hardware deze fout opmerken en de controle teruggeven aan de monitor.

  • Timer
    De timer voorkomt dat een programma het systeem kan monopoliseren. Na een bepaalde tijd wordt de controle terug aan de monitor gegeven.

  • Speciale instructies
    Bepaalde op machine niveau gelegen instructies zijn enkel voorbehouden aan de monitor. In het geval dat het gebruikersprogramma ze toch zou uitvoeren wordt de controle teruggeven aan het monitorprogramma.
    B.v. I/O toegang instructies, job control instructies

  • Interrupts
    Interrupts worden ingesteld om de controle over te nemen van een job.

  • 2.2.2.2. Modus van uitvoeren

    De beschouwingen van geheugenbeveiliging en speciale instructie heeft geleid tot een concept van uitvoeringmodus.

  • Gebruikersmodus
    Bepaalde delen worden beveiligd voor de gebruiker en waarin bepaalde instructies niet mogen worden uitgevoerd.
  • Kernel of systeemmodus
    Speciale instructies en in beveiligde geheugenruimtes kunnen worden uitgevoerd.
  • Bij een batch OS, tijd schakelt tussen uitvoering gebruikersprogramma en monitor. Twee nadelen zijn hier aan verbonden:

  • Deel van het geheugen wordt overgenomen door de monitor
  • Deel van de processortijd wordt overgenomen door de monitor
  • Ondanks deze overhead, verbeterd het gebruik van de computer bij de eenvoudige batchverwerking.

    2.2.3. Meervoudige batchverwerking

    Zelfs bij eenvoudige batchverwerking loopt de processor vaak idle. Omdat probleem tegen te gaan heeft men de meervoudige batchverwerking ontwikkeld. Meerdere programma's worden gelijktijdig in het geheugen geladen en hierdoor kan men efficiŽnt schakelen tussen de programma's om de onnodige I/O wachttijden te overbruggen. Dit schakelen tussen applicaties heet multiprogrammering of multitasking welk een centraal thema is in een modern OS.

    In tegenstelling tot eenvoudige batchsystemen, moeten meervoudige batchverwerkers kunnen werken met bepaalde computer hardware functies. De voornaamste zijn de I/O interrupts en DMA (direct memory access). Met deze functies kan de processor een I/O commando afgeven voor ťťn job en doorgaan met een andere job terwijl de I/O wordt verder uitgevoerd door de hardware controller. Zodra de I/O operatie is voltooid wordt de processor onderbroken met een interrupt en de controle wordt afgewerkt door de interrupt-handler in het OS.

    Meervoudig programmeerbare besturingssystemen zijn tamelijk geavanceerd vergeleken met een enkelvoudig programma of enkelvoudig programmeerbare systemen.

    Om verschillende jobs startklaar te houden moet er voldaan worden aan een of andere vorm van:

  • Geheugenbeheer
  • Job planner
  • 2.2.4. Timesharing

    Alhoewel het gebruik van meervoudig programmeerbare batchverwerking zeer efficiŽnt kan zijn is er soms nood aan een modus waarin de gebruiker rechtstreeks werkt met de computer. Voor sommige jobs zoals transactie verwerking is een interactieve modus essentieel.

    De noodzaak voor interactieve verwerking wordt opgelost door middel van een eigen computer of werkstation.

    Dit was in de jaren 1960 niet mogelijk door de fysieke grootheid en het financiŽle kostenaspect. In de plaats daarvan werd timesharing ontwikkeld.

    Bij het vroeger gedeeld systeem (timesharing) kon men:

  • Meerdere batch jobs op hetzelfde moment uitvoeren
  • Processortijd verdelen over meerdere gebruikers
  • Eigenschappen van dit systeem heet time-slicing:

  • Meerdere gebruikers op het gelijke moment
  • OS verdeelt tijd evenredig over de gebruikers
  • Bv 5 gebruikers, elke gebruiker heeft 1/5 van de tijd.
  • Dankzij trage menselijke reactie lijkt het alsof het even snel is als men zou werken op een eigen machine
  • 2.3. Belangrijkste realisaties

    Besturingssystemen behoren tot de meest complexe stukken software ooit ontwikkeld. Dit weerspiegeld de uitdaging om proberen toe te komen aan de moeilijke en soms concurrerende objectieven van gemak, efficiŽntie en de mogelijkheid om zich verder te ontwikkelen. Dit stelt voor dat er vier theoretische omstandigheden zijn in de ontwikkeling van besturingssystemen.

    2.3.1. Processen

    Het centrale thema in het ontwerp van een besturingssysteem is het concept van een proces, ook een ietwat meer algemenere term voor job.

    Enkele definities voor de term proces:

  • Programma in uitvoering
  • Een instantie van een programma in uitvoering op de computer
  • Een entiteit dat kan worden toegewezen en worden uitgevoerd door de processor
  • Een eenheid van activiteit gekenmerkt door een enkele sequentiŽle uitvoeringsketen (thread), huidige status en geassocieerde set van systeembronnen
  • De drie belangrijkste gebieden van computer systemen creŽerde problemen in de timing en synchronisatie van de volgende gebieden:

  • Multiprogrammering
    Dit was ontworpen om de processor en I/O apparaten, inclusief opslagapparaten simultaan bezig te houden om maximale efficiŽntie te bereiken.
  • General-purpose time sharing
    Het sleutelobjectief was dat het ontwerp responsief was voor de behoeften van de individuele gebruiker, voor de kostprijs en moest mogelijk zijn meerdere gebruikers simultaan te kunnen verwerken.
  • Real-time transactie systemen
    In dit geval een aantal gebruikers voeren een query in of updates in een database
  • De voornaamste tool voor systeemprogrammeurs in de ontwikkeling van vroegere multiprogrammering en multi-user interactieve systemen was de interrupt. De activiteit van eender welke job kon worden onderbroken bij het gebeuren van een gedefinieerde event (bv I/O voltooiing). De processor bewaarde de huidige staat van de CPU (PC en registers) en begon instructies uit te voeren van de interrupt routine en als het hier mee klaar was vervolgde hij het oorspronkelijk programma.

    Het ontwerp van de systeem software die deze acties coŲrdineerde was ontzettend moeilijk. Met veel jobs tegelijk in uitvoering, waar bij elk een aantal stappen moest worden ondernomen, was het bijna onmogelijk het aantal combinaties van sequenties van events te analyseren.

    Door het ontbreken van systematiek van coŲrdinatie en coŲperatie tussen activiteiten gebruikten programmeurs ad-hoc methoden gebruikmakend van hun kennis van de omgeving wat eigenlijk door het OS geregeld moest worden. Deze inspanningen waren kwetsbaar voor kleine programmeerfouten waarvan de effecten enkel konden worden opgemerkt wanneer vreemde of ongewone reeksen van acties zich voordeden. Deze fouten waren zeer moeilijk te diagnosticeren omdat gesplitst moesten worden van applicatie software en hardware fouten. De condities waarin de fouten optraden waren zeer moeilijk reproduceerbaar. In het algemene termen kon men spreken voor vier hoofdoorzaken van zulke fouten:

  • Onjuiste synchronisatie
    Vaak het geval als een routine moet worden onderbroken om ergens anders in het systeem een event af te handelen. Onjuist ontwerp het signalering mechanisme kan er toe leiden dat signalen verloren gaan of dat er dubbele signalen ontvangen worden. (bv. Een programma initieert dat een I/O leesopdracht moet wachten totdat data beschikbaar is in de buffer voordat hij verder mag gaan. In zulke gevallen een signaal van een of andere routine is nodig.
  • Gefaalde wederzijdse uitsluiting
    Dit is dikwijls het geval als twee of meer gebruikers of programma's een gedeelde bron proberen te benaderen zonder dat er mechanismen zijn voorzien om dit te regelen. (bv. De toegang en wijziging van een bestand door verschillende gebruikers op hetzelfde moment)
  • Niet-deterministische programma uitvoering
    Als programma's geheugen delen en hun uitvoering wordt onderbroken door de processor, kan er onvoorspelbare interferentie optreden met een ander programma als geheugen wordt overschreven
  • Deadlocks
    Het is mogelijk dat twee of meer programma's op elkaar blijven wachten. (bv. Als twee programma's I/O apparaten nodig hebben voor een of andere operatie (disk naar tape kopiŽren) Een programma neemt controle over ťťn apparaat en het andere programma neemt de controle over het andere apparaat.)
  • Om deze problemen te vermijden is een systematische manier nodig om de verschillende uitvoerende programma's op de processor te monitoren en te controleren. We zouden kunnen denken aan een proces van drie componenten:

  • Een uitvoerbaar programma
  • De behorende data benodigd door het programma (variabelen, werkruimte, buffers, etc...)
  • Uitvoeringscontext van het programma
  • De uitvoeringscontext of processtatus is essentieel en is de interne data benodigd is door het OS om te kunnen superviseren en de processen te controleren. De context bevat de inhoud van de diverse processorregisters, zoals programmateller en data registers. Ook bevat het informatie nodig voor het OS zoals de prioriteit van het proces en of het proces wachtend is op de voltooiing van een bepaald I/O event.

    2.3.2. Geheugenbeheer

    De behoeften van gebruikers is het beste in een omgeving waarin modulaire programmering en het flexibel gebruik van data wordt toegepast. Systeembeheerders daarentegen hebben veelal een efficiŽnt en gecontroleerde opslaglocatie nodig. Om te voldoen aan deze vereisten heeft het OS een aantal beheeropslag verantwoordelijkheden.

  • Proces isolatie
    Het OS moet zorgen dat onafhankelijke processen geen interferentie veroorzaken in elkaars geheugen.

  • Automatisch allocatie en beheer
    Programma's moeten het geheugen dynamisch worden toegewezen transparant voor de programmeur. Het OS bereikt een hogere efficiŽntie door enkel geheugen toe te wijzen wat nodig is.

  • Ondersteuning van modulaire programmering
    Voor programmeurs moet het mogelijk zijn om dynamisch programmamodules te creŽren, wijzigen en te verwijderen.

  • Beveiliging en toegangscontrole
    Het delen van geheugen in eender welke hiŽrarchie van het geheugen geeft de mogelijkheid elkaars geheugen te adresseren. Dit is wenselijk als het nodig, dit kan ook een risico zijn voor de programma's en het OS. Het OS moet toelaten om delen van het geheugen op verschillende manieren te benaderen.

  • Lange termijnopslag
    Ook nadat de computer is uitgeschakeld is het soms nodig dat informatie bewaard moet blijven.

  • Besturingssystemen voldoen aan deze vereisten met virtueel geheugen en bestandsbeheer faciliteiten. Het bestandssysteem zorgt voor een lange-termijn opslag, waarin informatie wordt opgeslagen in objecten genaamd bestanden. Het bestand is een handig concept voor de programmeur en is bruikbare basis voor toegangscontrole en beveiliging door het OS.

    Virtueel geheugen is een faciliteit dat programmeurs toelaat om vanuit een logisch oogpunt geheugen te adresseren.

    Omdat niet alle processen tegelijk in het geheugen kunnen bestaan is het paging system ontworpen. Dit laat toe om processen uit te maken in een aantal fixed-size blokken, genaamd pages. Het pagineringssyteem laat toe om dynamisch het virtueel en fysiek geheugenadres in kaart te brengen.

  • Virtual address
    Is een referentie bestaande uit een pagina nummer en een offset binnen die pagina.
  • Real address
    Dit is het fysieke adres in het hoofdgeheugen.
  • De volgende stap was om referenties te maken die niet in het fysiek geheugen zaten. Alle pagina's van een proces bevonden op een externe opslaglocatie. Zodra een proces een pagina nodig had dat niet in het geheugen was geladen zorgde het hardware matige geheugenbeheer ervoor dat de missende pagina werd geladen.

    2.3.3. Gegevensbescherming en veiligheid

    De expansie in het gebruik van timesharing en meer recent computernetwerken zorgt samen voor een groei van beveiliging van informatie, alhoewel er algemene hulpprogramma's zijn dat kan worden ingebouwd in de computer en besturingssystemen dat kan zorgen voor diverse beschermings- en beschermingsmiddelen. Beveiliging en bescherming met bettrekking tot besturingssystemen kan men ruwweg in vier groepen indelen:

  • Beschikbaarheid
    Betrokken bij de bescherming van het systeem tegen onderbreking
  • Vertrouwelijkheid
    Zorgt ervoor dat gebruikers geen data kan lezen waar ze niet voor gemachtigd zijn
  • Data integriteit
    Bescherming van data tegen ongeoorloofde wijziging
  • Authenticiteit
    Betrokken met de juiste identiteitsverificatie en geldigheid van berichten of data
  • 2.3.4. Planning en bronnenbeheer

    Een hoofdverantwoordelijkheid van een OS is het beheren van diverse beschikbare bronnen (hoofdgeheugenruimte, I/O apparaten, processors) en hun gebruik te plannen door diverse actieve processen. Eender welke brontoewijzing en planningsbeleid moet volgende drie factoren beschouwen:

  • Evenredigheid
    We zouden graag alle competitieve processen voor het gebruik van een bepaalde bron ongeveer evenveel en billijke toegang willen verschaffen tot die bron. Dit is vooral bij jobs van dezelfde klasse, en zelfde behoeften en noden.
  • DifferentiŽle responsiviteit
    Aan de andere kant moet het OS soms discrimineren tussen diverse klassen van jobs met verschillende servicebehoeften. Het OS moet proberen beslissingen toe te kennen en te plannen om te voldoen aan de totale behoeften. Het OS moet deze beslissingen dynamisch kunnen nemen. (bv. Als een proces aan het wachten is op het gebruik van een I/O apparaat, kan het OS zo snel als mogelijk beslissen om te uitvoering van het proces later in te plannen zodat mogelijk wordt het apparaat vrij te geven voor behoeften in een ander proces.
  • EfficiŽntie
    Het OS moet proberen om de throughput te maximaliseren, de responsetijd te minimaliseren en in het geval van timesharing plaats te bieden aan zoveel mogelijk gebruikers als mogelijk.
  • Planning- en bronnenbeheer zijn in wezen essentiŽle uitvoerings-onderzoek problematieken en de rekenkundige resultaten van die discipline kan worden toegepast. Om de prestaties te monitoren of aan te passen is belangrijk om metingen en aanpassingen van de systeemactiviteit te kunnen doen.

    2.4. Moderne besturingssysteem ontwikkelingen

    De snelheid van veranderingen in de vraag naar behoeften van een besturingssysteem, niet enkel modificaties en verbeteringen in bestaande architecturen maar nieuwe manieren om het OS te organiseren. Een brede waaier van verschillende manieren van aanpakken en ontwerpelementen zijn uitgeprobeerd in zowel experimentele als commerciŽle besturingssystemen. Veel van dit werk past in de volgende categorieŽn:

  • Microkernel architectuur
  • Multithreading
  • Symmetrische meervoudige verwerking
  • Gedistribueerde besturingssystemen
  • Object georiŽnteerd ontwerp
  • 2.4.1. Microkernel architectuur

    De meeste besturingssystemen, tot recentelijk, werden gevormd door een monolithische kernel. Het meeste waar men aan kon denken dat het OS functionaliteit betrof was voorzien in grote kernels, inclusief planning, bestandsbeheer, netwerkfunctionaliteit, stuurprogramma's, geheugenbeheer enzovoorts.

    Een monolithische kernel is geÔmplementeerd als een enkelvoudig proces, waarin alle elementen dezelfde adresruimte delen. Een microkernel architectuur wijst enkel een paar essentiŽle functies toe aan de kernel, inclusief adresruimte, interprocescommunicatie (IPC) en basisplanning.

    Andere OS diensten worden voorzien door processen, soms servers genaamd, die in user mode draaien en in de microkernel zoals elk ander programma wordt behandelt. Deze aanpak zorgt voor de loskoppeling tussen kernel en server ontwikkeling.

    2.4.2. Multithreading

    Multithreading is een techniek waarbij een proces een applicatie uitvoert en deze verdeeld over verschillende uitvoeringsketens (threads) die gelijktijdig uitgevoerd kunnen worden.

  • Thread
    Een thread is een verdeelbare werkeenheid dat eveneens de processor context (de programmateller en stack pointer) en zijn eigen datagebied voor een stack (om subroutinetakken mogelijk te maken) bevat. Een thread word sequentieel uitgevoerd en is interrupteerbaar zodat de processor kan schakelen naar een andere thread.
  • Proces
    Een proces is een verzameling van ťťn of meerdere threads en geassocieerde systeembronnen. Dit correspondeert dicht bij het concept van een programma in uitvoering. Door een programma op te splitsen in verschillende threads heeft de programmeur grote controle over de modulariteit van de applicatie en de timing van applicatie gerelateerde gebeurtenissen.
  • Multithreading is handig voor applicatie die een aantal taken moet uitvoeren dat niet nodig is dat die taken serieel moeten gebeuren.

    2.4.3. Symmetrische multiprocessing

    Symmetrische multiprocessing (SMP) is een term dat refereert naar een computer hardware architectuur alsook OS gedrag dat die architectuur exploiteert. Het OS van een SMP plant processen of threads over alle processors. SMP heeft een aantal mogelijke voordelen ten opzichte van een uniprocessor architectuur inclusief het volgende:

  • Performantie
    Als de computer het werk zo kan organiseren dat delen van het werk parallel kan gebeuren, dan heeft een systeem met meerdere processoren een hogere rekenkracht dat een systeem met een enkele processor.
  • Beschikbaarheid
    Omdat alle processors in een symmetrische dezelfde functies kunnen uitvoeren zal het uitvallen van ťťn processor niet tot een stop leiden van het systeem. Men zal enkel last hebben van verminderde prestaties.
  • Incrementele toename
    Een gebruiker kan rekenkracht toevoegen door processors toe te voegen.
  • Schaalbaarheid
    Door systemen met verschillende aantallen processoren te configureren kan met producten aanbieden met verschillende prijzen en verschillende prestaties.
  • 2.4.4. Gedistribueerd besturingssysteem

    Een gedistribueerd operating systeem schept de illusie dat het systeem bestaat uit:

  • 1 hoofdgeheugen
  • 1 secundair geheugen
  • een gedistribueerd bestandssysteem
  • Andere eengemaakte toegangsfaciliteiten
  • Alhoewel clusters zeer populair worden, blijven ze achter ten opzichte van de uniprocessor en SMP besturingssystemen.

    2.4.5. Object-georiŽnteerd ontwerp

    Een andere innovatie in besturingssysteemontwerp is het gebruik van objectgeoriŽnteerde technologieŽn. Het object georiŽnteerd ontwerp zorgt ervoor dat

    Dat je modulaire extensies kan toevoegen aan een kleine kernel. Op OS niveau kunnen programmeurs het OS aanpasbassen zonder de systeemintegriteit te verstoren. Het vergemakkelijkt de ontwikkeling van gedistribueerde tools en volledige gedistribueerde besturingssystemen.

    2.5. Virtuele Machines

    2.5.1. Virtuele machines en virtualisatie

    Traditioneel worden applicaties rechtstreeks op het besturingssysteem van een PC of server uitgevoerd. Iedere PC of server zou ťťn besturingssysteem tegelijk draaien. Een verkoper moest iedere applicatie herschrijven voor het gebruik op een ander OS/platform.

    Virtualisatie maakt het mogelijk om meerdere besturingssystemen gelijktijdig te draaien op een besturingssysteem. Een machine met virtualisatie kan vele applicaties uitvoeren, zelfs diegene die op andere moeten worden uitgevoerd op andere besturingssystemen.

    In wezen kan het gast besturingssysteem meerdere virtuele machines (VM) aanbieden, met elk de karakteristieken van een bepaald OS.

    De virtuele machine monitor (VMM), of hypervisor, draait boven op (of is ingebouwd in) de gast OS. De VMM ondersteund VM's welke geŽmuleerde hardware apparaten zijn.

    2.5.2. Virtuele machine architectuur

    Beschouw een proces die een gecompileerd applicatie uitvoert. Vanuit het proces oogpunt, de machine waarop het wordt uitgevoerd, bestaat uit een aan het proces toegewezen virtuele adresruimte, de processorregisters welke het gebruikt, de gebruikersniveau instructies dat het mag uitvoeren en de OS system calls welke het mag gebruiken voor I/O. Dus de ABI definieert de machine vanuit het oogpunt van een proces.

    Vanuit het perspectief van een applicatie, zijn de machine karakteristieken gespecificeerd bij high-level taal mogelijkheden, OS en systeem bibliotheek oproepen (calls). Dus de API definieert de machine voor een applicatie.

    Voor het besturingssysteem, doet de machine hardware het systeem definiŽren dat de werking van het OS en de talrijke samenwerkende processen ondersteund.

    Herhalingsvragen

    1. Wat zijn drie doelstellingen van een besturingssysteemontwerp?

      Gemak: Een besturingssysteem maakt een computer handiger in het gebruik.
      EfficiŽntie: Een besturingssysteem maakt het mogelijk om  computer systeembronnen op een efficiŽnte wijze te gebruiken.
      Mogelijkheid om te evolueren: Een besturingssysteem moet op zodanige wijze geconstrueerd zijn dat toelaat om effectief te ontwikkelen, te testen en nieuwe systeem functies te introducteren zonder interferentie van service.
       
    2. Wat is de kernel van een besturingssysteem?

      De kernel is een gedeelte van het besturingssysteem dat de meest gebruikte gedeelten van software bevat. In het algemeen zit de kernel permanent in het hoofdgeheugen. De kernel draait in een bevoorrechte modus en reageert op oproepen van processen en interrupts van apparaten.
       
    3. Wat is multiprogrammering?

      Multiprogrammering is een manier van werken die voorziet in tussengevoegde uitvoering van twee of meer computerprogramma's op een enkele processor.
       
    4. Wat is een proces?

      Een proces is een programma in uitvoering. Een proces wordt door het besturingssysteem gecontroleerd en gepland.
       
    5. Hoe wordt de uitvoeringscontext van een proces door het besturingssysteem gebruikt?

      De uitvoeringscontext, of de procestoestand, is het interne gegeven waarmee het besturingssysteem in staat is om toezicht en controle over het proces te houden. Deze interne informatie is gescheiden van het proces, omdat het besturingssysteem informatie heeft die niet toegestaan is voor het proces. De context bevat alle informatie die het besturingssysteem moet hebben om het proces te beheren en dat de processor nodig heeft het proces correct te kunnen uitvoeren. De context bevat de inhoud van de verschillende processorregisters, zoals de programmateller en data registers. Het bevat ook nuttige informatie voor het besturingssysteem, zoals de prioriteit van het proces en of het proces wacht op de voltooiing van een bepaalde I/O-gebeurtenis.
       
    6. Benoem en beschrijf beknopt vijf opslagbeheerverantwoordelijkheden van een standaardbesturingssysteem.

      Procesisolatie: Het besturingssysteem moet voorkomen dat onafhankelijke processen interfereren met het geheugen van de ander, zowel voor data als instructies.
      Automatische toewijzing en het beheer:
      Programma's moeten dynamisch worden verdeeld over de geheugenhiŽrarchie zoals vereist. Toewijzing dient transparant te zijn voor de programmeur. De programmeur wordt dus ontlast van de zorgen met betrekking tot de geheugenbeperkingen, en het besturingssysteem kan efficiŽnter worden door het toekennen van het geheugen aan jobs alleen als dat nodig is.
      Ondersteuning van modulaire programmering:
      Programmeurs moeten in staat zijn om de programmamodules dynamisch te definiŽren, aan te maken, verwijderen, en de grootte te veranderen.
      Beveiliging en toegangscontrole:
      Het delen van het geheugen, op elk gewenst niveau van de geheugenhiŽrarchie, schept de mogelijkheid van een programma om het de geheugenruimte van een ander te adresseren. Dit is gewenst wanneer het delen nodig voor bepaalde toepassingen. Op andere momenten, in dit een dreiging van de integriteit van programma's en zelfs het besturingssysteem zelf. Het besturingssysteem moet toestaan dat delen van het geheugen toegankelijk zijn en op verschillende manieren voor verschillende gebruikers.
      Langdurige opslag:
      Veel applicatieprogramma's vereisen middelen voor het opslaan van informatie voor langere tijd, nadat computer is uitgeschakeld.
       
    7. Beschrijf het verschil tussen een reŽel adres en een virtueel adres.

      Een virtueel adres verwijst naar een geheugen locatie in het virtuele geheugen. Die locatie is op schijf en op sommige momenten in het hoofdgeheugen. Een reŽel adres is een adres in het hoofdgeheugen.
       
    8. Beschrijf de round-robin planningstechniek.

      Round robin is een planningssalgoritme waarin processen in in een vaste cyclische orde geactiveerd worden; dat wil zeggen, dat alle processen in een cirkelvormige wachtrij zitten. Een proces dat niet verder kan gaan omdat het wacht op een gebeurtenis (bijvoorbeeld beŽindiging van een child-proces of een input/output bewerking) geeft controle terug aan de planner.
       
    9. Beschrijf het verschil tussen een monolithische kernel en een microkernel.

      Een monolithische kernel is een grote kernel dat  vrijwel het volledige operationele systeem bevat, met inbegrip van planning, bestandssysteem, stuurprogramma's, en het geheugenbeheer. Alle functionele onderdelen van de kernel hebben toegang tot al zijn internedata structuren en routines. Typisch wordt een monolithische kernel geÔmplementeerd als een enkel proces, met alle elementen dezelfde adresruimte delen.
      Een microkernel is een kleine bevoorrechte besturingssysteem kern van dat voorziet in procesplanning, geheugenbeheer, en communicatie diensten en zich op andere processen beroept om een deel van de functies te laten uitvoeren die traditioneel geassocieerd is met de besturingssysteem kernel.
       
    10. Wat  is multithreading?

      Multithreading is een techniek waarbij een proces, de een applicatie uitvoert, verdeeld wordt over threads die gelijktijdig kunnen draaien.
       
    11. Som de belangrijkste kwesties op voor een SMP-besturingssysteem.

    Probleemvraagstukken

    1. Stel we hebben een computer met multiprogrammering waarin elke taak dezelfde kenmerken heeft. In ťťn berekeningsperiode, T, voor een taak wordt de ene helft van de tijd besteed aan I/O en de andere helft aan processoractiviteit. Elke taak wordt in perioden uitgevoerd. Veronderstel dat een eenvoudige round-robinprioriteit wordt gebruikt en dat I/O-bewerkingen en processorbewerkingen elkaar kunnen overlappen Gebruik de volgende grootheden:

      omlooptijd = werkelijk benodigde tijd voor het voltooien van een taak;
      doorvoer = gemiddeld aantal taken dat wordt voltooid in tijdsperiode T;
      bezettingsgraad processor = percentage van de tijd dat de processor actief is (niet wacht).

      Bereken deze grootheden voor ťťn, twee en vier gelijktijdige taken en veronderstel daarbij dat de periode Top de twee volgende manieren is verdeeld:

      1. 110 eerste helft; processor tweede helft.
      2. 110 eerste en vierde kwart; processor tweede en derde kwart.

      The answers are the same for (a) and (b). Assume that although processor
      operations cannot overlap, I/O operations can.
      1 Job: TAT = NT Processor utilization = 50%
      2 Jobs: TAT = NT Processor utilization = 100%
      4 Jobs: TAT = (4N Ė 2)T Processor utilization = 100%
       

    2. Een I/O-gebonden programma is een programma dat als het alleen wordt uitgevoerd. meer tijd besteedt aan het wachten op 1/0 dan aan het gebruiken van de processor. Een processorgebonden programma is het tegenovergestelde. Stel dat een algoritme voor kortetermijnscheduling voorrang geeft aan programmaís die in het recente verleden weinig processortijd hebben gebruikt. Leg uit waarom deze algoritme voorrang geeft aan 1/0-gebonden programmaís maar toch niet permanent geen processortijd toewijst aan processorgebonden programmaís.

      I/O-bound programs use relatively little processor time and are therefore favored by the algorithm. However, if a processor-bound process is denied processor time for a sufficiently long period of time, the same algorithm will grant the processor to that process since it has not used the processor at all in the recent past. Therefore, a processor-bound process will not be permanently denied access.
       
    3. Vergelijk de schedulingstrategieŽn die u zou gebruiken voor het optimaliseren van een timesharingsysteem met de strategieŽn die u zou gebruiken voor het optimaliseren van een batchsysteem met multiprogrammering.

      With time sharing, the concern is turnaround time. Time-slicing is preferred because it gives all processes access to the processor over a short period of time. In a batch system, the concern is with throughput, and the less context switching, the more processing time is available for the processes. Therefore, policies that minimize context switching are favored.
       
    4. Wat is het doel van systeemaanroepen en welke rol spelen systeemaanroepen in het besturingssysteem en in het concept van verwerking in dual-mode (kernelmode en gebruikersmode)?

      A system call is used by an application program to invoke a function provided by the operating system. Typically, the system call results in transfer to a system program that runs in kernel mode.
       
    5. In OS/390, een besturingssysteem van IBM voor mainframes, is een van de belangrijkste modules in de kernel de System Resource Manager (SRM). Deze module is verantwoordelijk voor het toewijzen van bronnen aan adresruimten (processen). SRM geeft OS/390 een mate van verfijning die uniek is onder besturingssystemen Geen ander besturingssysteem voor mainframes, en zeker geen ander type besturingssysteem, kan tippen aan de functies die de SRM uitvoert. Het concept van een bron omvat de processor, reŽel geheugen en I/O-kanalen. De SRM verzamelt statistische gegevens over het gebruik van de processor, de kanalen en diverse belangrijke gegevensstructuren. Het doel van de SRM is het bieden van optimale prestaties basis van de bewaking en de analyse van de prestaties. Er worden prestatiedoelen voor het systeem opgesteld en deze dienen als richtlijnen voor de SRM, die het systeem en de prestatiekenmerken van taken dynamisch aanpast op basis van gebruik van het systeem. De SRM maakt ook rapporten, die de getrainde operat kan gebruiken voor het bijstellen van de systeem- en parameterinstellingen om dienstverlening aan de gebruiker te verbeteren.
      Deze opgave betreft een voorbeeld van de activiteit van de SRM. Het reŽle geheugen wordt verdeeld in even grote blokken die frames worden genoemd en waarvan er duizenden kunnen zijn. Elk frame kan een blok met virtueel geheugen bevatten dat een pagina wordt genoemd. De SRM krijgt ongeveer twintig keer per seconde het beheer over het systeem en inspecteert alle paginaframes. Is er niet verwezen naar de pagina of is de pagina niet gewijzigd, dan wordt een teller verhoogd met 1. De SRM berekent het gemiddelde van deze waarden over een bepaalde tijdsperiode om het gemiddeld aantal seconden te bepalen dat een paginaframe in het systeem ongebruikt blijft. Wat zou het doel hiervan kunnen zijn en welke actie zou de SRM kunnen uitvoeren?
       
    6. A multiprocessor with eight processors has 20 attached tape drives. There is a large  number of jobs submitted to the system that each require a maximum of four tape drives to complete execution. Assume that each job starts running with only three tape drives for a long period before requiring the fourth tape drive for a short period toward the end of its operation. Also assume an endless supply of such jobs.
      1. Assume the scheduler in the OS will not start a job unless there are four tape drives available. When a job is started, four drives are assigned immediately and are not released until the job finishes. What is the maximum number of jobs that can be in progress at once? What are the maximum and minimum number of tape drives that may be left idle as a result of this policy?
      2. Suggest an alternative policy to improve tape drive utilization and at the same time avoid system deadlock. What is the maximum number of jobs that can be in progress at once? What are the bounds on the number of idling tape drives?