Bevezetés az operációs rendszerekbe

Szia Habr! Szeretnék figyelmébe ajánlani egy cikk-fordítás sorozatot egy véleményem szerint érdekes irodalomból - OSTEP. Ez az anyag meglehetősen mélyrehatóan megvizsgálja a unix-szerű operációs rendszerek működését, nevezetesen a folyamatokkal, különféle ütemezőkkel, memóriával és más hasonló összetevőkkel való munkát, amelyek egy modern operációs rendszert alkotnak. Az összes anyag eredetijét itt tekintheti meg itt. Kérem, vegye figyelembe, hogy a fordítás szakszerűtlenül (elég szabadon) készült, de remélem, megtartottam az általános jelentést.

A témában végzett labormunkák itt találhatók:
- eredeti: pages.cs.wisc.edu/~remzi/OSTEP/Homework/homework.html
- eredeti: github.com/remzi-arpacidusseau/ostep-code
- személyes adaptációm: github.com/bykvaadm/OS/tree/master/ostep

Megnézheted a csatornámat is a címen távirat =)

A program működése

Mi történik, ha egy program fut? Egy futó program egyetlen egyszerű dolgot tesz: utasításokat hajt végre. A processzor másodpercenként millió, sőt milliárdnyi utasítást kér le a RAM-ból, dekódolja azokat (például felismeri, hogy ezek az utasítások milyen típushoz tartoznak) és végrehajtja azokat. Ez lehet két szám összeadása, memória elérése, feltétel tesztelése, függvényre ugrás stb. Az egyik utasítás befejezése után a processzor egy másik végrehajtására lép. Utasítás után utasítások végrehajtása a program végéig történik.
Ezt a példát természetesen leegyszerűsítve tekintjük – valójában a processzor felgyorsítása érdekében a modern hardver lehetővé teszi az utasítások soron kívüli végrehajtását, a lehetséges eredmények kiszámítását, az utasítások egyidejű végrehajtását és hasonló trükköket.

Von Neumann számítási modell

Az általunk leírt egyszerűsített működési forma hasonló a Von Neumann számítástechnikai modellhez. Von Neumann a számítógépes rendszerek egyik úttörője, a játékelmélet egyik szerzője is. A program futása közben egy csomó egyéb esemény történik, sok más folyamat és külső logika fut, amelyek fő célja a rendszer indításának, üzemeltetésének és karbantartásának egyszerűsítése.
Létezik egy olyan szoftverkészlet, amely a programok egyszerű futtatásáért felelős (vagy akár több program egyidejű futtatását is lehetővé teszi), lehetővé téve a programoknak ugyanazt a memóriát, valamint a különböző eszközökkel való kommunikációt. Az ilyen szoftvereket (szoftvereket) lényegében operációs rendszernek nevezzük, és feladatai közé tartozik a rendszer helyes és hatékony működésének felügyelete, valamint a rendszer egyszerű kezelésének biztosítása.

Operációs rendszer

Az operációs rendszer, rövidítve OS, egymással összekapcsolt programok halmaza, amelyek a számítógépes erőforrások kezelésére és a számítógéppel való felhasználói interakció megszervezésére szolgálnak..
Az operációs rendszer hatékonyságát elsősorban a legfontosabb technika - technológia - révén éri el virtualizáció. Az operációs rendszer kölcsönhatásba lép egy fizikai erőforrással (processzor, memória, lemez stb.), és átalakítja azt egy általánosabb, jobban használható és könnyebben használható formává. Ezért az általános megértés kedvéért nagyon durván össze lehet hasonlítani egy operációs rendszert egy virtuális géppel.
Annak érdekében, hogy a felhasználók parancsokat adhassanak az operációs rendszernek, és ezáltal kihasználhassák a virtuális gép képességeit (például: program futtatása, memória lefoglalása, fájl elérése stb.), az operációs rendszer egy interfészt biztosít az ún. API (alkalmazás programozási felület), és amelyre hívásokat lehet kezdeményezni. Egy tipikus operációs rendszer lehetővé teszi több száz rendszerhívás lebonyolítását.
Végül, mivel a virtualizáció lehetővé teszi több program futtatását (így megosztva a CPU-t), és egyidejűleg hozzáférhet az utasításaikhoz és adataikhoz (ezáltal megosztja a memóriát), és elérheti a lemezeket (így megosztva az I/O eszközöket) , az operációs rendszert erőforrásnak is nevezik. menedzser. Minden processzor, lemez és memória a rendszer erőforrása, így az operációs rendszer egyik szerepe az erőforrások kezelésének feladata lesz, ezt hatékonyan, tisztességesen, vagy éppen ellenkezőleg, attól függően, hogy milyen feladatot lát el az operációs rendszer. tervezett.

CPU virtualizáció

Fontolja meg a következő programot:
(https://www.youtube.com/watch?v=zDwT5fUcki4&feature=youtu.be)

Nem hajt végre semmilyen különleges műveletet, valójában csak egy függvényt hív meg forog(), melynek feladata az idő ciklikus ellenőrzése és egy másodperc elteltével visszatérés. Így a végtelenségig ismétli a felhasználó által argumentumként megadott karakterláncot.
Futtassuk ezt a programot, és adjuk át neki az „A” szimbólumot argumentumként. Az eredmény nem különösebben érdekes - a rendszer egyszerűen végrehajt egy programot, amely rendszeresen megjeleníti az „A” szimbólumot a képernyőn.
Most próbáljuk meg azt a lehetőséget, amikor ugyanannak a programnak több példánya indul el, de különböző betűket jelenít meg, hogy világosabb legyen. Ebben az esetben az eredmény kissé eltérő lesz. Annak ellenére, hogy egy processzorunk van, a program egyszerre fut. Hogyan történik ez? De kiderül, hogy az operációs rendszer a hardveres képességek segítsége nélkül illúziót kelt. Az az illúzió, hogy több virtuális processzor van a rendszerben, ami egy fizikai processzort elméletileg végtelen számmá alakít, és ezáltal lehetővé teszi a programok látszólag egyidejű futtatását. Ezt az illúziót hívják CPU virtualizáció.
Ez a kép sok kérdést felvet, például ha több program akar egyszerre futni, akkor melyik indul el? Az operációs rendszer „házirendjei” felelősek ezért a problémáért. A házirendek sok helyen használatosak az operációs rendszerben, és az ehhez hasonló kérdésekre válaszolnak, és egyben az operációs rendszer által megvalósított alapvető mechanizmusok is. Innen ered az operációs rendszer erőforrás-kezelő szerepe.

Memória virtualizáció

Most nézzük a memóriát. A modern rendszerekben a memória fizikai modelljét bájttömbként ábrázolják. A memóriából való olvasáshoz meg kell adni cella címehozzáférni. Adatok írásához vagy frissítéséhez meg kell adni az adatokat és annak a cellának a címét is, ahova írjuk.
A program végrehajtása során a memóriahozzáférések folyamatosan történnek. Egy program a teljes adatszerkezetét a memóriában tárolja, és különféle utasítások végrehajtásával éri el. Eközben az utasítások a memóriában is tárolódnak, így a következő utasítás minden kérésére is hozzáférnek.

malloc() hívása

Tekintsük a következő programot, amely a hívás segítségével memóriaterületet foglal le malloc () (https://youtu.be/jnlKRnoT1m0):

A program több dolgot is megtesz. Először lefoglal némi memóriát (7. sor), majd kiírja a lefoglalt cella címét (9. sor), nullát ír a lefoglalt memória első slotjába. Ezután a program belép egy ciklusba, amelyben megnöveli a memóriában tárolt értéket a „p” változóban lévő címen. Megjeleníti saját folyamatazonosítóját is. A folyamatazonosító minden futó folyamathoz egyedi. Több példány elindítása után érdekes eredménnyel fogunk találkozni: Az első esetben, ha nem teszünk semmit, és csak több példányt indítunk el, a címek eltérőek lesznek. De ez nem tartozik az elméletünk alá! Igaz, mert a modern disztribúciókban alapértelmezés szerint engedélyezve van a memória véletlenszerűsítése. Ha letiltja, a várt eredményt kapjuk - két egyidejűleg futó program memóriacíme egybeesik.

Az eredmény az, hogy két független program saját privát címterével dolgozik, amelyeket viszont az operációs rendszer leképez a fizikai memóriában.. Ezért a memóriacímek használata egy programon belül semmilyen módon nem érinti a többit, és úgy tűnik, hogy minden programnak megvan a saját fizikai memóriája, amely teljes mértékben a rendelkezésére áll. A valóság azonban az, hogy a fizikai memória egy megosztott erőforrás, amelyet az operációs rendszer kezel.

Következetesség

Egy másik fontos téma az operációs rendszereken belül következetesség. Ezt a kifejezést akkor használjuk, amikor olyan rendszerproblémákról beszélünk, amelyek akkor fordulhatnak elő, ha egyetlen programon belül több dologgal dolgozik egyszerre. A konzisztencia problémák még magában az operációs rendszerben is előfordulnak. A memória- és processzorvirtualizációval kapcsolatos korábbi példákban rájöttünk, hogy az operációs rendszer sok dolgot kezel egyszerre - elindítja az első folyamatot, majd a másodikat, és így tovább. Mint kiderült, ez a viselkedés bizonyos problémákhoz vezethet. Például a modern többszálú programok ilyen nehézségekkel küzdenek.

Fontolja meg a következő programot:

A fő függvényben lévő program két szálat hoz létre a hívás segítségével Pthread_create(). Ebben a példában egy szál egy olyan függvénynek tekinthető, amely ugyanabban a memóriatérben fut más függvények mellett, és egyértelműen több függvény fut egyszerre. Ebben a példában minden szál elindul és végrehajt egy függvényt worker(), ami viszont egyszerűen növeli a változót,.

Futtassuk ezt a programot 1000-es argumentummal. Ahogy sejtette, az eredménynek 2000-nek kell lennie, mivel minden szál 1000-szeresére növelte a változót. Azonban nem minden ilyen egyszerű. Próbáljuk meg egy nagyságrenddel több ismétléssel futtatni a programot.

Ha beírunk egy számot, például 100000 200000-et, azt várjuk, hogy a kimeneten a 100000 XNUMX. A XNUMX XNUMX szám többszöri lefuttatásával azonban nemcsak nem látjuk a helyes választ, hanem különböző helytelen válaszokat is kapunk. A válasz abban rejlik, hogy egy szám növeléséhez három műveletre van szükség – a szám előhívása a memóriából, növelése, majd a szám visszaírása. Mivel ezeket az utasításokat nem atomosan hajtják végre (egyszerre), ilyen furcsa dolgok történhetnek. Ezt a problémát a programozásban hívják verseny állapot - verseny állapot. Amikor egy ismeretlen pillanatban ismeretlen erők befolyásolhatják bármelyik művelet végrehajtását.

Forrás: will.com