Introduksjon til operativsystemer
Hei Habr! Jeg vil gjerne gjøre deg oppmerksom på en serie artikler-oversettelser av en interessant litteratur etter min mening - OSTEP. Dette materialet diskuterer ganske dypt arbeidet til unix-lignende operativsystemer, nemlig arbeid med prosesser, ulike planleggere, minne og andre lignende komponenter som utgjør et moderne OS. Du kan se originalen av alt materiale her . Vær oppmerksom på at oversettelsen ble gjort uprofesjonelt (ganske fritt), men jeg håper jeg beholdt den generelle betydningen.
Laboratoriearbeid om dette emnet finner du her:
- opprinnelig:
- opprinnelig:
- min personlige tilpasning:
Andre deler:
Du kan også sjekke kanalen min på =)
La oss se på den mest grunnleggende abstraksjonen som OS gir brukere: prosessen. Definisjonen av prosessen er ganske enkel - det er den kjørende program. Selve programmet er en livløs ting som ligger på disken - det er et sett med instruksjoner og muligens noen statiske data som venter på å bli lansert. Det er operativsystemet som tar disse bytene og kjører dem, og transformerer programmet til noe nyttig.
Som oftest ønsker brukere å kjøre mer enn ett program samtidig, for eksempel kan du kjøre en nettleser, spill, mediespiller, tekstredigering og lignende på den bærbare datamaskinen. Faktisk kan et typisk system kjøre titalls eller hundrevis av prosesser samtidig. Dette faktum gjør systemet enklere å bruke, du trenger aldri å bekymre deg for om CPU-en er ledig, du kjører bare programmer.
Dette reiser problemet: hvordan gi illusjonen av mange CPUer? Hvordan kan operativsystemet skape en illusjon av et nesten uendelig antall CPUer, selv om du bare har én fysisk CPU?
OS skaper denne illusjonen gjennom CPU-virtualisering. Ved å starte en prosess, deretter stoppe den, starte en annen prosess, og så videre, kan operativsystemet opprettholde illusjonen om at det er mange virtuelle CPUer, når det faktisk vil være en eller flere fysiske prosessorer. Denne teknikken kalles deling av CPU-ressurser etter tid. Denne teknikken lar brukere kjøre så mange samtidige prosesser de ønsker. Kostnaden for denne løsningen er ytelse - siden hvis CPU deles av flere prosesser, vil hver prosess bli behandlet langsommere.
For å implementere CPU-virtualisering, og spesielt for å gjøre det bra, trenger operativsystemet både lavnivå- og høynivåstøtte. Lavt nivå støtte kalles mekanismer er lavnivåmetoder eller protokoller som implementerer den nødvendige delen av funksjonaliteten. Et eksempel på slik funksjonalitet er kontekstbytte, som gir operativsystemet muligheten til å stoppe ett program og kjøre et annet program på prosessoren. Denne tidsinndelingen er implementert i alle moderne operativsystemer.
På toppen av disse mekanismene er en viss logikk innebygd i operativsystemet, i form av "policyer". Politikk er en bestemt beslutningsalgoritme for operativsystemet. Slike retningslinjer bestemmer for eksempel hvilket program som skal startes (fra en liste over kommandoer) først. Så, for eksempel, vil dette problemet løses av en policy kalt planlegger (planleggingspolicy) og når du velger en løsning, vil den bli styrt av slike data som: oppstartshistorikk (hvilket program ble lansert lengst i løpet av de siste minuttene), hvilken belastning denne prosessen bærer (hvilke typer programmer ble lansert), ytelsesmålinger (om systemet er optimalisert for interaktiv interaksjon eller for gjennomstrømning ) og så videre.
Abstraksjon: prosess
Abstraksjonen av et kjørende program som kjøres av operativsystemet er det vi kaller prosess. Som nevnt tidligere, er en prosess ganske enkelt et kjørende program, til enhver umiddelbar tidsperiode. Et program som vi kan hente sammendragsinformasjon fra ulike systemressurser som dette programmet får tilgang til eller påvirker under utførelse.
For å forstå komponentene i prosessen, må du forstå tilstandene til systemet: hva programmet kan lese eller endre under driften. Til enhver tid må du forstå hvilke elementer i systemet som er viktige for gjennomføringen av programmet.
En av de åpenbare elementene i systemet sier at prosessen inkluderer er minne. Instruksjoner er plassert i minnet. Dataene som programmet leser eller skriver ligger også i minnet. Dermed er minnet som en prosess kan adressere (kalt adresserom) en del av prosessen.
En del av systemtilstanden er også registre. Mange instruksjoner er rettet mot å endre verdien på registre eller lese verdien av dem, og dermed blir også registre en viktig del av driften av prosessen.
Det skal bemerkes at maskintilstanden også dannes fra noen spesielle registre. For eksempel, IP - instruksjonspeker — en peker til instruksjonen som programmet kjører for øyeblikket. Det er også stabelpekeren og relatert til det rammepeker, som brukes til å administrere: funksjonsparametere, lokale variabler og returadresser.
Endelig har programmer ofte tilgang til ROM (skrivebeskyttet minne). Denne "I/O"-informasjonen (input/output) bør inkludere en liste over filer som for øyeblikket er åpne av prosessen.
Prosess API
For å forbedre vår forståelse av hvordan prosessen fungerer, la oss studere eksempler på systemanrop som bør inkluderes i et hvilket som helst operativsystemgrensesnitt. Disse API-ene er tilgjengelige i en eller annen form på et hvilket som helst operativsystem.
● Opprett (oppretting): OS må inkludere en metode som lar deg lage nye prosesser. Når du skriver inn en kommando i terminalen eller starter et program ved å dobbeltklikke på et ikon, sendes et anrop til operativsystemet for å opprette en ny prosess og deretter starte det angitte programmet.
● Fjerning: Siden det er et grensesnitt for å lage en prosess, bør operativsystemet også gi muligheten til å tvinge fjerning av en prosess. De fleste programmer vil naturlig starte og avslutte av seg selv mens de kjører. Ellers vil brukeren gjerne kunne drepe dem, og dermed vil et grensesnitt for å stoppe prosessen være nyttig.
● Vent (venter): Noen ganger er det nyttig å vente på at en prosess skal fullføres, så noen grensesnitt er gitt som gir mulighet til å vente.
● Diverse kontroll (diverse kontroll): I tillegg til å drepe og vente på prosessen, finnes det også andre ulike kontrollmetoder. For eksempel gir de fleste operativsystemer muligheten til å fryse en prosess (stoppe kjøringen i en viss periode) og deretter gjenoppta den (fortsette kjøringen)
● status (tilstand): Det finnes ulike grensesnitt for å få informasjon om statusen til en prosess, for eksempel hvor lenge den har kjørt eller hvilken tilstand den er i.
Prosessoppretting: Detaljer
En av de interessante tingene er hvordan akkurat programmer omdannes til prosesser. Spesielt hvordan OS plukker opp og kjører programmet. Hvordan nøyaktig prosessen er opprettet.
Først av alt må operativsystemet laste programkoden og statiske data inn i minnet (inn i prosessadresserommet). Programmer er vanligvis plassert på en disk eller solid-state-stasjon i et eller annet kjørbart format. Dermed krever prosessen med å laste inn program og statiske data inn i minnet at operativsystemet kan lese disse bytene fra disken og plassere dem et sted i minnet.
I tidlige operativsystemer ble oppstartsprosessen gjort ivrig, noe som betyr at hele koden ble lastet inn i minnet før programmet ble lansert. Moderne operativsystemer gjør dette dovent, det vil si at de laster kode eller data kun når programmet krever dem under kjøringen.
Når koden og statiske data er lastet inn i OS-minnet, er det noen flere ting som må gjøres før prosessen kan kjøres. En viss mengde minne må tildeles for stabelen. Programmer bruker stabelen for lokale variabler, funksjonsparametere og returadresser. OS tildeler dette minnet og gir det til prosessen. Stabelen kan også tildeles noen argumenter, spesifikt fyller den parametrene til main() funksjonen, for eksempel med en matrise av argc og argv.
Operativsystemet kan også allokere noe minne til programhaugen. Heapen brukes av programmer til å eksplisitt be om dynamisk allokert data. Programmer ber om denne plassen ved å kalle funksjonen malloc () og sletter den eksplisitt ved å kalle opp funksjonen gratis(). Heapen er nødvendig for datastrukturer som koblede ark, hashtabeller, trær og andre. Til å begynne med blir en liten mengde minne allokert til haugen, men over tid, mens programmet kjører, kan haugen be om mer minne gjennom bibliotekets API-kall malloc(). Operativsystemet er involvert i prosessen med å tildele mer minne for å tilfredsstille disse samtalene.
Operativsystemet vil også utføre initialiseringsoppgaver, spesielt de som er relatert til I/O. For eksempel, på UNIX-systemer, har hver prosess som standard 3 åpne filbeskrivelser, for standard input, output og feil. Disse håndtakene lar programmer lese input fra terminalen samt vise informasjon på skjermen.
Ved å laste kode og statiske data inn i minnet, opprette og initialisere stabelen og gjøre annet arbeid relatert til å utføre I/O-oppgaver, forbereder operativsystemet trinnet for at prosessen skal utføres. Til slutt er det en siste oppgave igjen: kjøre programmet gjennom inngangspunktet, kalt main()-funksjonen. Ved å utføre hovedfunksjonen() overfører operativsystemet CPU-kontroll til den nyopprettede prosessen, og dermed begynner programmet å kjøre.
Prosesstilstand
Nå som vi har en viss forståelse av hva en prosess er og hvordan den er opprettet, la oss liste opp prosesstilstandene den kan være i. I sin enkleste form kan en prosess være i en av disse tilstandene:
● kjører. Når du kjører, kjører prosessen på prosessoren. Dette betyr at instruksjoner blir utført.
● Klar. I klar-tilstanden er prosessen klar til å kjøre, men av en eller annen grunn kjører ikke OS den på det angitte tidspunktet.
● blokkert. I blokkert tilstand utfører en prosess noen operasjoner som hindrer den fra å være klar til å utføres før en hendelse inntreffer. Et vanlig eksempel er når en prosess starter en IO-operasjon, blir den blokkert slik at en annen prosess kan bruke prosessoren.
Du kan forestille deg disse tilstandene i form av en graf. Som vi kan se på bildet, kan prosesstilstanden endres mellom RUNNING og READY etter operativsystemets skjønn. Når tilstanden til en prosess endres fra KLAR til KJØRER, betyr det at prosessen er planlagt. I motsatt retning - fjernet fra oppsettet. I det øyeblikket en prosess blir BLOKKERT, for eksempel, starter jeg en IO-operasjon, OS vil holde den i denne tilstanden til en eller annen hendelse inntreffer, for eksempel fullføring av IO. i dette øyeblikk overgangen til KLAR-tilstanden og muligens umiddelbart til KJØR-tilstanden hvis OS bestemmer det.
La oss se på et eksempel på hvordan to prosesser beveger seg gjennom disse tilstandene. Til å begynne med, la oss forestille oss at begge prosessene kjører, og hver bruker bare CPU. I dette tilfellet vil statene deres se slik ut.
I det følgende eksempelet ber den første prosessen, etter en tid pågående, IO og går inn i BLOKKERT-tilstanden, slik at en annen prosess kan kjøres (FIG. 1.4). OS ser at prosess 0 ikke bruker CPU og starter prosess 1. Mens prosess 1 kjører, fullføres IO og statusen til prosess 0 endres til KLAR. Endelig er prosess 1 fullført, og etter fullføring starter prosess 0, utfører og fullfører arbeidet.
Data struktur
OS i seg selv er et program, og akkurat som ethvert annet program har det noen viktige datastrukturer som holder styr på ulike relevante opplysninger. For å spore tilstanden til hver prosess vil operativsystemet støtte noen prosessliste for alle prosesser i KLAR-tilstanden og noe tilleggsinformasjon for å spore prosesser som kjører for øyeblikket. OS bør også overvåke blokkerte prosesser. Etter at IO er fullført, må operativsystemet vekke den nødvendige prosessen og sette den i en tilstand klar til å kjøre.
For eksempel må operativsystemet bevare tilstanden til prosessorregistrene. I det øyeblikket prosessen stopper, lagres statusen til registrene i prosessens adresserom, og i det øyeblikket driften fortsetter, gjenopprettes verdiene til registrene og fortsetter dermed utførelsen av denne prosessen.
I tillegg til klare, blokkerte, kjørende tilstander, er det noen andre tilstander. Noen ganger, på tidspunktet for opprettelsen, kan en prosess være i INIT-tilstanden. Til slutt kan en prosess settes i ENDELIG tilstand når den allerede er fullført, men dens informasjon er ennå ikke slettet. På UNIX-systemer kalles denne tilstanden zombie prosess. Denne tilstanden er nyttig for tilfeller der en overordnet prosess ønsker å vite returkoden til et barn, for eksempel, vanligvis signaliserer 0 en suksess og 1 en feil, men programmerere kan utstede ytterligere utgangskoder for å signalisere forskjellige problemer. Når den overordnede prosessen avsluttes, foretar den et siste systemkall, for eksempel wait(), for å vente på at den underordnede prosessen avsluttes og signalisere til operativsystemet at den kan slette alle data knyttet til den avsluttede prosessen.
Hovedpunkter i foredraget:
● prosessen — hovedabstraksjonen av et kjørende program i operativsystemet. Til enhver tid kan en prosess beskrives ved dens tilstand: innholdet i minnet i adresserommet, innholdet i prosessorregistrene, inkludert instruksjonspeker og stabelpeker, og IO-informasjon, for eksempel åpne filer som leses eller skrives.
● Prosess API består av anrop som programmer kan gjøre til prosesser. Disse er vanligvis opprettelse, sletting eller andre samtaler.
● Prosessen er i en av mange tilstander, inkludert kjører, klar, blokkert. Ulike hendelser som planlegging, unntak fra planlegging eller venter kan endre tilstanden til en prosess fra én til en annen.
● Prosessliste inneholder informasjon om alle prosesser i systemet. Hver oppføring i den kalles en prosesskontrollblokk, som i virkeligheten er en struktur som inneholder all nødvendig informasjon om en spesifikk prosess.
Kilde: www.habr.com