Inleiding tot besturingssystemen

Hé Habr! Ik zou graag een reeks artikelen onder uw aandacht willen brengen - vertalingen van een naar mijn mening interessante literatuur: OSTEP. Dit materiaal bespreekt vrij diepgaand het werk van Unix-achtige besturingssystemen, namelijk het werken met processen, verschillende planners, geheugen en andere soortgelijke componenten waaruit een modern besturingssysteem bestaat. Hier kunt u het origineel van alle materialen bekijken hier. Houd er rekening mee dat de vertaling onprofessioneel (vrij vrij) is gemaakt, maar ik hoop dat ik de algemene betekenis heb behouden.

Labwerk over dit onderwerp is hier te vinden:
- origineel: pagina's.cs.wisc.edu/~remzi/OSTEP/Homework/homework.html
- origineel: github.com/remzi-arpacidusseau/ostep-code
- mijn persoonlijke aanpassing: github.com/bykvaadm/OS/tree/master/ostep

Je kunt ook kijken op mijn kanaal op telegram =)

Programma bediening

Wat gebeurt er als een programma wordt uitgevoerd? Een lopend programma doet één ding: het voert instructies uit. Elke seconde haalt de processor miljoenen en mogelijk zelfs miljarden instructies uit het RAM-geheugen, decodeert ze op zijn beurt (het herkent bijvoorbeeld tot welk type deze instructies behoren) en voert ze uit. Dit kan het optellen van twee getallen zijn, toegang krijgen tot het geheugen, een voorwaarde controleren, naar een functie springen, enzovoort. Na de uitvoering van de ene instructie gaat de processor verder met de uitvoering van een andere. En zo worden instructie na instructie uitgevoerd totdat het programma eindigt.
Dit voorbeeld wordt natuurlijk als vereenvoudigd beschouwd - om de processor te versnellen, kunt u met moderne hardware instructies voor uw beurt uitvoeren, mogelijke resultaten berekenen, instructies tegelijkertijd uitvoeren en soortgelijke trucs.

Von Neumann-berekeningsmodel

De door ons beschreven vereenvoudigde werkvorm is vergelijkbaar met het rekenmodel van Von Neumann. Von Neumann is een van de pioniers van computersystemen, hij is ook een van de auteurs van de speltheorie. Terwijl het programma draait, vinden er een heleboel andere gebeurtenissen plaats, veel andere processen en logica van derden, waarvan het belangrijkste doel is om de lancering, bediening en onderhoud van het systeem te vereenvoudigen.
Er is een set software die ervoor zorgt dat programma's eenvoudig kunnen worden uitgevoerd (of zelfs meerdere programma's tegelijkertijd kunnen worden uitgevoerd), waardoor programma's hetzelfde geheugen kunnen delen en met verschillende apparaten kunnen communiceren. Een dergelijke set software (software) wordt in wezen het besturingssysteem genoemd en zijn taken omvatten onder meer het controleren of het systeem correct en efficiënt werkt, en het zorgen voor een eenvoudig beheer van dit systeem.

Besturingssysteem

Besturingssysteem, afgekort als OS, is een reeks onderling gerelateerde programma's die zijn ontworpen om computerbronnen te beheren en gebruikersinteractie met een computer te organiseren..
Het besturingssysteem bereikt zijn effectiviteit in de eerste plaats door de belangrijkste techniek: de techniek virtualisatie. Het besturingssysteem communiceert met een fysieke bron (processor, geheugen, schijf, enz.) en transformeert deze in een meer algemene, krachtigere en gemakkelijker te gebruiken vorm van zichzelf. Daarom kunt u voor een algemeen begrip het besturingssysteem grofweg vergelijken met een virtuele machine.
Om gebruikers in staat te stellen opdrachten aan het besturingssysteem te geven en zo de mogelijkheden van de virtuele machine te gebruiken (zoals het uitvoeren van een programma, het toewijzen van geheugen, toegang tot een bestand, enzovoort), biedt het besturingssysteem een ​​interface genaamd API (Application Programming Interface) en waarnaar u kunt bellen (call). Met een typisch besturingssysteem kunnen honderden systeemaanroepen worden gedaan.
Ten slotte, aangezien virtualisatie het mogelijk maakt dat meerdere programma's worden uitgevoerd (waardoor de CPU wordt gedeeld), en tegelijkertijd toegang hebben tot hun instructies en gegevens (waardoor geheugen wordt gedeeld), en toegang krijgen tot schijven (waardoor I/O-apparaten worden gedeeld). ), wordt het besturingssysteem ook wel een resource beheerder. Elke processor, schijf en geheugen is een bron van het systeem, en dus wordt een van de rollen van het besturingssysteem de taak om deze bronnen te beheren, dit efficiënt, eerlijk of vice versa te doen, afhankelijk van de taak waarvoor dit besturingssysteem is ontworpen.

CPU-virtualisatie

Beschouw het volgende programma:
(https://www.youtube.com/watch?v=zDwT5fUcki4&feature=youtu.be)

Het voert geen speciale acties uit, in feite roept het alleen een functie aan spinnen(), wiens taak het is om door de tijdcontrole te bladeren en na één seconde terug te keren. Het herhaalt dus voor onbepaalde tijd de string die de gebruiker als argument heeft doorgegeven.
Laten we dit programma uitvoeren en het karakter "A" als argument doorgeven. Het resultaat is niet bijzonder interessant - het systeem voert gewoon een programma uit dat periodiek het teken "A" weergeeft.
Laten we nu de optie proberen wanneer veel instanties van hetzelfde programma actief zijn, maar verschillende letters uitvoeren om het duidelijker te maken. In dit geval zal het resultaat iets anders zijn. Ondanks dat we één processor hebben, wordt het programma gelijktijdig uitgevoerd. Hoe gebeurt het? Maar het blijkt dat het besturingssysteem, niet zonder de hulp van hardwaremogelijkheden, een illusie creëert. De illusie dat het systeem meerdere virtuele processors heeft, waardoor een enkele fysieke processor in een theoretisch oneindig aantal verandert en daardoor ogenschijnlijk programma's gelijktijdig kunnen worden uitgevoerd. Deze illusie wordt genoemd CPU-virtualisatie.
Deze afbeelding roept veel vragen op, bijvoorbeeld, als er meerdere programma's tegelijkertijd willen draaien, welke wordt er dan gestart? Het "beleid" van het besturingssysteem is verantwoordelijk voor deze vraag. Beleid wordt op veel plaatsen in het besturingssysteem gebruikt en beantwoordt dit soort vragen, en is de basismechanismen die het besturingssysteem implementeert. Vandaar de rol van het besturingssysteem als resourcemanager.

Geheugenvirtualisatie

Laten we nu eens kijken naar het geheugen. Het fysieke geheugenmodel in moderne systemen wordt weergegeven als een reeks bytes.. Om uit het geheugen te lezen, moet u specificeren mobiel adresom er toegang toe te krijgen. Om gegevens te schrijven of bij te werken, moet u ook de gegevens specificeren en het adres van de cel waar u ze wilt schrijven.
Het geheugen wordt constant gebruikt tijdens de uitvoering van het programma. Een programma slaat zijn volledige gegevensstructuur op in het geheugen en benadert deze door verschillende instructies uit te voeren. De instructies worden ondertussen ook in het geheugen opgeslagen, dus het is ook toegankelijk voor elk verzoek voor de volgende instructie.

malloc() bellen

Beschouw het volgende programma, dat een geheugengebied toewijst met behulp van de aanroep malloc () (https://youtu.be/jnlKRnoT1m0):

Het programma doet verschillende dingen. Eerst wijst het wat geheugen toe (regel 7), drukt vervolgens het adres van de toegewezen cel af (regel 9), schrijft nul naar het eerste slot van het toegewezen geheugen. Vervolgens komt het programma in een lus waarin het de waarde verhoogt die is opgeslagen in het geheugen op het adres in de variabele "p". Het drukt ook de proces-ID van zichzelf af. De proces-ID is uniek voor elk lopend proces. Nadat we meerdere exemplaren hebben gelanceerd, zullen we een interessant resultaat tegenkomen: in het eerste geval, als u niets doet en slechts meerdere exemplaren gebruikt, zullen de adressen anders zijn. Maar dit valt niet onder onze theorie! Klopt, aangezien moderne distributies geheugenrandomisatie standaard hebben ingeschakeld. Als het is uitgeschakeld, krijgen we het verwachte resultaat - de geheugenadressen van twee gelijktijdig lopende programma's komen overeen.

Als gevolg hiervan blijken twee onafhankelijke programma's te werken met hun eigen privé-adresruimten, die op hun beurt door het besturingssysteem worden toegewezen aan het fysieke geheugen. Daarom heeft het gebruik van geheugenadressen binnen één programma op geen enkele manier invloed op andere, en het lijkt voor elk programma alsof het zijn eigen stukje fysiek geheugen heeft, dat er volledig aan is gegeven. De realiteit is echter dat fysiek geheugen een gedeelde bron is die wordt beheerd door het besturingssysteem.

Consistentie

Een ander belangrijk onderwerp binnen besturingssystemen is − samenhang. Deze term wordt gebruikt wanneer we het hebben over problemen in het systeem die kunnen optreden wanneer met veel dingen tegelijkertijd binnen hetzelfde programma wordt gewerkt. Consistentieproblemen doen zich zelfs binnen het besturingssysteem zelf voor. In de vorige voorbeelden van geheugen- en processorvirtualisatie realiseerden we ons dat het besturingssysteem veel dingen tegelijkertijd beheert: het start het eerste proces, dan het tweede, enzovoort. Het bleek dat dit gedrag tot problemen kan leiden. Moderne multi-threaded programma's ondervinden bijvoorbeeld dergelijke moeilijkheden.

Beschouw het volgende programma:

Het programma in de hoofdfunctie maakt twee threads met behulp van de aanroep pthread_create(). In dit voorbeeld kan een thread worden gezien als een functie die naast andere functies in dezelfde geheugenruimte wordt uitgevoerd, waarbij duidelijk meer dan één functie tegelijkertijd wordt uitgevoerd. In dit voorbeeld start en voert elke thread de functie uit worker() die op zijn beurt eenvoudig de variabele verhoogt,.

Laten we dit programma uitvoeren met een argument van 1000. Zoals je misschien al geraden had, zou het resultaat 2000 moeten zijn omdat elke thread de variabele 1000 keer heeft opgehoogd. Alles is echter niet zo eenvoudig. Laten we proberen het programma uit te voeren met een orde van grootte meer herhalingen.

Door een getal in te voeren, bijvoorbeeld 100000, verwachten we de uitvoer te zien als het getal 200000. Als we echter het getal 100000 meerdere keren uitvoeren, zien we niet alleen het juiste antwoord niet, maar krijgen we ook verschillende foute antwoorden. Het antwoord ligt in het feit dat om het getal te verhogen drie bewerkingen nodig zijn: het getal uit het geheugen halen, verhogen en vervolgens het getal terugschrijven. Omdat al deze instructies niet atomair (allemaal tegelijkertijd) worden uitgevoerd, kunnen dit soort vreemde dingen gebeuren. Dit probleem wordt in programmeren genoemd race conditie. Wanneer onbekende krachten op een onbekend moment de prestaties van al uw operaties kunnen beïnvloeden.

Bron: www.habr.com