Introduktion til operativsystemer
Hej Habr! Jeg vil gerne henlede din opmærksomhed på en række artikler-oversættelser af en interessant litteratur efter min mening - OSTEP. Dette materiale diskuterer ganske dybt arbejdet med unix-lignende operativsystemer, nemlig arbejde med processer, forskellige skemalæggere, hukommelse og andre lignende komponenter, der udgør et moderne OS. Du kan se originalen af alle materialer her . Bemærk venligst, at oversættelsen er lavet uprofessionelt (ganske frit), men jeg håber, at jeg har bevaret den generelle betydning.
Laboratoriearbejde om dette emne kan findes her:
- original:
- original:
- min personlige tilpasning:
Andre dele:
Du kan også tjekke min kanal på =)
Lad os se på den mest fundamentale abstraktion, som operativsystemet giver brugerne: processen. Definitionen af processen er ret enkel – det er den kørende program. Selve programmet er en livløs ting placeret på disken - det er et sæt instruktioner og muligvis nogle statiske data, der venter på at blive lanceret. Det er OS, der tager disse bytes og kører dem, og transformerer programmet til noget nyttigt.
Oftest ønsker brugere at køre mere end et program på samme tid, for eksempel kan du køre en browser, spil, medieafspiller, teksteditor og lignende på din bærbare computer. Faktisk kan et typisk system køre titusinder eller hundredvis af processer samtidigt. Denne kendsgerning gør systemet nemmere at bruge, du behøver aldrig at bekymre dig om, hvorvidt CPU'en er gratis, du kører bare programmer.
Dette rejser problemet: hvordan giver man illusionen om mange CPU'er? Hvordan kan operativsystemet skabe illusionen om et næsten uendeligt antal CPU'er, selvom du kun har én fysisk CPU?
OS skaber denne illusion gennem CPU-virtualisering. Ved at starte en proces, derefter stoppe den, starte en anden proces og så videre, kan operativsystemet opretholde illusionen om, at der er mange virtuelle CPU'er, mens der faktisk vil være en eller flere fysiske processorer. Denne teknik kaldes opdeling af CPU-ressourcer efter tid. Denne teknik giver brugerne mulighed for at køre så mange samtidige processer, som de ønsker. Prisen for denne løsning er ydeevne - da hvis CPU'en deles af flere processer, vil hver proces blive behandlet langsommere.
For at implementere CPU-virtualisering, og især for at gøre det godt, har operativsystemet brug for både lav-niveau og højt niveau support. Low level support kaldes mekanismer er metoder eller protokoller på lavt niveau, der implementerer den nødvendige del af funktionaliteten. Et eksempel på en sådan funktionalitet er kontekstskift, som giver operativsystemet mulighed for at stoppe et program og køre et andet program på processoren. Denne tidsinddeling er implementeret i alle moderne operativsystemer.
Oven i disse mekanismer er en vis logik indbygget i operativsystemet, i form af "politikker". Politik er en bestemt beslutningsalgoritme for operativsystemet. Sådanne politikker bestemmer for eksempel, hvilket program der skal startes (fra en liste over kommandoer) først. Så for eksempel vil dette problem blive løst ved en politik kaldet skemalægger (planlægningspolitik) og når du vælger en løsning, vil den blive styret af sådanne data som: opstartshistorik (hvilket program blev lanceret længst i de sidste minutter), hvilken belastning denne proces bærer (hvilke typer programmer blev lanceret), ydeevnemålinger (om systemet er optimeret til interaktiv interaktion eller til gennemstrømning ) og så videre.
Abstraktion: proces
Abstraktionen af et kørende program, der udføres af operativsystemet, kalder vi proces. Som nævnt tidligere er en proces simpelthen et kørende program, på et hvilket som helst øjeblikkeligt tidspunkt. Et program, hvormed vi kan få oversigtsoplysninger fra forskellige systemressourcer, som dette program får adgang til eller påvirker under dets udførelse.
For at forstå komponenterne i processen skal du forstå systemets tilstande: hvad programmet kan læse eller ændre under dets drift. Du skal til enhver tid forstå, hvilke elementer i systemet, der er vigtige for programmets eksekvering.
Et af de åbenlyse elementer i systemet, som processen omfatter, er hukommelse. Instruktionerne er placeret i hukommelsen. De data, som programmet læser eller skriver, er også placeret i hukommelsen. Den hukommelse, som en proces kan adressere (kaldet adresserum), er således en del af processen.
En del af systemtilstanden er også registre. Mange instruktioner er rettet mod at ændre værdien af registre eller aflæse deres værdi, og dermed bliver registre også en vigtig del af driften af processen.
Det skal bemærkes, at maskintilstanden også er dannet ud fra nogle specielle registre. For eksempel, IP - instruktionsmarkør — en pegepind til den instruktion, som programmet i øjeblikket udfører. Der er også stakviseren og relateret til det ramme pointer, som bruges til at administrere: funktionsparametre, lokale variabler og returadresser.
Endelig har programmer ofte adgang til ROM (skrivebeskyttet hukommelse). Denne "I/O" (input/output) information bør omfatte en liste over filer, der i øjeblikket åbnes af processen.
Proces API
For at forbedre vores forståelse af, hvordan processen fungerer, lad os studere eksempler på systemkald, der bør inkluderes i enhver operativsystemgrænseflade. Disse API'er er tilgængelige i en eller anden form på ethvert operativsystem.
● Opret (oprettelse): OS skal omfatte en metode, der giver dig mulighed for at oprette nye processer. Når du indtaster en kommando i terminalen eller starter et program ved at dobbeltklikke på et ikon, sendes et opkald til operativsystemet for at oprette en ny proces og derefter starte det angivne program.
● Fjernelse: Da der er en grænseflade til at skabe en proces, bør operativsystemet også give mulighed for at tvinge fjernelse af en proces. De fleste programmer vil naturligvis starte og afslutte af sig selv, mens de kører. Ellers vil brugeren gerne være i stand til at dræbe dem, og derfor ville en grænseflade til at stoppe processen være nyttig.
● Vent (venter): Nogle gange er det nyttigt at vente på, at en proces er fuldført, så der findes nogle grænseflader, der giver mulighed for at vente.
● Diverse kontrol (diverse kontrol): Udover at aflive og vente på processen, er der også andre forskellige kontrolmetoder. For eksempel giver de fleste operativsystemer mulighed for at fryse en proces (stoppe dens eksekvering i en vis periode) og derefter genoptage den (fortsætte eksekveringen)
● Status (tilstand): Der er forskellige grænseflader til at få nogle oplysninger om status for en proces, såsom hvor længe den har kørt, eller hvilken tilstand den er i i øjeblikket.
Procesoprettelse: Detaljer
En af de interessante ting er, hvordan netop programmer transformeres til processer. Især hvordan OS samler op og kører programmet. Hvordan processen helt præcist er skabt.
Først og fremmest skal operativsystemet indlæse programkoden og statiske data i hukommelsen (i procesadresserummet). Programmer er normalt placeret på en disk eller et solid-state-drev i et eller andet eksekverbart format. Processen med at indlæse program og statiske data i hukommelsen kræver således, at OS er i stand til at læse disse bytes fra disken og placere dem et sted i hukommelsen.
I tidlige operativsystemer blev indlæsningsprocessen udført ivrigt, hvilket betyder, at hele koden blev indlæst i hukommelsen, før programmet blev lanceret. Moderne operativsystemer gør dette dovent, det vil sige, at de kun indlæser stykker kode eller data, når programmet kræver dem under dets udførelse.
Når koden og de statiske data er indlæst i OS-hukommelsen, er der et par flere ting, der skal gøres, før processen kan køre. Der skal allokeres en vis mængde hukommelse til stakken. Programmer bruger stakken til lokale variabler, funktionsparametre og returadresser. OS tildeler denne hukommelse og giver den til processen. Stakken kan også tildeles nogle argumenter, specifikt udfylder den parametrene for main()-funktionen, for eksempel med et array af argc og argv.
Operativsystemet kan også allokere noget hukommelse til programbunken. Heapen bruges af programmer til eksplicit at anmode om dynamisk allokerede data. Programmer anmoder om denne plads ved at kalde funktionen malloc () og rydder det eksplicit ved at kalde funktionen ledig(). Heapen er nødvendig til datastrukturer såsom sammenkædede ark, hashtabeller, træer og andre. Til at begynde med allokeres en lille mængde hukommelse til heapen, men over tid, mens programmet kører, kan heapen anmode om mere hukommelse gennem bibliotekets API kaldet malloc(). Operativsystemet er involveret i processen med at allokere mere hukommelse for at hjælpe med at tilfredsstille disse opkald.
Operativsystemet vil også udføre initialiseringsopgaver, især dem, der er relateret til I/O. For eksempel på UNIX-systemer har hver proces som standard 3 åbne filbeskrivelser for standard input, output og fejl. Disse håndtag gør det muligt for programmer at læse input fra terminalen samt vise information på skærmen.
Ved at indlæse kode og statiske data i hukommelsen, oprette og initialisere stakken og udføre andet arbejde relateret til udførelse af I/O-opgaver, forbereder operativsystemet således stadiet for, at processen kan udføres. Til sidst er der en sidste opgave tilbage: at køre programmet gennem dets indgangspunkt, kaldet main()-funktionen. Ved at udføre funktionen main() overfører operativsystemet CPU-kontrol til den nyoprettede proces, hvorved programmet begynder at køre.
Procestilstand
Nu hvor vi har en vis forståelse af, hvad en proces er, og hvordan den skabes, lad os liste de procestilstande, den kan være i. I sin enkleste form kan en proces være i en af disse tilstande:
● Løb. Når den kører, kører processen på processoren. Det betyder, at instruktionerne bliver udført.
● Ready. I klar-tilstand er processen klar til at køre, men af en eller anden grund udfører OS den ikke på det angivne tidspunkt.
● Blokeret. I den blokerede tilstand udfører en proces nogle operationer, der forhindrer den i at være klar til at udføre, indtil en begivenhed indtræffer. Et almindeligt eksempel er, når en proces starter en IO-operation, bliver den blokeret, så en anden proces kan bruge processoren.
Du kan forestille dig disse tilstande i form af en graf. Som vi kan se på billedet, kan procestilstanden skifte mellem RUNNING og READY efter OS'ets skøn. Når status for en proces ændres fra KLAR til KØRER, betyder det, at processen er blevet planlagt. I modsat retning - fjernet fra layoutet. I det øjeblik, hvor en proces bliver BLOKERET, for eksempel, starter jeg en IO-operation, OS vil holde den i denne tilstand, indtil der sker en hændelse, f.eks. færdiggørelsen af IO. i dette øjeblik overgangen til READY-tilstanden og muligvis straks til RUNNING-tilstanden, hvis OS beslutter det.
Lad os se på et eksempel på, hvordan to processer bevæger sig gennem disse tilstande. Til at begynde med, lad os forestille os, at begge processer kører, og hver enkelt kun bruger CPU'en. I dette tilfælde vil deres stater se sådan ud.
I det følgende eksempel anmoder den første proces, efter at have kørt nogen tid, IO og går ind i BLOKERET tilstand, hvilket tillader en anden proces at køre (FIG. 1.4). OS ser, at proces 0 ikke bruger CPU'en og starter proces 1. Mens proces 1 kører, er IO afsluttet, og status for proces 0 ændres til KLAR. Endelig er proces 1 afsluttet, og efter afslutning starter proces 0, udfører og afslutter sit arbejde.
Datastruktur
Selve operativsystemet er et program, og ligesom ethvert andet program har det nogle vigtige datastrukturer, der holder styr på forskellige relevante informationer. For at spore tilstanden for hver proces understøtter operativsystemet nogle procesliste for alle processer i tilstanden KLAR og nogle yderligere oplysninger til at spore processer, der kører i øjeblikket. OS bør også overvåge blokerede processer. Efter IO er afsluttet, skal OS vække den påkrævede proces og sætte den i en tilstand klar til at køre.
For eksempel skal OS'et bevare tilstanden af processorregistrene. I det øjeblik processen stopper, gemmes registrenes tilstand i processens adresserum, og i det øjeblik dens drift fortsætter, gendannes værdierne af registrene og fortsætter således udførelsen af denne proces.
Ud over klar, blokerede, kørende tilstande, er der nogle andre tilstande. Nogle gange, på tidspunktet for oprettelsen, kan en proces være i INIT-tilstanden. Endelig kan en proces placeres i FINAL tilstand, når den allerede er afsluttet, men dens information er endnu ikke blevet slettet. På UNIX-systemer kaldes denne tilstand zombie proces. Denne tilstand er nyttig i tilfælde, hvor en overordnet proces ønsker at kende returkoden for et barn, f.eks. signalerer normalt 0 en succes og 1 en fejl, men programmører kan udstede yderligere outputkoder for at signalere forskellige problemer. Når den overordnede proces afsluttes, foretager den et sidste systemkald, såsom wait(), for at vente på, at den underordnede proces afsluttes og signalerer til OS, at den kan slette alle data, der er forbundet med den afsluttede proces.
Hovedpunkter i foredraget:
● Процесс - hovedabstraktionen af et kørende program i OS. På ethvert givet tidspunkt kan en proces beskrives ved dens tilstand: indholdet af hukommelsen i dens adresserum, indholdet af processorregistre, inklusive instruktionsmarkør og stak-pointer, og IO-information, såsom åbne filer, der læses eller skrives.
● Proces API består af opkald, som programmer kan foretage til processer. Disse er typisk oprettelse, sletning eller andre opkald.
● Processen er i en af mange tilstande, inklusive kørende, klar, blokeret. Forskellige begivenheder såsom planlægning, undtagelser fra planlægning eller ventetider kan ændre tilstanden af en proces fra den ene til den anden.
● Procesliste indeholder information om alle processer i systemet. Hver post i den kaldes en proceskontrolblok, som i virkeligheden er en struktur, der indeholder al den nødvendige information om en specifik proces.
Kilde: www.habr.com