Operaciós rendszerek

Operációs rendszerek

Rendszer fogalma:

Az ember a valós világból kiválaszt egy egy olyan részt, melyet éppen vizsgálni akar. A vizsgált szempontok alapján ezek a bizonyos részek összefüggnek egymással.

Akkor beszélünk rendszerrôl, amikor a valós világból kiválaszt az ember valamilyen részt, és azok a részek összefüggnek egymással. A rendszert tovább szokták bontani alrendszerre, részrendszerre, szoktak beszélni modulról nyilván a rendszer nagyságától függôen kisebb részekrôl.

Rendszer környezete:

A valós világnak az a része, ami lazán kapcsolódik a rendszerhez lazán körülveszi a rendszert. Ez a következôk miatt érdekes: Megkülönböztetnek zárt ill. nyílt rendszereket:

Zárt rendszer: Együtt tartalmazza a rendszert és a környezetet.

Nyílt rendszer: Környezetét nem tartalmazza.

Komponens:

Rendszer alkotóelemeit komponenseknek nevezik. A részletes felosztásban a legelemibb részeket nevezik így.

Rendszer megadása:

elemek (komponensek) megadása, felsorolása

elemek közötti összefüggések megadása.

A rendszer megadása ebben a formába egy statikus megadási forma.

mozgásokat írunk le (a rendszerben lezajló tevékenységeket, folyamatokat adjuk meg)

A rendszernek ezen megadása a dinamikus megadási forma.

A rendszerben lezajló folyamatok nyilván akkor érdekesek számunkra, ha azok céltudatosak és valamilyen vezérlési elv alapján hajtódnak végre ezek a tevékenységek.

A vezérlés folyamán programozásból már ismert eljuthatunk döntési pontokhoz, ahol valamilyen feltételtôl függôen dönteni kell, hogy merre folytatódjon a rendszerben az a bizonyos folyamat (erre döntés születik). Bizonyos tevékenységek ciklikusan ismétlôdhetnek.

Interfész:

A rendszer és a környezet közötti rész leírása az interfész megadásával történik. A rendszerben a folyamatoknak bizonyos erôforrásigénye van. Ahhoz, hogy egy bizonyos folyamat végrehajtódjon, bizonyos rendszererôforrásokra szükség van. Ezekért az erôforrásokért általában többen is jelentkeznek és ezekért versenyezni szoktak. Majd meglátjuk, hogy számítógépes rendszerekben is így történik.

Folyamatok csoportosítása az idôbeli lezajlás (lefolyás) alapján:

Soros folyamatok: Idôben egymás után zajlanak a folyamatok szünet lehet közöttük.

Párhuzamos folyamatok: Idôben átfedéssel zajlanak a folyamatok, tehát egy idôben több folyamat is végrehajtásra kerülhet. Bizonyos operációs rendszerekben, számítógépes rendszerekben csak úgy képzelhetô el hatékonyan a munka, ha párhuzamos munkafolyamatok zajlanak benne, nem pedig csak egyik a másik után.

Szinkron folyamatok: A folyamatok között kapcsolat van, mégpedig olyan, hogy egyiknek a működését egy másik váltja ki. Tehát van egy szinkronizáló és van egy szinkronizált folyamat.

Aszinkron folyamatok: Olyan párhuzamos folyamatok, melyek nem függenek egymástól. Értelemszerűn a szinkronnak a tagadása.

Izokron folyamatok: Egyidejű folyamatok. Olyan párhuzamos folyamatok, amelyeknek egy adott idôpillanatban mindegyike működik. Tehát egy bizonyos intervallumban mindegyik működik.

Ütemezett párhuzamos folyamatok: Párhuzamos folyamatokról van szó, de egy idôben mindig csak egy működik közülük. Lehet, hogy a párhuzamos folyamatok közül egy kitüntetett olyan szempontból, hogy ô vezérli a többinek a működését. Ezt szokták nevezni ütemezônek ütemezi a folyamatoknak a lezajlását, végrehajtását. Pl. Ha van több folyamat, és egy erôforrás van csak, akkor nyilván azzal az egy erôforrással egyidôben csak egy valaki dolgozhat a folyamatok közül, nyilvánvalóan ez egy ütemezett párhuzamos, ha ezt megfelelô módon egy ütemezô vezérli.

Rendszerek felépítése

Többféle módon lehet elképzelni. A rendszer felépítését, leírását általában valamilyen modellel szoktuk jellemezni és leírni. Nyilvánvalóan a legegzaktabb a matematikai modell.

A rendszer struktúrája háromféle lehet:

Párhuzamos struktúrájú: A rendszer egymással egyenrangú részekbôl felépülô részrendszerekbôl áll. Tehát egymástól független, egymással párhuzamos, egyenrangú részrendszerekbôl áll.

Hierachikus struktúrájú rendszer: Az elôzôvel ellentétes. Egymástól függô, egymásra épülô részrendszerekbôl épül fel a rendszer. Pl. Ha egymásra épülô, hierarchiában szereplô részrendszerekrôl van szó, akkor lehetnek olyan részrendszerek, amelyek azonos szinten vannak. Az azonos szinten lévô részrendszereket együttesen rétegnek szokták nevezni.

A rendszeren belül, ha hierarchikus struktúrájú egymásra épülô, egymással összefüggô részekbôl áll , akkor a részek közötti kapcsolat a rétegek között fog lezajlani.

Bonyolult vagy struktúrálatlan rendszer: Se nem párhuzamos, se nem hierarchikus.

Számítógépes rendszerek

Számítógépes rendszerek felépítését rétegszintekkel, hierarchikus szintekkel lehet jellemezni. Többféle megközelítés létezik, attól függôen, honnan nézzük és milyen szempontból.

Elsô megközelítésben induljunk föntrôl lefelé:

Alkalmazók (környezet): A számítógépes rendszerrel szemben ott állnak az alkalmazók. Az alkalmazók alkotják a számítógépes rendszernek a környezetét. Az alkalmazók vannak kapcsolatban a számítógépes rendszerrel.

Alkalmazói réteg: A számítógépes rendszernek van egy olyan része, amelyiken keresztül kapcsolat teremthetô az alkalmazók és a számítógépes rendszer között. Nyilván van egy alkalmazó, a számítógépes rendszer nem minden részével beszélget közvetlenül. Nyilván lesz egy pár olyan dolog, amihez hozzáférünk, amin keresztül beszélgetünk a rendszerrel.

Nyelvi réteg: Az alkalmazói réteg egy nyelvi réteghez kapcsolódik. Nyilván valamilyen nyelveken társalgunk a rendszerrel. Programozási nyelvek, parancsnyelvek ezek, amin leírjuk, mit szeretnénk csinálni.

Operációs rendszer réteg: A nyelvi rétegen keresztül kommunikálunk a géppel, azon túlmenôen még van egy operációs rendszer rész is, ami aztán kapcsolódik ténylegesen a gépi dolgokhoz.

Hardver réteg: Ez a gépi dolog a hardver réteg.

Lehet egy másikféle megközelítést is megadni, ahogy a rendszernek az üzemeltetôje látja.

Alkalmazók (környezet)

Beviteli kiviteli (I/O) réteg: Ahogyan az adatokat tudjuk a rendszerbe bevinni és a rendszertôl kérünk és várunk eredményeket.

Ütemezô réteg: Akkor szükséges és akkor kell, amikor több munkát akarunk egyidôben számítógépes rendszerben valamilyen szisztémával végrehajtatni. Ekkor ezek között rendet kell teremteni, tehát ütemezni kell a dolgokat.

Operációs rendszer réteg:

Hardver réteg:

Természetesen a rétegek között van valamilyen interfész, van valami lyen kapcsolat, amivel egyik a másikkal tud kommunikálni. Ezekrôl késôbb fogok beszélni. A másodiknál érdekes az, hogy milyen eszközök állnak a rendelkezésünkre az egyes számítógépes rendszer rétegek közötti kommunikációra. Ezek a következôk lesznek:

parancsnyelv: ezzel a felhasználót tudjuk kezelni

amikor az ütemezôhöz kapcsolódunk, akkor kell egy olyan interfész, ami az erôforrások igényeket szépen ki tudja elégíteni tehát az ezzel kapcsolatos dolgokat tudja végezni

az ütemezô és az operációs rendszer réteg között egy operátori rendszer kapcsolat, interfész fog létezni

és az operációs rendszer és a hardver között pedig egy ún. hardver mérnöki interfész létezik.

Operációs rendszer

A számítógépes rendszereken belül eljutottunk az operációs rendszer fogalmáig. Ehhez egy ISO (Nemzetközi Standard Szervezet) fogalmat mondanék el.

Az operációs rendszer olyan programrendszer, amely a számítógépes rendszerben a programok végrehajtását vezérli, így például:

ütemezi a programok végrehajtását, elosztja az erôforrásokat, biztosítja a felhasználó és a számítógépes rendszer közötti kommunikációt (a minél kényelmesebb és jobb kommunikációt).

Aki már kapcsolatba került számítógépes rendszerrel, különbözô szintű kapcsolatokat tud teremteni. Milyen kapcsolat lehetséges mondjuk egy pc-s számítógépes rendszer esetén, hogyan tudunk kommunikálni a rendszerrel? Milyen eszközök, eszközrendszerek állnak a rendelkezésünkre? Van a billentyűzet, a monitor, legtöbb esetben ezt tudjuk használni. Itt is a legegyszerűbb és tulajdonképpen a legbonyolultabb kapcsolat az, amikor le kell írnunk minden parancsot, mit akarok csinálni? Már kényelmesebb felhasználás, ha van valamilyen segégprogram, pl. Norton Commander. Vagy van egy olyan programrendszer, amiben vannak ilyen o lyan menürendszerek, amibôl ki kell választani, mit akarok csinálni, nem kell leírni.

Továbbá nem csak a billentyűzeten keresztül lehet kommunikálni, hanem pl. egérkével és így tovább.

És vannak más programok, pl. Windows, ahol ikonok jelennek meg. És vannak kísérletezések arra, hogy nem kell nyomogatni, hanem ülünk ké nyelmesen és beszélünk a számítógéphez.

Mi tartozik bele egy operációs rendszerbe?

Mik azok a részek, melyek azok a programok, amelyek az operációs rendszerhez szorosan hozzákapcsolódnak? Ez nagyon régóta vitatéma a számítástechnikusok között.

PC s rendszerektôl jóval nagyobb számítógépes rendszerek is léteznek, még Magyarországon is. Nem beszélve arról, ha kijjebb megyünk. Nyugat felé a PC ket nem ismerik, nem téma, ha valaki PC dolgozik. Ténylegesen problémáznak mindig azon, hogy azok a programok, amelyek léteznek adott számítógépen közülük melyek azok, amelyek az operációs rendszerhez tartoznak és melyek azok, amelyek csak úgy külön vannak, ilyen olyan funkcióban léteznek és lehet használni valamire.

Az biztos, hogy azok a részek hozzá kell, hogy tartozzanak, amelyek a gépkezelôi (operátori) beavatkozást megvalósító részek. Olyanra kell gondolni, hogy be lehet állítani bizonyos paramétereket aktuálisan, milyen egységek kapcsolódnak a rendszerek, milyen egységek működôképesek, stb. ezek milyen néven ismertek. Minden egységnek, minden berendezésnek, számítógépnek kell hogy legyen saját önálló neve ahhoz, hogy kommunikálni tudjanak egymással a számítógép egyes részei, információkat tudjanak egyik helyrôl a másikra eljuttatni. Itt nyilván változások következhetnek be, bizonyos berendezéseket kiveszünk onnan, bizonyos berendezéseket be rakunk a rendszerbe mindezt az operációs rendszernek a tudomására kell hozni.

Különféle lekérdezések, hogy bizonyos berendezések léteznek, nem léteznek, milyen állapotban vannak, a rendszer milyen állapotban van, mit hajt éppen végre, milyen programon van a vezérlés stb. Nagyon sok minden tartozik ide a rendszer működéséhez, fôleg olyankor, amikor több programot fogunk végrehajtatni a géppel, te hát ún. multiprogramozott rendszerben gondolkodunk. Nagyon sok minden tartozik ide operátori szinten.

Tehát ezek mindenképp az operációs rendszer részét kell hogy képezzék.

A bemenet és kimenet (I/O) lesz a legalsó szintje ,hogy ez mit jelent, természetesen operációs rendszer függô is.Mi az a legalsó szint, ami az operációs rendszerhez tartozik. Talán az I/O nak a legalsó szintje az mindig az operációs rendszer része kell hogy legyen. Tehát az I/O kéréseknek az összehangolása, ütemezése, az I/O utasításoknak a beindítása, az egységekrôl érkezô különbözô kéréseknek, jelzéseknek a fogadása, feldolgozása úgy mondják, hogy a külsô egységekbôl érkezô megszakításoknak a kezelése. Bizonyos komolyabb operációs rendszerekben az I/O nak a szinte elég magas ez a következôt jelenti. Egy bizonyos nagyságú vagy bizonyos szintű operációs rendszerben - itt elsôsorban nagygépes rendszerrôl van szó - az I/O meg van valósítva egy elég magas szinten és minden része a számítógépes rendszernek ezt az egy közös I/O rendszert használja. Vagyis teljesen mindegy, hogy milyen programozási nyelvet, programfejlesztési környezetet használok, egy I/O kezelô rendszer van és az az operációs rendszer része és mindegyik saját környezetén belül ezt az egy közös rendszert fogja használni. És ha a PC s rendszerre gondolnak, itt csak a legalacsonyabb szintű I/O van meg, az operációs rendszerben nincsenek benne az adatkezelési részek, hanem kifejlesztették pl. a Turbo Pascalhoz van egy kis adatkezelôrész, egy másikhoz van egy másik, egy harmadikhoz egy harmadik, mindegyik önállóan kifejlesztette, hogyan kezeli a lemezeket. Tehát azt kell elmondani, hogy ez nem mindig egységes.

A multiprogramozást megvalósító rész. Tehát a multiprogramozást vezérlô programrendszer, multiprogramozást vezérlô részek. Azok a részek, amelyek az erôforrás elosztást vezérlik és ún. munkavezérlô nyelvek, amik segítségével le tudjuk írni, mit is akarunk csinálni a számítógépes rendszerrel.

A fenti részek biztosan az operációs rendszerhez tartoznak. Az, hogy ezen túlmenôen mit fogunk az operációs rendszer részének tekinteni, ez már sokszor ízlés kérdése. Nagyon sokszor, mint ahogy kitűnik a beosztásból, nem része az operációs rendszernek egyik programozási nyelv sem, vagyis a programozási nyelvet kezelô, a programozási nyelven megírt programok, a lefordított programok stb. Persze nagyon sokszor maga az operációs rendszer egy adott programozási nyelv köré épül (pl. Commodore). Vagy bizonyos számítógépes rendszereknél a másik operációs rendszert megvalósító programozási nyelv a C tehát ez egy programozási nyelv. Természetesen része egy adott nyelv az operációs rendszernek, de egyébként nem tartozik bele. Nyilván egy PC s rendszernél ez nyilvánvaló, hiszen ha valaki vesz egy gépet és vesz hozzá egy operációs rendszert, akkor abban nincsen benne semmi. Ha azzal dolgozni akar, ahhoz venni kell egy Pascalt, vagy mást.

Hardver alapfogalmak

Processzor: CPU

Ma a leggyakrabban használt processzorok a Neumann elvű processzorok. Ez azt jelenti, hogy a számítógép belsejében, az operatív tárban van letárolva a program, teljesen hasonló módon mint az egyéb információk (számok, betűk stb.)

Címzési mechanizmus

Arra vonatkozik, hogy hogyan lehet hivatkozni a címekre az operatív táron belül. Hogyan lehet az operatív táron belüli tárolóhelyeket elérni? Különbözô címzési lehetôségek vannak, ezek a processzortól függenek.

Direkt címzés: közvetlenül egy tárolóhelyre hivatkozok.

Indirekt címzés: valahol le van tárolva egy memóriabeli cím, és arra a memóriabeli címre úgy hivatkozok, hogy megmondjuk, hol van annak a címe.

Bázisregiszteres címzés: A processzoron belül vannak kitüntetett tárolóhelyek, ezeket regisztereknek hívják. Ezek speciális tartalommal rendelkezhetnek. Közöttük lehet olyan kitüntetett, amelybe egy bizonyos terület kezdôcímét lehet letárolni. Ehhez képest adunk meg ún. relatív címeket.

Virtuális címek (nem valódi címek): Ez azt jelenti, hogy a memória valameddig tart és van egy legutolsó címe (a legutolsó bájtnak is van egy címe). Általában a címzés itt úgy szokott lezajlani, hogy van egy hely biztosítva arra, hogy itt letároljunk egy címet (valahány bit vagy bájt). Attól függôen, hogy itt hány bit van a rendelkezésünkre bocsájtva, megadja a lehetséges tartományt. Pl. Két bájt esetén a csupa egyes bit adja a legnagyobb címet. Négy bájt esetén nagyobb címtartományt kapunk. Az operatív tár felépítése elég bonyolult volt és elég drága volt. Ezért a tényleges valódi tárat viszonylag kicsire építették. A tényleges memória tartomány nagyobb lehetett volna a címzés szempontjából. A kettô közötti hézagot lefedték háttértárral (ha van). Amikor memória dolgozunk, biztosítani kell igazi címeket, tehát csere-berét kell végrehajtani, hogy a lemezen lévô virtuális memória tartalmát be kell olvasni az igazi memóriába, hogy dolgozni tudjunk vele. Az, hogy ezt a címzési mechanizmust megengedi a processzor, ettôl függôen lesz a virtuális címzés biztosított. Egyáltalán, virtuális címzés mindig azt fogja jelenteni, hogy van nekünk ennyi valódi (reális) tárunk és virtuális tárak. îrhatok olyan programot, melynek a memória igénye ennél nagyobb, tehát belelóg a virtuális részbe.

program

reális virtuális

Nem akarok azzal foglalkozni, hogy a gép hogyan helyezi el. Ha az épp aktuális programrész a virtuális részre esik, akkor a lemezen azt meg kell neki keresni, be kell neki hozni a reális tárba. Ott felülír egy másik programrészt, de ezt nyilván elôtte neki ki kell menteni lemezre. Ezt nyilván nem nekem, mint programozónak kell megoldani, hanem a rendszer biztosítja a számomra.

Ez nem azonos pl. a PASCAL ban ismert overlay technikával, ahol a programozónak van olyan eszköze, hogy szét tudja darabolni a programját, és meg tudja oldani, hogy most éppen melyik programrész kerüljön be. Ezt neki kell megcsinálni. A fenti lehetôségnél viszont a programozónak semmi dolga. Az a jó, ha ilyen tárkezelése van a rendszernek. Van ún. beépített tárkezelési rendszer, ami ehhez kapcsolódik. Ezt szokták nevezni lapozásnak vagy szegmentálásnak.

A lapozás nagyon hatékonyan meg tudja oldani az operatív tár kezelését olyan módon, hogy a programot az operációs rendszer úgy tudja kezelni és a gép is úgy tudja kezelni, hogy a memóriának egy jól meghatározott helyén folytonosan helyezkedik el. Ha ilyen módon tudja csak elhelyezni a programot, akkor ez esetben fôleg multiprogramozott környezetben ezt nem könnyű biztosítani, hogy összefüggô terület legyen biztosítva a program számára. Jóval egyszerűbbm hogy ahol van egy kis hely, azt kitöltjük, megint keresünk egy kis szabad részt, azt megint kitöltjük és így tovább. Ezt úgy oldották meg, hogy a tárat felosztották lapokra. A lap úgy néz ki, hogy 2 K vagy 4 K ezek a leggyakoribb lapméretek. És akkor azt mondták, ez egy összefüggô rész, nem lehet tovább bontani. Van egy program valamekkor memória igénnyel, pl. 100 lap. Hogy ez a száz lap a memórián belül hol helyezkedik el, az teljesen mind egy. Nyilván megfelelô módon le tudja tárolni, hogy a programnak az elsô lapja az itt van, a második az ott van stb. És természete sen tudja, ha a programnak azt a részét kell végrehajtani, ami a harmadik lapon van, akkor tudja, hogy a memóriának melyik részén helyezkedik el. Ha éppen memóriára van szüksége a rendszernek és nincsen, akkor az operációs rendszer meg tud olyan dolgokat csinálni, hogya régen használt részeket kimenti lemezre és ezáltal fölszabadulnak részek.

A szegmentálás csak annyival bôvebb a szegmentálásnál, hogy törekszik arra, hogy összefüggô részek legyenek egymás után, tehát hogy több lapot együtt tudjon kezelni, és azt mondja, ez egy szegmens.

Utasításrendszer:

Számítógépünk bizonyos gépi kódú utasításokat ismer, azokat tudja végrehajtani.

A processzor utasításkészlete lehet:

csökkentett utasításkészlet

komplex utasításkészlet.

Processzor állapotok:

normál állapot: nem lehet végrehajtani minden utasítást

privilegizált állapot: minden utasítás végrehajtható.

Megszakítási rendszer:

Bizonyos eseményekre reagálni tudjon az operációs rendszer a megszakítások teszik lehetôvé.

Megszakítások:

központi egységen belüli megszakítások

kívülrôl érkezô megszakítások

párhuzamosan működô egységek koordinálása.

Megszakítás kérés érkezik kívülrôl erôltetett gépi vezrélésátadás történik. Folytatni akarjuk a megszakított folyamatot bizonyos információkat meg kell ôriznünk (pl. regiszterek tartalma, hol tartottunk).

Megszakítások letilthatók.

Megszakítás menete:

Megszakítási kérelem érkezik. Ez várakozik, aminek két oka lehet:

az épp folyó utasítás még nem fejezôdött be

megszakítás le van tiltva, mert egy másik megszakítás feldolgozása folyik.

Ha a rendszer elfogadta a megszakítást, akkor a megfelelô állapotnak az elmentése megtörténik.

A processzor privilegizált állapotba kerül, ez azért kell, hogy minden utasítás végrehajtható legyen. Ezután letiltásra kerül ez a megszakítás.

Elindítja a megszakító rutint.

Megszakítás végrehajtása (megfelelô tevékenység végrehajtása).

Kritikus pont elérése után megszakíthatóság visszaállítása.

A megszakító rutin befejezte a működését, akkor vissza kell adni a vezérlést az operációs rendszer valamelyik részének, általában az ütemezônek. Az ütemezô ezután dönt a folytatásról. Ez azért van, mert nem szükségképpen az a pogram kapja vissza a vezérlést, ame lyiknél a megszakítás történt.

Nem szabad leragadni a PC nél, mert nagyobb és jelentôsebb rendszerek is vannak.

Az, hogya konkrét megszakítási rendszer hogyan működik, milyen dolgokat kell kimenteni, konkrét számítógépes rendszertôl függ. Ha a megszakító rendszer nincs jól kidolgozva, akkor nem képzelhetô el, hogy jól működô számítógépes rendszer legyen.

Védelmi mechanizmus:

A processzoron belül lényeges kérdés. Több mindet védeni kell:

Processzor: Védelme abban áll, hogy nagyon könnyedén lehet írni végtelen ciklust. Honnan lehet észrevenni, hogy egy program vég telen ciklusban van? Elôre nyilatkozni kell, hogy mennyi idôt igényel a program. Ez több program esetén érdekes, mert azt kell észrevenni, hogy sok program közül egy végtelen ciklusban van. A megadott idô tiszta idô, tehát nem a rendszerben eltöltött idô.

Operatív tárat: Mindig úgy képzelendô el, hogy mindenkinek van valamennyi területe. Nyilván van egy olyan rész, mely az operációs rendszernek a saját területe. Oda felhasználói program nem teheti be a lábát, legfeljebb néhány információt kiolvashat. Ha több felhasználói program van, akkor egymástól is védeni kell ôket. Tehát, ha egyik program a másik program területére akar nyúlni, akkor ezt nem engedi meg az operációs rendszer.

I/O műveletek során: Szintén nem keveredhetnek össze az operatív területen. Már operációs rendszer szinten nagyon komoly védelmek vannak.

Hardver eszközök:

Tárak

Háttértárak Mágneslemezes

Mágnesszalagos

Egyéb perifériák Lyukszalagos, lyukkártyás berendezések

Billentyűzet

Monitor

Nyomtatók

Adatátviteli vonalak

Csatorna

Rajzgépek

Optikai olvasók

Tárak:

Történetileg: az elsô tárak nagyon kicsik és lassúk voltak.

Technikailag: mágnesdobok (ODRA 1003)

ferritgyűrű (ODRA 1013 ban 256 szó)

félvezetôs tárak

További fogalmak: RAM, ROM, PROM, EPROM

Mindegyik memóriarész ugyanannyi idô alatt érhetô el (kis túlzással igaz).

Mai világban az érdekes, hogy mekkora az operatív tár mérete és ebbôl mennyit tud kihasználni.

Háttértárak:

Két csoportja: mágneslemez: fix vagy cserélhetô

merev vagy hajlékony

kapacitás

mágnesszalag.

Közös tulajdonságok:

Információ tárolása gyakorlatilag olyan módon történhet, mint az operatív tárban. Ebben az a jó, amikor az operatív tár és a háttértár között információt akarunk átvinni, nincs idôveszteség az átalakítással. Ez az átalakítás nem hagyható el a billentyűzet vagy a képernyô esetén.

A háttértár eleve azért kell, mert kicsi az operatív tár és ha nem használjuk, elvész belôle az információ.

Mágneslemez:

Minden lemezkötetnek van egy saját egyedi neve, ez az ún. kötetcímke (volume). Kisebb rendszerben nincs jelentôsége, mert nem kerül ellenôrzésre a lemeznév, de nagyobb rendszerekben igen. Ahol egy személyzet cseréli a lemezeket, nem mindegy, hogy melyik lemezen vannak az információk.

A lemez esetén fontos információt tartalmaz a tartalomjegyzék. Itt rendelkezésre áll minden állományról az összes információ (név, hely foglalás, mikor készült, meddig ôrizzük meg). Természetesen azok az információk is ott vannak, hogy hol van szabad hely. Tartalomjegyzék sérülése esetén szinte lehetetlen a lemez hely reállítása.

Állományok elhelyezkedése a lemezen:

egy szinten (egymás mellett) vannak az állományok

hierarchia: könyvtárakban, alkönyvtárakban vannak elhelyezve az állományok (ez egy logikai struktúra, logikai szerkezet) nem fizikailag van a lemez ilyen részekre felosztva, hanem logikailag.

Bizonyos rendszerekben a lemezek használatánál elôre helyet kell foglalni a lemezen. PC esetén a Disk Full üzenettel találkozhatunk, nincs elôre helyfoglalás. Programba beépíthetek ellenôrzô utasításokat, de egyszerűbb, ha ezt az operációs rendszer csinálja.

Mágnesszalag:

Kötet és kötetcimke fogalom itt is van. Lehetséges, hogy 1 szalagon több állomány van, ill. 1 állomány több szalagon.

Hagyományos mágneslemezegységre 1 szalag tehetô fel. Újabb egységeknél egy szalagegységre több szalag is feltehetô. PC- s formája a Streamer.

Lyukkártya:

Az 1800 as évek végén, az akkori 1 dolláros méretével volt azonos méretű.

Billentyűzet:

Párbeszédes üzemmód eszköze.

Nyomtatók:

Nagysebességű nyomtatás: fix karakterek vannak pl. egy hengeren. Mátrixnyomtatás, lézernyomtatás, tintasugaras nyomtatás, színes nyomtatás.

Adatátviteli vonalak:

Akkor jelennek meg, amikor több számítógépet kell összekapcsolni. Itt az átvitel során jelentkezik a sebesség és minôség probléma.

Csatorna:

Hogyan van hozzákapcsolva a periféria a központi egységhez? Régi rendszerek esetén a központi egység csak egy perifériával tudott fog lalkozni. Ez elég lassú volt. Ezért kialakult egy olyan dolog, hogy a központi egység csak addig foglalkozik a perifériákkal, amíg valamit elindít, vagy valami már befejezôdött. Ezután minden munkát átad egy ún. csatornának. A csatorna olyan eszköz, mely a központi egység és a periféria között helyezkedik el. A központi egységnek jelentôs ideje felszabadul, mert a munkát átadja a csatornának. A csatorna és az egységek közé nagyon sokszor beépítette egy egység vezérlôt is. A csatorna tud foglalkozni egy csomó mágneslemezegységgel stb., de hogy mégis valami rend legyen közöttük, van egy vezérlô.

Többféle csatornát különböztetnek meg:

gyors perifériákkal dolgozó csatorna (lemezek, szalagok) megfelelô vezérlôn keresztül egy idôben csak egy egységgel tartja a kapcsolatot

a másik fajta csatorna olyan, hogy végigszalad a hozzákapcsolt perifériákon és megnézi, hogy melyik akar adatot átvinni erre a lassú perifériákat szokták rákapcsolni (nyomtató).

Egy adott rendszernél több csatorna is lehet, bár nem olcsók. Jól meg kell határozni, hány csatornát vesznek. A csatornák tették lehetôvé a multiprogramozást.

Gyártók, gépek, gépcsaládok:

IBM

ESZR Magyarországon (IBM koppintás)

VAX gépcsalád neve, korábban PDP néven volt ismert DEC cég gyártmánya

PC Magyarországon eredeti IBM PC nem nagyon van

Operációs rendszerek

Operációs rendszerek osztályozása:

Többféle módon képzelhetô el.

Hány felhasználó fér hozzá egyidejűleg a rendszerhez?

egyfelhasználós

többfelhasználós (multiprogramozott rendszerek).

Mi az elérésnek a módja? Hogyan tudunk az operációs rendszerrel kommunikálni?

kötegelt operációs rendszer: a kártyakötegrôl kapta a nevét (batch) a kártyaköteg azt jelképezi, hogy az operációs rendszerhez intézendô parancsainkat, kéréseinket valamilyen munka vezérlô nyelven leírjuk (ezt régen kártyákra írták le, melybôl egy kártyaköteget alakítottak ki) ezt valamilyen módon átadták a gépnek, ami azt végrehajtotta

interaktív operációs rendszer: erre az üzemmódra az jellemzô, hogy beírok egy utasítást vagy parancsot a rendszernek, és ezt a rendszer azonnal visszautasítja, vagy végrehajtja

valós idejű rendszer: real time: tükörfordítás történt lényege, hogy az adatok keletkezésétôl, egy jól meghatározott idôn belül valamilyen reagálás történik, feldolgozás megkezdôdik elsôsorban ezt folyamat irányításokban használják

tranzakciós rendszer: inkább felhasználói rendszerekhez kapcsolódik pl. helyfoglaló rendszer utazás esetén.

Kötegelt és interaktív üzemmód mindegyike meg van PC s rendszer esetén.

Nagygépes, középképes, kisgépes, mikrogépes operációs rendszerek.

Hogyan épül fel a számítógépes rendszer?

centralizált: olyan számítógépes rendszer, amikor az erôforrások egy adott helyen (épület, szoba) vannak

hálózati: a számítógépes rendszer egy hálózatba van összeállít va, amely rendszerben több processzor is elképzelhetô lehet közöttük kitüntetett is (PC s hálózat esetén a server) lehet kommunikálni a hálózatban, dolgozni a saját géppel

osztott vagy elosztott rendszer: bizonyos jogokat megosztanak, ami úgy történik a hálózati rendszerhez képest, hogy vannak majdnem hasonló felépítésű részrendszerek, és a rendszer működése során meg lehet osztani feladatokat, állományokat

idôosztásos operációs rendszer: time sharing

virtuális operációs rendszerek: számítógépes átmenetek segítésére készítenek egy olyan operációs rendszert, amelynek a működése során definiálni lehet virtuális számítógépeket, amely gépek rendelkeznek minden olyan erôforrással, ami egy számító géphez kell (memória, nyomtató, lemezegység) mindez nincs, de leszimulálja, annyit, amennyi szükséges ezen gépek mindegyikének kell operációs rendszer tehát az egyik gépen elindítunk egyfajta operációs rendszert, a másik gépen egy másikat, ha történetesen két gépet szimulálunk ezután az kell, hogy ezeknek a működését összehangoljam továbbra is egy gépem van, ami szimulál több gépet, és azokon a gépeken több operációs rendszert le het elindítani sôt az egyik ilyen definiált gépen el lehet in dítani ezt a virtuális gépet definiáló operációs rendszert, te hát egy virtuális operációs rendszer alatt elindít egy virtuális operációs rendszert.

Operációs rendszerek funkciói:

A következôképp alakulnak. Vannak:

elemi funkciók (primitívek)

összetett funkciók (több elemi funkció van összevonva)

fô funkciók (ezek önálló egységeket jelentenek).

Számunkra elsôsorban a fô funkciók érdekesek. Ezek közé tartoznak:

rendszeradminisztráció

programfejlesztési támogatás

alkalmazói támogatás.

Rendszeradminisztráció alatt értjük:

processzor ütemezés

megszakításkezelés

szinkronizálás (különbözô folyamatok között)

folyamatvezérlés

tárkezelés

perifériakezelés

adatkezelés

működés nyilvántartás (különféle nyilvántartásokat kell vezetni a rendszernek milyen folyamatok hogyan zajlanak, mennyi ideig, milyen műveleteket hányszor hajt végre a gép stb.)

operátori kapcsolat.

Ez egy lehetséges felosztás. Ez inkább csak funkció szerinti. Különbözô operációs rendszereknél más felosztás is lehet. Kisebb operációs rendszerek esetén nincs is nagy értelme felosztani a különbözô részeket, hiszen kicsi az operációs rendszer. Leginkább az utasítások felsorolása az érdekes.

A rendszer belsô kezelése nem annyira fontos számunkra, az csak annyiban lényeges, hogy tudunk róla, ilyen van.

Programfejlesztési támogatás:

Kapunk egy feladatot, ki kell találni, mit akarunk csinálni. Ilyen módon a programozási munkát több részre föl lehet bontani:

Feladat elemzése:

Elsô lépésként célszerű végiggondolni, mit is kell csinálni, hogyan kell csinálni. A legfontosabb, hogy megtaláljuk és leírjuk az adatszerkezeteket. Tehát milyen adatokkal, mit akarunk csinálni. Milyen állományokkal akarunk dolgozni. Mik a bemenô adatok és milyen eredményeket várunk. Hogy ezt milyen formában, milyen eszközökkel írjuk le, erre a legkülönfélébb megoldások vannak. De ezt rögzíteni kell valamilyen módon.

Algoritmusok:

Ezekkel az adatokakkal, amelyeket leírtunk, mit akarunk csinálni. Lehet olyan, hogy már kész algoritmusokat használok. Átveszünk valahonnan kész dolgokat. Ezt is rögzítjük valamilyen írásos formában.

Részfeladatokra való bontás (ha viszonylag nagy feladatról van szó):

A nagy feladatokat célszerű kisebb részekre felbontani. Vagy azért, mert nem olyan túl jó az ember átfogó képessége (kisebb részeket könnyebb megfogni), vagy többen csinálják a nagy feladatot (pl. rövid a határidô). Tehát ennek több oka lehet. És természetesen ezeket a részeket külön külön kell kidolgozni.

Program(ok) írása:

Egy alkalmas programozási nyelven. Kérdás az, mit jelent ez. Az emberek, a programozók többsége úgy szokott lenni, hogy nem túl sok programozási nyelvet tanul meg olyan szinten, hogy alkotó szinten. Hanem kiválaszt valamilyen szinpátia, vagy bármi alapján egy esetleg két nyelvet és erre alapozva irogatja a programjait. Még abban az esetben is, ha lenne rá alkalmasabb programozási nyelv.

Programok belövése, tesztelése modul teszt:

Arról van szó, hogy az egyes programokat önállóan próbáljuk meg letesztelni és ennek megfelelôen a modulokra történô felbontás modul tesztet jelent.

Programok összeépítése, integrálása:

Bizonyos szintuációkban nem egy túl egyszerű feladat. Az önálló programokat kipróbálgatjuk, mennek. Ezeket összerakjuk és ekkor elôjönnek ilyen olyan problémák.

Nézzük, hogy az egyes munkafázisokhoz milyen támogatást biztosít az operációs rendszer?

Probléma elemzése:

Sajnos az a helyzet, hogy pont ez az egyik legkényesebb dolog. Ha a problémát nem jól elemezzük, nem jól fogjuk meg, utána egy rosszul megtervezett program készülhet csak. Az operációs rendszerek sajnos ezen a területen adják a legkevesebb segítséget. Természetesen vannak különféle olyan, nevezhetjük fordítóprogramoknak, amelyek problémákat megértenek, problémákat leíró feladatokat megértenek és abból valamiféle algoritmust fel tudnak építeni.

Általában vannak olyan speciális programfejlesztési eszközök, a melyekkel bizonyos alapfeladatokra program generátorok léteznek. Tehát léteznek olyan eszközök, amelyeknek a segítségével bizonyos típusú feladatokra, viszonylag egyszerű eszközökkel, kész programot lehet generáltatni. Nem kell megírni magát a programot vala milyen programnyelven (pl. Pascal ban), hanem valamilyen egyéb eszközökkel le kell írni, hogy nézzenek ki az adatok, meg kell fogalmazni a feladatot, mit akarok csinálni. És ekkor egy alkalmas program tulajdonképpen készít belôle egy programot ez a programgenerátor.

Ilyen programgenerátorok beépítettek bizonyos rendszerekbe, nyelvekbe. Tehát valamilyen programozási nyelvhez kapcsolódnak. Korábban is léteztek bizonyos magasszintű programozási nyelveknél. Aztán egyre inkább elôjöttek, de leginkább valamilyen részfeladatban.

Példák: Képernyô képet kell készíteni egy programhoz. Ennek a megírása nehéz, fáradságos munka. Hova, mit írunk ki, milyen színnel stb. Ez elég könnyen algoritmizálható. Meg kell tervezni, meg kell rajzolni magát a képernyôt, mi hova kerüljön: állandó szövegek, változó részek mik legyen, vonalak hol legyenek, adatokat hol visszük be. S ha ezzel készen vagyunk, akkor van ehhez egy alkalmas program, ami ebbôl elkészítí azt a programot, ami nekünk kell ahhoz, hogy tudjunk vele dolgozni meg tudjuk jeleníteni ezt a képernyôt, be tudjunk adatokat olvasni vele stb. Ez az eszköz különféle programozási környezetekben meg van (pl. PC s adatbáziskezelôknél vagy a COBOL nál). Nagygépes operációs rendszerekben természetesen meg van. Annyi a különbség, hogy PC szoftverek esetén mindegyikben külön külön van, ahol ezt megoldották, és más más féleképpen. Nagygépes operációs rendszerekben pedig egy ilyen van, amit föl lehet használni az összes programozási nyelvben.

Más program generálási eszköz is létezik, pl COBOL. Ahhoz kapcsolódóan lehet generáltatni olyan programot, ami képernyôn keresztül be tud vinni indexelt állományba adatokat, onnan le tudja kérdezni, meg tudja jeleníteni stb. Egész nagy méretű programot lehet vele készíteni.

Természetesen voltak egyéni próbálkozások programgenerátor készítésére. Általában valamiféle speciális feladatsorra vagy feladat típusokra.

A feladat elemzése kapcsán lényeges az is, hogy valamiféle programtervezési módszereket is megemlítsünk. A legöbb ember úgy van vele, ha össze lehet hasonlítani a hardver és a szoftver készítést, akkor a szoftver készítés kézi munka, a hardver pedig valamilyen technológiával készül.

Ezzel szemben pedig a programok, amiket mi irogatunk, általában középkori, kôkorszaki módszerekkel készülnek. Mindenki újra és újra megszenved bizonyos algoritmusokkal, szervezési módszerekkel stb. Annyit nem árt azonban tudni ezen a szinten, vannak és léteznek programtervezési módszerek, amelyeket használva, valami féle közös nyelvet ki lehet alakítani. Nem minden feladatnál ter mészetesen, de bizonyos típusfeladatoknál igen. És ez nem egy meg vetendô szempont, hogy meg tudjuk érteni egymásnak a programjait. Itt nem egy kis öt hat soros programra kell gondolni, hanem egy több ezer soros programot kell megfejteni, hogyan is működik. Ha közös nyelvet, szervezési módszereket használunk, akkor ez lehet séges.

Erre vannak különféle próbálkozások Magyarországon. A két leginkább elterjedt programtervezési módszer:

Jackson féle programtervezési módszer

Warnier féle programtervezési módszer (Varnié) francia.

Vannak egyéb más módszerek is.

A feladat elemzése során természetesen vannak olyan lehetôségek, hogy bizonyos szoftverek már elkészültek arra, hogy a szervezésnél adjanak olyan segítséget, hogy a szervezésnél ne kelljen mindent kézzel megírni, hanme ábrákat tudjak készíteni, vagy blokk diagrammféléket tudjak rajzolni, vagy ezekkel a programtervezési módszerekkel kapcsolatban valamiféle ilyen tervezési módszert segítô programtervet készít (ábrakészítô programok). A lényeg az, amikor eljutunk a következô részhez, akkor írásos formában lenni kell egy olyan tervnek már, ami alapján el lehet kezdeni, hogyan bontjuk el modulokra és el lehet kezdeni a programnak a konkrét szervezését.

Részfeladatokra való bontás:

Szintén nem túl sok támogatást kapunk az operációs rendszertôl. Módszert sem sokat. Inkább tapasztalat vagy intuíció alapján tör ténik meg egy nagy feladatnak a felbontása. Van amikor adódik magától a feladatból, hogy mi legyen, különálló modul, vagy hagyományos adatfeldolgozás: létrehozzuk az adatokat, módosítjuk, töröljük, különbözô lekérdezések képernyôre, nyomtatóra stb. Sokszor még az sem természetes, hogy ezeket hogyan építik fel. Vannak különféle megoldások. Jó tanácsot mondok, olyan részekre kell felbontani amelyek önállóak. Van persze elmélete, nem megyünk bele, modulokra való bontásnál, milyenek legyenek azok a modulok. Nagyon lényeges feltétel, hogy a modulok közötti kapcsolatok milyenek. Egymással hogyan tudnak kommunikálni? Hogyan lehet adatot egyik helyrôl a másik helyre átadni stb.

A lényeg az, olyan részfeladatokatra célszerű felbontani, amelye ket át lehet látni viszonylag könnyedén. Se túl kicsik, se túl nagyok ne legyenek.

Programok írása:

Ehhez már komolyabb támogatást adnak a rendszerek. Lényeges kér dés az, hogy célszerű-e ha tudjuk, milyen egyéb más elkészült szoftverek vannak, amelyeket fel tudunk használni? Mindig úgy kell dolgoznunk, hogy újra lehetôleg ne írjunk programokat. Ha már egyszer valaki, valahol úgy értve, hogy ott, abban a környezetben elkészített valamit, akkor azt ne felejtsük el és ne dobjuk el, hanem megfelelô formában ôrizzük meg, és késôbb használjuk fel.

Tehát arról van szó, hogy a programok írásánál a már meglévô, kész programrészekre lehet keményen támaszkodni. Nagyon sokszor az fordul elô, hogy biztos hogy létezik az adott operációs rendszer környezetében olyan program vagy programrész, amit jól fel tudnánk használni, de nem tudunk róla és megírjuk újra. Nem biz tos, hogy rosszabbul, lehet, hogy jobban, de feleslegesen dolgozunk.

Vagyis nagyon lényeges, az ún. programkönyvtáraknak a szerepe. Ebben fogjuk és tudjuk tárolni a már kész programjainkat. Természetesen különbözô formában. Errôl mindjárt részletesebben beszélünk. Vagy eredeti formában, vagy lefordított formában. Természetesen van olyan, mely futtatható formában létezik. Ezeknek a programkönyvtáraknak a szerep azért nagyon fontos, mert egyrészt olyan programok vannak benne, melyeket a számítógépes rendszerrel megvásároltunk. Vagy folyamatos karbantartással szereztünk, hiszen egy programból újabb és újabb verziók vannak. Illetve, ahogy elkezdünk dolgozni egy adott számítógépes rendszerben, úgy készülnek az általunk megírt programrészek és prog ramok, amelyeket késôbb fel tudunk és fel is kell használnunk. Az a jó programozói szemlélet, ha megpróbálunk kész programrészeket egyszer s mindenkorra elkészíteni bizonyos funkcióknak a megoldására, s ezután a programunk megírása abból áll, hogy ezekbôl össze kell vadásznunk a különbözô részleteket és csak egy keret programot kell hozzá megírni. Pl. bizonyos deklarációkat, plusz kívánságokat.

Tehát a programkönyvtárakban benne vannak a számítógépes rendszer által megkapott kész programok, programrészek, illetve, amiket mi fejlesztünk hozzá, vagy valahonnan még vásároltunk.

A programok készülhetnek gépi kódban. Most is vannak, akik gépi kódban (assembler) programoznak. Általában azonban valamelyik magasszintű programozási nyelven készülnek. Ezekhez a különbözô magasszintű programozási nyelvekhez valamiféle közbensô tolmácsot kellett keresni a gép és az ember közé. A gép gépi kódú nyelven tud, az ember pedig Pascal ban stb. A tolmácsokat két különbözô kategóriába szokták besorolni:

a. Fordítóprogram: Olyan program, mely egy adott programozási nyelvet ismer, egy adott nyelven megírt programot amennyiben az hibátlan lefordítja gépi kódú nyelvre. Olyan nyelvre, a mit a számítógép hardvere már meg tud érteni, és megfelelô módon végre tudja hajtani.

Természetesen ez azt jelenti, hogy különbözô gépeken különbözô fordítóprogramok kellenek egy adott programozási nyelvhez. Lényeges szerepük van, olyan vonatkozásban is, mikor megírtuk a programot, megadja nekünk azokat az információkat, nelyek a lapján az elkövetett hibákat könnyen ki tudjuk deríteni. Legalábbis a jó fordítóprogramok úgy adják meg a hibajelzéseket, hogy ez megy.

Van olyan jellegű fordítóprogram, mely ezeket a hibákat meg próbálja kijavítani.

Késôbb még beszélünk a fordítóprogramokról, milyen más egyéb funkciókat lehet tôlük elvárni.

b. Interpreter (értelmezô program): Olyan program, mely egy adott nyelven megírt programot gyakorlatilag soronként vagy utasításonként képes értelmezni és megpróbálja végre is hajtani, ill. végrehajtatni a géppel. Természetesen ez azt jelenti, hogy az interpreter működéséhez a programon kívül a szükséges adatokat is biztosítani kell. A fordítóprogramnak csak az adott nyelven megírt programot kellett odaadni.

A fordítás során tehát különválik a fordítás és a végrehajtás, az interpreternél ez egyetlen folyamat.

Az interpreter egy lassúbb a végrehajtás szempontjából, hiszen ha ha egy ciklusra gondolunk, akkor a ciklusban szereplô utasításokat minden egyes alkalommal újra és újra értelmezni fogja az interpreter. A fordítóprogram az lefordítja és gépi kódú utasításokat fog végrehajtani.

Olyan extrém eset is elôfordulhat, ha interpreteres üzemmódban van egy olyan programunk, melyben vannak hibás utasítások. És az interpreter ezt nem veszi észre. Hogy lehet ez? Nagyon egy szerű módon, arra a programágra nem ment rá a vezérlés. Pl. egy IF THEN ELSE esetén. Az egyik ágra ráment a vezérlés, a másikra nem és ott egy szintaktikusan hibás utasítás. Működik a program interpreteres üzemmódban már két hete, adunk neki egy olyan adatot és egyszer csak puff, fejre áll, ezért.

Egy programozási nyelvben természetesen létezhet egy adott környezetben mind fordítóprogram, mind pedig interpreter. Korábbi idôszakban voltak olyan gondok, hogy ugyanaz a program másképp működik az interpreter és a fordítóprogram esetén. Ez az interpreter és fordítóprogram hibából adódott. Ha ugyanahhoz a nyelvhez létezik interpreter vagy fordító, nem biztos, hogy ugyanaz a hatása olyan szempontból, hogy ugyanazok az utasítások léteznek ugyanolyan formában, lehet hogy az egyik szűkebb a másik bôvebb. Az egyikben több minden van, új utasításokat vagy kiegészítéseket tartalmaz bizonyos szempontból.

A kettô között ez a lényeges különbség.

A programok írásakor nem mindig komplex programot írunk, hanem el képzelhetô, hogy egy programrészt készítünk. Ezért elég hamar létrejött egy olyan, hogy részenként lehessen elkészíteni programokat. Tehát megírunk pl. egy eljárást, modult és ezt külön lehessen lefordítani és elhelyezni valahova. Majd ezekbôl összeépítjük a programokat. Tehát felmerült az igény, hogy így külön külön lehessen lefordítani programrészeket. De arról is szó volt, hogy olyan programrészeket készítsünk, amelyeket fel akarunk használni egyéb más programokban is. Ezért az ún. szerkesztô program vált szükségessé. Ehhez általában még hozzá szoktak mostanában tenni a kapcsolat jelzôt: kapcsolat szerkesztô (linkage editor). Ne keverhessük össze a szövegszerkesztôkkel. Röviden csak linknek mondjuk. Ennek a szerkesztô programnak az lesz a feladat, hogy az ilyen önállóan elkészített programrészekbôl össze lehessen állítani egy komplett, nagy programot. Magyarul, szerkessze össze, kapcsolja össze ezeket az önállóan, valahol elhelyezett programrészeket, programmodulokat.

Sok minden feladata van még. Pl. PASCAL nál nagyon feltűnôen sok kész eljárás, függvény van beépítve a nyelvbe. Ezek önálló kis programrészek, melyek meg vannak valahol, programkönyvtárban stb. Majd a szerkesztôprogram tudja, hol találja meg ezeket a modulokat, hogy be tudja megfelelô módon szerkeszteni a programunkba. Tehát a másik lényeges feladata, hogy a korábban elkészített programrészeket is kapcsolja hozzá a programunkhoz, természetesen csak azokat, amelyekre hivatkozunk.

Volt olyan mikrogépes rendszerekben, hogy hozzá kapcsolták az öszszes létezô kis programrészt és így egy öt soros programhoz is ekkora nagy egyéb dolgot hozzákapcsolt. Természetesen ez eléggé primitív megoldás. Ma már nem nagyunk találunk ilyet. Mindig csak a szükséges programot, programrészeket kapcsolja hozzá.

Elôfordul olyan, hogy vannak kész program moduljaink, önállóan mindegyike szép és jó, le vannak fordítva (fordítóprogram nem talált bennük hibát), és a szerkesztôprogrammal össze szerkesszük, majd a szerkesztô program ilyen meg ilyen hibákat fog nekünk közölni. Mert pl. mi úgy tudjuk, hogy ez meg ez a modul létezik és mégsem létezik. Teljesen mindegy, hogy miért nem létezik. És azt mondja, hogy bizonyos modulokat nem talált meg. Egyéb más hibák is elôfordulhatnak a szerkesztésnél. Méret problémák. Túl nagy programot sikerül esetleg összeszerkesztenünk olyan helyen, ahol nem túl nagy memória áll a rendelkezésünkre. Ez is hiba lehet. Akkor, a címzéssel lehetnek hibák stb.

A másik program, aki kifejlesztésre került a programkönyvtárak, moduláris programozás kapcsán, az a betöltôprogram. Erre a következôk miatt volt szükség: ha egyetlen egy program futhat csak a gépen, akkor nincsen semmi probléma. Ez a program szabadon garázdálkodhat a gépen, annak memóriájában. Nyilván csak az operációs rendszerre kell vigyáznia.

Ha több felhasználói program van benna gépben, már más a helyzet. Ebben az esetben már osztozni kell a memórián. Meg kell mondani, a memóriának melyik része az egyiké és melyik része a másiké. Abban az esetben, ha a szerkesztés során eldôl, hogy hol van a helye a programnak a memóriában, akkor ez eléggé nehézkes a futtatás szempontjából. Lehet, hogy a memóriának épp az a része foglalt, ahol az én programom futhatna. Egy másik része pedig ott áll üresen a memóriának. Hogy ez ne okozzon nekem gondot, ehhez az kell, hogy a betöltés során dôljön el, hogy a program hova kerül. Tehát szerkesztéskor ne dôljön el, hogy mi a fix kezdôcíme programnak, hanem ez változtatható legyen. A változtatást az ún. betöltôprogram végezze el. A betöltôprogramnak lehessen mondani azt, általában nem is közvetlenül, hanem operációs rendszer intézi el, hogy keress szabad helyet. És a betöltés dolga, döntse el, az aktuális program, ami bekerül a memóriába végrehajtásra, hova kerül jön. És természetesen az ehhez szükséges esetleges átcímzéseket elvégzi. Ebben az esetben célszerű, ha a programok úgy vannak el készítve, hogy fix cím, állandó cím nem létezik bennük, hanem csak relatív cím. Mihez relatív cím? Általában egy kezdôcímhez képest. Fontos tehát, hogy a program szabadon áthelyezhetô legyen a memóriában.

Programkönyvtárak:

Lényeges az, hogy milyen formában tudjuk elhelyezni és megôrizni a programjainkat:

forrásnyelvű könyvtárak source library (a leglényegesebb)

A forrásnyelvű könyvtárak valamilyen nyelven megírt programot vagy programrészt, eljárást stb. tartalmaznak önálló egységenként. Általában szabadon keverhetô, hogy egy adott forrásnyelvű könyvtárban milyen típusú, milyen nyelven megírt programokat rakunk be, de lehetnek rendszerezetten elhelyezve.

Lényeges az is, hogy egy ilyen könyvtárat hányan használhatnak. Egy baráti kör, egy csoport kizárólagos joggal használhat egy könyvtárat multiprogramozott környezetben meg kell, hogy valósítsák a védelmet. Ezenkívül mindenkinek van egy része, amit csak ô használhat és vannak ilyen csoportszintű részek is.

Lehetnek olyan jellegű programok a forrásnyelvű könyvtárban, amelye ket úgy használunk fel, hogy bemásolásra kerül a forrásnyelvű programukba. Pl. van egy nagyobb rendszer, ami több önálló programból áll. Ezekben a programokban vannak deklarációk, amelyeknek minden programban meg kell lenni. Ezt minden programba be kell írni, Jó, hát tudunk másolni. Namost. Minden egyes program meg van forrásnyelven. Ha minden egyes programba ezt bemásoljuk, akkor ez annyi példányban lesz meg, ahány programunk van. Ennyi példányban elfoglal egy csomó helyet a lemezen. Holott, elég lenne csak egyszer. És fordításkor egyetlen utasítással jelezni fogjuk a fordítóprogramnak, mielôtt tovább menne, keresse már meg ezt a kis programrészt, és másolja már hozzá a programhoz. Tehát lemezen egyetlen egy példányban meg, és minden egyes programban a programrész helyett csak egyetlen egy sor van, egy hivatkozás. Ez a hivatkozás a programozási nyelvekben általában így kezdôdik, INCLUDE töltse be az ilyen és ilyen nevű programrészt. Ez a betöltés a fordítás idejére szól. A futásra kész program benne kell, hogy legyen, a forrásnyelvű programban nem kell benne lenni.

Ide jönnek különbözô elôfordítók is (preprocesszorok). Nem megyünk bele részletekbe. A különbözô programgenerátor lehetôségeket használni.

Az assembler nyelvű programozásban megjelennek ún. makrotechnikák. Nem megyünk bele részletekbe. Bizonyos keretek között programutasításokat tudunk generálni, generáltatni. A makro írása azt jelenti, hogy megírunk egy olyan programot, ami ha aktivizálunk, eredményeképpen kapunk assembler utasításokat. Más más képpen aktivizálva elôfordulhat az, hogy különbözô utasításokat fogunk kapni. Itt olyan sok para méterrel ellátott makróra kell gondolni. Ilyenek léteznek készen, ál talában az input/output, tehát az adatkezelésére makrotechnikát al kalmaznak a rendszerekben. Tehát mi tudjuk meghatározni, hogy aktuálisan most éppen milyen típusú adatokkal, milyen állományokkal, milyen hosszú rekordokkal stb. És ezeket megfelelô módon paraméterezve megkapjuk a kész programutasításokat. Léteznek magasszintű nyelven makro lehetôségek, de hát azok nem annyira elterjedtek.

Az elôfordításhoz tartozik egy kicsit az INCLUDE is, de egyéb más elôfordítások is léteznek. Általában mind azt jelenti, azoknak a segítségével bizonyos programutasításokat el lehet készíteni, amelyek a programunkba bemásolásra kerülnek.

Mégegy megjegyzés az INCLUDE hoz. Komolyabb operációs rendszereknél, mint pl. a VAX VMS operációs rendszere, ez a deklarációs példa: ha egy deklarációt megírunk egyszer egy példányban, vagy több deklarációt és ezt egyszer letároljuk és bemásoljuk. Ez akkor úgy működik, hogy ezt a deklarációt megírtunk pl. Turbo Pascal ban, Ha most ez a deklaráció kellene egy másik programhoz, akkor át kellene írni, mert másképp néz ki a deklaráció. Ezt egy VMS operációs rendszerben úgy oldották meg, hogy azt mondják, létezik egy Közös Adat Szótár (CDD). Ez egy olyan hely, ahol le lehet írni adatokat. Pl. rekordleírásokat. Egy adott nyelven, egy CDD nyelven. Ez gyakorlatilag olyan, mint bármilyen deklaráció.

Van egy nagy program rendszer, ebben dolgozunk öten és mindenki más nyelven dolgozik (Pascal, C, Cobol stb.) Egyszer leírjuk ezeket a deklarációkat, elhelyezzük a CDD-n, szintaktikusan leellenôrizzük. Majd megírok valamilyen nyelven egy programot, ami ezt a deklarációt használja. Ebbe viszont csak egyetlen egy sort fogunk írni, egy hivatkozást, és ekkor ez a bizonyos elôfordító ezt a definíciót átülteti az én nyelvemre. Ha egy másik nyelvben szeretenénk felhasználni ezt a deklarációt, annak megint van egy elôfordítója, ami tehát csinál egy adott nyelvű definíciót. Nagy elônye: bármilyen változás van, mivel egyetlen példányban van, egyetlen egy helyen kell javítani Ha jó, akkor az összes programban jó. A leggyakoribb program hibák ebbôl adódnak, mert a programba van beépítve az adatnak a definiciója. Biztosan változik valami. Mert holnapután kitalálják, hogy akkora az infláció, hogy nem elég a fizetésnek a nem tudom hány karakter, növeljék meg kettôvel. Minden programot átjavítani, rengeteg hiba lehet.

A forrásnyelvű könyvtáraknál forrásnyelvű utasításokat tudunk generálni, generáltatni.

Szövegszerkesztôk:

Rengeteg van. Mindenki esküszik valamelyikre. Amelyiket elôször meg tanulta, vagy megmutatták neki.

Programíráshoz ún. karakteres üzemmódú (ASCII kódot használó) szöveg szerkesztôknek kell lenni.

Levelezéshez, könyvekhez stb. igényesebb szövegszerkesztôk kellenek. Lényege, hogy tudunk különbözô betűtípusokat, betűméretet stb. használni.

Léteznek elég komoly (pl. matematikai cikkek megírásához használható) szövegszerkesztôk.

Egy szövegszerkesztôben rengeteg olyan lehetôség van, amit a normál földi halandók többsége nem fog használni (pl. definiálni makrókat).

A PC-s környezet megint úgy néz ki, hogy van kismillió fajta szöveg szerkesztô. Alaphelyzetben két típust különböztetünk meg:

önálló szövegszerkesztô

beépített szövegszerkesztô (minden PC s szoftvert úgy készítettek el, hogy legyen egy saját szerkesztôje pl. Pascal, DBase ennek az a szépséghibája, hogy másképp lehet ugyanazt a funkciót elvégezni az egyikben, mint a másikban a Turbo C és a Turbo Pascal esetén, csodák csodájára, nagyjából ugyanazt a szövegszerkesztést fogjuk csinálni).

Szövegszerkesztés funkcióiba, másolás, törlés, blokkok kijelölése, átmozgatni stb. nem foglalkozunk vele.

Beépített szerkesztôket programfejlesztés mellett használjuk, nagyon kényelmes, mert bemegyünk a szövegszerkesztôbe, megírtuk a programot, nem kell kilépni, futtatjuk a programot és automatikusan visszaadódik a vezérlés a szerkesztônek. Önálló szövegszerkesztô esetén ez egy kicsit nehézkes.

VAX VMS operációs rendszerben alaphelyzetben van két szövegszerkesz tô. Az egyik egy normál editor, amivel lehet mindenféle szöveget, programot szerkeszteni. A másiknak van egy jelzôje (LS Language Sensitive). Ez azt jelenti, hogy nyelv érzékeny. Tehát beépítí a szövegszerkesztôbe egy vagy több programozási nyelvnek a szintaxisát (definíciókat, deklarációkat, utasításokat stb.) És ezt a segít séget megadja nekünk a szövegszerkesztô. Tehát, ha írok egy programot valamilyen nyelven, akkor felajánlja a segítségét. Mit akarok írni: programot vagy modult? (Pl. Pascal esetén) Természetesen ilyenkor ezen szerkesztôbôl az adott fordítóprogramot meg lehet hívni.

Nyilván, ha egy közös adat szótárban akarok valamit elhelyezni, akkor azt is ismerni fogja. Fontos tudni, hogy fôleg a kiadványszerkesztôk más más módon tárolják a karaktereket. Fôleg a magyar karakterek okozzák, nem pedig az angol karakterek. Ez fôleg adatátvitelnél jelent problémát, ahol 7 bitet visznek át. A 127 feletti kódok nem mennek át. Nyilván induláskor át kell kódolni az üzenete, majd visszakódolni.

Tárgynyelvű könyvtárak:

Szokás nevezni Object Modulnak, ill. Object Modul Library nek. Nagyon sok fordító program úgy dolgozik, hogy a lefordított programok kiterjesztése .OBJ lesz (tárgymodul rövidítése). PC s rendszerben találkozunk vele, a VAX rendszerében egyértelműen van. A tárgynyelvű könyvtárakban általában modulok, másnéven szubrutinok (eljárások) helyezkednek. Általában megôrizni tárgynyelvű könyvtárakban csak azokat a lefordított programrészeket célszerű, amelyeket fölhasználunk késôbb, más programoknak az elôállításánál. Normál esetben, ha van egy programom, amelyet futtatható állapotban akarunk megôrizni és használni, a közbeesô változatot nem célszerű sokáig ôrizgetni, csak azért, hogy meglegyen. A fordítóprogramok általában elég gyorsan működnek. Ha szükség van, az object rôl akkor nagy valószínűséggel úgyis azért van rá szükség, mert belenyúltunk a library programba.

Normál módon a tárgynyelvű könyvtárakban nem minden programot ôrzünk meg, hanem csak azokat, amelyekre késôbb szükségünk lesz. Itt is természetesen meg vannak azok a dolgok, hogy egy jô részükben azok a programrészek vannak benne, amelyeket szállítottak a rendszerrel együtt. Ezek kapcsolódnak egy egy programozási nyelvhez, egy Pascalhoz stb. Különféle megoldások vannak, lehet olyannal találkozni, ahol egy nagy könyvtárban vannak benne az összes ilyen jellegű dolgok. Más megoldásoknál ezek önálló környezetben vannak (pl. Pascal fejlesztô környezetben csak a Pascalhoz tartozó dolgok vannak benne). Nincsen semmi közösködés.

Ez megint csak ott érdekes, ahol van valami közös (pl. VAX VMS). Itt közös részekkel dolgoznak az egyes programozási nyelvekkel. Természetesen itt is lehet olyan, amirôl már beszéltem, tehát lehet nek mindenki által használt részek, lehet saját, vagy olyan amit bôvíteni lehet.

Alaphelyzetben nem kerül be minden a tárgynyelvű könyvtárba, hanem valahova ideiglenesen kerül be. Nyilván ezeket az object kiterjesztésű állományokat ki kell pucolni, ha ez nem automatikusan történik. Többnyire automatikusan nem történik meg. Márpedig túlságosan sok helyet foglalnak el egy idô után.

Korábban elhangzott, tárgynyelvű könyvtárakkal a szerkesztô program foglalkozik és a fordítóprogram. A fordítóprogramok működésének eredményeképpen kerülhetnek be a tárgynyelvű könyvtárba eljárások, szubrutinok. És a szerkesztô program a megadott library könyvtárakban fog keresgélni, hol fogja megtalálni azokat a programrészeket, modulokat, amelyeket bele fog rakni egy programba.

Bináris könyvtár:

A program harmadik állapota: a futtatható állapot. Nevezhetjük futtatható programokat tartalmazó könyvtárnak. Angol szavával: core image library. Olyan állapotban van a program, ami megfelel a gépen belül tárolt képének állapotának. Ahogyan a gépen belül a memóriában tárolva van, ugyanúgy van tárolva itt ebben a könyvtárban. Csak itt nyilvánvalóan ideiglenesen, még mielôtt a gép memóriájába bekerülve végrehajtásra nem kerül (ne kelljen mindig újra szerkeszteni, fordí tani stb).

Nem kötelezô ilyen formában megôrizni a programokat, de mindig plusz idô mindig újra lefordítani stb, és újraindítani. Célszerű, ha gyakran van egy program futtatására szükség.

A bináris könyvtárban tehát végrehajtható programok vannak. Ezen programok, programrészek a betöltô program segítségével kerülnek be a gépnek a memóriájába sok esetben. Van ahol nincs erre szükség, pl. mono üzemmódban, egy program esetén, mindig ugyanoda kerül be. Nincs mit betöltôprogramozni, de multiprogramozott környezetben természetesen kell.

A végrehajtható programokkal kapcsolatban egy két jelzôt kell megem lítani. Egyik az, hogy nem szükségképpen van benn mindig a teljes, komplett program a memóriában, hanem lehet az, hogy bizonyos részei nincsenek benn, hanem kint vannak mágneslemezen. És amikor szükség van rá, akkor betöltésre kerülnek.

De természetesen a végrehajtáshoz mindig szükség van egy ún. rezidens részre és ezzel ellentétben van egy tranziens része a programnak, ami kikerülhet. A tranziens része a programnak mindig az a része, amely nek állandóan benn kell lenni a memóriában, nem kerülhet ki, nem változtathatom meg úgy, hogy kikerüljön a háttértárra. A tranziens rész be pedig azok a programrészek kerülnek, melyek ideiglenesen kikerülnek a mágneslemezre, és amikor szükség van rájuk, betöltésre kerülnek.

Lényeges, hogy áthelyezhetô-e egy program? Ami azt jelenti, hogy át lehet-e rakni egyik memória területrôl egy másikra tetszôleges módon. Tehát bárhol futtatható a memóriában. Ez megint csak multiprogramozott környezetben érdekes.

Kódmegosztás:

Lényeges lehet az, hogy egy program több példányban futhat-e? Több példányban fut úgy, hogy nyilván mindegyik külön külön használ egy memóriarészt, de ez nem különösebben izgalmas. Hanem ha egy programnak a végrehajtása úgy történik meg, hogy csak egy példányban van benn a memóriában, de többen elkezdtek vele dolgozni. Ugyanazt a modult, ugyanazt a programrészt többször hajtjuk végre és a különbözô végrehajtások különbözô helyeken tartanak. Ugyanazt a modult több feladatnál is felhasználjuk, ilyet megenged-e a rendszer? Nyilvánvalóan ezek elsôsorban nem felhasználói szintű modulok, hanem rendszer modulok. Ezt úgy szokták nevezni, hogy kódmegosztás. Ez tehát azt jelenti, hogy egy példányban van benn a memóriában egy modul, de több feladat is használja.

Ennek a modulnak olyannak kell lenni, amelyik önmagát nem módosíthat ja. Régebben gépi kódú programozás esetén szükség volt (fôleg memóriahiány vagy gyorsaság miatt) olyan programokra, mely menet közben önmagát módosította. Volt benne olyan utasítás mely a program bizonyos részét átírta más utasításra, majd ráadta a vezérlést.

Speciális könyvtári funkciók:

Minden könyvtár típusra vonatkozik. Az ilyenek tartoznak ide:

könyvtárak létrehozása: meg kell adni a nevet, ha a rendszer olyan, akkor a maximális méretet (lemezkapacitásból hány sáv vagy rekord lehet benne, vagy valami ehhez hasonló) meddig kell ôrizni stb.

könyvtárak másolása : egyik könyvtárból másolunk programokat a másik könyvtárba mi van akkor, ha olyan nevű modul már van ott, a hova másolni szeretnénk, mi legyen?

különbözô törlési funkciók : általában csak könyvtár elemekre vonatkozik, könyvtár törlése többnyire csak úgy lehetséges, ha elôtte kitakarítjuk a könyvtárat

könyvtári elem beírása

átnevezések.

Könyvtárak esetén nagyon sokszor van önálló könyvtárkezelôi program vagy programok, és ezeknek ezek speciális utasításai.

tömörítés nagyon sok operációs rendszer úgy dolgozik, hogy a könyvtáraknak van egy maximált helye általában mindenféle módosítási dolog úgy zajlik le, hogy a régi megôrzôdik név nélkül, de helyileg és fizikailag megôrzôdik lefoglalódik az a hely, ahol egy programnak a régi állapota van a VMS olyan, hogy az állomány azonosítására van egy verziószám, ezzel jelzi a rendszer, hogy hanyadik verziónál tartunk meg van fizikailag mindegyik ha ez forrásnyelvű állomány volt, lefordítás, szerkesztés után mindegyik állomány meg van verziószámmal egy idô után közelúti a telített séget a könyvtár amúgy nem lenne tele, de fizikailag tele van ezzel a sok módosítással bizonyos dolgokat kitöröltünk, de a törlés mindig csak logikai törlést jelent, fizikait nem tehát megmarad minden ez a szituáció még jól is jöhet, mert vissza lehet állítani valamelyik korábbi változatot tehát bizonyos esetekben elfogyhat a hely, logikailag lenne még, de fizikailag már nincsen ebben az esetben kell végrehajtani egy ilyen tömörítési funkciót, ami azt jelenti, hogy azokat a területeket, amelyeket korábban le foglalt, de valamilyen oknál fogva már nincs rá szükség, tehát fizikailag ott van, de logikailag már nincs rá szükség, akkor ezeket szépen .... magyarul az lesz, hogy a tömörítés a felületet úgy fogja átalakítani, hogy az elejére rakja a meglévô programokat és utána lesz a szabad hely tehát fizikailag átrendezi a lemezterületet olyan gépen, ahol nem 100% os biztonságú a hardver, mi történik, ha egy ilyen tömörítés közben szállt el, akkor, ha egy ilyen könytárról nem volt mentés, akkor az a könyvtár ebbe belehalt bizonyos rendszerekben ez még ma is létezô dolog, létezô probléma.

PC-s rendszerben ezek a könyvtár kezelô funkciók így önállóan nem jelentkeznek, csak egy kettô: létrehozás, törlés stb.

Program belövése:

Egy programból egy kvázi jó programot akarunk csinálni, tehát most már lehet használni.

A programot megtervezzük, megírjuk, eljutunk oda, hogy szintaktikusan jó, elkezdjük próbálgatni, futtatjuk és csinál mindenféle hülyeséget. Nagyon durva hibákat meg tudjuk találni (pl. nullával való osztás). De ha már nem azt az eredményt adja, amit várunk, meg kellene fejteni, hogy mit dolgozik a programunk. Nyomon kellene követni a program működését és ehhez van-e támogatás az operációs rend szerben, ez lényeges kérdés. Milyen támogatást ad a különbözô hibák nak a kiderítésére a program működése során. Nem arról van szó, hogy hibásan írtam be egy utasítást, mert azt kijavítom. Hanem az, hogy dolgozik dolgozik, csak éppen nem tudom, hogy merre jár és mit csi nál.

Milyen támogatások vannak a program belövése során? Amit meg kell nézünk, az a nyomkövetés. Angol szavai: TRACE, DEBUG. A lényeg az, hogy valamiféle információt kérünk és várunk a rendszertôl, hogy a mivel kicsit könnyebben tudjuk eldönteni azt, hogy a programun milyen sorrendben hajtotta végre az utasításokat, hányszor hajtott végre egy ciklust, eljárások hívása hogyan történt, hogy jött vissza, vagy nem jött vissza. Tehát, mi történt a végrehajtás során? Gyakorlatilag azt jelenti a nyomkövetés, ahhoz, hogy ezek az információk eljussanak hozzánk, ehhez bizonyos speciális utasításokat be kell építeni a programba, azon túl, amiket mi írtunk bele. Ilyeneket én is beépíthetek, mint normál felhasználói programozó, pl. változók tartalmának kiírása, vagy a végén: 'Hurrá vége!' Nem lett volna rá szükség, csak hogy meg lehessen nézni, hogy jött ki ez a részeredmény.

Egyéb más dolgokat is be lehet így építeni. Erre vonatkozóan bizonyos rendszerek adnak is olyan lehetôséget, hogy ezek az utasítások vagy benne legyenek végrehajtás szempontjából, vagy ne legyenek benne. Pl. ismert a megjegyzés, comment fogalma. Többféle programozási nyelvben van. Lehet olyat csinálni, hogy a megjegyzés elejét és végét valahova rakom, valahanyadik pozícióra, attól, függôen, hány karakteres a megjegyzés (van ahol egy karakter, Pascalban két karakter). És akkor azt mondjuk, hogy ez elé nem írunk utasításokat. Csak a megjegyzésnek a karakterét. És a fordító programnak meg lehet mondani, honnantól tekintse a szöveget. Pl.

< ezt a részt tekintse >

< avagy, ezt a részt tekintse a fordítóprogram >

A kipontozott rész programrész lesz, vagy megjegyzés rész.

Egyébként ezeket a részeket fizkailag ki kell szednem, ki kell radíroznom.

Korábbi idôkben a nyomkövetés egy elég nehéz dolog volt. Gyakorlatilag csak olyan lehetôség állt rendelkezésre, hogy valahol leállítot tuk a programot és megnéztük az állapotát. Milyen állapotát lehet megnézni? Az, ami az operatívtárban van. Ilyeneket lehetett kiíratni (elfogadható forma itt a hexadecimális kiírás): programot, ekkor tudni kell az illetô gépi kódot, részeredmények hol vannak.

Vannak olyan lehetôségek, hogy a hardver szolgál valamiféle segédinformációval a nyomkövetéshez, de általában ehhez túl sok közünk nincs. Minket elsôsorban a szoftveres nyomkövetés érdekel.

Szoftveres nyomkövetés:

Különbözôképp működik interpreteres és fordító üzemmód esetén. Interpreteresetén be lehet kapcsolni a nyomkövetés elindítását, menet közben le lehet állítani, különbözô információkat lehet tôle kérni. Legtöbbsször azt, hogy bizonyos változók tartalmát írja ki, vagy valamelyik eljárás címét írja ki.

Fordítóprogramoknál valamilyen módon be kell építeni a programba menet közben, fordítás során a nyomkövetési utasításokat. Ezek természetesen valamilyen módon kapcsolódnak az adott programozási nyelvhez. Vagy úgy, hogy most ezen a ponton, innentôl kezdve írja ki ennek meg ennek a változónak a tartalmát, ha azoknak a változóknak a tartalma megváltozik. Vagy írja ki (ez nehezen követhetô), milyen sorrendben hajtotta végre az eljárásokat, függvényeket, milyen volt a hívási struktúrája, hívási fája a végrehajtás során. Hányszor ment végig egy ciklusan, hányszor hajtott végre egy bizonyos utasítást. Menet közben lehet ezeket vizsgáli, nézni. Ezek a dolgok adott rendszertôl függô dolgok, általában operációs rendszertôl. Kérdés az, hogy milyen jellegű nyomkövetési lehetôségek vannak alaphelyzetben?

Vannak még olyan lehetôségek, hogy lépésenkénti végrehajtás, de hát bizonyos szituációkban nem tudjuk kivárni, amíg végigmegyünk nem tudom hány ezer utasításon.

Amikor programjainkat összeillesztjük egy nagy rendszerré, ezzel szoktak lenni gondjaink. Az önállóan elkészített programrészeket, modulokat valamilyen módon kipróbáljuk. Mindegyik működik, oké. îrunk rá egy keretprogramot, amivel aktivizáljuk ôket részenként, megy a dolog. Majd az egészet összerakjuk és kiderül, hogy mégis másféle képpen beszélnek egymással az egyes eljárások. Az egyik küld egy egész számot, a másik pedig vár egy valós számot. Vagy nem megfelelô olyan szempontból a dolog, hogy bizonyos programrészek egyik a másikba bele tud nyúlni, valamilyen módon (pl. globális változókat hasz nálnak és akkor azzal stb). Nem megyünk bele részletekbe, de amikor összerakunk egy részenként kipróbált egy nagy programot, akkor abból lehet zűr és nagy zűr. Eleve elég kényes kipróbálni és átadni egy programot úgy, hogy szerintünk jól működik. Ez egy komoly nagy terület, mely azzal foglalkozik, hogy program helyesség és bizonyítás. Jól letesztelni, ez is nagyon lényeges kérdés. Oda kell ültetni valakit. Merjen hozzányúlni a géphez, biztos, hogy ki fogja hozni a legkomolyabb és leglényegesebb hibákat. Úgy szoktuk mondani, hogy bolondbiztos programokat kell írni. Ne lehessen csak úgy, hogy rákönyököl a billentyűre és máris meghal, ez nem program a mai világban.

Konkrét operációs rendszerek:

Az operációs rendszerek szintjén is vannak rendszerváltások. Nyilván mindig kitalálnak új dolgokat, könnyebbé akarják tenni ezeket a rend szereket.

Az elején ezek az operációs rendszerek kevés funkcióval voltak ellátva, lassan működtek, nem sok mindenre terjedtek ki. Sok mindent fel használói programban kellett megoldani.

Az egyik elsô operációs rendszer talán az IBM nagygépekre készült operációs rendszerek. IBM gépek mintájára készültek az ESZR típusú gépek, ezért hosszú ideig Magyarországon is az uralkodó operációs rendszer fajta volt.

Használatos rövidítések:

OS = operating system

D = disk

Az esetek döntô többségében az operációs rendszereknek egy jó része lemezen van és onnan kerül betöltésre. Nagygépes rendszereknél minimális az, ami be van építve, csak ilyen mikroprogramok. Onnantól kezdve az indulás, bekapcsolás, minden lemezrôl került betöltésre, és úgy dolgozott.

DOS disk operating system

DOS/VS Virtual Storage (virtuális tárkezelés)

DL/I Database Language (egy)

Az utóbbi években olyan géptípustól független adatbázis kezelô rendszereket fejlesztettek ki, amelynek az a csábító ereje, hogy elkészítik minden géptípusra tehát minden géptípuson fut. Nyilván, a megfelelô szinten ugyanúgy kell leírni a dolgokat és csak a megfelelô csatlakozás kell hozzá.

OS rendszerek:

PCP

MFT multi fix task

> OS/VS1

MVT multi variable task

> SVS single virtual disk

> MVS multiple virtual disk

PC-k világa:

MS DOS vagy PC DOS operációs rendszer Egyfelhasználós, interaktív, monoprogramozás jellemzi ôket.

XENIX (a UNIX PC s változata)

Többfelhasználós, multiprogramozott.

OS/2

Multiprogramozott, egyfelhasználós rendszer.

Számítógépek indítása:

A gép bekapcsoláskor automatikusan megpróbál elindítani valamilyen indító rendszert. Az, hogy hol akarja elindítani, gép típusától, fejlettségétôl függ. Valamelyik automatikusan arról az egységrôl indít, amelyik aktív állapotban van és van egy meghatározott sorrend, milyen sorrendben próbálja ezeket megnézni.

Vagy pedig mindig ugyanarról indítja, hiába aktív más periféria. Kérdés még, hogy ezt meg lehet változtatni.

Joker karakterek:

akárhány és akármilyen karakter állhat ezen a helyen

Alkönyvtárrendszer kezelése:

egy alkönyvtárba csak egy úton tudunk eljutni (nincs más lehetôség) ha egy másik ágra akarunk eljutni, akkor elôbb vissza kell másznunk

Jelölések alkönyvtárhasználattal kapcsolatosan:

\ fôkönyvtár jele

. saját magára mutató cím (vagy mutató)

.. az elôzôre mutató cím

Állományok listázása:

TYPE név.kit | more

A filter hatására egy képernyôoldal után megáll a kiírás.

Állományok másolása:

COPY input output

CONFIG.SYS:

BATCH fájlok utasításai:

Operációs rendszerek fajtái

Egyfelhasználós operációs rendszer:

Gyakorlatilag minden erôforrást szabadon használhat egyetlen felhasználó, nem kell osztozni senkimással, csak az operációs rendszerrel.

Pl. Memória felosztása nagy vonalakban úgy néz ki, hogy van egy operációs rendszer rész (szokták nevezni monitor résznek), plusz a felhasználói terület.

Operációs rendszeri részre a felhasználó nem irogathat, esetleg egy két információt onnan kiolvashat és van egy maradék terület, amit ô szabadon használhat.

Lényeges dolog a perifériák használatánál az, hogy olyan jellegű programokat tudjunk írni, amelyekben nem kell beépíteni a perifériát vagy perifériákat (melyiket akarjuk használni), nevezzük ezt perifériafüggetlenség elvének. A programban csak egy logikai elnevezést használunk és hogy fizikailag melyik berendezét kívánjuk használni, ezt kívűlrôl lehessen megváltoztatni. Hogy ez milyen formában (program kéri be vagy van olyan parancsnyelv, amin keresztül ez) érvényesül, ez természetesen más-más képpen néz ki egyes operációs rendszerekben.

Multiprogramozott rendszerek:

Alapelve onnan indult ki, hogy egy programnak a végrehajtása során elég gyakran szükség van arra, hogy az a program valamire várjon és ekkor ennek a programnak a működése abba marad, felfüggesztésre ke rül. Az, hogy mire vár a program, különbözô okra vezethetô vissza. A leggyakoribb, ami hosszabb idejű várakozásra készteti a programot az adatoknak a beolvasása és kiírása, tehát az I/O műveletek. Amíg ez az I/O művelet végre nem hajtódik, addig a következô utasítást nem lehet végrehajtani.

Az, hogy ebben a felfüggesztett állapotban a processzor mivel foglalkozik, az már sok mindentôl függ. Elsôsorban függ a hardver állapotától. A hardvernek olyannak kell lenni, hogy meg lehessen valósítani azt, hogy amikor egy program felfüggesztésre kerül, ekkor a program ne igényelje ezalatt a központi egységet, hanem a processzor szabadon tudjon más dologgal foglalkozni. Tehát pl. az I/O a központi egységtôl függetlenül menjen végbe. Ez általában úgy megy végbe, hogy erre külön részei vannak a számítógépes rendszernek, amelyek ezt a I/O-t levezénylik. Tehát a központi résznek csak a feladat, hogy elindítja a folyamatot és onnantól kezdve átveszik az irányítást. Attól függôen, milyen rendszerben vagyunk, szokták nevezni csatornáknak, ilyen olyan vezérlô egységeknek stb. Valamikor vissza fog jelezni ez az egész rendszer a központi egységnek, hogy befejezte az I/O műveletet.

Természetesen ez csak akkor érvényesül, ha van is ilyen várakozó munka, ami dolgozni akar. Valamilyen stratégiákkal választódik ki, hogy a sorbanálló munkák közül melyik kerül kiválasztásra. Egy ütemezô végzi ezt a kiválasztást.

Multiprogramozás két fogalma:

multitasking: egy feladatot több részre fel tudunk bontani és az operációs rendszerben (számítógépes rendszerben) egy önálló résznek tekinthetô, ami önállóan kezelhetô és ezt elnevezzük tasknak a mikor arról van szó, hogy van egy nagyobb feladat, amelynek vannak elkülöníthetô részei végrehajtás szempontjából, és ezek a részek olyanok, hogy vannak köztük egymással párhuzamosan futtatható folyamatok és ezt megtudjuk valósítani a rendszerben, ekkor beszélünk multitaskingról a rendszer magától nem tudja kitalálni, melyek azok a programrészek, amelyeket én egymással párhuzamosan futtathatok ezt nekem, mint programozónak kell eldöntenem és megterveznem magának a nyelvnek is olyannak kell lenni, hogy ezt a le hetôséget biztosítsa a számomra, tehát legyen olyan eszköz benne, amivel ilyen taszkokat tudunk tervezni, elindítani, befejeztetni stb. ennek megszervezésére nem minden programozási nyelv alkal mas (pl. Pascalban sincs, de nagygépes PL/I ben van vagy az ADA ban is).

multiuser: ebben az esetben ténylegesen több felhasználó, több különálló program fog egymás mellett párhuzamosan működni, különbözô alkalmazásokhoz tartozó programok futnak egymás mellett ennek a megtervezése, megszervezése már az operációs rendszer feladata.

Az, hogy az operációs rendszer melyiket támogatja, operációs rendszer függô. Legtöbb megengedi mind a kettôt.

Multiprogramozott környezetben sok probléma merül fel. Ezen megyünk sorba.

Memória használata multiprogramozott rendszerben:

Alapkövetelmény, hogy a programoknak olyanoknak kell lenni, hogy át lehessen rakni a memóriába bárhova áthelyezhetô programokkal tudunk dolgozni.

Swapping:

Korai idôszakban voltak olyan próbálkozások (fôleg akkor, amikor még nem volt túl nagy memóriája a számítógépeknek), az ún. csere-bere akciója. A memóriában mindig csak egy felhasználói programot tudtak elhelyezni és multiprogramozott rendszer itt csak úgy képzelhetô el, hogy mindig az aktuálisan futó program kerül be a memóriába, de ahhoz, hogy késôbb folytatni lehessen azt a programot, amit megszakí tottunk, a program teljes állapotát ki kellett menteni lemezre.

Partíciókra való bontás:

A memória úgy lett kiosztva, hogy egy része hozzá lett rendelve az operációs rendszerhez és különbözô partíciók lettek definiálva a me mória maradék részén. Ezen partíciók mindegyike önálló olyan szempontból, hogy mindegyik részben egy egy program futtatható. Ilyen esetben a partíciók mérete szabadon változtatható bizonyos keretek között. Partíció méretet csak úgy szabad megváltoztatni, hogy ebbôl ne legyen baj. Ha az egyik partíciót megnövelném a másik rovására, akkor a másik partícióban futó program meghalna. Tehát csak akkor lehet partíció felosztást változtatni, ha mindegyik partíció üres.

Minden egyes partícióhoz prioritás van rendelve, egy erôsségi sorrend, ami azt jelenti, amikor a programoknak a végrehajtása zajlik, és elérkezünk egy olyan pillanathoz, amikor van egy megszakítás, és keres az ütemezô egy programot, amit végre akar hajtani (ill. folytatni akar legtöbb esetben), akkor a kiválasztás az ún. prioritás alapján történik ebben az esetben. Amelyik partíció a legerôsebb, az ebben lévô program ha dolgozni akar, ô kapja meg a vezérlést. A második partícióban lévô program csak akkor kapja meg a vezérlést, ha az elsô partícióban lévô programon van a megszakítás, vagy ugyan máshol van, de az elsô partícióban lévô program még mindig nem akar dolgozni. El lehet képzelni, hogy egy ilyen rendszerben a legutolsó prioritásúra (a sor végén álló programra) mikor adódik a vezérlés. Az viszont, hogy az egyes partíciókba milyen programot rakunk, ez már a mi feladatunk.

Vannak (prioritásos) elvek:

legerôsebb helyre olyan programokat kell besorolni, amelyek végre hajtása során sok a megszakítás (jó sok I/O t végez) csak ekkor van remény, hogy a hátrébb lévô programok is kapnak processzoridôt

hátrébb azokat a programokat kell sorolni, amelyek kevés I/O-t igényelnek és sok processzoridôt.

Amikor valamelyik partícióban lévô program befejezte a munkát, helyére újabb programot lehet betölteni.

Lapkezelés:

A memória lapokra van felosztva, és egy programnak a helyfoglalása úgy zajlik le, hogy valahány lapot rendelek hozzá. Nem szükségképpen a teljes program van benn a memóriában, hanem csak valamelyik része. Az, hogy a programnak benn legyen az a része ami végrehajtás alatt áll, ez természetesen az operációs rendszer feladata ha nincsen benn a soron következô utasítás, amit végre kell hajtani. Megkeresi lemezen a szükséges részt és betölti, ha nincs hely csinál neki helyet, tehát bizonyos részeket kiment lemezre stb. Ez elég komoly nyilvántartást igényel az operációs rendszer részérôl, melyik programnak melyik része hol helyezkedik el. Nem túl nagy méretűek ezek a lapok (2 4 K). De ezzel a programozónak nincsen gondja. A programozónak csak azt kell közölni a rendszerrel, mennyi az a memória, amit ez a program igényel.

Szegmentálás:

Több lapot összefüggônek tekintve törekszik arra az operációs rendszer, hogy mégis összefüggô részterületekbôl épüljön fel a program.

Overlay:

A memória kezelésénél szóba kerül az, amikor egy partícióba nem fér be a program, az ún. overlay technika. Az adott programot föl kell szabdalnunk és nekünk kell gondoskodni róla, hogy az adott program aktuális része bekerüljön a memóriába. Nyilván van egy rezidens része a programnak, ami állandóan benn van és vannak változó részek. Ezek betöltése, esetleges kimentése programozó feladata. Ez megint csak operációs rendszer és programozási nyelv függô, van-e ilyen utasítás (pl. Turbo Pascalban van).

Perifériák használata:

Részben már volt szó: különbözô perifériákat lehet-e együtt használni. Vagy pl. a nyomtatót nem igen tudjuk ketten együtt használni. Csak a lemez típusú berendezések azok, amit többen is használhatunk egyidôben.

Multiprogramozott rendszerekben felmerült egészen korán egy olyan jellegű probléma, hogy a programnak a végrehajtási ideje döntô mértékben, a kezdet kezdetén attól függött, hogy mennyi output perifériát használ. A nyomtatók sebessége jóval lassúbb, mint egyéb más perifériák sebessége. Elég hamar felmerült az a gondolat, hogy a program végrehajtási idejét lehetôleg a legrövidebbre próbáljuk leszorítani azzal, hogy a program végrehajtása közben perifériák közül csak a leggyorsabb perifériákkal dolgozzon csak. Tehát lassú perifériával ne dolgozzon. Tehát a program csak lemezekkel működjön. Ez azt jelenti, ha egy program eredendôen lassú peridériát használna, akkor ha ezek egy lassú periférián lévô bemenô adatok, akkor ezeket elôzôleg, a végrehajtás elôtt át kell másolni gyors perifériára, tehát lemezre. A másik irány pedig, amikor a program elkészítí az eredményeket, ekkor a program lemezre viszi a nyomtatandó adatokat. Ekkor természetesen a program befejezése után jön még egy fázis, amikor az elkészült eredményeket, amik ideiglenesen lemezen vannak tárolva, ki kell nyomtatni. Tehát van egy elômunka és van egy utómunka és közte van a program futtatása. Ezt angol szóval spooling technikának nevezték el. Ez egy rövidítés. Ennek lényege tehát, a lassú perifériának a kiküszöbölése a program végrehajtása idején. Ezzel fel tudták gyorsítani a számítógépek működését, azért, mert ezek a műveletek mind ilyen hulladékidôkben, töredékidôkben elvégez hetôk.

Ez egy elég régen kialakult és ma is használt technika, gyakorlatilag minden olyan operációs rendszer, amiben multiprogramozási üzemmód van, a lassú perifériákat közvetlenül nem igen tudja használni. Multiprogramozott rendszerben nem lenne túl célszerű valamelyik programnak odaadni a nyomtatót. A már ismertetett dolgot célszerű csinálni, és nyomtató sorokat (queue) csinálunk.

Perifériák használatánál olyan jellegű hozzárendeléseket tudunk elvégezni multiprogramozott környezetben, hogy vannak olyan perifériák, berendezések, amelyek kizárólagos joggal egy programhoz vannak hozzá rendelve, és csak az program tud vele dolgozni. Lemezekkel is meg lehet ezt csinálni, de lehet akár nyomtató is.

Multiprogramozott környezetben meg kell lenni annak a lehetôségnek, hogy ugyanazt az állományt többen használjuk egyidôben, nem csak a lemezegységet. Ilyenek pl. a programkönyvtárak általános célú programokkal. Persze elsôsorban olvasásra, de lehet, hogy írhatunk is bele. Ez egy nagyon kemény dolog, de meg kell oldani, hogy egyidôben ugyanazzal az állománnyal többen is dolgozzanak.

Központi egység:

Szerepe nagyon fontos a multiprogramozott környezetekben. Használata döntô, mennyire tudjuk kihasználni.

Itt jön egy olyan kérdés, hogy ütemezés, ütemezni kell a központi egységnek a munkáját. Amikor egy folyamatról beszélünk, az több állapotban lehet: új (most érkezett), aktív (dolgozik), várakozó (valami miatt épp most nem dolgozik), holtpont (különleges helyzet, amit el kell kerülni), befejezett (befejezôdik a folyamat. És az ütemezés ezeknek a folyamatoknak a végrehajtására vonatkozik. Egy folyamat úgy kezdôdik, hogy egy program sorozat bekerül a rendszerbe. Bekerül egy ún. várakozási sorba. Különbözô sorok léteznek a rendszerben, egy végrehajtásra váró sorba kerül. Különbözô jellemzôk alapján változhat, hogy ki hol áll a sorban. Valamilyen prioritás a lapján egy munka elôrébb kerülhet a sorban. Pl. ebben a rendszerben van egy ilyen elv. De lehet az is, hogy tiszta érkezési sorrend számít. Lehet az is, hogy bekerül a sorba, de valami még hiányzik, ilyenkor visszatartjuk. Lehet olyan, hogy egy megadott idôpontban induljon el, mert akkor kap meg a rendszer olyan adatokat, amire még szükség van.

A rendszerben lehet több ilyen várakozási sor is van, tehát nem egy hosszú sor. Egymással párhuzamos várakozási sorok. Ezek között szintén rendet lehet és kell csinálni, ez szintén az operációs rendszer feladata. Egyszer majd a programok bekerülnek abba a sorba, melyben végrehajtás alatt álló programok vannak. Lesznek olyan sorok, amelyek végrehajtási sorok. Multiprogramozott üzemmódban ezek a sorok fel váltva fognak dolgozni. Az, hogy melyik dolgozik, az mindig kiválasztásra kerül.

Amikor a processzor munkát keres, valamilyen elvek vannak a kiválasztásra. Melyik program kerüljön a várakozók közül kiválasztásra. Nyilvánvalóan a várakozó programok közül lehet választani. Ilyen kiválasztási elvek lehetnek:

elôbb jött, akkor ez fog elôbb futni

legrövidebb (futási idejű) elônyben van elôzetesen meg kell mondanom egy, az operációs rendszernek szóló üzenetben, mennyi ideig fog futni a program, mást is meg kell mondani: memóriaigény, perifériaigény

különbözô prioritások: a programokat besoroljuk különbözô osztályokba, prioritásokat adunk nekik meg van határozva, hogy milyen tartományban lehet választani több várakozási sor van, ezek között is van valamiféle prioritás, és egy végrehajtási soron belül is biztosítunk prioritást (a fônök programja jön, hadd menjen, vagy ez a program már 3 napja vár, kicsi a proritása, le kellene futtatni, gyorsan adunk neki egy nagyobb prioritást) kétféle prioritási elvet szoktak megkülönböztetni: relatív és abszolút mindenképp az van, hogy a nagyobb prioritású program kapja meg a vezérlést ha többen vannak, akkor aki elôrébb van a sorban, az jön aki már régebb ideje várakozik a relatív és abszolút prioritás arra vonatkozik, hogy ha egy programnak nagyobb a prioritása mint annak a programnak, ami éppen most dolgozik, akkor a relatív prioritás elve esetén a nagyobb prioritású program szépen megvárja amíg majd az a gyengébb prioritású befejezi a munkáját (tudja, hogy ô a nagyobb prioritású, de hadd dolgozzon már az a másik is egy kicsit, aztán jön egy megszakítás és befejezi a munkát a futó program, és ekkor a processzor az erôsebb prioritásúak közül választ az abszolút prioritás pedig azt jelenti, hogy amikor ô dolgozni akar, akkor elveszi a processzort, tehát ha egy alacsonyabb prioritású dolgozik és jön egy magasabb prioritású, hogy ô most már dolgozni akar, akkor elveszi a processzort egy olyan megszakítást fog be jelenteni, hogy elveszi, hiába sír az, hogy dolgozni szeretne

a prioritáson túlmenôen van egy másik elv, a körbenjárás: ami azt jelenti, hogy szépen megy, egy meghatározott sorrend szerint kör be van egy megszakítás, nézi a következôt, akarsz dolgozni vagy nem akarsz ha akarsz, akkor kapsz gépidôt ez akkor célszerű, ha van egy csomó terminál és ott ülnek az emberek általában minden kinek kevés idô kell.