Os Eloadas Diak

Bevezetés Bevezetés Operációs rendszerek jellemzése
Áttekintés Mi egy operációs rendszer?
Egy modern számı́tógép a következő dolgokból áll:

• Egy vagy több processzor
1 Bevezetés • Memória
Operációs rendszerek jellemzése • Lemezek
Az operációs rendszerek története • Nyomtatók
Rendszerhı́vások
• Különböző I/O eszközök
Az OS struktúrája
• ...
Ezen komponensek kezelése egy szoftver réteget igényel – Ez a réteg az

operációs rendszer
4 5
Bevezetés Operációs rendszerek jellemzése Bevezetés Operációs rendszerek jellemzése
Operációs Rendszerek helye Operációs Rendszerek helye - Szoftver elemek
Számı́tógépes Rendszer + Felhasználók = Egységes Tervezési Egység.
• Számı́tógépes Rendszer: hardver, szoftver, hálózat. • Alapszoftverek: általános funkciókat biztosı́tanak

• Felhasználók: ember (programozó is), gép, program, másik • Hardver-közeli, pl. driver-ek
számı́tógépes rendszer. • Hálózati, pl. kommunikációs
• Operációs Rendszer (OS)
• Segédprogramok: fordı́tók, egyszerű szöveg-editorok, adatbázis-kezelők
• Felhasználói v. applikációs programok: konkrét probléma megoldására
született program.
• Általános applikációk: táblázatkezelők, szövegszerkesztők, WEB
böngésző, ... stb.
• Célrendszerek: ETR, banki alkalmazások, ... stb.
6 7
Operációs Rendszerek helye Operációs rendszerek alapvető feladatai
• A felhasználó kényelmének, védelmének biztosı́tása = Kiterjesztett

(Virtuális) gép
• Az emberi felhasználó számára kényelmes kezelési funkciók;
jogosultságok kezelése
• Programok számára futás közben használható eljárások, függvények; a
futó program memóriaterületének védelme
• A rendszer hatékonyságának, teljesı́tményének maximalizálása =
Erőforrás-kezelés
• Hardver erőforrások: CPU (processzor), memória, I/O
(Bemeneti/Kimeneti) eszközök, fájlkezelés, ... stb.
• Szoftver erőforrások: eljárások, buffer-ek (átmeneti tárolók), üzenetek,
szolgáltatások, ... stb.
8 9
Operációs rendszerek alapvető tulajdonságai Operációs Rendszer Állatkert
• Processzusok (folyamatok) az alapvető aktı́v alkotóelemek • Nagyszámı́tógépes (mainframe) operációs rendszerek: Nagy I/O
• Processzus (proc): végrehajtás alatt lévő program kapacitás, Sok job végrehajtása, Batch, tranzakciók feldolgozása. Pl:
• Processzus létrejön (programbetöltés, végrehajtás indı́tása, ...), létezik OS/390, UNIX, Linux
(”fut”), majd megszűnik (exit) • Szerver operációs rendszerek: sok user, kozösen használt hw és sw
• Egyidejűleg több processzus létezik: A processzor (CPU) idejét meg erőforrások. Pl. Solaris, FreeBSD, Linux, Windows Server 200x
kell osztani az egyidejűleg létező procok között: időosztás (time • Többprocesszoros operációs rendszerek, Pl. Windows, Linux
sharing) • PC-s operációs rendszerek, Pl. Linux, FreeBSD, Windows
• Az erőforrások centralizált kezelése: Az erőforrásokat a processzusok • Handheld operációs rendszerek: PDA. Pl. Symbian OS, Palm OS
(kérésükre) az OS-től kapják
• Beágyazott operációs rendszerek: Tv, hűtő. Pl. QNX, VxWorks
• Esemény-vezérelt
• Érzékelő csomópontos operációs rendszerek: Tűz érzékelő. Pl:
1 esemény
2 megszakı́tás TinyOS
3 esemény feldolgozása • Real-time operációs rendszerek: Hard, soft. Ipari robotok, digitális
4 esemény kiszolgálása multimédia eszközök.
5 visszatérés a megszakı́tás helyére • Smart card operációs rendszerek: Java SmartCard
10 11
Bevezetés Az operációs rendszerek története Bevezetés Az operációs rendszerek története
Generációk Az első generáció

Vákuumcsövek és kapcsolótáblák (1945-1955)
• Nincs operációs rendszer

• Az első generáció: Vákuumcsövek és kapcsolótáblák (1945-1955) • Howard Aiken, Neumann János, J. Presper Eckert, John William
• A második generáció: Tranzisztorok és kötegelt rendszerek Machley, Konrad Zuse
(1955-1965) • 1 felhasználó, 1 program, fix memóriacı́mek, megbı́zhatatlan hardver
• A harmadik generáció: Integrált áramkörök és multiprogramozás • ”Üresen indul a gép”: bootstrap;
(1965-1980)
• Programozó = Gépkezelő = Programok végrehajtásának vezérlője
• A negyedik generáció: Személyi számı́tógépek (1980- )
• Programozási nyelvek ismeretlenek (még assembly sem): bináris
kódolás
• 1950-es évek eleje: lyukkártyák
12 13
A második generáció A második generáció

Tranzisztorok és kötegelt rendszerek (1955-1965) Egy szokásos FMS feladat
• Operációs rendszer van, rezidens a memóriában

• Tranzisztorok – megbı́zható számı́tógépek
• Mainframe / nagyszámı́tógép
• Papı́ron ı́rt programok – lyukkártya – kezelő - kávézás – eredmény –
nyomtató – kiviteli terem
• Egyidejűleg csak 1 proc
• Feladat (job) sorozat (köteg) végrehajtását vezérli az OS →
teljesı́tőképesség növekedett
• Programozók támogatására bevezetett megoldások:
• verem-memória
• eszközvezérlők
• hı́vható OS eljárások
• relatı́v cı́mezhetőség
• FORTRAN, ALGOL programozás
14 15
A második generáció A harmadik generáció

Egy korai kötegelt rendszer Integrált áramkörök és multiprogramozás (1965-1980)
• Operációs rendszer van, rezidens/tranziens a memóriában

• CPU és I/O átfedően képes dolgozni - a CPU teljes idejének
kihasználása csak több proc egyidejű létezésével lehetséges →
multiprogramozás
• Több felhasználó: terminálok, on-line programvégrehajtás
• CPU időszeletelés (time slicing)
• Átmeneti tárolás (spooling)
(a) A programozó a kártyáit az 1401-eshez juttatja
• Memória-partı́ciók: minden partı́cióban egymástól függetlenül folynak
(b) A feladatköteg szalagra olvasása
job kötegek végrehajtásai
(c) A gépkezelő átviszi a bemeneti szalagot a 7094-eshez
(d) Számolás végrehajtása • COBOL, ADA, PASCAL, SIMULA, ... programozás
(e) A gépkezelő átviszi a kimeneti szalagot a 1401-eshez
(f) Eredmény nyomtatása
16 17
Időszeletelés - Time Slicing Átmeneti tárolás - Spooling
• az I/O adatok először gyors háttértárolóra (disk) kerülnek (spool

terület), a proc innen kapja / ide ı́rja az adatait
• jobb periféria (erőforrás)-kihasználás (olvasók, nyomtatók)
• CPU időszeletelés: egy proc csak egy meghatározott maximális
időintervallumon keresztül használhatja a CPU-t folyamatosan
• Legyen tmax az az időintervallum, amely alatt egy p proc
folyamatosan birtokolhatja a CPU-t.
• Ha tmax letelik: az OS processzus-ütemező alrendszere átadja a
CPU-t egy (másik) proc-nak; később p újra kap tmax intervallumot.
• tmax kb. 10-20 msec
18 19
Memória-partı́ciók A negyedik generáció

Személyi számı́tógépek (1980- )
• Statikus: OS indulásakor fix darabszámú (pl.16), fix méretű partı́ció
képződik. Egy program végrehajtásához megkeres egy szabad és
elegendő méretű partı́ciót, amelyben a program végrehajtását • Operációs rendszer van, több tı́pus
megkezdi.
• LSI áramkörök fejlődése
• Dinamikus: OS egy program végrehajtásához a szabad • Kategóriák
memóriaterületből készı́t egy elegendő méretű partı́ciót, amelyben a • PC, Workstation: egyetlen felhasználó, egy időben több feladat (Pl.
program végrehajtását megkezdi – a partı́ciók száma és mérete változó Windows, Mac OS, OS/2)
• Hálózati OS: hálózaton keresztül több felhasználó kapcsolódik, minden
felhasználó egy időben több feladatot futtathat (Pl. UNIX, LINUX,
NT)
• Osztott (hálózati) OS: egy feladatot egy időben több számı́tógépes
rendszer végez. Erőforrások (CPU, Memória, HDD, ...) megosztása
egy feladat elvégzéséhez. (pl. GRID, SETI)
20 21
A negyedik generáció jellemzői OS felületei

Személyi számı́tógépek (1980- )
• Felhasználói felület (ff): a felhasználó (ember) és az OS kapcsolati
alrendszer.
Parancsértelmező (Command Interface, Shell); Grafikus felület
• Program felület (pf): proc és OS kapcsolati alrendszer
• Alkalmazásfejlesztés segı́tése: Objektum-orientált és kliens-szerver
Rendszerhı́vások (OS eljárások, függvények; system calls); OS
módszerek.
szolgáltatások (services)
• Hordozhatóság (hardver-függetlenség) segı́tése. Problémák: grafikus
felületek alapjaiban különböznek.
• Egyes szolgáltatások leválasztása az OS magjáról, a szolgáltatások
egymástól való függetlensége
• Spool-technika (cache) hardverrel segı́tett és széles körben
alkalmazott (RAM-ban is) adatokra, programokra egyaránt
22 23
Bevezetés Rendszerhı́vások Bevezetés Rendszerhı́vások
Rendszerhı́vások – System calls Rendszerhı́vások – System calls
• Processzus kezelés (process management)

• Jelzések (signals), Események (events) kezelése
• Memóriakezelés (memory management)
• Fájl (file), Könyvtár (directory) és Fájlrendszer (file system) kezelés
• Védelem (protection) – adat, user, program, ...
• Üzenetkezelés (message handling)
1 a hı́vó proc-nak joga volt-e

2 hı́vás paraméterek ellenőrzése
3 táblázat rendszer eljárások kezdő cı́mét tárolja
4 vezérlés visszaadása a proc-nak
24 25
Példa: a read(fd, buffer, nbytes) rendszerhı́vása Processzuskezelés
pid = fork(); // Create a child process identical to the parent

pid = waitpid(pid , &statloc , opts ); // Wait for a child to terminate
s = wait(&status); // Old version of waitpid
s = execve(name, argv, envp); // Replace a process core image
exit ( status ); // Terminate process execution and return status
size = brk(addr); // Set the size of the data segment
pid = getpid(); // Return the caller ’ s process id
pid = getpgrp(); // Return the id of the caller ’ s process group
pid = setsid (); // Create a new session and return its proc. group id
l = ptrace(req, pid , addr, data ); // Used for debugging
26 27
Szignálkezelés Könyvtár- és fájlrendszerkezelés, védelem
s = mkdir(name, mode); // Create a new directory

s = rmdir(name); // Remove an empty directory
s = link(name1, name2); // Create a new entry, name2, pointing to name1
s = unlink(name); // Remove a directory entry
s = sigaction( sig , &act, &oldact); // Define action to take on signals s = mount(special, name, flag ); // Mount a file system
s = sigreturn(&context); // Return from a signal s = umount(special); // Unmount a file system
s = sigprocmask(how, &set, &old); // Examine or change the signal mask s = sync(); // Flush all cached blocks to the disk
s = sigpending(set ); // Get the set of blocked signals s = chdir(dirname); // Change the working directory
s = sigsuspend(sigmask); // Replace the signal mask and suspend the process s = chroot(dirname); // Change the root directory
s = kill (pid , sig ); // Send a signal to a process
residual = alarm(seconds); // Set the alarm clock s = chmod(name, mode); // Change a file’s protection bits
s = pause(); // Suspend the caller until the next signal uid = getuid (); // Get the caller ’ s uid
gid = getgid (); // Get the caller ’ s gid
s = setuid(uid ); // Set the caller ’ s uid
s = setgid(gid ); // Set the caller ’ s gid
s = chown(name, owner, group); // Change a file’s owner and group
oldmask = umask(complmode); // Change the mode mask
28 29
Fájlkezelés Rendszerhı́vások – System calls

A Win32 API hı́vások, amelyek nagyjából hasonlı́tanak a UNIX hı́vásokra
fd = creat(name, mode); // Obsolete way to create a new file

fd = mknod(name, mode, addr); // Create a regular, special , or directory i −node
fd = open(file , how, ...); // Open a file for reading , writing or both
s = close(fd ); // Close an open file
n = read(fd, buffer , nbytes ); // Read data from a file into a buffer
n = write(fd, buffer , nbytes ); // Write data from a buffer into a file
pos = lseek(fd, offset , whence); // Move the file pointer
s = stat(name, &buf); // Get a file ’ s status information
s = fstat (fd , &buf); // Get a file ’ s status information
fd = dup(fd); // Allocate a new file descriptor for an open file
s = pipe(&fd[0]); // Create a pipe
s = ioctl (fd , request , argp ); // Perform special operations on a file
s = access(name, amode); // Check a file ’ s accessibility
s = rename(old, new); // Give a file a new name
s = fcntl (fd , cmd, ...); // File locking and other operations
30 31
Bevezetés Az OS struktúrája Bevezetés Az OS struktúrája
OS struktúrák Monolitikus rendszerek

A ”Nagy összevisszaság”
• Legelterjedtebb szervezési mód. Főprogram: meghı́vja a kért

szolgáltatás eljárását, szolgáltató eljárások: teljesı́tik a
rendszerhı́vásokat, segéd eljárások: segı́tik a szolgáltatás eljárásokat.
• Monolitikus rendszerek • Struktúrája a strukturálatlanság
• Rétegelt rendszerek • Eljárások gyűjteménye, bármelyik hı́vhatja a másikat
• Virtuális gépek
• Exokernelek
• Kliens szerver
32 33
Rétegelt OS Virtuális gépek

• Eljárások, Függvények halmaza, amelyek rétegekbe csoportosulnak
• Virtuális gép monitor a nyers hardveren fut és akár több virtuális
• Felügyelt eljárás-hı́vások (supervisor calls)
gépet is szolgáltat.
• Programvégrehajtás-szintek: normál mód (az OS eljárások egy
• A virtuális gépek különbözőek is lehetnek.
meghatározott részhalmaza hı́vható; felhasználói programok);
kitüntetett (supervisor, kernel) mód(ok) (speciális OS eljárások is • Pentium processzorokba beépı́tettek egy virtuális 8086 módot.
hı́vhatóak; rendszerprogramok) • VMWare, Microsoft Virtual PC, Virtual Box
• Szabály a rétegekre: bármely n-edik rétegbeli eljárás csak a közvetlen • Java Virtual Machine
alatta lévő n-1-edik réteg eljárásait hı́vhatja - Áttekinthető
eljárásrendszer alakı́tható ki
• A rétegek saját (globális) adatterülettel rendelkezhetnek -
Áttekinthető adatáramlás
• Konfigurálható: pl. az eszközvezérlők egy rétegbe csoportosı́thatóak
• Rezidens, Tranziens rétegek
• Egy réteg = Virtuális (absztrakt) gép: a rétegbeli függvények által
nyújtott funkciók összessége (pl. IBM VM/370)
• 1-rétegű (”monolitikus”), 2-, 3-, ... rétegű
34 35
Kliens/Szerver Kliens/szerver modell előnyei
• Egymással ”kommunikáló” processzusok rendszere

• Szerver processzusokkal az OS szolgáltatásai bármikor bővı́thetők –
• Kommunikáció: üzenet adás/vétel
az OS eljárásokra épülő része (kernel) szűkebbre vehető
• Szerver proc: meghatározott szolgáltatásokat végez: terminál-, web-,
• Szerver programok egymástól teljesen függetlenül programozhatóak
file i/o-, szolgáltatás-csoportok
• Hálózaton keresztül is alkalmazható: szerver és kliens proc külön OS
• Kliens proc: egy szerver proc szolgáltatásait veszi igénybe; kérés =
fölött fut, ezek hálózaton keresztül cserélnek üzeneteket
üzenet (tartalma specifikálja a pontos kérést): terminál-kliens ; válasz
= üzenet
• Üzenet = fejléc (header) + tartalom (body)
• Header: az üzenet továbbı́tásához szükséges információk; cı́mzett
(proc), feladó, hossz, kódolás, idő-bélyegzők, ...
• Tartalom: feladó állı́tja össze, cı́mzett értelmezi; szerkezete pontosan
specifikált = kommunikációs protokoll OS feladata: az üzenetek
közvetı́tése processzusok között; csak a fejléccel kell foglalkoznia
36 37
Kliens/szerver modell osztott rendszerekben Kliens/szerver programozás
Kliensnek nem kell tudnia, hogy a szerver lokálisan, vagy hálózaton

keresztül lesz elérhető
• 2-, 3-rétegű alkalmazás-szerkezet: a kliens gépen kliens proc fut, a
szükséges szolgáltatásokat (hálózaton keresztül) szerver gép(ek)től
üzenetek formájában kéri
• Kliens gép feladata: képernyő kezelése, felhasználó akcióinak
megfelelő kérések továbbı́tása, válaszok fogadása
• X-terminál, Adatbázis-szerver, WEB, Fájl-megosztás, . . .
• ASP – Application Service Provider – Távoli Alkalmazás Kiszolgáló
38 39
Bevezetés Az OS struktúrája
Operációs rendszerek alrendszerei
• Processzuskezelő alrendszer; process handling

• Erőforráskezelő alrendszer; resource handling ( Kölcsönös kizárás,
Szinkronizáció, Üzenetközvetı́tés)
• Memóriakezelő alrendszer (spec erőforrás); memory management
• Bevitel/Kivitel; Input/Output
• Fájlkezelő alrendszer (spec erőforrás); file, directory and file system
management
• Időkezelés; time management (spec esemény)
• Védelmi (protection), biztonsági (security) rendszer
• Jelkezelő alrendszer; signal handling
• Eseménykezelő alrendszer; event handling
• Felhasználói felület(ek); parancsértelmező (shell)
40
Processzusok 2
Bevezetés
• A CPU minden időpillanatban csak egy programot futtat
• Egyik program végrehajtásáról a másik program végrehajtására
vált
PROCESSZUSOK I. • Párhuzamosság illúzióját kelti a felhasználóban
• Látszatpárhuzamosság
• Nem keverjük össze a többprocesszoros rendszerek valódi
Bevezetés hardverpárhuzamosságával
Processzusok • Többszörös párhuzamos tevékenységek követése nehéz
Szálak • Szekvenciális processzusok
• Fogalmi modell
Processzusok 3 Processzusok 4
Processzusmodell Processzusmodell
• Számítógépen futtatható szoftver
• Szekvenciális processzusok sorozata
• Processzusok
• Az operációs rendszer is
• Processzus
• Végrehajtás alatt álló program
• Utasításszámláló
• Regiszterek
• Változók aktuális értéke
• Minden processzusnak saját VIRTUÁLIS CPU-ja van

• A VALÓSÁGBAN a CPU kapcsolgat a processzusok között Multiprogramozás Független szekvenciális Egyszerre csak egy aktív
• Multiprogramozásnak nevezzük a gyors oda-vissza kapcsolást
Ábra forrása: Tanenbaum könyv
Processzusmodell Processzusok
• A processzusok nem állandó sebességgel haladnak a • Egyetlen vezérlési szállal
végrehajtásban előre rendelkezik
• Erőforrás birtokló egység
• Még akkor sem, ha újrafuttatjuk azokat
• Kizárólagosan
• Nem szabad belső időzítési feltételeket rakni • Osztottan
• Pl. üres ciklusok • Címtartománnyal rendelkezik
• Speciális utasításokat kell használni • Saját memória
• Osztott memória
• A processzusok nagy részét nem befolyásolja
• Végrehajtási állapota van
• a CPU multiprogramozása
• Utasítás számláló
• Processzusok relatív sebessége • Regiszterek
• Veremmemóriája van
• Saját
• Jogosultságokkal rendelkezik
• Adathozzáférési jogok
Oda-vissza kapcsolgatás 
Processzusállapotok
Kontextus csere
• Több egyidejűleg létező processzus • Futó
• Egyetlen CPU • Éppen használja a CPU-t
• A CPU váltakozva hajtja végre a processzusokat • Futáskész

• Készen áll a futásra
• Kontextus csere
• Ideiglenesen leállították, hogy egy másik processzus futhasson
• A CPU átvált P1 processzusról a P2 processzusra
• P1 állapotát a CPU regisztereiből el kell menteni • Blokkolt
• Erre fenntartott memóriaterületre • Bizonyos külső esemény bekövetkezéséig nem képes futni
• P2 korábban elmentett állapotát helyre kell állítani a CPU regisztereiben
• Többprocesszoros rendszerekben is szükséges

• M db. CPU
• N db. processzus
Processzusállapotok Processzusállapotok
• Egyes processzusok olyan programokat futtatnak,
5
Terminális amelyek a felhasználó által begépelt parancsokat hajtják
végre
• Más processzusok a rendszer részei
1. Processzus blokkolódik input miatt • Fájlkiszolgáló felé érkező igények kiszolgálása
2. Az ütemező egy másik processzust • A processzusok blokkolódnak
választ ki
3. Az ütemező ezt a processzust • Amikor valaminek a bekövetkezésére várnak
választja ki • Amikor az adott esemény bekövetkezik
4. Az input elérhetővé válik
• A blokkolódás feloldódik
Iniciális
Processzusállapotok Processzusok megvalósítása

• Processzustáblázat
• Az operációs rendszer legalsó szintje az ütemező • Processzusonként egy bejegyzés
• Felette helyezkednek el a processzusok • Processzus vezérlő blokkok (PCB)
• Processzus vezérlő blokk
• Az ütemezőben vannak megvalósítva • Processzus állapota
• A kontextus cseréhez
• A megszakítás kezelés • Utasításszámláló
• Veremmutató
• Processzusok indítása és megállítása • Jogosultságok
• Prioritás
• Az ütemező elég kicsi • Létrehozó állítja be
• Birtokolt erőforrások
• Lefoglalt memória
• Megnyitott fájlok állapota
• Kért, de meg nem kapott
erőforrások
• Ütemezési információk
• Elszámolás
• Ébresztői jelek
• Szignálok
• Egyéb információk
Ábra forrása: Tanenbaum könyv Ábra forrása: Tanenbaum könyv

Processzusok megvalósítása Processzusok megvalósítása

• Egyidejűleg létező processzusok leírásai • Processzus futásban bekövetkező megszakítások
• Processzusok láncára vannak fűzve lekezelése
• Processzus létrejöttekor a PCB a láncra fűződik (pl. a végére) • Minden B/K eszköz(osztályhoz) tartozik egy tábla
• Processzus megszűnésekor a PCB láncszem törlődik a láncból • Megszakításleíró tábla
• A bejegyzések legfontosabb része a megszakításvektor
• Műveletek a láncon
• A megszakítást kiszolgáló eljárás címét határozza meg
• Egy processzus gyermekeinek keresése pl. a szülő
megszűnésekor a fastruktúra megőrzéséhez • Megszakításkor
• Futás-kész állapotú processzusok keresése pl. a következő • a hardver a verembe menti
időintervallumra a CPU kiosztásához • Utasításszámlálót
• Erőforrást igényelt processzusok keresése pl. az erőforrás • Programállapot szót

odaítélésekor • Esetleg egy vagy több regisztert
• … • A vektorban meghatározott címre ugrik a számítógép
Processzusok megvalósítása Processzusok megvalósítása

• A megszakító eljárás 1. Az utasításszámlálót a hardver a veremre teszi stb.
• Az összes regisztert elmenti 2. A megszakításvektorból a hardver betölti az új utasítás
• Aktuális processzushoz tartozó PCB-be számlálót.
• Processzus ID és bejegyzésre mutató pointer globális 3. Az assembly eljárás elmenti a regisztereket.
• A veremből kikerülnek a megszakítás által lerakott információk 4. Az assembly eljárás új vermet hoz létre
• A veremmutató egy ideiglenes veremre állítódik át
5. C megszakítás kezelő szolgáltatás fut
• Processzus kezelő használja
(tipikusan olvassa és puffereli az inputot)
• Ezután egy C eljárás hívódik meg
6. Az ütemező eldönti, hogy melyik processzust kell futtatni
• A megszakításhoz tartozó feladat elvégzésére
• A lemezprocesszusnak küldünk egy üzenetet
7. Az üzenetküldő kód az üzenetre várakozót futáskészre állítja
• Az üzenetet elő kell állítani 8. C eljárás visszatér az assembly kódba
• A lemezprocesszus állapota futáskész lesz 9. Az assembly eljárás elindítja az új aktuális processzust
• Visszatérés után elindítjuk az aktuális processzust
Processzusok létrehozása Processzusok létrehozása

• Egyszerű esetekben megoldható, hogy minden • Az OS indulásakor sok • Interaktív rendszerekben
processzus elérhető legyen az OS elindulása után processzus keletkezik • Felhasználói parancsok
• Felhasználókkal tartják a kiadása
• Általános célú rendszerekben szükség van a kapcsolatot • Kötegelt rendszerekben
processzusok létrehozására és megszüntetésére • Előtérben futnak
• Amennyiben rendelkezésre
• Nincsenek felhasználóhoz áll egy erőforrás
• Processzusokat létrehozó események rendelve • Új processzus futtatására
• Rendszer inicializálása • Saját feladatuk van
• Háttérben futnak
• Gyerek processzus létrehozásának kezdeményezése • Démonok
• Rendszerhívás
• Futó processzusok is
• Felhasználó által kezdeményezett létrehozhatnak
• Kötegelt feladat kezdeményezése processzusokat
• Kooperatív folyamatok
• Egymással együttműködő, de
amúgy független processzusok
Processzusok létrehozása Processzusok befejezése

• Lépései • Előbb vagy utóbb a processzus befejeződik
• Memóriaterület foglalása a PCB számára
• Szabályos kilépés
• PCB kitöltése iniciális adatokkal
• Önkéntes
• kezdeti memóriatérkép,
• állapot = iniciális, • Végzett a feladatával
• kizárólagosan használható erőforrások lefoglalása, • Kilépés hiba miatt
• CPU állapot USz = indítási cím, • Önkéntes
• jogosultságok a létrehozó jogosultságaiból, • Lekezelt hiba miatt
• …
• Kilépés végzetes hiba miatt
• Memóriafoglalás
• Önkéntelen
• Programszöveg,
• adatok, • Processzus által okozott hiba
• verem számára • Hibás program
• Betöltés • Másik processzus kezdeményezi a befejezést
• Ezt általában a létrehozó feladatának tekinti az OS
• Önkéntelen
• A PCB processzusok láncára fűzése,
• Másik processzus kill utasítása
• Állapot = futáskész.
• Ettől kezdve a processzus osztozik a CPU-n.
Processzusok befejezése Processzushiearchiák

• Lépései • Amikor processzusok másik processzusokat hoznak létre
• A gyermek processzusok megszüntetése • Bizonyos esetekben kapcsolatban maradnak
• rekurzív vagy más szülőhöz csatolása • Szülő – gyermek
• A PCB processzusok láncáról való levétele • Egy szülő
• Állapot = terminális • Nulla vagy több gyerek processzus
• Ettől kezdve a processzus • További leszármazottak is lehetnek
nem osztozik a CPU-n. • Pl. egy billentyűzetről elküldött szignált
• A megszűnéskor a processzus birtokában
• a szülő processzushoz kötött eseményt mindegyik gyerek is
lévő erőforrások felszabadítása
megkapja
• A PCB-beli nyilvántartás szerint
• Elkaphatja vagy figyelmen kívül hagyhatja
• pl. nyitott fájlok lezárása
• Vagy alapértelmezett módon cselekedhet
• A memóriatérképnek megfelelő • Szignál általi befejezést jelent
memóriaterületek felszabadítása
• A PCB memóriaterületének felszabadítása
Processzushiearchiák A multi-programozás modellezése

• Processzusfák használatának egyszerű példája • Ha egy átlagos processzus az idő 20%-át használja
• Reinkarnációs szerver feladatai számításra,
• Meghajtó programok indítása
• Kiszolgálók
• Akkor a CPU-t teljesen 5 processzus használja ki.
• Indítása • Nagyon optimista
• Újraindítása • Nem veszi figyelembe, hogy a processzusok I/O műveletekre is várhatnak egy
• Blokkolt állapotban van elinduláskor időben
• Vár arra, hogy mit hozzon létre
• Init
• Valószínűségi megközelítés
• /etc/rc szkriptek végrehajtása • Thf. egy processzus az idejének egy p töredékét tölti I/O műveletekre
• A reinkarnációs szervert utasítja való várakozásra
• Reinkarnációs szerver gyerek processzusai
• n processzus esetén annak a valószínűsége, hogy mindegyik
• Amikor egy gyerekprocesszus befejeződik
• Értesül erről a reinkarnációs szerver
processzus I/O műveletre várakozik pn
• Újraindíthatja azokat • Feltételezve, hogy mindegyik processzus független
• A szkriptek végrehajtása után /etc/ttytab
konfigurációs állomány • A CPU kihasználtság = 1 – pn
• Terminálok és virtuális terminálok
• Fork-ol egy gettty processzust
• Ez egy közelítés csak
• … • Egy CPU esetén nem tehetjük fel, hogy egyszerre több
• A shell az init gyerekprocesszusai lesznek
• A felhasználó processzusai a shell gyerekei
processzus fut.
• Init unokái
Multi-programozás modellezése Multi-programozás modellezése

• Ha egy processzus idejének 80%-át tölti B/K műveletekre • A modell nagyon egyszerű
való várakozással • Nem veszi figyelembe a memória igényeit a
• Legalább 10 processzusnak kell egyszerre a memóriában lennie, programoknak
hogy a CPU 10%-ának az idejét vesztegesse el csak
• A memória megnövelésével a CPU kihasználtsága is növelhető
• Természetesen figyelembe kell venni a befektetés és a növekedés
mértékeinek az arányát
Multi-programozás foka Tanenbaum, Modern Operating Systems 3 e, (c)

2008 Prentice-Hall, Inc. All rights reserved. 0-13-6006639
Szálak Szálak
• Processzusok egymással összefüggő erőforrások egy • A processzusok rendelkeznek végrehajtási szállal
csoportosítása • A szál
• Utasításszámláló
• Címtartománya tartalmazza
• Melyik utasítás végrehajtása következik
• A programkódját
• Regiszterek
• Adatait • Aktuális munkaváltozókat tárolnak
• Erőforrásait • Verem
• Megnyitott fájlok • Végrehajtás eseményeit rögzítik
• Gyerekprocesszusok • Egy-egy keret minden meghívott eljáráshoz
• Függőben lévő ébresztések • A szálat egy processzuson belül kell végrehajtani
• Szignálkezelők
• Statisztikai információk
• A szál és annak processzusa külön fogalmak
• Processzus erőforrás csoportosítása
• Egyszerűbben kezelhetők ilyen formában ezek az
• Szálak azok az egyedek, amelyeket a CPU-n végrehajtása
információk ütemeznek
Szálak Szálak
• Ugyanazon a processzuson belül • Többszörös szálak használata
• Több végrehajtás kezdeményezése • Web böngésző
• Egymástól nagy mértékben függetlenek • Sok kép letöltése egyetlen egy kapcsolat felépítésével
• Külön álló szállak indítása az adott kapcsolat felhasználásával
a képek letöltésére
• Web szerver
Irányító szál Dolgozó szál
Ábra forrása: Tanenbaum könyv Tanenbaum, Modern Operating Systems 3 e, (c)

Szálak Szálak
• Ugyanazon a címtartományon lévő több szál esetén • Bizonyos esetekben az OS nem vesz tudomást a
• A processzustáblázatban nem processzus, hanem szálként szálakról
értendő információk • A felhasználó hatáskörében vannak egészen
• Pl. a szál kiválaszthatja azt másik szálat a blokkolódásakor,
Processzushoz tartozó elemek Szálhoz tarozó elemek
amelyiknek átadhatja a vezérlést
Címtartomány Utasításszámláló
• Feltéve, hogy a tmax időt még nem használta el teljesen
Globális változók Regiszterek
• Megvalósítások szálkezelésekre
Megnyitott fájlok Verem
• POSIX P-szálak
Gyerekprocesszusok Állapot • Mach C-szálak
Függőben lévő ébresztők
Szignálok és szignálkezelők
Elszámolási funkciók
Tanenbaum, Modern Operating Systems 3 e, (c)

Szálak Szálak
• Felhasználói területen található szál-csomag • Más esetekben az OS nyilvántartja a processzusok
• A kernel nem tud semmit róluk szálait
• Egy szálú processzusként kezeli • Szál blokkolódáskor az OS választja ki a következő szálat
• Megvalósítható olyan operációs rendszeren is, amely nem • Ugyanabból vagy egy másik processzusból
támogatja a szálakat • Egy globális száltáblázatban tartja
• Könyvtárként van megvalósítva nyílván a szálhoz tartozó információkat
• Ugyan az az általános struktúra jellemző rájuk • Kernel hívásokkal jönnek létre az új szálak,
• Saját privát száltáblázattal rendelkezik a megszűntetésük is kernel hívásokon
mindegyik processzus keresztül történik
• Analóg a kernel processzus táblával (PCB)
• Csak a szál tulajdonságokat tartja nyílván
Tanenbaum, Modern Operating Systems 3 e, (c) Tanenbaum, Modern Operating Systems 3 e, (c)
2008 Prentice-Hall, Inc. All rights reserved. 0-13-6006639 2008 Prentice-Hall, Inc. All rights reserved. 0-13-6006639
Szálak Szálak
• Sor probléma merül fel
• A két megoldás teljesítményben különböznek
• Szülőprocesszushoz tartozó szálakat létrehozzuk-e a gyerekprocesszusoknál
• A szálak közötti váltás sokkal gyorsabb, ha felhasználói szinten is?
történik • Ha a szülő- és a gyerekprocesszus is több szállal rendelkezik
• Mi történik, ha az egyik blokkolódik?
• Amikor teljes egészében felhasználói szinten kezeljük a szálakat • Szálak közös adatszerkezeten való osztozásakor
• Egy szál blokkolásakor a teljes processzus blokkolódik • Egyik szál lezár egy fájlt, de még a másik olvasná azt
• Kevés memória esetén memória foglalás
• Hybrid megvalósítások • Szálváltás után mi történik?
• Hibajelzés
• Globális változók használata
• Szálakban lévő rendszerhívások felülírják az előző értékeket
• Szignálok
• Egy része szál specifikus másik nem
• Nyomon kell követni a riasztásokat, akkor amikor az OS nem tud a szálakról
• Veremkezelés
• Veremtúlcsordulás esetén verem méretének megnövelése
• Több szál több verem
• Amennyiben a kernel nem tud a vermekről, akkor ki fogja azokat megnövelni?

Processzusok 37
Szálak
• Felbukkanó szálak (pop-up)
• Elosztott rendszereknél igen hasznosak a szálak használata.
• Bejövő üzenet új szál kreálását eredményezi,
• Feldolgozza az üzenetet.
• Előnyök
• Teljesen újak
• Nincsenek regiszterek, amiket helyre kell állítani az üzenet feldolgozáshoz
• Gyorsan létrehozhatóak
• Lecsökkenthető az üzenet beérkezése és az adott válasz közötti idő
• Fejlettebb tervezési technikák esetén
• Milyen processzusban fusson?
• Ha a rendszer támogatja a kernel szintű szálakat
• Könnyebb és gyorsabb
• Könnyebben eléri a kernel táblázatokat
• B/K eszközöket
• Kernel szintű szállal nagyobb kárt tudunk okozni
• Amennyiben hosszú ideig fut és nem lehet megszakítani, akkor elveszhetnek
bejövő adatok
Processzusok 2
Processzusok kommunikációja
• A processzusoknak szükségük vannak a kommunikációra
• Pl. parancsértelmező csővezeték
• Előnyös, ha ez nem magszakításokkal történik
PROCESSZUSOK II. • Jól strukturált módon

• InterProcess Communication (IPC)
• Témakörök
Processzusok kommunikációja • Hogyan lehet információt küldeni egy processzus a másiknak?
• Kettő vagy több processzus ne tudja egymás útját keresztezni
Klasszikus IPC problémák • Kritikus tevékenység esetén
• Versenyhelyzet
• Repülőjegy foglaló rendszerben az utolsó hely foglalása egy gépen különböző utasok
számára
• Megfelelő sorrendbe állítás függőség esetén
• Pl. gyártó - fogyasztó probléma
• Gyártó = termelő
• Egyik adatot állít elő a másik számára
Processzusok kommunikációja Versenyhelyzetek

• A szálak esetén • Kooperatív processzusok közös tárolóterületen dolgoznak
• Olvashatnak, írhatnak
hasonló problémák
• Lehet memória terület vagy megosztott fájl
• Információ küldés
• Általános probléma – Háttérnyomtatás
egyszerű
• A kliens
• Közös címtartományon
• Nyomtatáskor beteszi a fájl nevét egy háttérkatalógusba
dolgoznak
• Sorszámmal azonosított rekeszek
• Egymás akadályozása • Fájlnevek tárolására alkalmas
és megfelelő sorrend • Nyomtató démon
• A problémák megoldása • Rendszeresen ellenőrzi, hogy kell-e nyomtatni
megegyeznek • Ha van
• Akkor kinyomtatja
• Kitörli a nevét a katalógusból
Versenyhelyzetek Kritikus szekció

• Általános probléma – • Versenyhelyzet elkerülése
Háttérnyomtatás • Meg kell tiltani, hogy egy időben egynél több processzus hozzáférjen a
• Két megosztott változó
• out megosztott adatokhoz
• in
• A következő nyomtatandó állományra mutat
• Kölcsönös kizárás
• A katalógus következő szabad helyére mutat
• Biztosítja, hogy ha egy processzus használ egy megosztott erőforrást,
• Legrosszabb eset
• A olvassa az in értékét és eltárolja egy
akkor a többi processzus ne tehesse ezt
lokális változóban
• Kontextus csere történik
• OS tervezési szempontja
• B eltárolja az állományt és az in-t frissíti • Alkalmas primitív műveletek a kölcsönös kizárás megoldására
az új értekkel
• A folytatja a futását • Szétbontjuk a problémát
• Felülírja a korábbi rekesz tartalmát
• Kitörli a B által beírt állomány nevét • A processzus olyan tevékenységet folytat, ahol nincs szüksége osztott
• Frissíti az in értékét
erőforrásokra
• Versenyhelyzet
• Megosztott adatok esetén a • Kritikus szekció, ahol a program versenyhelyzetbe kerül
végeredmény attól függ, hogy ki mikor
fut • Ha két processzus soha nincs egyszerre a kritikus
szekciójában
• A versenyhelyzet elkerülhető
Kritikus szekció Kölcsönös kizárás tevékeny várakozással

• Szükséges feltételek a kooperatív processzusok • Módszerek a
megfelelő együttműködéséhez
kölcsönös kizárás
1. Ne legyen két processzus egyszerre a saját kritikus szekciójában
2. Semmilyen előfeltétel ne legyen a sebességekről vagy a CPU-k
eléréséhez
számáról • Megszakítások tiltása
3. Egyetlen, a kritikus szekcióján kívül futó processzus sem • Zárolásváltozók
blokkolhat más processzusokat
• Szigorú váltogatás
4. Egyetlen processzusnak se kelljen örökké várni arra, hogy
belépjen a kritikus szekciójába • Peterson megoldása
• A TSL utasítás
Kölcsönös kizárás tevékeny várakozással Kölcsönös kizárás tevékeny várakozással

Megszakítások tiltása Zárolásváltozók
• Minden processzus letiltja • Egy felhasználói program • Szofveres megoldás • A probléma ugyanaz, mint a
letiltja a megszakításokat háttérkatalógusnál
az összes megszakítást a • Mi van akkor, ha nem engedélyezi
• Egyetlen osztott zárolási
• Megkerülhetjük a
kritikus szekcióba lépés azokat újból?! változó problémát?
után • Több processzoros rendszernél • Kezdeti értéke 0 • Először kiolvassuk
• Újraengedélyezi, mielőtt
• Csak az adott CPU-ra vonatkozik • Kritikus szekcióba lépés előtt • Aztán mielőtt írnánk bele
a megszakítás tiltása • Újra ellenőrizzük
elhagyja azt • Teszteli ezt a változót
• A kernel leszokta tiltani a • Nem jó
• Ha az értéke 0,
• Nem fordulhat elő megszakításokat • A verseny akkor fog
• Akkor 1-re állítja és bekövetkezni, miután a
óramegszakítás • Változók és listák frissítésekor
• Belép a kritikus szekciójába második processzus azután
• CPU nem fog másik • Az operációs rendszereknél • Ha az értéke 1 módosítja a változót, amikor az
processzusra váltani megengedett ez a technika első processzus befejezte az
• Addig várakozik, amíg újraellenőrzést
• Problem solved?! értéke 0 nem lesz
Kölcsönös kizárás tevékeny várakozással Kölcsönös kizárás tevékeny várakozással

Szigorú váltogatás Peterson megoldása
• Folyamatosan tesztel • Sérti a 3-ik feltételt • T. Dekker kombinálta • Udvarias megoldás

• Egymás váltogatása
• Pazarolja a CPU-t • A processzus blokkolja • Maga elé engedi a másik
másik processzus kritikus • Zárolás változók processzust
• Problémás, ha a szekcióba való lépését a • Figyelmeztető változók
sebessége a kritikus szekción kívül • G.L. Peterson egyszerűbb
processzusnak eltér megoldást adott
• Két C eljárás
• Kritikus szekcióba lépés előtt
• enter_region
• Kritikus szekció elhagyása
után
• leave_region

Kölcsönös kizárás tevékeny várakozással Altatás és ébresztés

• Tevékeny várakozás
A TSL utasítás
• Ha nem léphet be a kritikus szekcióba, akkor egy ciklusban
várakozik arra, hogy megkapja az engedélyt
• Hardveres segítség • Párban kell használni az • Használja a CPU-t
• Általában többprocesszoros
gépeknél eljárásokat • „Pazarolja”
• Más hatással is járhat
• Test and Set Lock • Ha valaki csal, akkor a
• TSL RX,LOCK • Magas (H) és alacsony (L) prioritású processzusok esetén
kölcsönös kizárás meghiúsul • Ha a magas prioritású futáskész állapotban van, akkor megkapja a CPU-t
• Beolvassa a LOCK memória
szót az RX regiszterbe • Futni fog
• Nem nulla értéket ír a memória
2008 Prentice-Hall, Inc. All rights reserved. 0-13-6006639 • Bizonyos pillanatban L a kritikus szekciójában van
címre • A H futáskész állapotba kerül
• A kiolvasási és a tárolási • Tevékeny várakozás
művelet nem választható szét • L nem tud kilépni a kritikus szekciójából, mivel nem kap CPU-t az ütemezőtől
• CPU zárolja a memóriasínt • H végtelenségig ismétel
• Tiltva van a memória elérés a • Fordított prioritási probléma
CPU-knak a művelet • A példa egy kicsit el van túlozva
befejezéséig • Az ütemezőt meg lehet valósítani úgy, hogy ez az eset ne forduljon elő
Altatás és ébresztés Altatás és ébresztés

• sleep • Gyártó és fogyasztó probléma
• Korlátos tároló probléma
• Rendszerhívás
• Rögzített memória területen osztozik két processzus
• Blokkolja a hívót • Gyártó
• Fel lesz függesztve addig, amíg egy másik processzus fel nem ébreszti • Adatokat helyez el a tárolóban
• wakeup • Fogyasztó
• Paramétere egy processzus azonosító • Kiveszi az adatokat a tárolóból
• Feldolgozza azokat
• Különböző megvalósítások • A probléma általánosítható
• Egy memória cím paraméterrel össze lehet kötni a sleep-wakeup • m gyártó n fogyasztó
párokat • Ha a tároló tele van
• A gyártó elaszik, ha elemet akar berakni a tárolóba
• Felébreszti a fogyasztó, ha egy elemet a fogyasztó kivesz a tárolóból
• Ha a tároló üres
• A fogyasztó elalszik, ha ki akar egy elemet venni
• Felébreszti a gyártó, ha legyártott egy elemet
• Hasonlít a háttérkatalógus problémára
Altatás és ébresztés Altatás és ébresztés

• Versenyhelyzet
• A count változóhoz való hozzáférés nem korlátozott
• Ha a tároló üres
• A fogyasztó éppen most olvasta ki a count értéket
• Ellenőrzi, hogy nulla-e
• Az ütemező kontextus cserét hajt végre
• Átadja a CPU-t a gyártónak
• A gyártó be tesz egy elemet a tárolóba
• Növeli a count értékét
• 1 lesz az új érték
• Azt hiszi, hogy a fogyasztó éppen alszik
• 0 volt előzőleg a count értéke
• Meghívja a wakeup-ot
• Felébreszti a fogyasztót
• A fogyasztó nem alszik még
• Az ébresztés elveszik
• Amikor a fogyasztó visszakapja a CPU-t
• Elalszik
• A gyártó addig pakolgat, amíg tele nem lesz a tároló
• Ő is elalszik
• Vissza a kódhoz!!!
Gyártó-fogyasztó probléma megvalósítása végzetes versenyhelyzettel
Altatás és ébresztés Tanenbaum, Modern Operating Systems 3 e, (c)

Altatás és ébresztés
• Még nem alvó processzusnak küldött ébresztőjel elveszik
• Gyors javítás
• Ébresztőt váró bit hozzáadása
• Ha ébren lévő processzusnak küldünk ébresztést
• A bit beállítódik
• Ha a processzus „alváshoz készül” van és ez a bit be van állítva
• Kikapcsolja a bitet
• Ébren marad
• Másodlagos eszköz az ébresztőjel számára
• Ebben az esetben megoldást jelent
• Könnyű olyan példát keresni három vagy több processzus esetén
• Egy ébresztő bit nem elegendő
• Probléma specifikus megoldás
• A probléma megmarad
Gyártó-fogyasztó probléma megvalósítása végzetes versenyhelyzettel

Szemaforok Szemaforok
• E.W. Dijkstra • Az oszthatatlan megvalósítás nélkülözhetetlen
• Egész változókban számoljuk az ébresztéseket • up és down rendszerhívások
• Új változó típus bevezetése
• Az OS letiltja a megszakításokat
• Szemafor
• a szemaforok ellenőrzésének és frissítésének
• 0, ha nincs elmentett ébresztés
• Valamilyen pozitív érték
• a processzus altatásának idejére
• Egy vagy több ébresztés van függőben • Csak néhány utasítás erejéig
• Műveletek • Nem ér sérelem senkit
• down
• Megvizsgálja, hogy a szemafor értéke nagyobb-e, mint 0
• Biztosítja, hogy a végén engedélyezi a megszakításokat
• Ha igen, akkor csökkenti annak értékét és azonnal folytatja munkáját • Több CPU esetén mindegyik szemafort védeni kell egy zárolási
• Ha 0, akkor a processzust elaltatja, mielőtt a down() befejeződne
• A művelet egyetlen oszthatatlan elemi műveletként hajtódik végre változóval
• up • Csak egy CPU vizsgálja a szemafort egy időben
• Növeli a szemafor értékét
• Olyan szemaforon végrehajtva a műveletet, amelyen több processzus aludt, a szemafor • TSL utasítást használva
értéke 0 marad, de eggyel kevesebb processzus fog rajta aludni • Tevékeny várakozás
• Az érték növelése és a processzus felébresztése szintén elemi műveletként hajtódik végre
• Szemafor műveletek csak néhány mikrosec.-et vesznek igénybe
Szemaforok Szemaforok
• Teli rekeszek számolása
• full
• 0
• Üres rekeszek számolása
• empty
• N – max. helyek száma
• A puffert egyszerre csak
egy processzus érhesse el
• mutex
• 1
• két értéke lehet csak
• 0 vagy 1
• Bináris szemafor
• Kölcsönös kizárás garantált a közös terület eléréséhez
• Mindegyik processzus végrehajt egy down()műveletet mielőtt belép a kritikus szekciójába
• csak egy up() hajtódik végre közvetlenül a kritikus szekció elhagyása után
• Szinkronizáció
• Eseménysorozatok bekövetkezésének biztosítása
• Ez különbözik a kölcsönös kizárástól
Gyártó-fogyasztó probléma megoldás szemaforokkal

Mutex-ek Mutex-ek
• Mutual exclusion • Processzusok vagy szálak esetén
• Kölcsönös kizárás
• Az a szál, amelyik be akar lépni a kritikus szekcióba,
• Nincs szükség az altatások
számlálására először megpróbálja zárolni a megfelelő mutex-et.
• Megvalósítás könnyű és • Ha a mutex nem zárolt, akkor egyből beléphet a kritikus szekcióba
hatékony
• A zárolás automatikusan beállítódik
• Kétféle állapota lehet
• Nem zárolt • Megelőzve azt, hogy másik szál belépjen a kritikus szekcióba
• Zárolt • Ha a mutex már zárolt,
• Egyetlen bit is elegendő lenne
• A hívó szál blokkolódik addig, ameddig a zárolás fel nem oldódik.
• A gyakorlatban egy egész értéket
használnak • Ha több szál is vár ugyanarra a mutex-re
• 0  nem zárolt
• Bármilyen más érték  zárolt • Ha feloldódik, akkor csak az egyik szálnak lesz engedélyezve
• Két eljárás folytatódjon és újra zárolja azt
• mutex_lock • Ezek a zárolások nem kötelezőek
• mutex_unlock
• Csak a programozótól függ, hogy helyesen használja-e azokat

Mutex-ek Mutex-ek
• Néhány Pthreads hívás a mutex-ekre • Másik szinkronizálási
mechanizmus
• Feltételes változók
• Megengedi a szálaknak,
hogy blokkolódjanak,
amennyiben valamilyen
feltétel nem teljesül
• Két módszert gyakran
együtt használjuk
• Zárol egy mutex-et
• Várakozik egy feltételes
változóra, amikor nem
kapja meg azt amire
szüksége van

Monitorok Monitorok
• Úgy tűnik, hogy a szemaforokkal és mutex-ekkel a • Helyes programok írásának megkönnyítése
processzusok közötti kommunikációt könnyen meg lehet • Brinch Hansen és Hoare
oldani • Magasabb szintű szinkronizációs primitívek használatának javaslata
• A gyártó kódjában két down-t megcserélve • Monitoroknak nevezték el
• A mutex értékét csökkenti először az empty előtt • Monitor
• Ha tároló teljesen tele lenne, akkor a gyártó blokkolódna • Eljárások, változók és adatszerkezetek együttese
• mutex = 0 • Speciális modulba/csomagba vannak összegyűjtve
• A fogyasztó ezután próbálná a tárolót elérni • A processzusok bármikor hívhatják a monitorban lévő eljárásokat
• down végrehajtása a mutex-en • Nem érhetik el a belső adatszerkezeteit
• Szintén blokkolódna • Objektumorientált nyelvekben is használt szabály
• Végtelenségig blokkolt állapotban maradna • Minden időpillanatban csak egy processzus lehet aktív egy monitorban
• Nem folytatódna soha a munka • A monitor eljárásokat másképpen kell kezelni
• Holtpont alakulna ki • Az első néhány utasítás ellenőrzi, hogy van-e már aktív processzus a monitoron
• Ezt később részletesen fogjuk tárgyalni! belül
• Óvatosan kell a szemaforok használatát kezelni • A fordítóprogramtól függ a megvalósítás
Monitorok Monitorok
• Könnyű módszer a kölcsönös kizárás eléréséhez • Szükség van egy szabályra
• Nem elegendő • Mi történjen a signal után?
• Szükség van olyan módszerre, amellyel egy processzust
blokkolhatunk, ha nem tud tovább haladni • Hoare
• Megoldás állapot változók bevezetése • Az újonnan felébresztett processzust hagyjuk futni
• Nem számlálók • A másikat felfüggesztjük
• Nem gyűjtenek signal-okat későbbi felhasználásra • Brinch Hansen
• Rajtuk végezhető műveletek • A signal-t végrehajtó processzus azonnal lépjen ki a monitorból
• wait
• signal csak az utolsó utasítás lehet
• signal
• Egy monitorban lévő eljárás nem tudd tovább dolgozni • Egyszerűbb és könnyebb is megvalósítani
• Végrehajt egy wait-et egy állapotváltozón • Ha több processzus is vár ugyanarra a változóra
• Ez a hívó processzus blokkolását okozza • Az ütemező által meghatározott fog felébredni a signal hatására
• Megengedi azt is, hogy egy előzőleg a monitorba való belépéstől eltiltott
processzus belépjen a monitorba
• Felébresztheti az alvó processzust egy signal-lal azon az állapotváltozón, amelyre a másik
éppen vár
Üzenetküldés Üzenetküldés
• Processzusok kommunikációja • Tervezési kérdések az
• Két primitívet használ üzenetküldési rendszereknél
• send(cél, &üzenet) • Hálózatba kötött gépeken futó
• receive(forrás, &üzenet)
processzusok kommunikációja
• Az üzenet elveszhet a hálózaton
• Rendszerhívások • Nyugtázó üzenet visszaküldése
• Hasonlítanak a szemaforokra • Amennyiben a küldő, adott
• Nem monitorok időkorláton belül nem kapja meg a
visszaigazolást, akkor újra küldi az
üzenet
• A válasz nem jutott vissza a feladóhoz?
• Üzenetek azonosítása
• Hitelesítés
• A megfelelő processzus kapja meg az
üzenetet
• Küldő és fogadó ugyanazon a
gépen található
• Teljesítményi problémák
• Lassabb, mint a többi eddigi eszköz
A gyártó-fogyasztó probléma üzenetküldéssel
Üzenetküldés Üzenetküldés
• Levelesláda • Ideiglenes tárolás
adatszerkezet elhagyása
• Adott számú üzenet • Ha receive előtt send-et
tárolására alkalmas hajtunk végre
• Elküldött, de még fel nem • Küldő blokkolódik, amíg a
dolgozott üzenetek receive végrehajtódik
• A cím paraméterek ilyenkor • Ha a send előtt receive
nem processzusok hajtódik végre
• Levelesládák • Fogadó blokkolódik, amíg a
• Ha tele van a levelesláda send blokkolódik
• A küldő felfüggesztődik • Randevúnak nevezzük ezt
• Üres a levelesláda
a stratégiát
• Könnyebb megvalósítani
• A fogadó
A gyártó-fogyasztó probléma üzenetküldéssel felfüggesztődik???!!! • Kevésbé rugalmas
• Erre nincs utalás a könyvben
Sorompók Sorompók
• Sorompó primitív
• Könyvtári eljárás
• Fázisokra osztjuk az alkalmazást
• Szabály
• Egyetlen processzus sem mehet tovább a következő fázisra, amíg
az összes processzus nem áll készen
• Sorompó elhelyezése mindegyik fázis végére
• Amikor egy processzus a sorompóhoz ér, akkor addig blokkolódik
ameddig az összes processzus el nem éri a sorompót
• A sorompó az utolsó processzus beérkezése után Sorompó használata:
elengedi a azokat a. Processzusok közelítenek egy sorompóhoz.
b. Egy processzus kivételével mindegyik processzus blokkolódik a sorompónál.
• Nagy mátrix-okon végzett párhuzamos műveletek c. Amikor az utolsó processzus a sorompóhoz ér, mindegyiket tovább engedi
Klasszikus IPC-problémák Klasszikus IPC-problémák

• Étkező filozófusok
• Egy rossz megoldás
• Éhezés
Egy megoldás az étkező filozófusok problémájára I.

Klasszikus IPC-problémák Klasszikus IPC problémák
Egy megoldás az étkező filozófusok problémájára II. Egy megoldás az étkező filozófusok problémájára III.
Klasszikus IPC-problémák Klasszikus IPC-problémákra

• Kizárólagos hozzáférés korlátozott számú erőforrásokhoz
(pl. I/O eszközök)
• Olvasók és írók problémája
• Repülő foglalási rendszer
• Olvasó növel egy számlálót a belépéskor
• Kilépéskor csökkent
• Az utolsó elengedi az adatbázist
• Beléphet egy író
• Éhezés
• Megoldás a később érkező olvasók blokkolása
Egy megoldás az olvasók és írók problémájára I.
Processzusok 45
Klasszikus IPC-problémák
Egy megoldás az olvasók és írók problémájára II.

Processzusok 2
Ütemezés
• Processzusok versengenek a CPU-ért
• Egy CPU áll rendelkezésre
PROCESSZUSOK III.
• Az OS dönti el, hogy melyik kapja meg a CPU-t
• Az ütemező (scheduler) hozza meg a döntést
• Ütemezési algoritmus
Ütemezés • Processzusok és szálak

• Hasonló megfontolások alkalmazhatóak
• Szálak esetén vannak speciális esetek
Ütemezés Ütemezés
• Kötegelt rendszereknél mágnesszalagon tárolták a • Processzusok viselkedése • Számítás (CPU) igényes
feladatokat • Váltogatva végzett processzusok
számítások és I/O műveletek • I/O igényes processzusok
• A szalagon következő feladatot futatták
• Tipikus működés
• Egyszerű • CPU dolgozik
• A CPU-k sebességének
• Rendszerhíváshoz ér növekedésével inkább I/O-
• Időosztásos rendszereknél • Pl. fájlt ír vagy olvas igényesek lettek a
• Bonyolultabb • Aztán újra dolgozik processzusok
• A következő B/K tevékenységig
• Több felhasználó várakozik
• Blokkolt állapot
• Lehetnek még kötegelt feladatsorok is
• Az eszköz tevékenységének a
• Háttérfeladatok egyfelhasználós rendszerek esetén befejezését meg kell várni
• Korlátozott számú CPU erőforrás
• Sohasem elég
• Mikor ütemezünk? • Időzítő megszakítás • Ütemezési algoritmusok csoportosítása
• Kötegelt
• Amikor a processzus kezelés • Nincsenek felhasználók
befejeződik • Nem megszakítható • Nem megszakítható ütemezési algoritmusok
• Amikor egy processzus • Amíg blokkolódik a • Hosszú időszeletek kombinálása megszakítható ütemezési algoritmusokkal
blokkolódik I/O művelet kiválasztott processzus nem • Csökken a kontextus cserék száma
miatt vagy szemafor miatt futhat • A teljesítmény nő
• Önszántából le nem mond a • Interaktív rendszerek
CPU-ról • Időnkénti megszakítás nélkülözhetetlen
• Új processzus jön létre
• Megszakítható • A CPU nem sajátítható ki
• I/O megszakítás • Előre meghatározott ideig
• Megszakításos ütemezésre van szükség
következik be futhat • Nem együtt működő processzusok
• Vannak ártó szándékúak is
• Időzítő megszakítás • Az időintervallum végén
• Valós idejű
következik be felfüggesztésre kerül
• Nem mindig van szükség megszakításos ütemezésre
• Az ütemező másik
• A processzusok eleve nem futnak sokáig
processzust választ
• Csak a feladatra koncentráló processzusok futnak
• Ütemezési algoritmusok céljai • Kötegelt rendszerek • Interaktív rendszerek
• Vannak olyam célok, amelyek elérése mindig kívánatos
• Áteresztő képesség • Válaszidő
• Az összes rendszerre vonatkozó elvek • Időegység alatt végrehajtott • A parancs kiadása és a
• Pártatlanság feladatok száma válasz megérkezése között
• Hasonló processzusok hasonló szolgáltatást kell kapniuk • Maximalizálni kell eltelt idő
• Különböző csoportok kezelése eltérhet • Áthaladási idő • Minimalizálni kell
• Ütemezési elvek betartása • Háttértevékenységeket
• A feladat beküldése és
• A policy-kat be kell tartani befejeződése között eltelt idő „háttérbe kell szorítani”
• Egységes terhelés elosztás • Minimalizálni kell • Arányosság
• Folyamatos kihasználtság • CPU kihasználtság • A felhasználók elvárásainak
• Feladatok összeválogatása való megfelelés
• Nem igazán jó mérőszám
• Processzusok helyes
• Az előző kettő jobb
sorrendjének megválasztása
Ütemezés Ütemezés kötegelt rendszereknél

• Sorrendi ütemezés • Hátrány
• Valós idejű rendszerek • Nem megszakítható • 1 CPU igényes
• Eltérő tulajdonságok • Olyan sorrendben osztja a CPU-t, • 1 mp-ig fut
ahogy a processzusok kérik azt • Sok I/O igényes processzus
• Szabályos időnként
• Egyetlen várakozósor a futáskész • Kevés CPU időt használ
bekövetkező események processzusok számára • 1000 lemezolvasást kell elvégeznie
• Probléma
• Határidők betartása • Addig fut, amíg nem blokkolódik
• A CPU igényes 1 mp-ig fut
• A sor elején lévő processzus kapja meg
• Adatvesztés elkerülése a CPU-t • Olvas egy lemezblokkot
• Amikor a blokkolt processzus újra • Blokkolódik
• Előre jelezhetőség futáskész lesz • Ezután az I/O igényes processzusok
• a sor végére kerül jönnek sorban
• Pontosan előre jelezhető • Könnyen megérthető és • Mindegyik egy blokkot olvas
és szabályos ütemezés megvalósítható • Az I/O igényes processzusok 1000 mp
alatt futnak le
szükséges • Pártatlan • Ha megszakítanánk a CPU igényes
processzust 10 ezred mp-ként
• Pl. minőség romlásának • 10 mp alatt végeztek volna
elkerülése multimédia • A CPU igényes sem lassult volna le
rendszereknél nagyon
Ütemezés kötegelt rendszereknél Ütemezés kötegelt rendszereknél

• Legrövidebb feladatot • Átlagos futási idő • Legrövidebb maradék idejű következzen
• Megszakítható
először • 4𝑎 + 3𝑏 + 2𝑐 + 𝑑 4
• Mindig azt a processzust választja az ütemező, amelynek
• Nem megszakítható • Ha 𝑎 nagy, akkor legkevesebb a befejeződésig még a hátralévő ideje
• Feltételezi, hogy a futási többszörösen járul hozzá • Új processzus esetén
időket előre ismerjük az átlaghoz • A teljes időt összehasonlítjuk az éppen futó processzus hátralévő
idejével
• Amikor több egyformán • Ha kevesebb időt igényel az új processzus, akkor lecseréljük az új
fontos feladat van, akkor processzusra
ezt kell használni • Az új, rövid feladatok jó kiszolgálásban részesülnek
• Csak akkor optimális
• Ha mindegyik feladat
egyszerre rendelkezésre áll

Ütemezés kötegelt rendszereknél Ütemezés kötegelt rendszereknél

• Háromszintű ütemezés • Memória ütemező folyt.
• Bebocsátó ütemező
• Körültekintően kell eljárnia
• Megfelelő keverék előállítása
• CPU és I/O igényes processzusokból • Memóriában tartott processzusok száma
• Rövid feladatokat először engedi be • Multiprogramozás mértéke
• A hosszabbaknak várakozniuk kell • Milyen processzusok legyenek a memóriában
• Bizonyosakat sorrendben tart
• Döntési szempontok
• Beengedhet később érkezőket
• Mennyi idő telt el a processzus lemezre vitele óta?
• Memóriaütemező
• Mennyi CPU időt használt fel processzus nemrégiben?
• Sok processzus esetén nem férnek el
a memóriában • Melyen nagy a processzus?
• Néhányat ki kell tenni a merevlemezre • Mennyire fontos?
• Melyik maradjon a memóriában?
• Sűrűn kell felülvizsgálni
• A lemezen lévőnek is legyen esélyük
• A gyakori lemez  memória mozgatások sem jók
Ütemezés kötegelt rendszereknél Ütemezés interaktív rendszerekben

• Mindegyike alkalmas a
kötegelt rendszerek
CPU ütemezőként való
alkalmazására
• Két szintű ütemezés
gyakori
• Memóriaütemezés
• CPU-ütemező
Háromszintű ütemezés
Ütemezés interaktív rendszerekben Ütemezés interaktív rendszerekben

• Kérdés a Round-robin ütemezés során
Round-robin ütemezés
• Mekkora legyen az időszelet hossza?
• Egyszerű, pártatlan, • Listát kell kezelni • A kontextus csere adminisztrációs időt igényel
széleskörűen használt • Regiszterek és memóriatérképek mentése és betöltése
• Futtatatható processzusok
• Processzusoknak ki van • Táblázatok aktualizálása
osztva egy időintervallum • Az időszelet felhasználása
• Gyorsítótárak tartalmának visszaírása
• Időszeletek után a lista végére kerül a
• Majd újratöltése
• Ezalatt engedélyezett a processzus
futtatás • T.f.h. (tegyük fel hogy)
• Az időszelet végén a futó • Kontextus csere
processzus átadja a CPU-t • 1 ezred mp-t igényel
másik processzusnak
• Időszelet nagysága
• Blokkolódás vagy befejeződés
esetén • 4 ezred mp
• Az időszelet lejárta előtt • A CPU 20%-t adminisztrációs feladatokra használjuk
átadódik a CPU • Túl sok


• Kérdés a Round-robin ütemezés során (folyt.)
• Lehetne az időszelet 100 ezred mp. Prioritásos ütemezés
• Az elpocsékolt CPU idő csak 1% lenne
• T.f.h. 10 processzus kerül futtatható állapotba közel egyszerre
• Az első azonnal el kezd futni • Minden processzus • Végtelen ideig való futtatás
• A második 100 ezred mp. után
• …
egyformán fontos!? megelőzése
• Előfordulhat, hogy az utolsó 1 mp-et kell várnia, hogy sorra kerüljön • Több felhasználós • Minden óraütemben csökkenti
• Ajaj!!!
számítógépek
• Másik szempont az éppen futó processzus
• Ha az időszelet az átlagos CPU használati periódusnál hosszabbra van állítva
• Külső tényezők figyelembe prioritását
• Az időszelet lejárta miatt ritkán fogja a CPU-t elvenni a futó processzustól vétele
• Amikor a második
• Valószínűleg az időszelet lejárta előtt blokkolódni fognak
• Kontextus csere fog történni • Alapötlet legfontosabb lesz, akkor
• Javítja a teljesítményt
• Csak akkor következik be a váltás, amikor amúgy sem tudná használni a CPU-t
• Minden processzushoz egy kontextus csere
• Túl kicsi időszelet
prioritást rendelünk hozzá • Maximális időszeletet
• Sok kontextus cserét eredményez • A legmagasabb prioritású rendelünk minden
• Csökken a CPU hatékonysága futáskész processzus kapja processzushoz
• Túl nagy időszelet meg a CPU-t
• Az időszelet lejárta után a
• Gyenge válaszidőt okoz
• Szükség van rá következő legmagasabb
• 20-50 ezred mp. elfogadott érték az időszelet nagyságára
• Egy felhasználó esetén is prioritású kapja meg a CPU-t

• Statikus prioritás hozzárendelés
• Prioritási osztályokba
• Adott rendszeren adott felhasználókra automatikusan adott
prioritású processzusok jönnek létre való besorolás
• nice Unix utasítás • Osztályon belül Round-
• Önkéntesen csökkenthetjük a processzus prioritását
robin ütemezés
• Senki nem használja
• Dinamikus prioritás hozzárendelés • Ha a prioritásokat
• Erősen I/O igényes processzusok esetén időnként nem igazítjuk
• Sok időt töltenek I/O műveletekre való várakozásra ki, akkor az alacsonyabb
• Azonnal meg kellene kapniuk a CPU-t osztályok éhen is
• Minél hamarabb el tudják indítani a következő I/O kérést
• Utána úgyis blokkolódik
halhatnak
• Másik processzus fog futni
• Prioritás 1 𝑓
• 𝑓 az utolsó időszeletben felhasznált rész aránya

Többszörös sorok • Többszörös sorok
(folyt.)
• Prioritási osztályok felállítása
• Ha lassú a kontextus
csere végrehajtása
• Legmagasabb osztályban egy
időszeletig futnak
• Induláskor hosszú
• Hatékonyabb, ha a CPU-
• Következő osztályban két
időszeletig
futás idő igénylése
igényes processzusok • Következő osztályban négy
• Később interaktívvá válik
időszeletig
időnként nagy időszelet • … • Pl. Enter-t ütnek a
kapnak • Valahányszor elhasználja az
terminálban
időszeletét
• Ha minden proc. nagy
• Egy osztállyal lejjebb kerül • A legmagasabb prioritási
időszeletet kapna, akkor a • 100 → 1, 2, 4, 8, 16, 32, 64 = 7
nagy lenne a válaszidő csere ↔ 100 csere
osztályba kerül
• Egyre kisebb gyakorisággal fog • Növeli a válaszidőt
futni, ahogy lejjebb kerül • Enter-t ütögetve
• CPU idő megtakarítása rövid
interaktív processzusok számára

Legrövidebb processzus
következzen Garantált ütemezés
• Becslés múltbéli viselkedés alapján

• Kötegelt rendszerekben • 𝑇0 , 𝑇1 → 𝑎𝑇0 + (1 − 𝑎)𝑇1
• Ígéret a teljesítménnyel • Az ígéret betartásához
minimális válaszidőt ad • 𝑎 értéke befolyásolja, hogy milyen
gyorsan felejti el a régi értékeket
kapcsolatban • Nyomon kell követni,
• Interaktív processzusok • 𝑇0 • Az ígéret szép szó … • mennyi CPU időt kapott a
létrehozása óta
• Reális ígéret, amit könnyű
• 𝑇0 2 + 𝑇1 2
1. Várakozás utasításra • 𝑇0 4 + 𝑇1 4 + 𝑇2 2 • Kiszámítja a neki járó
2. Utasítás végrehajtása • 𝑇0 8 + 𝑇1 8 + 𝑇2 4 + 𝑇3 2 betartani mennyiséget
• Öregedés
3. Goto 1. • A mért érték és az előző becslés
• 𝑛 felhasználó, CPU 1 𝑛-ed • A legkisebb arányszámmal
• Párhuzamos
súlyozott átlaga részét fogja megkapni rendelkező processzust fogja
• Könnyű kiszámítani 𝑎 = 1 2 esetén
futtatni
• 𝑛 processzus, CPU 1 𝑛-ed
processzusoknál nehéz • Új értéket hozzáadjuk a jelenlegi értékhez
• Összeget 2-vel osztjuk részét fogja megkapni
meghatározni, hogy • 1 bittel való jobbra léptetés
melyik a legrövidebb

Sorsjáték ütemezés Arányos ütemezés
• Minden processzus • Több sorsjegy növeli az • A processzusokat eddig • Minden felhasználó kap
sorsjegyet kap esélyét az erőforrás önmagukban tekintettük egy CPU hányadot
• Különböző rendszerbeli odaítélésének • Több felhasználós • Az ütemező figyelembe veszi
erőforrásokhoz • Nagyon jó a válaszidő rendszerek esetén minden a döntéskor
• Pl. CPU • Kooperatív processzusok felhasználó több processzust • Pl. két felhasználó esetén
• Sorsjegyet véletlenszerűen is elindíthat 50-50%
átadhatják egymásnak a
kiválasztjuk sorsjegyeket • Az ütemezéskor • Függetlenül attól, hogy ki
hány processzust indított el
• Az a processzus kapja meg
• Sok problémára kínál figyelembe vehetjük, hogy
az erőforrást, akinél a
sorsjegy van megoldást ki hozta létre a
• Pl. CPU adott arányú processzusokat
elosztása processzusok között
Ütemezés valós idejű rendszerekben Ütemezés valós idejű rendszerekben

• Alapvető szerepe van az időnek • Események, amelyekre válaszolni kell
• Adott időn belül reagálni kell a rendszernek a külső ingerre • Periodikusak
• Szigorú valós idejű rendszerek • Rendszeres intervallumonként fordulnak elő
• Abszolút határidők vannak • Aperiodikusak
• Kötelező betartani • Megjósolhatatlan az előfordulásuk
• Toleráns valós idejű rendszerek • Több periodikus (m) rendszer
• Néha egy határidő elmulasztása nem kívánatos • 𝑃𝑖 a periódusa, kezelésére 𝐶𝑖 mp időre van szükség
• De tolerálható 𝑚 𝐶𝑖
• ≤ 1  ütemezhető
• Valós idejű viselkedés eléréséhez
𝑖=1 𝑃
𝑖
• Programot több processzusra osztjuk • Az ütemezési algoritmusok

• Mindegyik viselkedése ismert/megjósolható • Dinamikusak vagy statikusak
• Rövid életűek, egy másodpercen belül befejezhetődnek • Statikus csak akkor, ha előre ismert az összes információ az
• Ütemező feladata, hogy a processzusokat úgy ütemezze, hogy a elvégzendő feladatokról és határidőkről
határidők be legyenek tartva
Elvek és megvalósítások Szálütemezés

• Azt tételeztük fel, hogy a rendszer minden processzusa • Több végrehajtási szál esetén
különböző felhasználóhoz tartozik • Kétszintű párhuzamosság
• Processzus
• Verseng a CPU-ért • Szálak
• Felhasználó szálak esetén
• Szülő – gyerek processzus • A kernel nem tud a szálak létezéséről
• Nem versengés, hanem elosztás a feladatoknak megfelelően • A száltáblázat processzus szinten van
eltárolva
• Az előző ütemezési algoritmusok nem veszik figyelembe • A processzuson belüli szálütemező dönt
• Melyik szál fusson
a kooperatív feladatok igényeit • Ha az időszelet lejár, akkor a kernel
másik processzusra vált át
• Ütemezés megvalósítását el kell választani az ütemezési • Bármelyik ütemezési algoritmus lehet a
korábbiak közül
elvektől • Round-robin és prioritásos a leggyakoribb
• Paraméterezhető ütemezési algoritmus • Egyedüli korlátozás
• Nincs időzítő, amellyel meg lehet szakítani
• A paramétereket a felhasználói processzusok adják meg
egy túl hosszan futó szálat
• Pl. prioritásos ütemezésnél a gyerek processzusok prioritását a Lehetséges felhasználói szintű

szülő processzus megváltoztathatja szálütemezés. 50 msec-es időszelet,
ha a szálak 5msec-ig futnak
• Rendszerhívás segítségével
Szálütemezés Szálütemezés
• Kernel-szintű szálak • Nagy különbség a felhasználói- és kernel-szintű szálak
között
• Kernel választja ki, hogy
• Teljesítmény
melyik szál fusson • Felhasználó szálak esetén
• Nem veszi figyelembe, • Néhány gépi utasítás a szálváltás
hogy melyik • Blokkolódik a processzus I/O művelet esetén
• Alkalmazás szerinti szálütemezés
processzushoz tartozik a • Ismeri a szálak feladatait
szál • Jobban be tudják hangolni az alkalmazáshoz
tartozó szálakat, mint a kernel
• Néha azért igen
• Kernel szintű szálak esetén
• Teljes kontextus cserére van szükség
• Ezt figyelembe veheti
Lehetséges kernel-szintű • Processzuson belül szálra vált
szálütemezés. 50 msec-es időszelet, • I/O művelet miatt blokkolás esetén
ha a szálak 5msec-ig futnak • Nem blokkolja az egész processzust
Input/Output
 Az OS főfeladata
 Az eszközök vezérlése
 Parancsok kiadása
 Megszakítás- és
Operációs Rendszerek
hibakezelés
 Könnyű használat
 Egységes módszer az
eszközök közötti
kapcsolat biztosítása
 Az OS teljes kódjának
jelentős része
Az I/O eszközök hardver alapjai Osztályozás

Blokkos eszközök Karakteres eszközök  Nem a legjobb
 Információ tárolása adott  Küldi vagy fogadja a  Bizonyos eszközök egyikbe sem illeszkednek
méretű blokkokban karakterek sorozatát  Pl. óra
 Saját címmel  Blokk szerkezet nélkül  Meghatározott időintervallumonként megszakításokat
 Blokk méret  Nem címezhető hoznak létre
 512 byte-32768 byte  Nincs keresési művelet  A blokkos és karakteres modell elég általános, hogy
 A blokkok egymástól  Nyomtató, hálózati alapja legyen az OS I/O-eszközfüggetlen
függetlenül írhatóak és csatlakozási felület, egér stb. szoftverjeinek
olvashatóak  Nem lemez jellegűek
 Pl. lemez
Eszközvezérlők Eszközvezérlő
 Mechanikus és elektromos összetevők  Vezérlőkártya – csatlakozó – kábel
 Elektromos komponens  Több hasonló eszközt is fel lehet csatolni
 Eszközvezérlő ~ adapter  Szabványos kapcsolódási felület esetén
 Mechanikus komponens maga az eszköz  Különböző gyártók eszközei is felcsatolhatóak
 Az OS majdnem mindig a vezérlővel foglalkozik
 A vezérlő és az eszköz közötti kapcsolódási felület
alacsony szintű
Memórialeképezésű I/O Megszakítások
 A vezérlők rendelkeznek néhány regiszterrel  A vezérlőregisztereknek egy vagy több állapotbitjük
 CPU-val való kapcsolat tartásra használ van
 Regiszterekbe való írással utasítja az eszközt  Tesztelés – küldés vagy fogadás történik-e
 Adat pufferrel is rendelkeznek, melyeket az OS írni és  Tevékeny várakozás
 CPU-ciklus, ami az állapotbit-et teszteli
olvasni is tud
 Készen áll-e az eszköz a feladat végrehajtására
 Pl. videó memória
 Nagy mennyiségű I/O esetén lehet, hogy hosszú ideig kell
várakozni
 Megszakítások
 Közli a CPU-val, hogy mikor lehet írni vagy olvasni a
regisztereket
Megszakítások Közvetlen memóriaelérés

 Adatcserélés
 Eszközvezérlő címzés segítségével
 Byte-onként – sok idő
 Direct Memory Acces (DMA)
 DMA vezérlő
 CPU-tól függetlenül hozzáfér a rendszersínhez
Be- és kivitel Lemezek
Lemezes egységek
Cı́mzés:
Közvetlen memóriaelérés • CHS (Cylinder, Head, Sector), Sugár, fej
és szög megadásával. Pl. IDE.
 Sín címsorában van az a memóriacím , ahová a belső • LBA (Logical Block Address), minden
pufferből kell a következő szót vinni szektornak külön azonosı́tó. Pl. SCSI,
 Miért nem egyből a memóriában tárolja a lemezről EIDE. Cilinder, Pálya, Szektor
érkező adatot? Átviteli idők:
 A lemezvezérlő ellenőrizheti a hibajavító kódot • Keresési (seek): cilinderek közötti ugrás
 Ha hiba van, akkor hibajelzés generálódik és nem történik • Fordulási (rotation): szektorok közötti fordulás
meg az adatátvitel a memóriába • Átviteli (transfer): adatı́rási/olvasási idő
 Folytonos adat a lemezről, állandóan a rendszersínhez kell Adatátvitel optimalizálása
fordulnia • Fordulási, átviteli idők adottak
 Ha foglalt a memóriasín, akkor a vezérlőnek várakoznia kellene
• Keresési idő befolyásolható az átviteli kérések kiszolgálási
 Tárolni kell az adatot
sorrendjének meghatározásával
151
Be- és kivitel Lemezek Be- és kivitel Lemezek
Lemezfej-ütemező algoritmusok Lemezfej-ütemező algoritmusok
Első kérés - első kiszolgálás (First-Come, First-Served) Liftes algoritmus (elevator algorithm)
Legközelebbit keres elsőként (Shortest Seek First)
Pályánkénti pufferolás (Track-at-a-Time Caching)
152 153
Be- és kivitel Lemezek
Lemezek kezelése
Szabad/Foglalt szektorok nyilvántartása: Bittérkép vagy Láncolás

Hibakezelés:
Az I/O szoftver
• Adathiba: Hibajelző/Hibajavı́tó kódolás  Eszközfüggetlenség
 Olyan programot lehet írni, amely hozzáfér bármely I/O
• Keresési hiba: szektorbejegyzések (henger/pálya/szektor)
eszközhöz anélkül, hogy az eszközt meg kellene adni
• Kopás-kı́mélés: motor ki/be  Pl. állomány olvasása CD-ről merevlemezről
 sort <input >output
• Cserélhető adathordozó: csere figyelése, ı́rás befejezettsége
 Egységes névhasználat
 Hibakezelés
Fájlrendszerek - formázás  Amennyire csak lehet, a hardver közeli szinten kell kezelni
 Pl. vezérlő olvasási hiba esetén, akkor megpróbálja a hibát javítani
 Ha nem sikerül, akkor az eszközmeghajtónak kell kezelnie a hibát
 Pl. blokk újraolvasásának megismétlésével
 Szinkron/aszinkron adatátvitel
 CPU elindítja a folyamatot, más feladatot lát el a megszakítás
érkezéséig
154
Az I/O szoftver Megszakítás kezelők

 Pufferezés  El kell rejteni
 Pl. csomagok érkezése a hálózaton keresztül  Az OS-nek csak kis része tudjon róla
 Tárolni kell, hogy megvizsgálja  I/O művelet elkezdésekor a meghajtó blokkolódik, amíg
az I/O végebe megy, és egy megszakításkérés érkezik
 Osztott és monopol használat
 Pl. szemafor down, feltételes változó wait, üzenet receive
 Lemez - szalagmeghajtó művelettel
 Blokkolt meghajtó folytatása
 Megszakítás esetén megszakítás-eljárás
 Szemafor up
Az I/O-szoftverrendszer  Monitor feltételváltozója signal-ra változik
rétegei
 Üzenet
Megszakítás kezelők Eszközmeghajtók
 El nem mentett regiszterek tartalmának elmentése  Mindegyik
 Megszakítás kezelő eljárás környezetének beállítása eszközvezérlőnek vannak
 Megszakítás kezelő eljárás verem beállítása regiszterei
 Megszakítás vezérlő visszaigazolása  Eszköz specifikus kódra
 Ha nincs központosított megszakítás vezérlő, akkor újra van szükség
engedélyezi a megszakításokat  Eszközmeghajtó
 Azon regiszterek másolása ahonnan a processzus táblába  Blokkos és karakteres
lettek mentve eszközök
 Futtassuk a megszakítás kezelő eljárást
 Eszköz független
 Válasszuk ki, hogy melyik processzus fog futni legközelebb szoftvertől érkező
 Az MMU környezet beállítása a következő processzus absztrakt kérések fogadása
számára és kielégítése
 Az új regiszterek betöltése a psw-t is beleértve
 Az újprocesszus elindítása
Eszközmeghajtók Eszközfüggetlen I/O szoftver

 I/O kérés végrehajtásakor  Alapvető feladatok
 Ellenőrizni kell az input paraméterek helyességét
 I/O tevékenységek
 Absztrakt alak konkrét formára alakra hozása
 A parancsok kiadása
végrehajtása
 Vezérlőregiszterekbe való beírása  Minden eszköznél közösek
 Egyszerű vezérlők – egy időben csak egy parancs  Szabványos
 Intelligensebb vezérlők – parancsok láncolt listájának a kapcsolódási felület
fogadása és végrehajtása biztosítása
 Várakozás a feladatok elvégzéséig – blokkolás a  Felhasználói szintű
megszakítás beérkezéséig szoftver részére
 Késedelem nélküli végrehajtás
 Képernyő műveletek
 Hiba ellenőrzés szükséges
 Az adatok átadása az eszköz független szoftvernek
Egységes kapcsolódási felület Eszköz független I/O-szoftver

Pufferezés Hibakezelés
 Blokkos  Gyakoriak
 Független egységek  Hibák eszközfüggőek
 Fél blokk-os írás olvasás  Különböző szintű
 Karakteres  Felhasználói
 Gyorsabb adatbevitel  Hívó értesítése
 billentyűzett  Rendszer
 Hibaüzenet és befejezés
Eszköz független I/O-szoftver Felhasználói szintű I/O szoftver
Monopol módú eszközök Eszköz független blokkméret  Kernelen kívül futó programok
 Lefoglalása  Nem minden lemez
 Használhatóságra vonatkozó szektormérete azonos
kérés megvizsgálása  Egységes blokkméret
 Open egy specifikus file-on  Karakteres
 Elengedése  Modem
 Bezárás teszi újból elérhetővé  Hálózati kártyák
Holtpontok 2
Holtpontok
• Sok olyan erőforrás van
• Egy időben csak egy processzus használhat
• Pl. nyomtató, szalagmeghajtó egység, OS belső táblázatainak bejegyzései
BE- ÉS KIVITEL (I/O) • Kizárólagos hozzáférés biztosítása processzusoknak bizonyos

erőforrásokhoz
• Egynél több erőforrás esetén is szükség van erre
Holtpontok • Pl. szalagos egységről való nyomtatás
• A és B processzus különböző módon foglalja le az erőforrásokat
• Először A a szalagegységet, B pedig a nyomtatót
• Másodjára A a nyomtatót, B pedig a szalagegységet próbálja lefoglalni kizárólagosan
• Mind a két processzus a másik processzus erőforrására vár
• Nem monopol módon használt I/O eszközök esetén is

kialakulhat ez a helyzet
• Pl. adatbázisrendszerben rekordok zárolása
• Párhuzamos rendszerek széles körében felmerülő probléma
Holtpontok 3 Holtpontok 4
Holtpontok Holtpontok
• Erőforrások fajtái
• Erőforrások
• Megszakítható
• Hardvereszközök • Hiba bekövetkezte nélkül elvehető a processzustól
• Pl. memória
• Információ • Megszakíthatatlan
• Monopol módú
• Felcserélhető erőforrások • Számolási hibát eredményez az elvétele a processzustól
• Az erőforrásnak több egymással példánya van • Általában a holtpontok megszakíthatatlan erőforrásokat foglalnak
magukba
• A kérést bármelyik példány teljesíteni tudja • A lefoglalható erőforrásoknál a potenciális holtpontok megoldhatóak az erőforrások
újra osztásával
• Erőforrás • Az erőforrások használatának esemény szekvenciája
• Ugyanabban az időben • Erőforrás igénylés
csak egy processzus használhat • Erőforrás használat
• Erőforrás elengedése
• Amennyiben az erőforrás nem áll rendelkezésre, akkor az igénylő
processzusnak várakoznia kell
• Blokkolás  ébresztés
• Hibaüzenet  várakozás  újra próbálkozás
(a) Egy erőforrás (b) Két erőforrás esetén.
Szemaforok használata erőforrások védelmére. Holtpont mentes kód Holtpont lehetséges

(Egy processzus esetén nincs versenyhelyzet!)
Tanenbaum, Modern Operating Systems 3 e, (c) Tanenbaum, Modern Operating Systems 3 e, (c)
2008 Prentice-Hall, Inc. All rights reserved. 0-13-6006639 2008 Prentice-Hall, Inc. All rights reserved. 0-13-6006639
• Mindegyik processzus
várakozik
• Egyikük sem okozhat olyan
A holtpont formális definíciója: eseményt, ami
felébresztene a halmaz
A processzusok egy halmaza holtpontban van, ha
bármelyik másik elemét
mindegyik halmazbeli processzus olyan eseményre
• Egy szálú processzusokat
várakozik, amelyet csak egy másik, halmazbeli
tételezünk fel és nem
processzus okozhat. keletkezik megszakítás
• Más processzus által
lefoglalt erőforrás
elengedésére várakoznak
• A holtpont feltételei • A holtpont feltételei (folyt.)
1. Kölcsönös kizárás
• Mindegyik feltételnek teljesülnie kell a holtpont
• Mutual exclusion
• Minden erőforrás vagy hozzá van rendelve egy processzushoz vagy
kialakulásához.
szabad • Kevesebb feltétel teljesülésekor nem alakul ki holtpont
2. Birtoklás és várakozás • Előfordulhatnak más jellegű holtpontok
• Hold and wait
• Ütemezési holtpont
• Erőforrásokat birtokló processzus újabb erőforrásokat kér
3. Nem megszakíthatóság • …
• Non-preemptable
• Egy processzustól erőszakkal nem vehető el az erőforrás
4. Ciklikus várakozás feltétel
• Kettőnél több processzusból álló listában mindegyik processzus olyan
erőforrásra várakozik, amely a listában rákövetkező processzushoz
tartozik. Az utolsó a lista első eleméhez tartozó erőforrásra vár.
• Négy feltétel irányított gráfokkal való modellezése
• Jelöljük
• Processzust körrel
• Erőforrást négyzettel
• Erőforrás birtoklás
• Nyíl négyzetből körbe
• Erőforrás kérés
• Nyíl körből négyzetbe
birtoklás kérés

Holtpont
Holtpontok Stratégiák holtpont kezelésére

1. A probléma figyelmen kívül hagyása
2. Detektálás és helyreállítás.
• A holtpont megjelenhet, észrevesszük és cselekedünk.
3. Dinamikus elkerülése az előforrások körültekintő
lefoglalásával
4. Megelőzés, strukturálisan meghiúsítva a négy feltétel
egyikét
Stratégiák holtpont kezelésére Stratégiák holtpont kezelésére

• Strucc algoritmus • Felismerés és helyreállítás
• Fej a homokba • Figyeljük az erőforrásigényeket és –elengedéseket
• No problem • Módosítjuk az erőforrás gráfot
• Matematikusok számára
• Ellenőrizzük, hogy van-e benne kör
elfogadhatatlan
• Ha van benne kör
• Mérnökök megkérdezik
• Milyen gyakran fordul elő ez a
• A körben lévő egyik processzust megszüntetjük
probléma? • Addig folytatjuk, amíg meg nem szűnik a kör
• Milyen gyakran okoz rendszer • Durvább módszer
összeomlást ez a probléma?
• Periodikusan ellenőrizzük
• Milyen súlyos a holtpont?
• Ha csak 5 évente egyszer fordul • Vannak-e olyan processzusok, amelyek már 1 óránál hosszabb ideig
csak elő, akkor a legtöbb mérnök blokkoltak
ezt figyelmen kívül hagyja, • Az ilyen processzusokat megszüntetjük
• Más problémák foglalkoztatják
• Unix, Minix 3, Windows • Nagy gépeknél gyakran használt stratégia
• Magas árat kell fizetni • Különösen kötegelt rendszereknél
• Szabályok betartása • Processzus leállítása illetve újraindítása elfogadott dolog
• Túl sok erőforrást igényelne
• Mellékhatásokat ki kell küszöbölni

• Mellékhatások (folyt.) • Ellenőrizzük, hogy van-e benne kör!
• Helyreállítás megszakítással • Hogyan?
• Ideiglenesen elvehető egy erőforrás az aktuálisan birtokló • Rendelkezésre áll egy erőforrásgráf
processzustól és egy másik processzusnak átadható
• Helyreállítás rollback-kel
• Processzusok időnkénti ellenőrzése
• Erőforrások állapotának mentése
• Rollback addig a pontig, amíg nem volt holtpont
• Az utolsó ponttól elvégzett munka elveszik


• Holtpont felismerése erőforrás osztályonkénti egy példány • Több példány esetén más megközelítést kell alkalmazni a
esetén
• Mindegyik N csomópontra a gráfban a következő 5 lépést hajtjuk
holtpont felismerésére
végre N kezdő ponttal • Mátrix alapú algoritmus
1. Üres L lista inicializálása
• Mindegyik ívet nem jelöltnek tekintjük • n processzus: P1, …, Pn
2. Az aktuális csomópont hozzáadása az L lista végéhez és ellenőrizzük, • m erőforrás osztály: E1, … Em
hogy ez a csomópont kétszer fordul-e elő
• Ha igen, akkor kört tartalmaz és az algoritmusnak vége • E erőforrás vektor, az erőforrások példányainak a száma
3. Az adott csomópontból indul-e ki nem-jelölt ív • Pl. E1=2
• Ha igen, akkor 4--ik lépés
• Ha nem, akkor az 5-ik lépés • A rendelkezésre álló erőforrás vektor
4. Fogjunk meg egy nem-jelölt ívet véletlen szerűen és jelöljük meg. • A1=0
• Ezután ezt a csomópontot vesszük és a 2-ik lépésre ugrunk
5. Ha ez a kezdő csomópont volt, akkor nincs kör a gráfban és az algoritmus • C aktuális foglaltsági mátrix
befejeződik • i-ik sora a Pi-hez tartozó erőforrások száma
• Ellenkező esetben zsákutcában vagyunk,
• Lépjünk vissza (töröljük a csomópontot) az előző csomópontra, • R kérésekhez tartozó mátrix
• Aktualizáljuk
• Lépjünk a 2-ik lépésre • i-ik sora a Pi által igényelt erőforrások száma, amit meg akar kapni

• Vektorok összehasonlításán alapszik a holtpont detektáló
algoritmus
• 𝑨 ≤ 𝑩, ha 𝑨 és 𝑩 minden elemére igaz az adott reláció
• Mindegyik processzus kezdetekben nincs megjelölve
• Az algoritmus megjelöli azokat a processzusokat, melyek képesek
a feladatukat befejezni
• Nem alakul ki holtpont
• Amikor az algoritmus befejeződik, akkor a nem megjelölt
processzusok holtpontban vannak
• Legrosszabb esetet tételezi fel
• A processzusok a futásuk végéig megtartják a kért erőforrásokat
n
C
i 1
ij  Aj  Ej


• Holtpont megelőzése, strukturálisan meghiúsítva a • Kölcsönös kizárás feltétel támadása
négy feltétel egyikét • Ha nincs kizárólagos hozzárendelés egy processzushoz
• Lehetőségek • Akkor nem alakulhat ki holtpont sem
• Kölcsönös kizárás feltétel támadása • Spooling technika
• Birtoklás és várakozás feltétel támadása • Csak a nyomtató démon kéri a fizikai nyomtatót
• Nem megszakíthatóság feltétel támadása • Csak akkor nyomtat ha a teljes output állomány a rendelkezésre áll, ami
• Ciklikus várakozási feltétel támadása holtponthoz vezethet
• Két processzus a spool terület 50-50%-át megtölti, de még nem fejezték be a
munkát
• Nem tudják folytatni a munkájukat
• A diszk-en van holtpont

• Birtoklás és várakozás feltétel támadása • Nem megszakíthatóság feltétel támadása
• Az összes erőforrás kérése a futás kezdete előtt • Eszközök virtualizálása
• Ha nem áll rendelkezésre az összes erőforrás, akkor várakozik • Nyomtató démon
• A processzusok nem mindig tudják, hogy hány erőforrásra lesz • Nagy diszk területtel
szükségük • Nem minden virtualizálható az operációs rendszerekben
• Bankár algoritmus • Adatbázis rekordjai vagy táblái
• Nem optimális kihasználása az erőforrásoknak • Zárolás → lehetséges holtpont

• Ciklikus várakozási feltétel támadása
• Minden idő pillanatban csak egy erőforrás használatára kap
jogosultságot
• Ha szüksége van egy másikra, akkor el kell engednie az előzőt
• Elfogadhatatlan egy szalagról való nyomtatás esetén
• Az összes erőforrás megszámozása
• Processzus bármikor igényelhet erőforrásokat
• Csak megadott sorrendben lehet kérni azokat
• i→A; j→B
• j→A; i→B
• Ha i>j, akkor nem kérheti A j-t
Holtpont nem lehetséges
• Ha i<j, akkor nem kérheti B i-t
A holtpont megelőzési technikák összefoglalása.
• Előfordulhat, hogy lehetetlen találni egy rendezést, ami mindent kielégít
• Proc. tábla, zárolt adatbázis rekord, más absztrakt erőforrások
• A különböző használat és a potenciális erőforrások számozásai olyan nagy lehet


• Holtpont dinamikus elkerülése az előforrások • Bankár algoritmus
körültekintő lefoglalásával egyetlen erőforrásra
• Van-e olyan algoritmus, amellyel mindig elkerülhető a holtpont? • Kisvárosi bankár
• Igen, ha bizonyos információ előzetesen rendelkezésre áll • Hitelt engedélyez
• Nincs annyi készpénze, ami
• Körültekintő erőforrás-lefoglalás elegendő az összes ügyfél
• Egy erőforrás odaítélése biztonságos vagy nem az teljes hiteligényének
• Csak akkor allokálunk, ha biztonságos
kielégítésére
• Tudja, hogy nem lesz
szüksége mindegyik
ügyfélnek azonnal a
maximális hitelre
• Bízik abban, hogy az
ügyfelek a teljes
hitelfelvétele után azonnal
visszafizetik a kölcsönt

• Erőforrás-lefoglalások szerinti rendszerállapot • Az algoritmus minden kéréskor megnézi
• Egy állapot biztonságos • Vajon az engedélyezése biztonságos állapothoz vezet-e
• Ha tétezik ezzel kezdődő olyan állapotsorozat, amelynek • Ha igen, akkor teljesíti

eredményeként mindegyik ügyfél felvehet összesen annyi kölcsönt, • Különben későbbre halasztja
amennyit a hitel lehetősége enged • Van-e elegendő erőforrás, hogy kielégítsen néhány kérést
• Mindegyik processzus megkapja az összes erőforrását és befejeződik • A hitel limithez lévő legközelebbit választja
• Hamarabb visszafizeti a kölcsönt
• Egy bizonytalan állapot nem felétlenül vezet holtponthoz
• Nem biztos, hogy a teljes hitel keretet igénylik
• Ezzel nem számolhatunk

Ábra forrása: Tanenbaum könyv 2008 Prentice-Hall, Inc. All rights reserved. 0-13-6006639

• Erőforrás-pályagörbék  Csak vízszintes és függőleges útvonalak lehetségesek
• Előző algoritmus egy processzoros esetben
• Egy erőforrásosztályra alkalmazható  Előrehaladás
• Két processzus, két erőforrás  Észak és kelet
 I2 és I6 kereszteződésénél holtpont
 A processzus plottert igényel
 B-nél van
 B processzus printert igényel
 A-nál van
 t pont → A processzus futtatása az I4 ponting

 B felfüggesztése, amíg az A processzus a plottert birtokolja

• Bankár algoritmus többpéldányos erőforrástípusok esetén 1. R olyan sorát keressük, amely eleget tesz az erőforrás
• E meglévő erőforrások szükségletekre ≤ A relációnak
• P foglalt erőforrások • Ha nincs ilyen sor, akkor végül is a rendszer holtpontban van, hiszen
egyik processzus sem tudja befejezni a futását
• A szabad erőforrások
2. T.f.h. a kiválasztott processzus sora az összes
erőforrást kéri és befejeződik.
• Megjelöljük, amint befejeződik és
• Az erőforrásait az A vektorhoz adjuk.
3. Ismételjük az 1-es és 2-es lépést, amíg mindegyik

processzus befejezettnek nem jelöljük (a kezdeti állapot
biztonságos volt) vagy nem maradt processzus,
amelyre az erőforrás szükséglet kielégíthető (holtpont
C mátrix R mátrix van).
Holtpontok 37
Stratégiák holtpont kezelésére

• Nem alkalmazható
• Processzus szám nem rögzített általában
• Ritkán tudjuk előre a maximális erőforrás igényeket
• Az erőforrások elromlanak néha
• Összefoglalva
• A megelőzésként megadott séma túlságosan megszorító
• Az elkerülés pedig olyan információkat igényel, amelyek általában
nem állnak rendelkezésre
Bevezetés
 Hierarchikus memória szervezés
 Kicsi, nagyon gyors, drága és felejtő
 Több száz megabyte, közepes sebességű és árú, felejtő
Memória kezelés  Több tíz vagy néhányszáz giga byte, lassú, olcsó, nem
felejtő
 Memóriakezelő
 Nyilvántartja a szabad és foglalt memória területeket
 Memóriát foglal a proc.-oknak, amikor szükséges
 Memóriát szabadít fel, ha már nincs rá szükség
 Csere vezérlése a központi memória és a lemez között
 Ha kicsi a központi tár
1 2
Monoprogramozás csere és lapozás

Alapvető memóriakezelés nélkül
 Algoritmusok  Legegyszerűbb memóriakezelési módszer
 Végrehajtás közben mozgatják a processzusokat  Csak egy program van a memóriában egy időben
 Csere/lapozás
 Nem mozgatják
 Kevés memória
 Memória pótlása
 640 Kbyte elég …
Kézi számítógép,
3 Nagy számítógépek MS-DOS 4
beágyazott rendszerek
Multiprogramozás rögzített méretű Multiprogramozás rögzített méretű

partíciókkal partíciókkal
 Időosztásos rendszerek  Egy várakozási sor
 Memória manuális felosztása rendszerindításnál  Amikor egy partíció kiürül, akkor az a munka töltődik
 Nem egyenlő méretre be, amelyik belefér és a sorban az első
 Berakja abba a legkisebb partíció várakozó sorába,  Legnagyobb munka kiválasztása, amelyik belefér
amelyikbe belefér a program  A kis munkák hátrányos helyzetbe kerülnek
 Egy kis partíció a kis munkáknak
 Nem használt terület elvész
 Egyetlen munka sem mellőzhető egy előre megadott számnál
 Hátrány többször a futás kiválasztásánál
 Nagy partíciók sora üres  Pl.
 Kicsikre sok munka várakozik  Prioritás növelése
 Megoldás  Plusz sorsjegyeket kap
 Egy várakozási sor
 Pontokat kap, adott határ elérésekor már nem mellőzhető
5 6
Relokáció és védelem Relokáció és védelem
 Munkák különböző címeken futnak  Bázis- és határregiszter
 Hol fog kezdődni a program a memóriában
 Partíció kezdő címe és a partíció hossza
 Egyetlen címtérbe szerkeszti össze a linker a programokat
 Memóriacím=bázisregiszter+hivatkozott memóriacím
 Relokációs probléma
 Címek ellenőrzése a határregiszter segítségével
 Program betöltésekor az utasítások módosítása
 Melyek a relokálandó címek? → térkép  Felhasználói program nem módosíthatja azok értékeit
 OS/MTF  Egy összeadás és egy összehasonlítás
 Multiprogramozás fix számú feladattal
 Speciális hardver az összeadásra
 2KB-os blokkok
 Kevés számítógép használja ezt a modellt
 Négybites védelmi kód
 A program állapotszó tartalmaz egy négybites kulcsot
 Védelmi kód ↔ négy bites kulcs
7 8
Csere Csere
 Kötegelt feldolgozású rendszereknél hatékony módszer a
rögzített méretű memória partíciók használata
 Időosztásos rendszereknél gyakran nincs elég memória
 Felesleges processzusokat a lemezen tároljuk
 Dinamikusan kell betölteni a futtatásra
 Stratégia
 Csere/swap
 Teljes egészükben való mozgatása a memória és lemez között
 Virtuális memória
 Egy része a memóriában marad
Memória változása a processzusok indulásakor és leállásánál
9 10
Csere Csere
 Csere lyukakat hoz létre a memóriában a processzusok
mozgatásával
 Összeolvasztás = memóriatömörítés
 Nagy processzorigény
 Processzusok adatszegmensének növekedése
problémát okoz
 Dinamikus memória foglalás
 Külön memóriarész foglalása, amikor egy proc.-ot
behozunk vagy áthelyezünk
 Csak a ténylegesen használt memóriaterületet kell kimásolni
(a) Növekvő adatszegmens (b) növekvő adat- és
11 veremszegmens számára lefoglalt memóriaterület 12
Memóriakezelés bittérképpel Memóriakezelés bittérképpel
 Memóriahasználat nyilvántartása  Allokációs egység mérete fontos tervezési szempont
 Bittérkép, szabadlista  Kicsi → bittérkép nagy
 Nagy → bittérkép kicsi
 Pocséklás az utolsó egységből, ha a proc.-ok mérete nem
pontos többszöröse az allokációs egységnek
 k méretű processzusnál
 k darab egybefüggő 0 bitet kell keresni
 Lassú művelet
(b) Bittérkép (c) Listában ábrázolva 13 14
Memóriakezelés láncolt listákkal Memóriakezelés láncolt listákkal

 Első-illeszkedés  Az első négy alg. felgyorsítható
 Szabad és foglalt szegmensek láncolt listába fűzzük  Első megfelelő méretű lyuk  Külön lista a proc.-oknak és
 Szegmensek keresése lyukaknak
 Leggyorsabb alg.  Memória foglalásnál és
 Processzusok és lyukak a processzusok között felszabadításnál ez plusz
 Következő-illesztés
feladatot jelent
 Kezdőcím szerint rendezett  Nem a lista elejéről keres
 Méret szerint rendezve a
 Megjegyzi, hogy hol találta az
 Könnyű karbantartani a listát előző megfelelő lyukat
legjobb-illeszkedés gyorsabb
lesz
 Legjobb-illeszkedés  Gyors-illeszkedés
 Egész lista végig keresése  Leggyakrabban kért
 Legkisebb alkalmas lyukat adja méretekhez külön lista
vissza létrehozása
 Legrosszabb-illeszkedés  Gyorsan meg lehet találni a
 Legnagyobb lyuk kiválasztása megfelelő méretű lyukat
 Költséges a szomszédos területek
összevonása
15 16
Virtuális memória Lapozás

 Programok túl nagyok  Memóriacím halmaz, amelyeket a programok elő
 Nem férnek el a memóriában
 Program rétegekre darabolása – overlays
tudnak állítani
 Először a 0-s sorszámú réteg kezd futni, amikor befejeződik, akkor  A címek indexelésekkel, bázis- vagy
hívja a következő réteget
szegmensregiszterből generálódhatnak
 Egyidejűleg több réteg is lehet a memóriában
 Rétegek a lemezen vannak tárolva  Virtuális címek –
 Szükség szerint cseréli őket virtuális címtartomány
 A rétegeket a programozó hozza létre
 Bonyolult → Virtuális memória használata
 Memóriakezelő egység
 Az operációsrendszer csak a program éppen használt részét tartja a (MMU)
memóriában
 Fizikai címekre való
 Virtuális memória a multi-programozást támogató
rendszereknél leképezése
 Több program darabja van a memóriában
17 18
Lapozás Lapozás
 16 bites címek  Ha a program egy olyan lapra hivatkozik, ami nincs a
 0-64 KB fizikai memóriában
 32 KB fizikai memória
 Laphiba megszakítás
 Lap = virtuális címtér
felosztása  Op.rendszer vesz egy lapkeretet
 4 KB  Kiírja annak a tartalmát
 Általában 512 Byte – 1 MB  Behozza a hivatkozott lapkeretet

közé esik a lapméret  Módosítja a laptérképet
 Nem leképezhető lapok =  A program folytatódik a megszakítástól
X
 Jelenlét/hiány bit mutatja
melyik lap van a fizikailag
a memóriában
19 20
Lapozás Laptáblák
 Kettő hatvány méretű  Laptábla
lapok  Virtuális lapok lapkeretre való leképzését szolgálja
 Egy függvény
 4 bites lapszám
 Argumentuma
 16 lap
 virtuális lapszám
 12 bites offset  Eredmény
 4096 cím egy lapon belül  Lapkeret száma
 Jelenlét/hiány bit  Problémák

 0 → megszakítás
 A laptábla nagyon nagy lehet
 32 bites virtuális címek
 1 → lapkeret száma
 4 KB-os lapméretnél a címtér több, mint 1 millió lapból áll
kimeneti regiszter 3 felső
bitjébe másolja + 12 bit-en  A leképezésnek gyorsnak kell lennie
az offset lesz.  A leképezést minden memóriahivatkozásánál végre kell hajtani
21 22
Laptáblák TLB-címfordítási gyorsítótár

 Különböző hardveres megoldások  A programok legtöbb hivatkozása a lapok egy kis részhalmazára
történik
 Többszintű laptáblák  A többire ritkán hivatkoznak
 Nem egy nagy laptáblát tartunk a memóriában  Laptábla megkerülésével történik a logikai címek leképezése
 Laptábla bejegyzés struktúrája  Translation Lookaside Buffer – asszociatív memória
 Az MMU-ban található
 Néhány bejegyzést tartalmaz
 Ha benne van a TLB-ben a cím, akkor innen veszi a címet
 Ha olvasható címre próbál írni, akkor védelmi hiba keletkezik
 Ha nincs benne, akkor az MMU a laptáblából keresi ki a megfelelő címet
 TLB-ből kidob egy címet
 A módosítás bitjét vissza kell másolni a memóriában lévő laptábla
bejegyzésre
23 24
TLB-címfordítási gyorsítótár Szoftveres TLB-kezelés
 Hardveres laptábla és TLB
 MMU kezeli
 Csak akkor kap megszakítást az op.rendszer, ha lap nincs a
memóriában
 Szoftveres megoldás
 Nagyon kevés utasítással kell megvalósítani a hiba kezelést
 A TLB hiba sokszor fordul elő
 Stratégiák
 Legvalószínűbb lapok meghatározása
 Előre látható folyamatok
 Pl. kliens proc. távoli eljárás hívás (RPC) ugyanazon a gépen

futó szerverproc.-hoz
25 26
Invertált laptáblák Invertált laptáblák

 Csak a laptáblának 30 000 000 GB?!  Sok helyet takarít meg
 64 bit-es virtuális címtér, 8 byte-os bejegyzésekkel  Nehezebb virtuálisról fizikaira váltani
 Processzus – lap párost meg kell keresni minden hivatkozástól
 Valós tár minden lapkeretéhez tartozik egy bejegyzés és laphiba esetén
 Pl. 64 bit-es virtuális címtér, 4 KB-os lapméret, 256 MB  TLB használata
RAM  TLB hiba esetén az invertált laptáblában szoftveresen kell
 65535 bejegyzés keresni

 Adott lapkeretet melyik  Tördelőtáblával való gyorsítás
 Tördelőtábla mérete = Fizikai lapok száma
processzus melyik lapja
• Átlagos lánc hossza 1
használja
27 28
Az optimális lapcserélési
Lapcserélési algoritmusok algoritmusok
 Laphiba esetén  Egyszerű, de lehetetlen végrehajtani
 Lapcsere – melyik lapot válasszuk, amelyik kikerül a  Hány utasítás után fogunk hivatkozni az adott lapra?
memóriából  A legnagyobb számú lapot kell kiválasztani
 Módosított lap, akkor a lapot vissza kell írni a lemezre  Program szimulátor
 Ritkábban használt lap kiválasztása  Nyomon követjük a hivatkozásokat
 Jobb teljesítmény  Ez csak szimulálás!!!
 Ugyanaz a probléma, mint a  Csak az adott körülményekre igazak a vizsgálatok
 Gyorsítótárak
 Webböngésző
29 30
Az NRU lapcserélési algoritmus NRU lapcserélési algoritmus
 Minden laphoz két állapotbit kapcsolódik  R-M bitek inicializálása 0-val
 R bit minden hivatkozáskor 1-re állítódik  Időnként nullázzuk az R bitet
 Olvasáskor és íráskor is  Utóbbi időben nem hivatkozott lapok megkülönböztetése
 M bit módosításkor lesz 1  Laphiba esetén az R-M bitek alapján 4 csoportot
 Hardveres karbantartás különböztethetünk meg
 1-es marad, amíg az op.rendszer vissza nem állítja 0-ra  0. osztály: nem hivatkozott, nem módosított
 Szoftveres szimulálás  1. osztály: nem hivatkozott, módosított
 Proc. inditásakor az összes laptáblabejegyzését megjelöljük
???
 2. osztály: hivatkozott, nem módosított
 Nincs bent a memóriában
 3. osztály: hivatkozott, módosított
 Ha egy lapra hivatkozunk
 Laphiba  op.rendsz. beállítja az R bitet és megváltoztatja a laptábla  Not Recently Used
bejegyzését CSAK_OLVASHATÓ-ra, majd a proc. az adott az utasítástól újra  Véletlenszerűen kiválaszt egy lapot
indul
 Ha később egy lapra írunk
 A legkisebb sorszámú nem üres osztályból
 Ezt dobja ki a memóriából
 Laphiba  op.rendsz. beállítja az M bitet és megváltoztatja a laptábla
bejegyzését ÍRHATÓ_OLVASHATÓ-ra, majd a proc. az adott az utasítástól  Egyszerű, közepesen hatékonyan megvalósítható
újra indul
 Nem optimális, gyakran megfelelő
31 32
A második lehetőség lapcserélési

A FIFO lapcserélési algoritmus algoritmus
 First-In, First-Out  FIFO egyszerű módosítása
 Listába fűzött memória lapok  Gyakran használt lapok kidobásának elkerülésére
 Elején a legrégebbi lap  Megvizsgáljuk a lap R bit-jét
 Végen a legutoljára beérkezett lap  Ha 0, akkor nem használt, eldobható
 Ebben a megvalósításban ritkán alkalmazzák  Ha 1, akkor töröljük a bit-et és a listavégére rakjuk
 Betöltés idejének a megváltoztatása (mostani időpontra)
 Folytatjuk a keresést
33 34
Az óra lapcserélési algoritmus Az LRU lapcserélési algoritmus

 Az előző algoritmus  Least Recently Used – legrégebben használt
 Megvalósítható, de művelet igényes – nem olcsó
 Körbe-körbe mozgathatja a lapokat a listában
 Lapok listában vannak tárolva
 Kevésbé hatékony
 Elől a legutoljára használt lap található
 Körkörös listában tároljuk a lapokat  Minden memóriahivatkozáskor
 A mutató mindig a legrégebbi lapra mutat  Az adott lapot a lista elejére rakjuk
 Hardveres implementáció
 64 bit-es számláló
 Minden memóriahivatkozásnál automatikusan eggyel nő
 Minden laptáblabejegyzésben van egy mező, amely az előző

értéket tárolja
 Laphiba esetén az op.rendszer a legkisebb számlálóértékkel
rendelkező lapot, ez lesz a legrégebben használt lap
35 36
Az LRU lapcserélési algoritmus Az LRU szoftveres szimulációja
 Egy n lapkeretes géphez nn-es bináris mátrixot rendelünk.  Kevés hardveres támogatottság
 Kezdetekben 0-val töltjük fel
 Szükség van szoftveres megvalósításra
 Amikor k lapkeretre hivatkozunk
 k-adik sor csupa 1-es-re állítjuk  NFU – Not Frequently Used – nem gyakran használt
 k-adik oszlop csupa 0-ra állítjuk algoritmus
 A legkisebb bináris értékű sor lesz a legrégebben használt lap  Minden laphoz egy szoftveres számláló tartozik
 Minden óramegszakításkor a lap R bitjét hozzáadja a
számlálóhoz
 Milyen gyakran használják a lapot
0, 1, 2, 3, 2, 1, 0, 3, 2, 3  Laphiba esetén a legkisebb értékű lapot dobjuk ki a

memóriából
 Probléma
 Nem felejt el semmit
37 38
Az LRU szoftveres szimulációja Az LRU szoftveres szimulációja

 NFU kis módosításával → LRU szimuláció  Laphiba esetén a legkisebb számlálóértékűt dobjuk ki
 Számlálót egy bit-tel jobbra toljuk mielőtt az R-et hozzáadjuk
 Véges sok bites számláló
 R-et nem a jobb oldali, hanem a bal oldali bit-hez adjuk
 Két számláló nulla
 Öregítő (aging)
 Véletlenszerűen választunk
 Egyiket csak 9 a másik 1000 időegység óta nem használtuk
 8 bit-es számláló általában elég egy 20 ezred mp időegységhez
 160 ezred mp-re már nem hivatkozunk
 Nem is annyira fontos
39 40
Lapozási rendszerek tervezési

szempontjai A munkahalmaz modell
 A működés ismerete nem elég  Nincsenek bent a lapok a program indulásakor
 Néhány laphiba után a program szükséges lapjai bent lesznek
 A rendszer tervezéshez több kell a memóriában
 Kevés laphiba fog történni
 Olyan szempontok, amelyeket figyelembe kell venni a
 Igény szerinti lapozás
tervezéskor, jó teljesítmény eléréséhez
 A legtöbb program nem úgy működik, hogy a teljes címtér
 Munkahalmaz modell összes lapját olvassa
 Lokális vagy globális helyfoglalás  Lokális hivatkozás
 Egy adott processzus egy fázisában csak a lapjainak egy kis
 Lapméret részhalmazára hivatkozik
 Többmenetes fordító
 Virtuális memória interface
 Munkahalmaz
 Processzus által éppen használt lapok halmaza
41 42
A munkahalmaz modell A munkahalmaz modell
 Ha a memória túl kicsi ahhoz, hogy befogadja az egész  Minden t időpillanatban létezik egy olyan halmaz, amely
minden, a k legújabb hivatkozásokat tartalmazó lapot
munkahalmazt tartalmazza
 A processzus sok laphibát okoz → lassabban fut  w(k, t) halmaz a munkahalmaz
 Minden t időpillanatban létezik egy olyan munkahalmaz, amely a k
 Vergődés legújabb hivatkozásokat tartalmazó lapok halmaza
 nagy k érték távolabbi múltat reprezentál
 Gyakori laphiba egy program esetén  A hozzá tartozó lapok száma nem csökkenhet k növekedésével
 Munkahalmaz modell  w(k, t) monoton nem csökkenő függvénye k-nak
 A lapozások rendszerek megpróbálják nyomon követni a

processzusok munkahalmazát
 A program indítása előtt a szükséges lapokat betölti
 Előlapozás
43 44
A munkahalmaz modell Lokális vagy globális helyfoglalás

 Lapok kis halmazának véletlenszerű használata
 Melyik lapot dobjuk ki laphiba esetén?
 A halmaz lassan változik
 Egy adott k értékétől a munkahalmaz nem változik  Fő szempont a
 Az előlapozáshoz szükséges lapok számának a meghatározása választás esetén
 A megvalósítása az operációs rendszer feladata
 Memória megosztása
 A munkahalmazba tarozó lapok nyilvántartása
 Öregítő algoritmussal megszerezhető az az információ 3 futó processzus között
 Ha lap számlálójának felső n bit-je tartalmaz egy egyest, akkor a lap eleme a  A, B, és C processzusok
laphalmaznak
 Lokális
 Utolsó n időegységben hivatkoztak az adott lapra
 A lapjai közül dobunk ki egy lapot
 A munkahalmazt fel lehet használni az óra algoritmus
teljesítményének növelésére  Az algoritmusok a memóriának egy rögzített méretű szeletét
 Javítás, megvizsgáljuk, hogy a lap eleme-e az aktív processzus halmaznak foglalják egy-egy proc. részére
 Ha eleme, akkor a lapot nem dobjuk ki
 Globális
 wsclock
 Az összes lap közül választunk
 Munkahalmaz óra algoritmus
 Dinamikusan osztják el a memória lapkereteit a futó proc.-ok
között
45 46
 A lapkeretek száma idővel változik
Lokális vagy globális helyfoglalás Lokális vagy globális helyfoglalás

 A globális algoritmusok működnek jobban,  Döntés a lapkeretek számáról
 mivel a munkahalmaz mérete a program futása során  Figyeljük a munkahalmaz méretét
változik.  Öregedés bit
 Dönteni kell, hogy mennyi lapkeretet kap egy-egy proc.  Durva mérték, sok idő kell a beállításához
 Ha lokálist alg.-ot használunk  Módszer, ami a lapkeretet rendeli a processzusokhoz

 Nő a munkahalmaz  Periodikusan meghatározzuk a futó proc.-ok számát
 Vergődés  Egyenlő arányban elosztjuk a lapkereteket közöttük
 Csökken a munkahalmaz  Processzus méretek arányában
 Memóriát pazarol el  Minimum szám, amivel még futni tud
47 48
Lokális vagy globális helyfoglalás Lokális vagy globális helyfoglalás
 Globális algoritmus  Ha sok proc. van a memóriában
 Ellátunk minden proc.-ot méretarányos számú lappal
 A foglalás dinamikusan változik a proc.-ok futásakor  Nem lehetséges az A szint alatt tartani laphibák számát
 Frissíteni kell  Néhány proc.-ot el kell távolítani a memóriából
 Laphiba gyakoriság (Page Fault Freq. ) algoritmus
 Növelni vagy csökkenteni kell a proc.lap foglalását
 Elosztjuk a többi proc. között
 Nem mond semmit arról, hogy melyik lapot kell kicserélni laphiba  Tartalék laphiba esetére
esetén
 Teherelosztás
 Melyik proc.-ot vigyük ki?!
Kevés lapkerete van
adni kell neki  Csere is szükséges a lapozás mellett
Sok lapkerete van

el kell venni tőle
49 50
Lapméret Lapméret
 Paraméter  Kis lapméret  Kis lapméret
 Hardver lapméret 512  Véletlenszerűen  A program több lapból áll → nagyobb laptábla szükséges
 Egy nagy lap átvitele majdnem ugyanannyi ideig tart, mint egy kis
byte kiválasztott kód-, adat-, lapé
 1 KB-os lapoknak veremszegmensek nem  Átlagos proc. méret s, lapméret p byte,
tekintheti az op.rendsz. foglalnak el egész számú laptáblabejegyzés mérete e byte
 2 egymás melletti 512 byte- lapot  Egy proc.-hoz s/p lap kell → se/p byte-ot foglal
os lapkeret
 Belső töredezettség  Elvesztett memória átlagosan p/2 byte
 Optimális lapméret  Utolsó lapnak átlagosan a  Költség = (se/p) + [p/2]
 Különböző tényezők fele üres marad
nagy, ha a p lapméret (kicsi) + [nagy]
n db szegmens, p byte-os
 p szerinti derivált –se/p2+1/2=0  p=(2se)1/2

egyensúlya lapméret
 Nincs optimum  Átlagos veszteség  Egy tipikus méret 1 KB
 np/2  4 KB és 8 KB a legelterjedtebb
51 52
Virtuális memória interface Szegmentálás

 Hagyományostól eltérő módú memória használat  Virtuális memória
 Egy dimenziós tömb →
 Memóriarész megosztása kettő vagy több processzus nullától egy maximális címig
között  Jobb lenne kettő vagy több
virtuális címtér bizonyos
 Memóriarészek elnevezése feladatoknál
 Közös elérés  Fordító
 Forráskód a lista
 Üzenetküldő rendszerek megvalósítása
nyomtatásához
 Lapnevek másolása  Szimbólum tábla a változók
 Elosztott közös memória nevével és attr.
 Egész és lebegőpontos
 Lapok megosztása processzusok között konst.-ok
 Egyetlen közös lineáris címtérrel  A prog. szintaktikai fája
 Fordítóprogram saját verme
53 54
Szegmentálás Szegmentálás
 Szegmensek  Szegmentált vagy két dimenziós memóriában
 Több, egymástól teljesen független címterek  A címek két részből kell állniuk
 Szegmens száma és a szegmensen belüli címből
 Változó méretű adatszerkezet egyszerű kezelése
 Osztott könyvtár
 Adatok vagy eljárások megosztása proc.-ok között
 Pl. graf. könyvtár
 Tiszta lapozásos rendszer esetén
 Bonyolult dolog
 Szegmentálás szimulálása
55 56
A tiszta szegmentálás
Szegmentálás implementációja – külső töredezettség
57 58
File-rendszerek
 Információ tárolás, visszakeresés
 A memóriában program csak egy részét tároljuk
 Helyfoglalási rendszerek
Operációs rendszerek  Banki alkalmazások
 Vállalati nyilvántartás
 A processzus befejezésekor az információk elvesznek
 Több processzusnak egy időben kell ugyanazon
információkhoz hozzáférnie
1 2
File-rendszerek File-rendszerek
 Hosszú távú információtárolás követelményei  A file-okat az operációs rendszer kezeli - File-rendszer
 File-ok szerkezete, elnevezése, hozzáférése, használata,
 Biztosítani kell a nagyméretű információ tárolását védelme, megvalósítása
 Az információ megmaradjon a processzus befejezése  Felhasználó szempontjai
után  Hogyan jelenik meg
 Mi a file-ok tartalma?
 Több proc. egy időben hozzáférjen az információkhoz  Hogyan lehet elnevezni a file-okat
 Védeni?
 Milyen műveleteket végezhetők file-okon?
 Mágneslemezen vagy külső tárolón tároljuk az  File-rendszer tervezői szempontok
információkat  Láncolt lista – bittérkép
 Tárolási egység – file  Hány szektor van a logikai blokkban?
 …
 Tartós tárolás
3 4
File-ok File-szerkezet
 File-nevek  Az operációs rendszer nem foglalkozik mi van a file-
 Absztrakciós mechanizmus ban
 Tárolás és visszaolvasás  Byte sorozat
 Objektumok elnevezése és kezelése  A jelentést a program adja
 Létrehozáskor a processzus nevet ad neki  Rögzített hosszúságú rekordok
 Eltérőek lehetnek a különböző operációs rendszerek esetén  Meghatározott belső struktúra
 MS-DOS, Unix, Windows 95,  Rekordokból felépülő fa

Windows NT, Windows 2000, Windows XP  A hosszuk nem feltétlenül azonos
 konvenciók  Kulcsmező
5 6
File-szerkezet File-típusok
 Karakter-specifikus
 Bemenet/kimenet
 Soros I/O eszközök modellezik
 Terminálok, nyomtatók és hálózatok
 Block-specifikus
 Mágneslemezegységek
 Közönséges file-ok
 ASCII
 Szöveg-sorok
 Megjeleníthető, szerkeszthető
 Bináris állományok
 Nem szöveges (ASCII) állományok
7 8
File-típusok File-elérés
 Szekvenciális
 A processzusok megadott sorrendben olvassák a file-
okat
 Az elsőtől (byte-ok, rekordok) kezdve
 Nem tud átlépni egy egységet
 Mágnesszalag
 Közvetlen elérés
 Mágneslemez
 Adatbázisok
 read, seek
Végrehajtható file Archív file 9 10
File-attribútumok File-műveletek
 Létesítés  Hozzátoldás
 Információk  File létrejöttének bejegyzése  Csak a file végéhez lehet
 Attribútumok beállítása  Pozicionálás
 Attribútumok  Törlés  Aktuális pozíció beállítása
 Lemezterület felszabadítása  Attribútum lekérdezés
 metaadatok  Megnyitás  Feladatok elvégzéséhez szükséges
 Attribútumok beolvasása információk
 Néhány lemezcím betöltése  Attribútum beállítás
 Lezárás  Pl. védelmi mód
 Belső memória terület felszabadítása  Átnevezés
 Utolsó blokk kiírása  Másolás – törlés ???
 Olvasás  Zárolás
 Adatok betöltése a memóriába aktuális  Nem férhet több processzus egyszerre
pozíciótól hozzá
 Byte-ok száma, hova  File vagy annak egy része
 Írás
 Aktuális pozíciótól
 Adatok felülírása
 Ha file végén áll, akkor növekszik a file
mérete
11 12
Könyvtárak Egyszerű könyvtárszerkezet
 Könyvtárak – mappák  Könyvtárak száma változó lehet
 Néha file-ok  Egy könyvtár – egy felhasználó
 Egyszerű könyvtár-szerkezet  Pl. PDA-k
 Egy bejegyzés egy file-hoz
 Több könyvtár – több felhasználó
 File megnyitásakor a rendszer keres a könyvtárban
 Kiolvassa a file attribútumait és a lemezcímeket Root directory
 Könyvtári bejegyzésből
 A könyvtári bejegyzés által mutatott címről
A B C
 Eltárolja ezekez az adatokat a memóriába
13
A A B B C C C 14
Útvonal megadása Könyvtár műveletek

 Abszolút (teljes) útvonal  Létrehozás  Olvasás
 Új könyvtár  read ↔ readdir
 Gyökérkönyvtártól  üres  Átnevezés
kiindulva  Törlés  Hasonlóan a file-okhoz
 Relatív útvonal  Csak üres könyvtár  Kapcsolás (link)
 Csak . és .. könyvtárak  A könyvtárban ugyanazok
 Aktuális könyvtár
 Megnyitás a file-ok, mint egy másik
 Olvasható lesz a könyvtár könyvtárban)
 Pl. listázás  Lekapcsolás (unlink)
 Lezárás  Egy könyvtári bejegyzés
 Olvasás után a memória törlése
felszabadítása  Unix-ban a file törlés egy
lekapcsolás
15 16
File-rendszerek megvalósítása File-rendszerek megvalósítása

 Elsődleges partíciók
 Kiterjesztett partíció
 Logikai partíciók láncolt listája
 Akárhány partíció
 Szuperblokk
 File-rendszer paraméterei
 Szabadterület kezelő
 Szabad blokkokról információ
 BIOS  i-node-k leírása
 Operációs rendszer betöltés  Tömb
 Minden file-hoz egy bejegyzés
 Initial Program Loader (IPL)  Szükséges adatok és hogy hol találhatók a file blokkjai
 Volume Boot Code  Gyökkérkönyvtár

 Masterboot  Könyvtára és file-ok
17 18
File-ok megvalósítása File-ok megvalósítása
 Melyik lemezblokk-ok tartoznak a file-hoz?  Láncolt listás helyfoglalás
 Folytonos helyfoglalás  Lemezblokk-ok láncolt listája
 Az első szó a következő blokk-ra mutató pointert tartalmazza
 Összefüggő blokkok
 A többi rész adatot tárol
 Első blokk címe, blokk-ok száma  Minden blokk felhasználható
 Hatékony olvasás  Csak az utolsó blokk belső töredezettsége
 Teljes file beolvasható egyetlen művelettel  A könyvtár bejegyzéseknél elegendő csak az első blokk címét
 Hátrány tárolni
 Töredezett lemez
 A szekvenciális olvasás egyértelmű
 File-ok és lyukak  A közvetlen elérés lassú
 CD, DVD  Nem lesz kettő hatvány a blokk mérete
 A mutató tárolása lefoglal néhány byte-ot
 Nem változik a file-rendszer
19 20
File-ok megvalósítása File-ok megvalósítása

 Láncolt listás helyfoglalás  Láncolt listás helyfoglalás memória táblázattal
 Mutatót kivesszük a blokk-okból
 Index tábla a memóriában
 File Allocation Table (FAT)
 A teljes blokkméret rendelkezésre
áll
 Egyszerűbb közvetlen elérés
 Hátrány
 A teljes táblázatnak a memóriában
kell lennie
 20 GB – 80 MB (4 byte-os elemek)
21 22
File-ok megvalósítása Könyvtárak megvalósítása

 i-csomópont (i-node)  File olvasás
 Index-csomópont
 Minden file-hoz tartozik egy  Meg kell nyitni
kis táblázat  Könyvtári bejegyzés megkeresés
 File- attribútumok
 File-hoz tartozó blokkok  Gyökérkönyvtár megkeresése
lemezcíme
 Partíció kezdetéhez lehet kötni
 Minden blokk elérhető
 Unix file-rendszerben szuperblokkban lévő információ
 Csak az i-csomópontnak
kell a  Első i-csomópont mutat a gyökérkönyvtárra
memóriában lennie  Windows XP
 Ha a file meg van nyitva
 Indítószektor tartalmazza az Master File Table-t
 Hátrány
 Rögzített számú lemezcímet  Könyvtárfa bejárásával megtalálhatjuk a keresett bejegyzést
tartalmaz  File számára foglalt lemezblokkok megkeresése
 Utolsó cím
 Indirekt blokk címe  Adatok elérése
23 24
Könyvtárak megvalósítása Könyvtárak megvalósítása
 A probléma szorosan kapcsolódik az attribútumok  File-ok kapcsolása/link
tárolásához  Unix
 i-csomópont
 Pl. file tulajdonosa, létrehozási dátuma  Akárhány könyvtári
bejegyzés mutathat
 Lehetőségek ugyanarra az i-csomópontra
 Könyvtári bejegyzésben  Mező, amely növekszik, ha
új kapcsolat létesül
 Fix méretű bejegyzés
 Csökken, ha kapcsolatot
 i-csomópont törlünk
 Csak akkor törlődik, ha 0 az
 Bejegyzés rövidebb lehet értéke
 Hard link
 Csak egy adott file-
rendszeren belül
25 26

 Szimbolikus kapcsolás  Törléskor a hivatkozás  Windows 98
 Új típusú file érvényét veszíti  Azonos volt az MS-DOS rendszerével
 Egy másik elérési  Megvalósítható, akkor is  Második kiadás támogatta a hosszabb file neveket és a
útvonalát tartalmazza ha a könyvtári
 Különböző file-rendszerek nagyobb file-okat
között is
bejegyzésekben tároljuk
az attribútumokat  Kétféle könyvtár bejegyzés
 Unix  Alapbejegyzés
 Szimbolikus link
 32 bites címek – file-rendszer maximális mérete
 Windows
 Short cut
8 3 1 1 1 4 2 2 4 2 4
 Mac Os N Létrehozás Utolsó Utolsó írás

Alapnév Kit. dátuma elérés dátuma File méret
 Alias T
27 Attr. Sec Kezdő blokk Kezdő blokk 28

felső 16 bitje alsó 16 bitje

 Windows 98  Unix könyvtárak
 Régi rendszerrel való kompatibilitás  Minden bejegyzés egy file nevet és a hozzá tartozó i-
 Hosszabb file nevek kezelése csomópont sorszámát tartalmazza
 Sorozat  A többi információt az i-csomópont tartalmazza
2 14
 Melyik az utolsó bejegyzés
File név
8 10 1 1 1 12 2 4
Az i-csomópont
száma
5 karakter 0 6 karakter 0 2 karakter
 Lemezblokkok megkeresése
 Gyökérkönyvtár megkeresése
 i-csomópontok a szuperblokkban
Sorozat Attribútumok Ellenőrzőösszeg 29  Tömb első eleme (i-csomópont) 30
 Unix könyvtárak  NTFS könyvtárak
 255 karakteres file nevek
 i-csomópont elérése  32 767 karakteres útvonalak
 Kiszámítható az i-csomópont sorszámából  Másodlagos 8+3 karakteres név a megosztott file-ok olvasására
 Unicode a file nevek képzéséhez
 16 bit
 Problémás a rendezés
 Attribútum a file név kisbetű-nagybetű konverziójára
 Problémák megoldása attribútumok bevezetése

 A file attribútumok gyűjteménye
 Master File Table
 16 attribútumot tartalmazhat
 Max. 1 KB lehet
 Egy attribútumban megadhatunk egy mutatót – bővítés
 Nem rezidens attribútum
31 32
Lemezterület kezelés Lemezterület kezelés

 Blokkméret  Meg kell becsülni az átlagos file
 Folytonosan lefoglalt lemezterület  Azonos méretű blokkok méretet
 File növeléskor másolni kell  Mekkora legyen a blokkok  1 KB?
mérete?  Kísérlet - medián
 Azonos méretű darabokra tördelve tárolják a file-rendszerek a  Szektor, sáv, cilinder?
 2475 byte
 Sok veszteség kis file-ok esetén
file-okat,  1 byte?  Medián
 Sok blokkból állna a file  rendezett file méretek közül a
 nem biztos, hogy szomszédosak középső
 Lassú file olvasás
 A medián jobb, mint az átlag
 Nem összefüggő blokkokból álló lemezterület  Blokk olvasás és
pozícionálás  A Windows NT file használata
Egy körbefordulást igényel

bonyolultabb a Unixnál
 Összefüggés  Példa
 A notepad-ban a file mentéshez
 Átlagos pozicionálás – 10 ms
26 rendszerhívás kell
 Szegmentált – lapozott memória kezelő rendszereknél  Rotációs késleltetés
 3 hibás megnyitás
 Sáv – 131 072 byte
 1 file felülírás
 Körbefordulási idő – 8,33 ms
 4 további megnyitás és lezárás
 k byte beolvasásához
művelet
szükséges idő
 10+4,165+(k/131072)x8,33
 Használattal súlyozott medián
 Csak olvasásra – 1 KB
 Csak írásra– 2,3 KB
33 34
 Írás olvasásra – 4,2 KB
Lemezterület kezelés Lemezterület kezelése

 2 KB-os file méret esetén  4 KB-os blokkméret  Szabad blokkok nyilvántartása
 Lemez tárkihasználtság jóválasztás  Láncolt lista, bittérkép
hatékonysága  MS-DOS
 Átviteli hatékonyság  512 – 32 KB
 Kettőhatvány
 Lemez kapacitás
függvénye
35 36
File-rendszerek megbízhatósága File-rendszerek megbízhatósága
 Mentések
 A file-rendszer segítheti az információ védelmét
 Helyreállítás katasztrófa esetén
 A lemezek nem tökéletesek, használat közben is  Helyreállítás hiba esetén
keletkezhetnek hibás blokkok  Hosszú idő, nagy hely igény

 Teljes file-rendszert vagy csak egy részét?
 A merevlemez hibás blokkjait a vezérlő kezeli,  Inkrementális mentés
helyettesíti az erre a célra fenntartott tartalékkal  Teljes mentés havonta vagy hetente
 Naponta csak azokat a file-okat kell menteni, amelyek megváltoztak a teljes
 SCSI-lemez jelzi a hibát mentés óta
 Csak az utolsó mentés óta megváltozott file-okat mentjük
 Ha gyakori a hiba, akkor cserélni kell
 Bonyolult a helyreállítás
 Szoftveres megoldás  Először a teljes mentést kell visszaállítani
 Aztán az inkrementális mentéseket fordított sorrendben
 Hibás blokkok összegyűjtése egy file-ba
 Tömörítés
 Nem olvashatjuk és írhatjuk
 Aktív file-rendszer mentése
 Mentéskor is vigyázni kell  Inkonzisztens állapot
 File-ok keletkezhetnek, törlődnek, módosulnak
37 38

 Fizikai mentés  Logikai mentés  File-rendszerek konzisztenciája
 0. blokk-tól minden blokk  Egy vagy több kijelölt
kiírása egy szalagra könyvtárban lévő file-t és  Ha nem minden módosult blokk került kiírásra a rendszer
 Nem használt blokkok? könyvtárat ment rekurzívan összeomlásakor
 Ki kell írni a sorszámát is a  Egyszerűen helyre lehet  Kritikus hiba, ha a blokk a következőket tartalmazza
blokknak állítani egyedi file-okat és  i-csomópont
 Hibás blokkok mentése könyvtárakat  Könyvtári bejegyzés
 Ha láthatóak a hibás blokkok,  Menteni kell a file útvonalat
 Szabadlista-elemek
akkor kezelni kell valamilyen  Könyvtári fa szerkezetet is
térképpel menteni kell  Unix – fsck
 Egyszerű és gyors  Menteni kell az  Windows – checkdisk/scandisk
attribútumokat is
 Módosult file útjába eső nem  Kétféle konzisztencia-ellenőrzés
módosult könyvtárakat is  Blokk
menteni kell  File
39 40

 Blokk-konzisztencia  File-konzisztencia
 Két táblázat - számlálók
 Hány file-ban fordul elő a  Számlálók file-onként
blokk  Gyökérkönyvtártól indulva rekurzívan járja be a fát
 i-csomópont
 Hányszor fordul elő a blokk a  Minden könyvtárat megvizsgál
szabad listában  Minden file esetén növeli a számlálót
 Szabad lista vagy bittérkép
 Merev kapcsolás – egy file több könyvtárban is előfordulhat
 Konzisztens ha minden
blokk vagy az egyik vagy a  Szimbolikus kapcsolódás nem számít – nem kell növelni a
másik táblázatban fordul elő hivatkozás számlálót
 Hiányzó blokk  i-csomópontonként index-elt lista
 mind a kettő 0
 A file hány könyvtárnak eleme
 Duplikált szabad blokk
 Egy blokk kétszer fordul elő a  Összevetjük az i-csomópontban tárolt információval
szabad listában
 Duplikált adatblokk  Több vagy kevesebb lehet a hivatkozás számláló
 Egy blokk kétszer fordul elő a
foglalt blokk listában
41 42
File-rendszerek megbízhatósága File-rendszerek konzisztenciája
 File-konzisztencia  A két módszer gyakran egybe van integrálva
 Ha az i-csomópontban tárolt számláló nagyobb
 A hivatkozás számláló még így is nagyobb 0-nál, ha törölnénk az  Hatékonysági okok miatt
összes file-t  Az i-csomópontokat csak egyszer kell végigjárni
 Az i-csomópont nem törlődne
 Tárhely veszteséget okoz  Más heurisztikus ellenőrzések is lehetségesek
 Lesz olyan file, amely egyetlen könyvtárban sem szerepel
 Könyvtáraknak meghatározott formájuk van
 Az i-csomópont számlálóját a helyes értékre kell állítani
 Ha az i-csomópontban tárolt érték kisebb  Minden i-csomópontnak van jogosultsági módja
 Katasztrofális  Gyanúsak megkeresése
 Két könyvtári bejegyzés ugyanahhoz a file-hoz van kapcsolva
 Akármelyik bejegyzést törölve az i-csomópont számlálója 0-vá
 A felhasználó védése önmaga ellen
válna
 Javítjuk az értéket
43 44
File-rendszer hatékonysága File-rendszer hatékonysága

 Elérési idő optimalizálása file-rendszerek esetén  Ha a gyorsító tár tele van, akkor ki kell írni valamelyik
 Gyorsító tár
bent lévő blokkot, mielőtt betöltjük az újat
 Hasonlít a lapozási technikákra
 Lemezfordulások csökkentése
 A különbség az, hogy gyorsító tárbeli hivatkozások ritkák
 Blokk-gyorsító tár = puffer-gyorsító tár  Az összes blokkot pontos LRU-sorrendben tarthatjuk
 Memóriában lévő lemezblokkok kollekciója  Csapda – file-rendszer inkonzisztencia esetén az LRU nem
 Ha a memóriában van a blokk, akkor lemezhez fordulás kívánatos
nélkül kielégíthető az igény  Sokára kerül kiírásra az utolsó elem
 Ha nincs, akkor először betöltjük a gyorsító tárba  Módosított LRU-séma
 Valószínű-e, hogy a blokkra hamarosan szükség lesz?
 Fontos-e a blokk a file-rendszer konzisztenciája

szempontjából?
45 46

 Kategóriák az első  Kategóriák a második  Blokk előreolvasás
kérdéshez kérdéshez
 i-csomópont, indirekt  Az adatblokk kivételével  Betöltés mielőtt szükség lenne rá
blokk, könyvtári blokk, mindegyik az  Szekvenciális olvasás
teli adatblokk, csonka  Módosult
adatblokk  k-adik blokkot kérjük – nagy valószínűséggel a k+1-edikre is
 Azonnal kiírandó a lemezre
 Amelyekre nem lesz szükség lesz
 Kritikus blokkok gyakori
szükség hamarosan kiírása  Direkt elérésű file-ok esetén az előre olvasás nem segít
 Az LRU elejére kerülnek
 Unix – sync
 Amelyekre szükség lesz  Update: 30 mp-ként sync
hamarosan (pl. csonka  Csak a szekvenciális olvasásnál használjuk
adatblokk)  Windows
 Az LRU végére kerülnek  Írásáteresztő gyorsító tár  Jelző bit
 Amelyik blokkba írtak, azt
 Sokáig ott maradnak egyből kiírja
Usb kivétele umount (sync) nélkül!!!

47 48
 Lemezfej mozgásának csökkentése  Első keresés – FIFO
 Egymásután igényelt blokkok  Legközelebbi keresés először
 Fizikailag egymáshoz közel kell elhelyezni
 Lehetőleg azonos cilinderen
 File kiíráskor egymás utáni blokkok lefoglalása

 i-csomópontoknál
 Liftes algoritmus
Hosszú pozícionálás
49
 Pályánkénti pufferolás 50
Naplózott file-rendszer Naplózott file-rendszer

 Log-structured File System (LFS) vezérlő elve  Vannak i-csomópontok
 Gyors processzor  A naplóban szétszórtan vannak
 Nagy memória  Nem a diszken rögzített helyen
 Lemez gyorsítótár gyorsan növekszik  i-csomópontok sorszámával index-elt táblázatban
 Lemezhez fordulás nagy része írási művelet lesz  i indexű elemben az i sorszámú i-csomópont lemezcíme van
 Egész lemez naplóvá szervezik  A táblázatot a lemezen tárolják
 Időnként és speciális igény esetén  Gyorsító tár
 A memória pufferben található összes függőben lévő írást
összegyűjtik egy szegmensbe, és azt egyben kiírják a napló végére  Végtelen kapacitású lemez esetén kész vagyunk
 Vegyes blokkok  A lemezek végesek
 A szegmens elején egy összefoglaló rész található
 A napló elfoglalja a teljes lemezt
 Mi van szegmensben?
 Ha a szegmens átlagos mérete kb. 1 MB lesz, akkor a lemez  Lehetnek olyan blokkok, amelyek továbbiakban nem kellenek
majdnem teljes sávszélessége kihasználható  File felülírásakor
51 52
Naplózott file-rendszer
 LFS takarítófonal/takarító szál
 Napló tömörítése
 Cirkuláris bejárással régi szegmensek eltávolítása a napló végéről
 Cirkuláris puffer
 Írást végző szál az elejéhez illeszt szegmenseket
 Takarító szál végéről távolítja el a szegmenseket
 Könyvelés nem triviális

 File blokk visszaírása egy új szegmensbe
 Meg kell keresni a file i-csomópontját
 Aktualizálni kell
 Ki kell írni a következő szegmensbe
 Módosítani az i-csomópontok cím táblazatát is
 Az új címet kell tartalmaznia
53

Os Eloadas Diak

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Os Eloadas Diak

Uploaded by

Copyright:

Available Formats

Bevezetés Bevezetés Operációs rendszerek jellemzése

Áttekintés Mi egy operációs rendszer?

Egy modern számı́tógép a következő dolgokból áll:

Ezen komponensek kezelése egy szoftver réteget igényel – Ez a réteg az

Bevezetés Operációs rendszerek jellemzése Bevezetés Operációs rendszerek jellemzése

Operációs Rendszerek helye Operációs Rendszerek helye - Szoftver elemek

Számı́tógépes Rendszer + Felhasználók = Egységes Tervezési Egység.

• Számı́tógépes Rendszer: hardver, szoftver, hálózat. • Alapszoftverek: általános funkciókat biztosı́tanak

Bevezetés Operációs rendszerek jellemzése Bevezetés Operációs rendszerek jellemzése

Operációs Rendszerek helye Operációs rendszerek alapvető feladatai

• A felhasználó kényelmének, védelmének biztosı́tása = Kiterjesztett

Operációs rendszerek alapvető tulajdonságai Operációs Rendszer Állatkert

Bevezetés Az operációs rendszerek története Bevezetés Az operációs rendszerek története

Generációk Az első generáció

• Nincs operációs rendszer

Bevezetés Az operációs rendszerek története Bevezetés Az operációs rendszerek története

A második generáció A második generáció

• Operációs rendszer van, rezidens a memóriában

A második generáció A harmadik generáció

• Operációs rendszer van, rezidens/tranziens a memóriában

Bevezetés Az operációs rendszerek története Bevezetés Az operációs rendszerek története

Időszeletelés - Time Slicing Átmeneti tárolás - Spooling

• az I/O adatok először gyors háttértárolóra (disk) kerülnek (spool

Bevezetés Az operációs rendszerek története Bevezetés Az operációs rendszerek története

Memória-partı́ciók A negyedik generáció

A negyedik generáció jellemzői OS felületei

Bevezetés Rendszerhı́vások Bevezetés Rendszerhı́vások

Rendszerhı́vások – System calls Rendszerhı́vások – System calls

• Processzus kezelés (process management)

1 a hı́vó proc-nak joga volt-e

Bevezetés Rendszerhı́vások Bevezetés Rendszerhı́vások

Példa: a read(fd, buffer, nbytes) rendszerhı́vása Processzuskezelés

pid = fork(); // Create a child process identical to the parent

Szignálkezelés Könyvtár- és fájlrendszerkezelés, védelem

s = mkdir(name, mode); // Create a new directory

Bevezetés Rendszerhı́vások Bevezetés Rendszerhı́vások

Fájlkezelés Rendszerhı́vások – System calls

fd = creat(name, mode); // Obsolete way to create a new file

Bevezetés Az OS struktúrája Bevezetés Az OS struktúrája

OS struktúrák Monolitikus rendszerek

• Legelterjedtebb szervezési mód. Főprogram: meghı́vja a kért

Rétegelt OS Virtuális gépek

Bevezetés Az OS struktúrája Bevezetés Az OS struktúrája

Kliens/Szerver Kliens/szerver modell előnyei

• Egymással ”kommunikáló” processzusok rendszere

Bevezetés Az OS struktúrája Bevezetés Az OS struktúrája

Kliens/szerver modell osztott rendszerekben Kliens/szerver programozás

Kliensnek nem kell tudnia, hogy a szerver lokálisan, vagy hálózaton

Operációs rendszerek alrendszerei

• Processzuskezelő alrendszer; process handling

• Minden processzusnak saját VIRTUÁLIS CPU-ja van

Ábra forrása: Tanenbaum könyv

• A CPU váltakozva hajtja végre a processzusokat • Futáskész

• Többprocesszoros rendszerekben is szükséges

Processzusállapotok Processzusok megvalósítása

Ábra forrása: Tanenbaum könyv Ábra forrása: Tanenbaum könyv

Processzusok megvalósítása Processzusok megvalósítása

• Erőforrást igényelt processzusok keresése pl. az erőforrás • Programállapot szót

• … • A vektorban meghatározott címre ugrik a számítógép

Processzusok megvalósítása Processzusok megvalósítása

Processzusok létrehozása Processzusok létrehozása

Processzusok létrehozása Processzusok befejezése

Processzusok befejezése Processzushiearchiák