Introduktion till operativsystem
Hej Habr! Jag skulle vilja uppmärksamma dig på en serie artiklar-översättningar av en intressant litteratur enligt min mening - OSTEP. Detta material diskuterar ganska djupt arbetet med unix-liknande operativsystem, nämligen arbete med processer, olika schemaläggare, minne och andra liknande komponenter som utgör ett modernt operativsystem. Du kan se originalet av allt material här . Observera att översättningen gjordes oprofessionellt (ganska fritt), men jag hoppas att jag behöll den allmänna innebörden.
Labbarbete i detta ämne finns här:
- original:
- original:
- min personliga anpassning:
Övriga delar:
Du kan också kolla in min kanal på =)
Låt oss titta på den mest grundläggande abstraktionen som operativsystemet ger användarna: processen. Definitionen av processen är ganska enkel - det är det kör program. Programmet i sig är en livlös sak som ligger på disken - det är en uppsättning instruktioner och möjligen en del statisk data som väntar på att lanseras. Det är operativsystemet som tar dessa bytes och kör dem, förvandlar programmet till något användbart.
Oftast vill användare köra mer än ett program samtidigt, till exempel kan du köra en webbläsare, spel, mediaspelare, textredigerare och liknande på din bärbara dator. Faktum är att ett typiskt system kan köra tiotals eller hundratals processer samtidigt. Detta faktum gör systemet lättare att använda, du behöver aldrig oroa dig för om processorn är ledig, du kör bara program.
Detta väcker problemet: hur kan man ge illusionen av många processorer? Hur kan operativsystemet skapa en illusion av ett nästan oändligt antal processorer, även om du bara har en fysisk processor?
OS skapar denna illusion genom CPU-virtualisering. Genom att starta en process, sedan stoppa den, starta en annan process, och så vidare, kan operativsystemet upprätthålla illusionen att det finns många virtuella processorer, när det i själva verket kommer att finnas en eller flera fysiska processorer. Denna teknik kallas uppdelning av CPU-resurser efter tid. Denna teknik tillåter användare att köra så många samtidiga processer som de vill. Kostnaden för denna lösning är prestanda - eftersom om processorn delas av flera processer kommer varje process att bearbetas långsammare.
För att implementera CPU-virtualisering, och speciellt för att göra det bra, behöver operativsystemet både lågnivå- och högnivåstöd. Lågnivåstöd kallas mekanismer är lågnivåmetoder eller protokoll som implementerar den nödvändiga delen av funktionaliteten. Ett exempel på sådan funktionalitet är kontextväxling, vilket ger operativsystemet möjlighet att stoppa ett program och köra ett annat program på processorn. Denna tidsindelning är implementerad i alla moderna operativsystem.
Ovanpå dessa mekanismer finns en viss logik inbyggd i operativsystemet, i form av "policyer". RџRѕR "Republic, ReRєR ° är en viss beslutsalgoritm för operativsystemet. Sådana policyer bestämmer till exempel vilket program som ska startas (från en lista med kommandon) först. Så, till exempel, kommer detta problem att lösas genom en policy som kallas schemaläggare (schemaläggningspolicy) och när man väljer en lösning kommer den att styras av sådana data som: starthistorik (vilket program lanserades längst under de senaste minuterna), vilken belastning denna process bär (vilka typer av program som lanserades), prestandamått (om systemet är optimerad för interaktiv interaktion eller för genomströmning ) och så vidare.
Abstraktion: process
Abstraktionen av ett körande program som körs av operativsystemet är vad vi kallar process. Som nämnts tidigare är en process helt enkelt ett pågående program, vid vilken som helst momentan tidsperiod. Ett program med vilket vi kan få sammanfattande information från olika systemresurser som detta program kommer åt eller påverkar under dess körning.
För att förstå komponenterna i processen måste du förstå systemets tillstånd: vad programmet kan läsa eller ändra under dess drift. Vid varje given tidpunkt måste du förstå vilka delar av systemet som är viktiga för programmets exekvering.
En av de uppenbara delarna av systemet säger att processen inkluderar är minne. Instruktionerna finns i minnet. Data som programmet läser eller skriver finns också i minnet. Således är minnet som en process kan adressera (kallat adressutrymme) en del av processen.
En del av systemtillståndet är också register. Många instruktioner syftar till att ändra värdet på register eller läsa deras värde, och därmed blir register också en viktig del av processens drift.
Det bör noteras att maskintillståndet också bildas av några speciella register. Till exempel, IP - instruktionspekare — en pekare till instruktionen som programmet för närvarande kör. Det finns också stack pekaren och relaterat till det rampekare, som används för att hantera: funktionsparametrar, lokala variabler och returadresser.
Slutligen har program ofta åtkomst till ROM (skrivskyddat minne). Denna "I/O" (ingång/utgång) information bör innehålla en lista över filer som för närvarande är öppna av processen.
Process API
För att förbättra vår förståelse för hur processen fungerar, låt oss studera exempel på systemanrop som bör inkluderas i alla operativsystems gränssnitt. Dessa API:er är tillgängliga i en eller annan form på vilket operativsystem som helst.
● Skapa (skapande): OS måste innehålla någon metod som låter dig skapa nya processer. När du anger ett kommando i terminalen eller startar ett program genom att dubbelklicka på en ikon skickas ett anrop till operativsystemet för att skapa en ny process och sedan starta det angivna programmet.
● Borttagning: Eftersom det finns ett gränssnitt för att skapa en process, bör operativsystemet också ge möjligheten att tvinga bort en process. De flesta program kommer naturligtvis att starta och avsluta av sig själva när de körs. Annars skulle användaren vilja kunna döda dem och därför skulle ett gränssnitt för att stoppa processen vara användbart.
● Vänta (väntar): Ibland är det användbart att vänta på att en process ska slutföras, så vissa gränssnitt tillhandahålls som ger möjlighet att vänta.
● Övrigt kontroll (diverse kontroll): Förutom att döda och vänta på processen finns det även andra olika kontrollmetoder. Till exempel ger de flesta operativsystem möjligheten att frysa en process (stoppa dess körning under en viss period) och sedan återuppta den (fortsätta körningen)
● status (tillstånd): Det finns olika gränssnitt för att få viss information om status för en process, till exempel hur länge den har pågått eller vilket tillstånd den är i för närvarande.
Processskapande: Detaljer
En av de intressanta sakerna är hur exakt program omvandlas till processer. Speciellt hur operativsystemet plockar upp och kör programmet. Hur exakt processen skapas.
Först och främst måste operativsystemet ladda programkoden och statiska data i minnet (i processadressutrymmet). Program finns vanligtvis på en disk eller SSD-enhet i något körbart format. Processen att ladda program och statisk data till minnet kräver alltså att operativsystemet kan läsa dessa bytes från disken och placera dem någonstans i minnet.
I tidiga operativsystem gjordes laddningsprocessen ivrigt, vilket innebär att hela koden laddades in i minnet innan programmet lanserades. Moderna operativsystem gör detta lätt, det vill säga laddar kod eller data endast när programmet kräver dem under dess körning.
När koden och statiska data har laddats in i OS-minnet, finns det några fler saker som måste göras innan processen kan köras. En viss mängd minne måste tilldelas för stacken. Program använder stacken för lokala variabler, funktionsparametrar och returadresser. OS allokerar detta minne och ger det till processen. Stacken kan också allokeras med vissa argument, specifikt fyller den parametrarna för main()-funktionen, till exempel med en array av argc och argv.
Operativsystemet kan också allokera lite minne till programhögen. Högen används av program för att explicit begära dynamiskt allokerad data. Program begär detta utrymme genom att anropa funktionen malloc () och rensar den explicit genom att anropa funktionen fri(). Högen behövs för datastrukturer som länkade ark, hashtabeller, träd och andra. Till en början allokeras en liten mängd minne till högen, men med tiden, när programmet körs, kan högen begära mer minne genom bibliotekets API-anrop malloc(). Operativsystemet är involverat i processen att allokera mer minne för att hjälpa till att tillfredsställa dessa samtal.
Operativsystemet kommer också att utföra initieringsuppgifter, särskilt de som är relaterade till I/O. Till exempel, på UNIX-system har varje process som standard tre öppna filbeskrivningar, för standardinmatning, utdata och fel. Dessa handtag gör att program kan läsa indata från terminalen samt visa information på skärmen.
Sålunda, genom att ladda kod och statisk data i minnet, skapa och initiera stacken och utföra annat arbete relaterat till att utföra I/O-uppgifter, förbereder operativsystemet scenen för att processen ska köras. Slutligen finns det en sista uppgift kvar: köra programmet genom dess ingångspunkt, kallad main()-funktionen. Genom att köra funktionen main() överför operativsystemet CPU-kontroll till den nyskapade processen, så att programmet börjar köras.
Processtillstånd
Nu när vi har en viss förståelse för vad en process är och hur den skapas, låt oss lista processtillstånden den kan vara i. I sin enklaste form kan en process vara i ett av dessa tillstånd:
● Springa. När den körs körs processen på processorn. Det betyder att instruktioner exekveras.
● Klar. I redo-läget är processen redo att köras, men av någon anledning kör OS den inte vid den angivna tidpunkten.
● Blockerad. I blockerat tillstånd utför en process vissa operationer som förhindrar att den är redo att köras tills någon händelse inträffar. Ett vanligt exempel är när en process initierar en IO-operation, blir den blockerad så att någon annan process kan använda processorn.
Du kan föreställa dig dessa tillstånd i form av en graf. Som vi kan se på bilden kan processtillståndet ändras mellan RUNNING och READY efter operativsystemets gottfinnande. När tillståndet för en process ändras från REDO till RUNNING betyder det att processen har schemalagts. I motsatt riktning - borttagen från layouten. I det ögonblick då en process blir BLOCKERAD, till exempel, initierar jag en IO-operation, OS kommer att hålla den i detta tillstånd tills någon händelse inträffar, till exempel slutförandet av IO. i detta ögonblick övergången till READY-tillståndet och eventuellt omedelbart till RUNNING-läget om OS beslutar så.
Låt oss titta på ett exempel på hur två processer rör sig genom dessa tillstånd. Till att börja med, låt oss föreställa oss att båda processerna körs, och att var och en endast använder processorn. I det här fallet kommer deras stater att se ut så här.
I följande exempel begär den första processen, efter att ha kört en tid, IO och går in i BLOCKAT-tillståndet, vilket tillåter en annan process att köras (FIG 1.4). OS ser att process 0 inte använder CPU och startar process 1. Medan process 1 körs är IO slutförd och statusen för process 0 ändras till READY. Slutligen har process 1 slutförts, och efter avslutad start startar process 0, exekverar och avslutar sitt arbete.
Datastruktur
Själva operativsystemet är ett program, och precis som alla andra program har det några viktiga datastrukturer som håller reda på olika relevanta delar av information. För att spåra tillståndet för varje process kommer operativsystemet att stödja vissa processlista för alla processer i READY-tillståndet och viss ytterligare information för att spåra processer som för närvarande körs. Dessutom bör operativsystemet övervaka blockerade processer. När IO är klar måste operativsystemet väcka den nödvändiga processen och sätta den i ett läge redo att köras.
Till exempel måste operativsystemet bevara tillståndet för processorregistren. I det ögonblick som processen stannar lagras registrens tillstånd i processens adressutrymme, och i det ögonblick som dess drift fortsätter återställs registrens värden och fortsätter således exekveringen av denna process.
Förutom klara, blockerade, körande tillstånd, finns det några andra tillstånd. Ibland, vid tidpunkten för skapandet, kan en process vara i INIT-tillståndet. Slutligen kan en process placeras i FINAL-läge när den redan har slutförts, men dess information har ännu inte rensats. På UNIX-system kallas detta tillstånd zombieprocess. Det här tillståndet är användbart för fall där en överordnad process vill veta returkoden för ett barn, till exempel brukar 0 signalera en framgång och 1 ett fel, men programmerare kan utfärda ytterligare utgångskoder för att signalera olika problem. När den överordnade processen avslutas gör den ett sista systemanrop, såsom wait(), för att vänta på att den underordnade processen ska avslutas och signalera till operativsystemet att den kan rensa all data som är associerad med den avslutade processen.
Huvudpunkter i föreläsningen:
● process — den huvudsakliga abstraktionen av ett program som körs i operativsystemet. Vid varje given tidpunkt kan en process beskrivas av dess tillstånd: innehållet i minnet i dess adressutrymme, innehållet i processorregister, inklusive instruktionspekare och stackpekare, och IO-information, såsom öppna filer som läses eller skrivs.
● Process API består av anrop som program kan göra till processer. Dessa är vanligtvis skapa, ta bort eller andra samtal.
● Processen är i ett av många tillstånd, inklusive kör, klar, blockerad. Olika händelser som schemaläggning, undantag från schemaläggning eller väntan kan ändra tillståndet för en process från en till en annan.
● Processlista innehåller information om alla processer i systemet. Varje post i den kallas ett processkontrollblock, vilket i själva verket är en struktur som innehåller all nödvändig information om en specifik process.
Källa: will.com