Introduktion till operativsystem

Hej, Habr! Jag vill presentera en serie artiklar med översättningar av en intressant litteratur — OSTEP. I detta material behandlas arbetet med Unix-liknande operativsystem på djupet, speciellt — hantering av processer, olika schemaläggare, minne och andra liknande komponenter som utgör ett modernt OS. Originalet av allt material kan du se här ). Ett typiskt exempel på användning:. Observera att översättningen är utförd oprofessionellt (relativt fritt), men jag hoppas att jag har bevarat den övergripande meningen.

Laborationsarbeten för detta ämne kan hittas här:
— originalet: pages.cs.wisc.edu/~remzi/OSTEP/Homework/homework.html
— originalet: github.com/remzi-arpacidusseau/ostep-code
— min personliga anpassning: github.com/bykvaadm/OS/tree/master/ostep

Och du kan också kolla in min kanal på telegram =)

Programmets arbete

Vad händer egentligen när ett program körs? Ett startat program utför en enkel uppgift — det exekverar instruktioner. Varje sekund hämtas miljoner, kanske till och med miljarder instruktioner av processorn från det interna minnet, som sedan dekoderar dem (till exempel identifierar vilken typ av instruktioner detta är) och exekverar dem. Detta kan inkludera att addera två siffror, få åtkomst till minnet, kontrollera ett villkor, hoppa till en funktion och så vidare. Efter att en instruktion har genomförts går processorn vidare till att utföra nästa. På så sätt exekveras instruktionerna en efter en tills programmet avslutas.
Detta exempel är naturligtvis förenklat — i verkligheten gör modern hårdvara det möjligt för processorn att exekvera instruktioner utanför sin ordning, beräkna möjliga resultat, exekvera instruktioner samtidigt och andra liknande knep för att snabba upp arbetet.

Von Neumann-modellen för beräkning

Den förenklade form som vi har beskrivit liknar Von Neumann-modellen för beräkningar. Von Neumann var en av pionjärerna inom datorsystem och en av författarna till spelteorin.. Under programkörningen inträffar många andra händelser, många andra processer och extern logik arbetar, vars huvudsakliga syfte är att förenkla starten, driften och underhållet av systemet.
Det finns en uppsättning programvara som ansvarar för att förenkla körningen av program (eller till och med möjliggör körning av flera program samtidigt), den låter program dela samma minne samt interagera med olika enheter. Denna programuppsättning kallas i grunden operativsystem och dess uppgifter inkluderar att övervaka så att systemet fungerar korrekt och effektivt, samt att säkerställa att systemet är lätt att hantera.

Operativsystem

Operativsystem, förkortat OS, är en uppsättning relaterade program som är avsedda att hantera datorresurser och organisera användarens interaktion med datorn..
OS uppnår sin effektivitet främst genom den viktigaste tekniken — tekniken för virtualisering.. OS interagerar med fysiska resurser (processor, minne, disk och liknande) och omvandlar dem till en mer generell, mer kapabel och enklare att använda form av sig själv. Därför kan man mycket grovt jämföra operativsystemet med en virtuell maskin för allmän förståelse.
För att möjliggöra för användare att ge kommandon till operativsystemet och därmed använda funktionerna hos den virtuella maskinen (såsom: köra program, tilldela minne, få tillgång till filer och så vidare), erbjuder operativsystemet ett gränssnitt som kallas API (application programming interface) och som man kan göra anrop (call) till. Ett typiskt operativsystem ger möjlighet att göra hundratals systemanrop.
Och slutligen, eftersom virtualisering tillåter många program att fungera (på så sätt dela CPU), och samtidigt få tillgång till deras instruktioner och data (därigenom dela minnet), samt få tillgång till diskar (på så sätt dela I/O-enheter), kallas operativsystemet också för resursförvaltare. Varje processor, disk och minne är systemresurser och därför blir en av operativsystemets roller att hantera dessa resurser, på ett effektivt, rättvist eller, tvärtom, beroende på uppgiften, som det operativsystemet är utvecklat för.

Virtualisering av CPU

Låt oss titta på följande program:
(https://www.youtube.com/watch?v=zDwT5fUcki4&feature=youtu.be)

Det utför inga särskilda åtgärder, allt det gör är att anropa funktionen spin(), vars uppgift är att cykliskt kontrollera tiden och returnera efter att en sekund har passerat. På så sätt upprepar den oändligt den sträng som användaren skickade som argument.
Låt oss köra detta program och ge den argumentet tecknet “A”. Resultatet blir inte särskilt intressant — systemet kör helt enkelt programmet som periodiskt skriver ut tecknet “A”.
Nu ska vi prova ett alternativ där flera instanser av samma program körs men skriver ut olika bokstäver för att göra det tydligare. I detta fall kommer resultatet att bli något annat. Trots att vi har en processor kör programmen samtidigt. Hur kan det vara så? Det är så att operativsystemet, med hjälp av hårdvarans möjligheter, skapar en illusion. Illusionen av att det finns flera virtuella processorer i systemet, vilket gör att en fysisk processor teoretiskt kan fungera som oändligt många och därmed låta programmen se ut som om de körs samtidigt. Denna illusion kallas CPU-virtualisering.
Denna bild ger upphov till många frågor, till exempel, om flera program vill starta samtidigt, vilket program kommer att startas? Denna fråga besvaras av “policyer” inom operativsystemet. Policyer används på många ställen i operativsystemet och svarar på liknande frågor, och de är även de grundläggande mekanismer som operativsystemet implementerar. Härifrån kommer operativsystemets roll som resurshanterare.

Minnevirtualisering

Nu låt oss titta på minnet. Den fysiska modellen av minnet i moderna system representeras som en matris av byte. För att läsa från minnet måste man ange adress för cellen, för att få tillgång till den. För att skriva eller uppdatera data behöver man också ange data samt adressen på cellen där de ska skrivas.
Åtkomster till minnet sker kontinuerligt under programmets körning. Programmet lagrar hela sin dataskruktur i minnet och kommer åt den medan det utför olika instruktioner. Instruktioner lagras också i minnet, så åtkomst sker också vid varje begäran för nästa instruktion.

Anrop av malloc()

Låt oss överväga följande program som allokerar minne genom ett anrop malloc() (https://youtu.be/jnlKRnoT1m0):

Programmet gör flera saker. Först allokerar det en viss mängd minne (rad 7), sedan skriver det ut adressen för den allokerade cellen (rad 9), och skriver noll i den första sloten av det allokerade minnet. Därefter går programmet in i en loop där det inkrementerar värdet som skrivs i minnet vid adressen i variabeln “p”. Det skriver också ut processens eget ID. Process-ID:t är unikt för varje körd process. Om vi kör flera instanser av programmet kommer vi att stöta på ett intressant resultat: I det första fallet, om vi inte gör något särskilt och bara kör flera kopior, så kommer adresserna att vara olika. Men det här stämmer inte med vår teori! Rätt, eftersom den moderna distributionen har funktionen för minnesrandomisering aktiverad som standard. Om vi stänger av den, får vi det förväntade resultatet — minnesadresserna för två program som körs samtidigt kommer att överensstämma.

Så det visar sig att två oberoende program arbetar med sina egna privata adressutrymmen, som i sin tur tilldelas av operativsystemet i det fysiska minnet.. Därför kommer användningen av minnesadresser inom ett program inte att påverka andra, och varje program tror att det har sin egen bit av det fysiska minnet till självkostnadspris. Verkligheten är dock att det fysiska minnet är en delad resurs, vars hantering utförs av operativsystemet.

Konsistens

En annan viktig fråga inom operativsystem är konsistens. Detta begrepp används när man talar om problem i systemet som kan uppstå när man arbetar med många saker samtidigt inom ett och samma program. Konsistensproblem kan uppstå även i själva operativsystemet. I de tidigare exemplen med minnes- och processorvirtualisering förstod vi att operativsystemet hanterar många saker samtidigt — det startar den första processen, sedan den andra och så vidare. Det visar sig att detta beteende kan leda till vissa problem. Till exempel upplever moderna flermålsprogram sådana svårigheter.

Låt oss titta på följande program:

Programmet i huvudfunktionen skapar två trådar genom ett anrop Pthread_create(). I det här exemplet kan vi tänka på en tråd som en funktion som körs i ett minnesutrymme bredvid andra funktioner, där antalet funktioner som körs samtidigt tydligt är mer än en. I det här exemplet startar varje tråd och utför funktionen worker() som i sin tur helt enkelt inkrementerar en variabel.,.

Vi kör detta program med argumentet 1000. Som du kanske har gissat, bör resultatet bli 2000, eftersom varje tråd inkrementerade variabeln 1000 gånger. Men allt är inte så enkelt. Låt oss försöka köra programmet med ett antal upprepningar som är en ordning större.

Genom att mata in ett nummer, till exempel 100000, förväntar vi oss att se ett utgångsvärde på 200000. Men när vi kör nummer 100000 flera gånger, ser vi inte bara fel svar, utan vi får olika felaktiga svar. Gåtan ligger i att för att öka talet krävs tre operationer — att hämta talet från minnet, inkrementera och sedan skriva tillbaka talet. Eftersom dessa instruktioner inte utförs atomärt (alla samtidigt), kan sådana konstiga saker hända. Detta problem kallas i programmering race condition — tävlingsvillkor. När okända krafter vid okända tidpunkter kan påverka utförandet av vissa av dina operationer.

Källa: habr.com