1/A Adatszerkezetek osztályozása. Mûveletek adatszerkezetekkel.

Átírás

1 1/A Adatszerkezetek osztályozása. Mûveletek adatszerkezetekkel. Adatszerkezetek osztályozása: Típus szerint: - Homogén: minden eleme azonos típusú (tömb, fa, stb) - Heterogén: lehetnek különbözõ típusú elemei (összetett lista, rekord) Reláció szerint (homogénen belül): - Struktúra nélküli: adatelemek közt nincs kapcsolat (halmaz, multihalmaz, szeriális állomány) - Asszociatív: laza kapcsolat van az adatelemek között. Az adatszerkezet elemei tartalmuk alapján címezhetõk (tömb, táblázat, direkt-, random-, indexelt- és invertált állomány) - Szekvenciális (lineáris): 2 kitüntetett elem van az elsõ és az utolsó. A kitüntetett elemeket kivéve minden elemnek van elõzõje és rákövetkezõje (sor, verem, sztring, lista, szekveciális- és multilista állomány) - Hierarchikus: Olyan adatszerkezetek, amelyek tulajdonképp a lista általánosításainak tekinthetõek. A hierarchikus szerkezetben egy elemnek akárhány rákövetkezõje lehet, de minden elemnek csak egyetlen megelõzõje van. Van egy kitüntetett eleme, amelynek nincs megelõzõje, és több olyan eleme, amelynek nincs rákövetkezõje (fa, ~lista, ~állomány) - Hálós: A fák általánosítása, olyan adatszerkezet, amelyben az elemeknek akárhány megelõzõjük és rákövetkezõjük lehet, beleértve azt is, hogy két elem között olyan kapcsolat van, hogy az egyik a másik megelõzõje és rákövetkezõje és viszont (kölcsönösen). Egy elem akár önmaga megelõzõje és rákövetkezõje is lehet. Nincs kitüntetet eleme. (gráf) Elemszám szerint: - Statikus: rögzített számú elem alkotja, számuk a feldolgozás folyamán nem változik, csak értékük változhat. (tömb, fix hosszúságú sztring) - Dinamikus: feldolgozás során az elemszám is változhat. (a memóriabeli helyfoglalás is). Reprezentáció (számítógépes ábrázolás) szerint: - Folyamatos: tömb, fix hosszúságú sztring - Szétszórt: az egyes elemeknek információt kell tartalmazni a következõ elem helyére (mutató) Mûveletek adatszerkezetekkel: Létrehozás: Nem volt adatszerkezet, lesz. Módosítás: bõvítés vagy beszúrás (csak dinamikus adatszerkezeteknél): Új adatelemek kerülnek be. Az adatelemek száma nõ. törlés: Csökken az adatszerkezet elemeinek a száma, az addig ottlévõ eleme(ke)t távolítom el. csere: Az elemek száma nem változik, csak valamely elem vagy elemek értéke, kicserélem egy másik értékre. Rendezés: pl. beszúrásos Keresés: adott értékû elem, vagy adott feltétele(ek)et kielégítõ elemek helyének meghatározása. Bejárás (elérés): Az adatszerkezet minden elemét érinteni akarom, kérdés, hogy ezt milyen sorrendben tehetem. Lehet soros (az adatszerkezet elemeit valamilyen fizikai sorrend alapján tudjuk megfogni, ahogy le vannak képezve (ld. mágnesszalag)), szekvenciális (valamilyen logikai sorrend az alapja (ld. szétszórtan tárolt elemek)), vagy közvetlen (független a többi adatelemektõl (ld. folytonos tárolás)). Feldolgozás: Az adott adatszerkezet hogyan és mire használható. fefe@coffein.hu ( 1 / 117 )

2 1/B /1 Kifejezés. Kifejezés kiértékelése. Az imperatív és deklaratív programnyelvek kifejezés fogalma. A kifejezések szintaktikai eszközök. Arra valók, hogy a program egy adott pontján ott már ismert értékekbõl új értéket határozzunk meg. Két komponensük van, érték és típus. Egy kifejezés formálisan a következõ összetevõkbõl áll: operandusok: Az operandus literál, nevesített konstans, változó vagy függvényhívás lehet. Az értéket képviseli. operátorok: Mûveleti jelek. Az értékekkel végrehajtandó mûveleteket határozzák meg. kerek zárójelek: A mûveletek végrehajtási sorrendjét befolyásolják. Minden nyelv megengedi a redundáns zárójelek alkalmazását. A legegyszerûbb kifejezés egyetlen operandusból áll. A kifejezésnek három alakja lehet attól függõen, hogy kétoperandusú operátorok esetén az operandusok és az operátor sorrendje milyen. A lehetséges esetek: prefix, az operátor az operandusok elõtt áll (* 3 5) infix, az operátor az operandusok között áll (3 * 5) postfix, az operátor az operandusok mögött áll (3 5 *) Azt a folyamatot, amikor a kifejezés értéke és típusa meghatározódik, a kifejezés kiértékelésének nevezzük. A kiértékelés során adott sorrendben elvégezzük a mûveleteket, elõáll az érték, és hozzárendelõdik a típus. A mûveletek végrehajtási sorrendje a következõ lehet: A mûveletek felírási sorrendje, azaz balról-jobbra. A felírási sorrenddel ellentétesen, azaz jobbról-balra. Balról-jobbra a precedencia táblázat figyelembevételével. Az infix alak nem egyértelmû. Az ilyen alakot használó nyelvekben az operátorok nem azonos erõsségûek. Az ilyen nyelvek operátoraikat egy precedencia táblázatban adják meg. A precedencia táblázat sorokból áll, az egy sorban megadott operátorok azonos erõsségûek (prioritásúak, precedenciájúak), az elõrébb szereplõk erõsebbek. Minden sorban meg van adva még a kötési irány, amely megmondja, hogy az adott sorban szereplõ operátorokat milyen sorrendben kell kiértékelni, ha egymás mellett állnak egy kifejezésben. A kötési irány lehet balról jobbra, vagy jobbról balra. Pascalban minden mûveleti jel balról jobbra köt. A C a jobbról balra kötést vallja. Egy infix alakú kifejezés kiértékelése a következõképpen történik: Indulunk a kifejezés elején (balról-jobbra szabály) és összehasonlítjuk az 1. és 2. operátor precedenciáját ( ha csak egyetlen operátor van, akkor az általa kijelölt mûveletet végezzük el, ha csak egy operandus van, akkor annak értéke adja a kifejezés értékét). Ha a baloldali erõsebb, vagy azonos erõsségûek és a precedencia táblázat adott sorában balról jobbra kötési irány van, akkor végrehajtódik a baloldali operátor által kijelölt mûvelet, különben továbblépünk a kifejezésben (ha még van operátor) és hasonlítjuk a következõ két operátor precedenciáját. Ez alapján az elsõnek elvégzendõ mûvelet egyértelmûen meghatározható, a folytatás viszont implementációfüggõ. Ugyanis az elsõ mûvelet végrehajtása után vagy visszalépünk a kifejezés elejére és megint az elsõ operátorral kezdjük a további vizsgálatokat, vagy a kifejezésben továbblépünk és csak akkor lépünk vissza az elejére, amikor a kifejezés végére értünk. A mûveletek elvégzése elõtt meg kell határozni az operandusok értékét. Ennek sorrendjét a hivatkozási nyelvek egy része szabályozza (általában elõbb a baloldaliét), más része nem mond róla semmit, a C pedig azt mondja, hogy tetszõleges (tehát implementációfüggõ). fefe@coffein.hu ( 2 / 117 )

3 1/B /2 Kifejezés. Kifejezés kiértékelése. Az imperatív és deklaratív programnyelvek kifejezés fogalma. Az infix kifejezések esetén kell használni a zárójeleket, amelyek a precedencia táblázat alapján következõ végrehajtási sorrendet tudják felülbírálni. Egy bezárójelezett részkifejezést mindig elõbb kell kiértékelni. A teljesen zárójelezett infix kifejezés egyértelmû, kiértékelésénél egyetlen sorrend létezik. Az eljárásorientált nyelvek az infix alakot használják. A kiértékelés szempontjából speciálisak azok a kifejezések, amelyekben logikai operátorok szerepelnek. Ezeknél ugyanis úgyis eldõlhet a kifejezés értéke, hogy nem végzem el az összes kijelölt mûveletet. A nyelvek az ilyen kifejezésekkel kapcsolatban a következõket vallják: - Az ilyen kifejezést is végig kell értékelni (pl. FORTRAN), ez a teljes kiértékelés. - Csak addig kell kiértékelni a kifejezést, amíg egyértelmûen el nem dõl az eredmény. Ez a rövidzár kiértékelés (pl. PL/I). - A nyelvben vannak rövidzár illetve nem rövidzár operátorok, a programozó döntheti el a kiértékelés módját (pl. Adában nem rövidzár : and, or; rövidzár: and then, or else). - A kifejezés kiértékelését futási üzemmódként lehet beállítani (pl. Turbo Pascal). A kifejezés típusának meghatározásánál kétféle elvet követnek a nyelvek. Típusegyenértékûséget: A típusegyenértékûséget valló nyelvek azt mondják, hogy egy kifejezésben egy kétoperandusú operátornak csak azonos típusú operandusai lehetnek. Ilyenkor nincs konverzió. Típuskényszerítést: 1) Egy operátor két oldalán különbözõ típusú operandusok is megengedettek. 2) Csak azonos típusú operandusok között lehet mûveletet végezni a két típus egyikét választja a nyelv, majd típuskonverziót hajt végre, így két azonos típusú operandus között hajtja végre a mûveletet. Szigorúan típusos nyelvek (pl. az ADA) semmilyen típuskeveredést nem engednek meg. A Pascal szigorúan típusos nyelv, kivéve a numerikus mûveleteket, ahol megengedett a típuskeveredés típuskényszerítést alkalmaz. Deklaratív nyelvek: Logikai nyelvek (PROLOG): Összetett objektumok: Az elemi objektumok, változók önmagukban illetve operátorokkal összefûzve kifejezést alkotnak. Funkcionális nyelvek (LISP kifejezés fogalma): szimbolikus kifejezés (s-kifejezés). Atomok és listák közös elnevezése. Két értelemben használható: maga a kifejezés, a szimbólumsorozat, karaktersorozat a lényeg. függvényként tekintjük. Ilyenkor a lista elsõ eleme a függvény neve (azonosító), a további elemei a függvény aktuális paraméterei. A szituáció dönti el, hogy minek tekinti a rendszer. fefe@coffein.hu ( 3 / 117 )

4 1/C Relációs algebra. Absztrakt kezelõ nyelvek Két lényeges osztálya : 1. Reláció algebra 2. Reláció kalkulus A reláció algebra halmazorientált és algebrai eszközökkel dolgozik. A relációkalkulus ezzel szemben a matematikai logikán alapul. Deklaratív nyelv. Reláció algebra UNÁRIS mûveletek: 1. Szelekció Egy adott reláció rekordjainak egy részhalmazát adja, amely részhalmazba egy feltételt teljesítõ rekordok fognak beletartozni. Ez a feltétel a szelekciós feltétel, ami általában egy logikai kifejezés. Ebben a kifejezésben hasonlító és logikai mûveleti jelek lehetnek. Formálisan a mûveletben attribútumok és konstansok vannak. feltétel (relációs_séma_név) Az eredményül kapott reláció fokszáma megegyezik a kiindulási reláció fokszámával. A kapott rekordok száma kisebb vagy egyenlõ mint az induló rekordok száma. pl.: feltétel = 4 OR DNO = 5 (EMPLOYEE) A szelekció kommutatív mûvelet: f1 ( f2 (R)) = f2 ( f1 (R)) 2. Projekció A kiinduló relációból kiválaszt bizonyos attribútumokat, és az eredményrelációba csak ezen attribútumokhoz tartozó értékeket viszi át. attributum_lista (relációs_séma_név) Logikai szint: a táblából oszlopok kiválasztása. pl.: FNAME, LNAME, BDATE (EMPLOYEE) Az attribútumlistán az attribútumok sorrendje tetszõleges, de a keletkezett reláció attribútumainak sorrendjét meghatározza a kiindulási attribútumok sorrendje. Az eredményreláció fokát a kiindulásban felsorolt attribútumok határozzák meg. Rekordszám: Ha a kiválasztott attribútumok között van kulcs, akkor az induló rekordok száma egyenlõ az eredményrekordok számával. Ha nem szerepel kulcs, akkor az eredményrekordok száma kevesebb lehet, mint az induló rekordok száma. (Mivel nincs duplikálás, - azonos rekordok esetén a projekció csak egyet választ ki.) 3. Halmazmûveletek A relációkat rekordok halmazának tekintjük, ezen hajtjuk végre a mûveleteket újból reláció. (a 1,..., a n ) n=m -nek kell lennie, hogy azonos fokú reláció séma legyen (b 1,..., b m ) illetve az egyes helyeken lévõ elemek ugyanazon tartományból legyenek a 1 -b 1 Ha tekintünk egy R(A 1,..., A n ) és S(B 1,..., B n ) relációkat, akkor ezeket unió-kompatibilisnek mondjuk, ha 1. fokszámuk azonos 2. dom(a i ) = dom(b i ) i=1,,n Halmazmûveleteknél a két relációnak unió-kompatibilisnek kell lennie. Unió R S - az új relációban a két rekordból álló elemek uniója lesz. fefe@coffein.hu ( 4 / 117 )

5 1/C /2 Relációs algebra. Metszet R S Kivonás R-S - a két relációnak unió-kompatibilisnek kell lennie. A szokásos halmazelméleti metszet. - R \ S. A szokásos halmazelméleti kivonás. Tulajdonságok R S = S R R - S S - R R (S T) = (R S) T R (S T) = (R S) T Descartes szorzat - a halmazelméleti értelemben vett Descartes szorzat. Ehhez nem szüksé- R S ges az unió-kompatibilitás. R(A 1,..., A n ) S(B 1,..., B n ) Az eredmény fokszáma: m+n rekordok száma: r - R-ben s - S-ben, az eredményben: r s JOIN (két reláció összekapcsolása) R feltétel S - a fokszám m+n lesz - a sorok száma maximum r s lehet, illetve a feltételtõl függõen kevesebb. A feltételek: f 1 AND f 2 AND... AND f n a részfeltétel: f i : A i B j alakú, ahol egy összehasonlító operátor. = {<, >,,, =, } EQUI-JOIN, ahol a operátor = valamely oszlopértékek a másikkal páronként megegyeznek. Természetes összekapcsolás (NATURAL-JOIN) Legyen R reláció séma: A B C S reláció séma: B D összekapcsoló: B a b c b x f g h c d i b h R B S a b c b x a b c c d f g h b x A b c b x a b c x f g h c d I b h b x i b h x i b h b x szelekció projekció i b h c d Teljessége Melyek azok a mûveletek, amelyek az eddig említett mûveletek segítségével kifejezhetõek. {,,,, } R S = R-(R-S) R f S = f (R S) két reláció descartes szorzata Az alkalmazás illetve a gyakoriság miatt további mûveletek: Osztás Elõfeltétele: R S S attribútumai elõ kell hogy forduljanak R attribútumaiban. fefe@coffein.hu ( 5 / 117 )

6 1/D Folytonos tárallokálás. Stratégiák, fragmentáció. Folytonos tárallokálás: Az operatív memóriát egyetlen folytonos tömbnek tekinthetjük. - A memória "rendszer"- és "felhasználói program" részekre bomlik. - A rendszer résznek tartalmaznia kell a memóriába beágyazott megszakítási vektort, az I/O kapukat (portok). Multipartíciós allokálás A felhasználói programok számára elérhetõ terület részekre (partíciókra) bomlik. Egy partíció egy felhasználói program (processzus) befogadására alkalmas. Fix, változó számú és hosszúságú partíciók, prioritás. Lyuk (hole): két foglalt partíció közötti szabad memória terület (blokk). A lyukak mérete változó lehet. Ha egy processzust létre kell hozni, akkor ehhez az operációs rendszernek egy megfelelõen nagy méretû lyukat kell kiválasztania. Példa: Az operációs rendszer nyomon követi az allokált és szabad partíciókat (hely és méret alapján). Dinamikus tár-hozzárendelési probléma: hogyan lehet kielégíteni egy adott méretû allokációs (tárfoglalási) igényt? First -fit: foglaljuk le az elsõ lyukat, amely elég hosszú! Best-fit: foglaljuk le az elég hosszú lyukak közül azt, amelynek hossza legközelebb esik a szükséges hosszhoz! Worst-fit: foglaljuk le a leghosszabb lyukat (ha az elég hosszú)! Értékelési szempontok / értékelés: Sebesség, tárkihasználás: a "first" és "best" jobb, mint a "worst". A lyukak adminisztrálása is idõt és memóriát igényel, deadlockhoz is vezethet! (többe kerülhet mint a szabad hely!) 50% szabály: (D. Knuth) a first fit stratégia statisztikai vizsgálata azt eredményezte, hogy n blokk elhelyezése során n/2 blokk (helye) elvész(!) (ez a kezdeti szabad terület egy harmada!) Külsõ és belsõ fragmentáció: A külsõ fragmentáció csökkentése tömörítéssel. cél: a lyukak egyesítése egy szabad területté. dinamikus relokáció szükséges függõben levõ I/O problémája. fefe@coffein.hu ( 6 / 117 )

7 2/A Verem /stack/ és sor. A verem a leggyakrabban alkalmazott adatszerkezet a tömb után. A verem egy olyan speciális lista, ahol az elõbb definiált mûveletek közül az 1-3 van megengedve. Olyan adatszerkezet, amelyet a kezelési módjával definiálunk. A mûveletek neve is hasonló: PUSH ( bõvítés az elején) POP (elsõ elem törlése) ACCESS helyett TOP van (elsõ elem elérése). Vannak olyan felfogások, amelyek a Pop-ba beleértik a Top-ot. A reprezentációja lehet: Folytonos A vermet vektorral kezeljük, ahol az elsõ elem mindig a verem alja. Kell használni egy mutatót, ami a verem tetejét mutatja. Bõvíteni, új elemet bevinni csak a verem tetejére lehet, ha van hely. Hozzáférni csak a tetejéhez lehet. Ha egy belsõ elemet akarunk, akkor törölni kell. Szétszórt: egyirányban láncolt lista. A listafej mindig az aktuális elsõ elemre mutat. Ide kell beszúrni adatfelvételnél. Üreslista, üresverem: a fej NIL. Rekurzív algoritmusoknál is alkalmazzák. Mûveletek Létrehozás: Van az üresverem és az érkezés sorrendjébe pakoljuk bele az elemeket. Bõvítés: Push mûvelet, definíció szerint csak a tetején. Törlés: Pop mûvelet, definició szerint csak a tetején. Definició szerinti keresés, rendezés, csere, bejárás nincs. Elérés: Top, a legfelsõ elem elérhetõ. Feldolgozás: Alapmûveletekkel. Sor (queue) FIFO (First in, first out) adatszerkezet. A sor egy speciális lista, ahol az mûvelet van csak értelmezve. A sor tehát olyan adatszerkezet, amelyet kezelésével definiálunk. Vannak speciális elnevezések: Inject helyett PUT. POP helyett GET. (Felfogás kérdése, hogy a GET-be beletartozik-e az 1-es) Létezik üres sor. Új elemet a sor végére lehet bevinni, hozzáférni a sor elejéhez lehet. Létezik a tele sor. fefe@coffein.hu ( 7 / 117 )

8 2/A /2 Verem /stack/ és sor. Reprezentációja Mindkét módszer megfelelõ. Folytonos ábrázolásnál vektorral képezzük le a sort, szétszórtnál egyirányban láncolt listát alkalmaznak. A folytonos ábrázolás megoldásai: 1. Fix kezdetû sor A sor elsõ elemének indexe 1, tehát rögzített, értéke x. Egy indexmutató van, ami a sor végét jelöli. Létezik üres sor és tele sor. Bõvítek a végén, az 1-es indexû elemhez férhetek hozzá. A többi eleméhez való hozzáférés azt jelenti, hogy az elõtte lévõ elemeket fizikailag törlöm. 2. Vándorló sor 3. Ciklikus sor A sort olyan szituációban használjuk, ha az adatokat idõrendben való beérkezés szerint akarjuk meghatározott sorrendben feldolgozni. A sor szerepe kevésbé fontos mint a veremé. Bármilyen adatszerkezet bejárása nem más, mint egy sorra való leképezése. A sor jelenik meg a puffernél. Ilyen a billentyûzet puffer. Mûveletek Létrehozás: Kiindulunk az üres sorból és az elemek a beérkezés sorrendjében bekerülnek. Bõvítés: A végén. Törlés: Csak az elején Csere, rendezés, elérés, bejárás: nincs értelmezve. Feldolgozás: Az mûveletek alapján. Ciklikus sor egy implementációja: Egydimenziós tömbbel valósítjuk meg. Kezeljük a szélsõséges eseteket. Ábra lásd fent. SOR[1..n], E, V: indexmutatók Üres sor: E=V=0 Sor tele: (E=1 vagy V=N) vagy (E=V+1) Vannak speciálisan kezelhetõ sorok is. 1. Kétvégû sor, kettõs sor (dequeue) Speciális lista, amelynél mind a hat mûvelet értelmezve van. Mind a két végén lehet bõvíteni és mind a két végén lévõ elemekhez hozzá lehet férni. A kétvégû sor tekinthetõ úgy, mint két darab aljánál illeszkedõ verem. Így a verem és a sor által megoldható problámák megoldására egyaránt alkalmas. Vannak speciális esetei: 2. Input korlátozott kettõssor Nincs értelmezve rá a 2-es mûvelet (RPUT), azaz nem lehet az elején bõvíteni, csak a végén. Elvinni elemet az elején és a végén egyaránt lehet. 3. Output korlátozott kettõs sor Nincs értelmezve rá az RGET, hozzáférni csak az elsõ elemhez lehet, bõvíteni viszont mindkettõt lehet. Reprezentációra, implementációra nézve átvihetõek az elõzõek. Memóriakezelési gondok megoldásánál szokták alkalmazni, dinamikusan. fefe@coffein.hu ( 8 / 117 )

9 2/B Az objektumorientált paradigma és programnyelvei. OBJEKTUM-ORIENTÁLTSÁG Meg fogunk állni a programozási nyelvek szintjén. Az objektum-orientált programozási módszertan filozófiáját amelynek alapgondolata, hogy az adat és a funkcionális modell egymástól elválaszthatatlan, lényegében egyetlen modell -követik az objektumorientált programozási nyelvek. Az OO programozási nyelvek imperatív jelleg û ek: algoritmikus szemléletet tükröznek. Az OO paradigma bevonul minden más nyelvi osztályba is. -A 60-as évek második felében jelenik meg a SIMULA67-ben az OO programozási eszközrendszer. A SIMULA67: Algol verzió, szimulációs, absztrakciós nyelv, minden objektum-orientált eszköz megvan benne. Észak-Európában születik meg. -Alan Kay amerikai egyetemista ben szakdolgozatában egy új világot vázol föl: az OO világot. A Xerox-nál próbálja megvalósítani. Egy projektet szervez, melynek célkit û zése egy személyi számítógép megtervezése (hardver, architektúra, szoftver). Õ használja az objektum-orientált elnevezést, fogalmakat. (A grafikus interfész, ablak és egér fogalma is ekkor jelent meg el õ ször.) Felvázol egy projektet: - csinálni kell személyi számítógépet -Windows típusú operációs rendszert, grafikus felhasználói felületet (ekkor még csak az elektromos írógép az input periféria) -mindezt objektum-orientált programozási környezetben es évek elején megszületik a Xerox-nál a Smalltalk programozási nyelv, melyet objektumorientáltnak terveznek, tiszta objektum-orientált nyelv, (SIMULA elemekkel). A világot csak objektumorientáltnak hagyja láttatni, másnak nem. Ekkor még a strukturált elv a dönt õ.a Smalltatkkal együtt megjelenik egy olyan paradigma, amelyet a szakma még nem tud befogadni, másrészt olyan hardver kell alá, ami még nem létezik. A 80-as évek második felét õ l jelenik meg ilyen hardver. Ezután õ rültmód elkezd terjedni az OO. Divattá válik. A Smalltalk napjainkban is él. -Megszületik a 80-as években a C++, jelenleg divatnyelv ben megjelenik a Meyer által kifejlesztett Eiffel nyelv, ami az OO területén azt a zerepet játsza, amit az eljárásorientált nyelvek területén a Algol. Nincs gyakorlati jelent õ sége : Turbo Pascal : Turbo Pascal 6.0: OO eszközrendszerrel rendelkezik. A 80-as évek második felében 90-es évek els õ felében minden magára valamit is adó programozási nyelvnek van olyan változata, amely már OO eszközrendszerrel rendelkezik valamilyen szinten. -Java: az OO vallásának istene. A C++ óta egyetlen, aminek gyakorlati jelent õ sége is van. Objektum-orientáltság jellemzõi: -az adatmodell és az eljárásmodell elválaszthatatlan (így szemléli a világot) -absztrakt eszköz és fogalomrendszer: Az újrafelhasználhatóságot olyan magas szintre elviszi, ameddig lehetséges, a valós világot nagyon megközelíti. -szemlélete: imperatív (algoritmus kódolni kell) eszközrendszer Jelen pillanatban az OO területén többféle iskola létezik, amelyek bizonyos pontokon élesen vitatkoznak egymással, nem csak nüansznyi különbségek vannak köztük. Jelen pillanatban folyik az OO matematikai hátterének elkészítése, kifejlesztése. fefe@coffein.hu ( 9 / 117 )

10 2/C Normálformák, normalizálás. Egy adatbázis, amely nem a megfelelõ relációsémákból áll (normalizálatlan), a következõ problémák forrása lehet: Módosítási anomália: az adatok módosításakor több rekordon kellene ugyanazt a módosítást elvégezni. Ez inkonzisztenciához vezethet. Beszúrási, törlési anomália: Ha egy sort beszútunk, olyan attributumértékekkel is fel kell tölteni, amik már tárolva vannak. Ha egy sort kitörlünk, olyan adatot veszíthetünk, ami még szükséges lehet. Az anomáliák következményei: Hiányos információ: bizonyos adatok nem tárolódnak (Pl. egy termékre éppen nincs megrendelés, a termék adatai sem tárolódnak) Redundancia: ugyanazok az attributumok több sorban, fölöslegesen is tárolódnak. (Minden megrendelésnél szerepelnek a termék adatai) Inkonzisztenciat: elõfordulhat, hogy különbözõ sorokban ugyanaz az attributum más-más értéket vesz fel. (A termék adatai másképp szerepelnek különbözõ megrendeléseknél) A normalizálás során az adatbázissal szemben egyre nagyobb szerkezeti követelményeket támasztunk. 1NF: Egy relációséma elsõ normálformában van, ha minden attributruma funkcionálisan függ az elsõdleges kulcstól, és nincs benne összetett vagy többértékû attributum. Funkcionális függés: Egy r(r) relációban Y attributumhalmaz funkcionálisan függ az X attributumhalmaztól, ha minden t, s sorára igaz, hogy ha t (X) = s (X), akkor t (Y) = s (Y). Ezt elérhetjük egyrészt a többértékû attributumok külön-külön sorban való szerepeltetésével, az összetett attributumok szétbontásával. A sémát olyan részsémákra bontjuk, amelyekben már minden attributum függ a kulcstól. Tehát új reláció(ka)t hozunk létre az ismétlõdõ attributumcsoport(ok)ból 2NF: Egy relációséma akkor van második normálformában, ha elsõ normálformában van és nem tartalmaz részleges függést. Részleges függés: Ha valamelyik leíró attributum függ az összetett kulcs egy részétõl. A részleges függést megszüntethetjük, ha a kulcsrésztõl függõ attributumokból új relációt képezünk, melynek kulcsa az adott kulcsrész, attributumai pedig azok, amelyek ettõl függenek. 3NF: Egy relációséma akkor van harmadik normálformában, ha második normálformában van és nem tartalmaz tranzitív függést. Tranzitív függés: Ha valamelyik attributum függ egy leíró attributumtól. (Azért tranzitív, mert a leíró attributum függ a kulcstól, a többi meg a leíró attributumtól.) Megszüntethetõ, ha leválasztjuk a trenzitív függésben lévõ attributumokat, ezekbõl új relációt hozunk létre, amelynek kulcsa az a leíró tulajdonség, amelytõl az attributumok függnek. fefe@coffein.hu ( 10 / 117 )

11 2/D Az operációs rendszer parancsnyelvi alrendszere, szkriptek, rendszerhívások. Rendszer-hívások Ha a futó (felhasználói) program valamilyen rendszerszolgáltatást igényel, ezt rendszerhívás formájában teheti meg. Általában assembly szintû utasításként jelen van az architektúrában. (INT, Tcc, SC, stb.) Magas szintû, rendszerprogramok írására szánt programozási nyelvekbe is beépítették. (C) Paraméterátadás módjai a rendszernek: regiszterben, paraméter-táblázatban, veremben (push- felh. program; pop- op. rendszer), a módszerek kombinálása, statusword-ok alkalmazói támogatás funkciói a számítógépes rendszer több szintjén valósulnak meg, és az alábbi fõ funkciókra bonthatók: * operátori parancsnyelvi rendszer: a számítógép géptermi üzemvitelének támogatására; * munkavezérlõ parancsnyelvi rendszer: a számítógép alkalmazói szintû igénybevételének megfogalmazására; * rendszerszolgáltatások: az operációs rendszer magjával közvetlenül meg nem oldható rendszerfeladatokra; * segédprogramkészlet: rutinfeladatok megoldására; * alkalmazói programkészlet: az alkalmazásfüggõ feladatok megoldására. Az alacsony szintû szolgáltatásokat nem a végfelhasználók, hanem a szoftverfejlesztõk, a programozók használják (illetve munkájuk eredményeként azok a programok, amiket megírnak). Az alacsony szintû szolgáltatásokat csak programokból lehet igénybe venni. Az igénybevétel módját rendszerhívásoknak nevezzük. Ezek - lényegüket tekintve - eljáráshívások, de az eljárások törzse a rendszermagban helyezkedik el, és ezért privilegizált üzemmódban dolgozhat. A hívások megvalósítási módja programnyelvenként változhat. A magas szintû programozási nyelvekben olykor a normál eljárások hívásával azonos elõírások szerint lehet õket kódolni, de elterjedtebb az, hogy a rendszerhívások módja eltérõ, és egyes hívások implicit módon hajtódnak végre egyes programnyelvi objektumok hatására (például: OPEN, CLOSE stb.). Az alacsony szintû programozási nyelvekben a rendszerhívás erõsen eltér a normál eljárások hívásától. A rendszerhívásokhoz más hardver gépi utasítást kell használni, mint a normál szubrutinhívásokhoz. Akár alacsony szintû, akár magas szintû nyelven programozunk, a programok végsõ fokon mind a szoftver megszakító utasításra támaszkodnak. A szoftver megszakító utasítás behívását a magas szintû nyelvekben a fordítóprogramok, alacsony szintû programokban pedig az úgynevezett makrohívások szervezik meg. A rendszerhívások módját alapvetõen az alacsony szintû programozáshoz optimalizálták. A fejlõdés azonban abba az irányba mutat, hogy a rendszerhívásokat a magas szintû programozási nyelvek igényeihez illesszék inkább. fefe@coffein.hu ( 11 / 117 )

12 3/A Adatszerkezetek reprezentációja. Reprezentáció: A tárolási mód és a leképezés együttese. Implementáció: A reprezentáció és a mûveletek együttese. A logikai adatszerkezeteket le kell képezni a tárba. A memóriában kétféle módon tárolhatunk adatszerkezeteket. 1. Folytonos (szekvenciális, vektorszerû) tárolás. Folytonos tárterületen. Az adattételek tárolási jellemzõi azonosak (típus, ábrázolási mód, hossz). Ismerni kell a kezdõcímet, a tárolási jellemzõket, és az elemek számát. Itt minden elemet közvetlenül meg tudok fogni, minden adatszerkezet tárolható ilyen módon. Mûveletek: Létrehozás: A kezdõcímtõl minden tételt folytonosan pakolunk a tárba. Bõvítés: A végére újabb elemeket lehet rakni. Beszúrásnál az adott elem behelyezésének helye után lévõ elemeket jobbra kell tolni, át kell mozgatni. Törlés: Megkülönböztetünk fizikai és logiakai törlést: Fizikai törlés: A tárrész mögött lévõ elemeket rácsúsztatom a törlendõ elemre, mindegyiket eggyel balra. Logikai törlés: Az elemek száma nem csökken. A törölni kívánt elemet megjelölöm, hogy törölve van ( törölt jellel). Ekkor az adatelem értéke változik meg, így ez valójában egy csere. Csere: bármely elem közvetlenül megfogható. Rendezés: Ha van értelme, akkor mindegyik rendezési algoritmus alkalmazható. Keresés: Ha van értelme, akkor minden keresési algolitmus alkalmazható. 2. Szétszórt tárolás (véletlenszerû). Az adatelemek tárolási jellemzõik lehetnek különbözõek. Minden adatszerkezet tárolható szétszórtan. Az adatelem mellett létezik a tárrésznek egy mutató része is, amely olyan információt tartalmaz, hogy az adott tárelem után melyik másik tárelem következik az adott adatszerkezetben. a) Egyirányban láncolt lista (linked list) Társzerkezet vagy tárolási mód. Minden elem mutatórésze tartalmazza a következõ elem tárolási címét, az adatrész az adatelem értékét tartalmazza. Tudni kell, hogy melyik a lista elsõ eleme. Ennek a címét a fej tartalmazza. Az utolsó elem mutatórésze nem mutat sehova sem, a lista végét jelzi. Üreslista: Mûveletek: Létrehozás: Elsõ lépésként létrehozom az üreslistát, utána bõvítek. Bõvítés: A lista bármelyik helyére beilleszthetek egy új tárolási elemet: a) A lista elejére: Lefoglalok egy helyet a tárban. Bárhol, de tudom a címét. A fej az új elemre, az újelem az eddigi elsõ elemre mutat. b) A lista végén: Lefoglalom a tárhelyet. Az új elem mutatója a lista végét jelzõ információ: NULL. Az utolsó elem mutatórészébe beírom az új elem címét, az eddigi utolsó elem mutatója az új elemre fog mutatni. Az utolsó elemet meg kell keresni, végig kell menni a listán, tehát szükség van egy bejárásra. Minden elem megmondja, hogy hol a rákövetkezõje. fefe@coffein.hu ( 12 / 117 )

13 3/A /2 Adatszerkezetek reprezentációja. c) Bõvítés a listában: Az elérés szekvenciális. (beszúrás) A listánál a keresés teljes keresés, ahol adatértéket keresek. Minden elemre csak úgy tudok eljutni, ha elõtte végig mentem az elõtte lévõ elemeken. Az az elem, amin állok az aktuális elem. Az aktuális elem elé, vagy mögé is beszúrhatok. Mögé bõvítek: A megelõzõ elemekrõl nincs információm. Az aktuális elem mutatórészébe az új elem címét írom, az új elem mutatórészébe az aktuális elem mutatórészében lévõ címet írom. Elé bõvítek: Az elõzõ módszerrel nem lehet bõvíteni, mert nem tudom megmondani, hogy mi az elõzõ elem címe. Meg kell jegyezni az aktuális elem elõtti elem címét. Törlés: Fordított bõvítés. a) Elsõ elem törlése: A lista fejébe az elsõ elem mutatóértékét viszem. b) Utolsó elem törlése: Az utolsó elõtti elemet megkeresem és a mutatórészébe NIL-t írok. c) Ha az aktuális elemet akarom törölni, akkor az aktuális elem mutatórészét átviszem a megelõzõ elem mutatórészébe. Csere: Simán végrehajtható. Keresés: Csak teljes kereséssel, amennyiben nem rendezett. Ha rendezett, lineáris kereséssel. Rendezés: Tegyük fel, hogy van egy listám, és azt saját helyén akarom rendezni. Ez nem célszerû. Gyakoribb, hogy egy új listát rendezetten hozok létre. Ezt úgy tehetem, hogy létrehozom az üres listát és beszúrásos rendezést alkalmazok. A beszúrandó elem helyét lineáris kereséssel keresem meg. Bejárás: Minden probléma nélkül megtehetõ. Feldolgozás: Adatszerkezet-függõ. b) Körkörös (cirkuláris) lista Az utolsó elem mutatója az elsõ elem címére mutat. Bármelyik elembõl körbe tudok menni, a bejárást egyszerûsíti. c) Kétirányba láncolt lista Minden elemnek két mutatója van, amelyek információt tartalmaznak a következõ és a megelõzõ elemrõl. Általában két fej van, a lista elejére és a végére mutatnak, így két irányba tudok haladni. d) Multilista Több értelmezése is van. 1) Az adatelemek összetettek, pl: Kialakítok az egyik és a másik részére egy listát. A listaszerkezet pl. tartalmazza a neveket ABC sorrendben, az átlagokat csökkenõ sorrendben. Több mutatórész van, mindegyik egy-egy adatelemrész szerint láncol. Annyi mutatórész és annyi fej van, ahány lánc. Ez is lehet kétirányba láncolt, illetve körkörös lista. fefe@coffein.hu ( 13 / 117 )

14 3/A /3 Adatszerkezetek reprezentációja. 2) Legyenek az adatelemek összetettek, így van egy adatelem sorozatom. Együtt akarom kezelni az azonos értékûeket, pl: a Debrecenben lakókat. Így olyan részlisták jönnek létre, amelyben azonos értékû elemek vannak. Annyi részlista és fej van, amennyi féle érték található. 3) Az adatrész is tartalmazhat mutatórészt, amely egy másik listára mutat. Ekkor listákat fûzök fel. Azt jelzi a jelzõrész, hogy tényleges adatra, vagy egy másik listára mutat. Jelzõ: 0,1 (bitek). Ezek tárolási szerkezetek!!! Vannak olyan adatszerkezetek, amelyekhez jobban illik a folytonos tárolás, másokhoz praktikusabb a szétszórt. Törlés Amikor adatszerkezetben törlést végzünk, akkor egy tárhely felszabadul. Kérdés az, hogy hogyan tudunk ezzel a szabad tárhelyekkel gazdálkodni. I. folytonos tárolás esetén: a) Az egyik megoldás, hogy ha felszabadul a tárhely, átszervezzük az adatszerkezetet, azaz a mögötte lévõ elemeket rácsúsztatjuk a törlendõ elemre. Szabad helyek ilyenkor mindig az adatszerkezet végén lesznek. Ez igen idõigényes, viszont a problémánkat biztosan megoldja. b) Hulladékgyûjtés: (garbage collection) A lyukakat otthagyom, csak logikai törlés van, folyamatosan írok tovább. Amikor elfogy a rendelkezésre álló tárhely, akkor rendszeres idõközönként szervezi, rendszerezi át a végére a szabad helyeket, hogy összefüggõ tárterületet kapjunk. Sok operációs rendszer van, amely így kezeli le a törlést. c) A tárhelyeket nyilvántartjuk egy bitmátrix segítségével. A mátrix elemei: 1 (foglalt), 0 (szabad), ez alapján tudok elemeket elrakni. Nem kell mozgatni az adatelemeket, viszont külön kell nyilvántartani. II. szétszórt ábrázolás esetén: a) A szabadhelyek össze vannak láncolva. A szabadhelyek listájáról leveszem az elsõ elemet, ha új elemet akarok láncolni, és azt fûzöm az állományhoz. Ha törlést végzek, akkor az adott elem helyét a szabad elemek láncához láncolom. Idõben gazdaságos. fefe@coffein.hu ( 14 / 117 )

15 3/A /4 Adatszerkezetek reprezentációja. Probléma: Különbözõ méretû tárhelyeket láncolok, így olyan algoritmusokat kell alkalmazni, amelyek ellenõrzik, hogy az új elem befér-e a tárrészbe (first fit: az elsõ megfelelõ tárhelyet lefoglalom; best fit: a megfelelõek közül a legkisebbet foglalom le). Meg kell keresni azt a tárhelyet, ahova befér. Ha túl kicsi elemet pakolok bele, akkor az nem gazdaságos. b) Szabadhelyek nyilvántartása: Lásd folyt. Bitmátrix segítségével történik. c) Hulladékgyûjtési technika, amelyben láncolom a szabadhelyeket. Ha elfogy a szabad hely, akkor láncolok. fefe@coffein.hu ( 15 / 117 )

16 3/B Az input-output programnyelvi eszközei. Az I/O az a területe a programnyelveknek, ahol azok leginkább eltérnek egymástól. Az I/O plattform-, operációs rendszer-, implementációfüggõ. Egyes nyelvek nem is tartalmaznak eszközt ennek megvalósítására, eleve az implementációra bízzák a megoldást. Az I/O az az eszközrendszer a programnyelvekben, amely a perifériákkal történõ kommunikációért felelõs, amely az operatív tárból oda küld adatokat, vagy onnan vár adatokat. Az I/O középpontjában az állomány áll. A programnyelvi állományfogalom megfelel az absztrakt állományfogalomnak (l. Adatszerkezetek és algoritmusok). Egy programban a logikai állomány egy olyan programozási eszköz, amelynek neve van és amelynél az absztrakt állományjellemzõk (rekordfelépítés, rekordformátum, elérés, szerkezet, blokkolás, rekordazonosító, stb.) attribútumként jelennek meg. A fizikai állomány pedig a szokásos operációs rendszer szintû, konkrét, a perifériákon megjelenõ, az adatokat tartalmazó állomány. Egy állomány funkció szerint lehet: input állomány: a feldolgozás elõtt már léteznie kell, és a feldolgozás során változatlan marad, csak olvasni lehet belõle, output állomány: a feldolgozás elõtt nem létezik, a feldolgozás hozza létre, csak írni lehet bele, input-output állomány: általában létezik a feldolgozás elõtt és létezik a feldolgozás után is, de a tartalma megváltozik, olvasni és írni is lehet. Az I/O során adatok mozognak a tár és a periféria között. A tárban is, és a periférián is van valamilyen ábrázolási mód. Kérdés, hogy az adatmozgatás közben történik-e konverzió. Kétféle adatátviteli mód létezik: - folyamatos (van konverzió) A folyamatos módú adatátvitelnél a tárban és a periférián eltér a reprezentáció - bináris vagy rekord módú (nincs konverzió). A nyelvekben három alapvetõ eszközrendszer alakult ki: formátumos módú adatátvitel: minden egyes egyedi adathoz a formátumok segítségével explicit módon meg kell adni a kezelendõ karakterek darabszámát és a típust. szerkesztett módú adatátvitel: minden egyes egyedi adathoz meg kell adni egy maszkot, amely szerkesztõ és átviendõ karakterekbõl áll. A maszk elemeinek száma határozza meg a kezelendõ karakterek darabszámát, a szerkesztõ karakterek megadják, hogy az adott pozíción milyen kategóriájú karakternek kell megjelennie, a többi karakter változtatás nélkül átvitelre kerül. listázott módú adatátvitel: itt a folytonos karaktersorozatban magában vannak a tördelést végzõ speciális karakterek, amelyek az egyedi adatokat elhatárolják egymástól, a típusra nézve pedig nincs explicit módon megadott információ. Ha egy programban állományokkal akarunk dolgozni, akkor a következõket kell végrehajtanunk: 1. Deklaráció: A logikai állományt mindig deklarálni kell az adott nyelv szabályainak megfelelõen. El kell látni a megfelelõ névvel és attribútumokkal. 2. Összerendelés: Ennek során a logikai állománynak megfeleltetünk egy fizikai állományt. 3. Állomány megnyitása: Egy állománnyal csak akkor tudunk dolgozni, ha megnyitottuk. Megnyitáskor operációs rendszer rutinok futnak le, ellenõrizve, hogy a logikai állomány attribútumai és a fizikai állomány jellemzõi megfelelnek-e egymásnak 4. Feldolgozás: Ha az állományt megnyitottuk, akkor abba írhatunk, vagy olvashatunk belõle. 5. Lezárás: A lezárás ismét operációs rendszer rutinokat aktivizál. Azért nagyon fontos, mert a könyvtárak információinak aktualizálása ilyenkor történik meg. Output és input-output állományokat le kell zárni, input állományokat pedig illik lezárni. A lezárás megszünteti a kapcsolatot a logikai állomány és a fizikai állomány között. fefe@coffein.hu ( 16 / 117 )

17 3/B /2 Az input-output programnyelvi eszközei. A programozási nyelvek a programozó számára megengedik azt, hogy input-output esetén ne állományokban gondolkozzon, hanem az írás-olvasást úgy képzelje el, hogy az közvetlenül valamelyik perifériával történik. Ezt hívjuk implicit állománynak. Tehát az implicit állományt nem kell deklarálni, összerendelni, megnyitni és lezárni. Implicit input állomány: szabvány rendszerbemeneti periféria (általában a billentyûzet)- Implicit output állomány a szabvány rendszerkimeneti periféria (általában a képernyõ). Az egyes nyelvek I/O eszközei FORTRAN: Szeriális, szekvenciális és direkt állományt tud kezelni. Eszközrendszere szegényes. Csak fix rekordformátumot tud kezelni. Õ vezeti be a formátumos adatátvitelt. A listázott átvitel a késõbbi verziókba kerül be. Létezik benne a bináris adatátvitel, azonban nem rekordonként, hanem egyedi adatokként. COBOL: Erõs I/O eszközrendszere van. Mindig konvertál. A COBOL vezeti be a szerkesztett átvitelt. Szeriális, szekvenciális, direkt, indexelt és invertált állományszerkezetet is ismer, de egyszerre csak egy másodlagos kulcs szerint tud keresni. Általában fix rekordformátumot kezel. Blokkolás lehetséges. PL/I: Kiemelkedõen a legjobb állománykezelési eszközrendszerrel dolgozik. Az összes állományszerkezetet, adatátviteli módot, rekordformátumot és blokkolási lehetõséget ismeri és kezeli. PASCAL: Állománykezelési eszközrendszere szegényes. Fix és változó rekordformátumú szeriális állományt kezel. Az egyes implementációk ismerik a bináris és a folyamatos módú (a formátumos és a listázott egyfajta keverékeként) átvitelt, és esetlegesen közvetlen eléréssel dolgoznak. Blokkolás nincs. Nincs I/O utasítás, beépített alprogramokkal dolgozik. C: Az I/O eszközrendszer nem része a nyelvnek. Standard könyvtári függvények állnak rendelkezésére. Létezik a bináris és a folyamatos módú átvitel, ez utóbbinál egy formátumos és egy szerkesztett átvitel keverékeként. Szeriális szerkezetet kezel fix és változó rekordformátummal. Az I/O függvények minimálisan egy karakter vagy karaktercsoport, illetve egy bájt vagy bájtcsoport írását és olvasását teszik lehetõvé. Ada: Minden perifériát tud nyelvi eszközökkel kezelni. Az Adának sem része az I/O, csomagok segítségével valósítja meg azt. Léteznek az alábbi csomagok: - SEQUENTIAL_IO: Szekvenciális állományok kezelésére szolgál. Indexelt szekvenciális állománnyal is tud dolgozni. - DIRECT_IO: Direkt állomány kezelésére szolgál. - TEXT_IO: Szöveges állomány kezelésére szolgál. - LOW_LEVEL_IO: Tetszõleges perifériával való kommunikációt biztosítása nyelvi eszközökkel. - IO_EXCEPTIONS: Az I/O kivételek kezelésénél van jelentõsége. A logikai állomány deklarálása és fizikai állománnyal való összerendelése után a megnyitott állomány funkciója a programon belül dinamikusan változtatható, például egy kivétel bekövetkeztekor. Lezáráskor elõírható, hogy az állomány megmaradjon vagy törlõdjön. fefe@coffein.hu ( 17 / 117 )

18 3/C Reláció kalkulus. Kétféle megközelítési módszer létezik : 1. Rekord alapú reláció kalkulus (Tuple Relation Calculus - TRC) Rekordváltozókat vezetünk be (pl.: t) amiket az ABC kisbetûivel jelölünk. Egy-egy ilyen változó tetszõleges sort vehet fel értékül. {t COND(t)} feltétel t-re vonatkozóan Ezen jelölés eredménye alatt azon rekordok halmazát értjük, melyre a megadott feltétel igaz. {t OKTATO(t) and t.tanszek_nev='analízis'} Ezzel az írásmóddal az összes attribútumot visszakapjuk. Ezt szabályozhatjuk, pl: {t.oktato_nev, t.szoba_szam OKTATO (t)... } projekciós mûvelet implementálása szelekciós mûvelet implementálása Általánosan : {t 1.A 1, t 2.A 2,... t n.a n COND(t 1, t 2,..., t n, t n+1,..., t n+m )} Példák : A. Adjuk meg az I1201 kódú tárgyat felvevõ hallgatók nevét és szakját! {t.hallgato_nev, t.hallgato_szak HALLGATO(t) and ( ( d)(tantargyfelvetel(d) and d.tantargy_kod = 'I1201' and d.hallgato_azonosito = t.hallgato_azonosito))} Itt t szabad, d pedig kötött változó B. Adjuk meg az Informatika1 tárgyat oktató oktatók nevét és tanszékük nevét! {t.oktato_nev, t.tanszek_nev OKTATO(t) and ( ( p)( w)(orarend(p) and TANTARGY(w) and w.tantargy_nev = 'INFORMATIKA1' and w.tantagy_kod = p.tantargy_kod and szûrõfeltétel p.oktato_azonosito = t.oktato_azonosito ))} C. Adjuk meg azon dolgozók nevét, akik az 5-ös osztály által irányított valamennyi projecten dolgoznak! {e.lname, e.fname EMPLOYEE(e) and (not ( x)(project(x) and x.dnum = 5 and not ( w)(works_on(w) and w.essn = e.ssn and x.number = w.pno )))} not (A and B) not A or not B ( x)(f(x)) not ( x) (not (F(x)) ez egy formula, mely tartalmazhat egzisztenciális és univerzális kvantorokat kapcsoló feltételek fefe@coffein.hu ( 18 / 117 )

19 3/C /2 Reláció kalkulus. Ezeket felhasználva a feladat megoldása lehet a következõ is: {e.lname, e.fname EMPLOYEE(e) and (( x)(not (PROJECT(x)) or (x.dnum = 5) or (( w)(works_on(w) and w.essn = e.ssn and x.number = w.pno ))))} A logikai feltétel véges számú rekordot kell eredményezzen! Példa a végtelen számú rekordot eredményezõ TRC-re: {t not (EMPLOYEE(t))} A világot tekintve ez tényleg végtelen sok rekordot eredményez. 2. Tartomány alapú reláció kalkulus Tartományváltozókat vezetünk be, melyek értékeiket az attribútumok tartományából vehetik fel. Általános alakja: {x 1,...,x n COND (x 1,...,x n, x n+1,...,x n+m )} Azon érték n-eseket eredményezi, melyekre a feltétel igaz. Példa: Az elõzõ A TRC-s példa. { u, s ( a)(hallgato(a, n, c, s, d) and ( t)( b)(tantargyfelvetel(b, f, t) and t = 'I1201' and b=a))} a,b n c s d t - hallgató_azonosító - név - cím - szak - születési_dátum - tantárgykód fefe@coffein.hu ( 19 / 117 )

20 3/D Az operációs rendszerek fõbb komponensei. Az operációs rendszer komponensei (idealizált) 1. Folyamat kezelés (Process management) 2. Memória kezelés (gazdálkodás) 3. Másodlagos tár kezelés 4. I/O rendszer kezelés 5. Fájl kezelés 6. Védelmi rendszer 7. Hálózat-elérés támogatása 8. Parancs interpreter rendszer 1. Folyamat kezelés (Process management) Folyamat (process - processzus) egy végrehajtás alat levõ program. A folyamatnak bizonyos erõforrásokra (így pl. CPU idõ, memória, állományok, I/O berendezések) van szüksége, hogy a feladatát megoldhassa. Az operációs rendszer az alábbi tevékenységekért felel a folyamatok felügyeletével kapcsolatban: Folyamat létrehozása és törlése. Folyamat felfüggesztése és ujraindítása. Eszközök biztosítása a folyamatok szinkronizációjához, a folyamatok kommunikációjához. 2. Memória (fõtár) kezelés (gazdálkodás) Az operatív memóriát bájtokból (szavakból) álló tömbnek fogjuk tekinteni, amelyet a CPU és az I/O vezérlõ megosztva (közösen) használ. Tatalma törlõdik a rendszerkikapcsolásakor és rendszerhibáknál. Az operációs rendszer a következõ dolgokért felelõs a memória kezelést illetõen: Nyilvántartani, hogy az operatív memória melyik részét ki (mi) használja. Eldönteni, melyik folyamatot kell betölteni, ha memória felszabadul. Szükség szerint allokálni és felszabadítani memória területeket a szükségleteknek megfelelõen 3. Másodlagos tár kezelés Mivel az operatív tár (elsõdleges tár) törlõdik (és egyébként sem alkalmas arra, hogy minden programot tároljon), a másodlagos tárra szükség van. Merev lemezes tár, a másodlagos tár legelterjedtebb megjelenése. Az operációs rendszer a következõ dolgokért felelõs a másodlagos tárkezelést illetõen: Szabad-hely kezelés Tár-hozzárendelés Lemez elosztás (scheduling) 4. I/O rendszer kezelés: Az I/O rendszer az alábbi részekbõl áll: Puffer (Buffer/Cache) rendszer Általános készülék-meghajtó (device driver) interface Speciális készülékek meghajtó programjai 5. Fájl (állomány) kezelés Egy fájl kapcsolódó információ (adatok) együttese, amelyet a létrehozója definiál. Általában program- (különbözõ formák), vagy adatfájlokkal dolgozunk. Az operációs rendszer a következõ dolgokért felelõs a fájl kezelést illetõen: Fájl létrehozása és törlése Könyvtár létrehozása és törlése Fájlok leképezése a másodlagos tárba. Fájlok mentése valamilyen nemtörlõdõ, stabil adathordozóra. Fájlokkal és könyvtárakal történõ alap-manipulációhoz nyújtott támogatás. fefe@coffein.hu ( 20 / 117 )

21 3/D /2 Az operációs rendszerek fõbb komponensei. 6. Védelmi rendszer Védelem általában valamilyen mechanizmusra utal, amelynek révén mind a rendszer-, mind a felhasználói erõforrásoknak a programok, folyamatok, vagy felhasználók által történõ elérése felügyelhetõ, irányítható. A védelmi mechanimusnak tudnia kell: különbséget tennie authorizált (jogos) és jogtalan használat között, specifikálni az alkalmazandó kontrolt, szolgáltatni a korlátozó eszközöket. 7. Hálózat-elérés támogatása (elosztott rendszerek) Egy elosztott rendszer processzorok adat és vezérlõ vonallal összekapcsolt együttese, ahol a processzorokhoz nincs közös memóriájuk és órájuk. (lokális memória, óra). Az adat- és vezérlõ vonalak egy kommunikációs hálózat részei. Az elosztott rendszer a felhasználóknak különbözõ osztott erõforrások elérését teszi lehetõvé. Az erõforrások osztott elérése lehetõvé teszi: a számítások felgyorsítását, a jobb adatelérhetõséget, a nagyobb megbízhatóságot. 8. Parancs interpreter (al)rendszer Az operációs rendszernek sok parancsot ún. vezérlõ utasítás formájában lehet megadni. Ezek a vezérlõ utasítások az alábbi területekhez tartozhatnak: folyamat létrehozás és kezelés I/O kezelés másodlagos tár kezelés operatív tár kezelés fájl rendszer elérés védelem hálózat kezelés Az operációs rendszernek azt a programját, amelyik a vezérlõ utasításokat (be)olvassa és interpretálja a rendszertõl függõen más és más módon nevezhetik: vezérlõ kártya interpreter (control-card Job Control, JC) parancs-sor interpreter (command-line) héj (burok, shell) (UNIX) fefe@coffein.hu ( 21 / 117 )

22 4/A halmaz /set/ és a multihalmaz. Struktúra nélküli adatszerkezet. Az egyes adatelemek közt nincs kapcsolat, sorrend. Statikus, homogén, véges. A multihalmazban ugyanaz az elem többször is elõfordulhat. Matematikai halmazfogalom megfeleltetése adatszerkezet szinten. Mindkét adatszerkezet dinamikus és véges. Beszélhetünk üreshalmazról is, viszont végtelen halmaz, mint adatszerkezet nem létezik. Speciális adatszerkezeti mûveletek vannak: (,,,\ in,+,*, ),in: Meg lehet állapítani, hogy egy adott elem benne van-e a halmazban, vagy sem. Eredménye mindig logikai érték., +: A multihalmazban az unió az összes elem unióját jelenti, tehát ha pl: az egyik halmazban "a" 5x szerepel, a másik halmazban 3x, akkor uniójukban 8x fog. Pl. ha A B=C, akkor A + B = C., *: Ugyanez igaz a metszetképzésre is, tehát az elõbb említett két halmaz metszetében "a" 3x fog szerepelni. A következõkben definiált mûveletek multihalmazra is igazak. Mûveletek Létrehozás: Megadhatok egy predikátumot (feltételt). A halmaz elemei azok lesznek, amelyek igazzá teszik a feltételt. pl: X={200-nál nem nagyobb pozitív egész számok} Felsorolhatom a halmaz elemeit, azaz konkrétan megadom õket. pl : Y={fekete, piros, kék, fehér, sárga} Létezik üreshalmaz, és ehhez unióval hozzápakolom az elemeket, és így jön létre a halmaz. Bõvítés: Unióképzéssel. Törlés: Különbségképzéssel. Csere: Nem létezik, mert nem tudom megfogni az elemeket. Ha kitörlök egy elemet és újat viszek be, akkor egy szimulált cserét csináltam. Keresés: Nincs, a fenti indok miatt. Rendezés: Nem értelmezhetõ. Rendezett halmaz nem halmaz, hanem egy másik adatszerkezet. Gyakran nincs is értelme a rendezésnek. Bejárás: Nincs, mert nem tudom megfogni az elemeket. Feldolgozás: A definiált mûveletek alkalmazása. A halmazok között értelmezhetõ az összehasonlítási mûvelet. Két halmaz egyenlõ, ha ugyanazokat az elemeket tartalmazza, egyébként nem. Ha az egyik halmaz részhalmaza a másiknak, akkor az a kisebb. H K H<K Halmazok reprezentációja: A karakterisztikus függvényen alapul, általában folytonos tárolást alkalmaznak. A reprezentációs szinten sorrend van, amikor a halmaz elemeit egy sorrendiséggel rendezett tárhelyre képezzük le. Annyi bitet foglalunk le, amennyi halmazelem van. A tár véges, a tárhely kicsi. Tudom, hogy maximálisan hány eleme van a halmaznak. A halmaz elemeit sorrendbe rakom. A biteket 1- re állítom, ha az adott elem benne van a halmazban, 0-ra ha nincs benne. üreshalmaznak minden bitje 0. Ha minden elem benne van a halmazban, akkor minden bit 1-es. Ez a karakterisztikus függvény. Pl. S= { hexadecimális számjegyek } Karakterisztikus függvény: 16 bit = 2 bájt. Legyen S={1,4,8,A} A feltételezett sorrend: 0,1,...,E,F Ez az S halmaz reprezentációja. Az implementáció dolga, hogy a halmaz elemei hol vannak, ezt a felhasználónak nem szabad, nem illik tudni. Elõnye, hogy az összes halmazmûvelet visszavezethetõ logikai mûveletre. Multihalmaz: vektorral ábrázolható.. Adott pozíción lévõ érték megmondja, hogy az elem hányszor fordul elõ a halmazban. fefe@coffein.hu ( 22 / 117 )

23 4/B A változó fogalma, a változó az imperatív és a deklaratív programnyelvekben. Imperatív nyelvek Programozási eszköz, 4 komponense: Név: a másik 3 komponens ehhez kötõdik. A tárrész neve. Attributumok: a változó futás közbeni viselkedését szabályozzák. A típusos nyelvekben a típus kötõdik a változóhoz. Az attributum hozzárendelése a változóhoz lehet: explicit: a deklaráció külön utasítás. (pl. VAR). A programozó kapcsolja az attributumot a változóhoz. Minden eljárásorientált nyelv ismeri. implicit: betûkhöz rendelhetõ attributum. Ha a változóhoz nincs explicit rendelve attributum, de a kezdõbetûjéhez van, akkor az rendelõdik hozzá. automatikus: a fordítóprogram rendel attributumot a változó nevéhez. (A név kezdõbetûje alapján). Pascal, ADA: minden változót explicit kell deklarálni. A FORTRAN, C mindhárom lehetõséget ismeri. Tárcím: a tár azon kezdõcíme, ahol a változó értéke elhelyezkedik. A tárkiosztás lehet: statikus: futás elõtt eldõl, hogy melyik tárcím lesz hozzárendelve. (Fordító, szerkesztõ vagy betöltõ rendeli hozzá.) A tárcím futás közben nem változik, címkomponense állandó. dinamikus: a címkomponens futási idõben dõl el, futás közben megváltozhat. Lehet olyen részideje a futásnak, amikor a változónak nincs címkomponense. A dinamikus változók akkor kapnak címkomponenst, amikor aktivizálódik az a programegység, amelynek lokális változói. A címkomponens megszûnik, ha a programegység befejezi mûködését. A címet a futtató rendszer rendeli a változóhoz. programozó által vezérelt: a címkiosztás a program szövegébe épített módon, futási idõben történik. Lehet abszulút, relatív vagy a futtató rendszer rendeljen hozzá. adott idõpontban címet. Az eljárásorientált nyelvekban statikus vagy dinamikus tárkiosztás szokott lenni. A Pascal a dinamikus és a programozó által vezérelt cmkiosztást ismeri, a Turbopascal, C mindhármat. A NIL nevesített konstans megszünteti a tárcímet. Érték: egy bitkombináció. Az értékkomponenst a változó megkaphatja: értékadó utasítással: programszövegben. Bal oldalán: változó, jobb oldalán: kifejezés. input perifériáról kezdõértékadással: explicit módon, ahogy az attributumokat is megadjuk. (A nyelvek egy részében lehetséges.) A hivatkozási nyelvekben a változó értéke határozatlan, amíg értéket nem kap. Az implementációk egy részében implicit értékadás történik, speciális bitkombinációt kap. (0). Tpas7.0-tól kezdve. Többszörös tárfoglalás: a változó neve, esetleg attributumok is különböznek, de az értékkomponens azonos. A C nyelvben a változó neve hordozhatja az érték, és a címkomponenst is. Deklaratív nyelvek: Prolog változó fogalma: Csak név, cím és értékkomponense van, attributumkomponense nincs. Nem típusos nyelv, nincs típusfogalom. Név: a program szövegében ezzel jelenik meg. Ez imperatív értelemben vett azonosító. Értékét speciálisan kezeli a Prolog. Két jól definiált állapota: van vagy nincs értéke. Egyik állapotból át lehet vinni a másikba, lehet törölni. Ha van értéke, azt nem lehet felülírni. (Egyszeres értékadás törvénye). fefe@coffein.hu ( 23 / 117 )

24 4/B /2 A változó fogalma, a változó az imperatív és a deklaratív programnyelvekben. A változó a programban mindenütt, ahol a neve le van írva, ugyanazt az értéket képviseli. (Tehát nincs értéke vagy egyforma értéke van mindenütt.) A szövegkörnyezettõl függ, hogy értéket hordoz vagy csak a nevét jelenti. A tárbeli érték nem a programozó számára létezik. Az értékadás a rendszer feladata. Lisp változó fogalma: létezik. Típusa nincs, de értéke megváltoztatható, értékül adható. fefe@coffein.hu ( 24 / 117 )

25 4/C Egy ER séma leképezése relációsra. Entry-Relationship (ER) 1967-ben CHEN írja le ezt a modellt. Maga a modell egy sématervezõ eszközként jött létre, növelvén a séma absztrakciós szintjét a hálós és relációs modellel szemben. Ez az elsõ szemantikus modell. A vele létrehozott koncepcionális sémát le lehet képezni vele hálós vagy relációs sémává, és innen kezelni lehet ezt hálós vagy relációs kezelõ nyelvvel. Az ilyen modellnek létezik persze absztrakt kezelõ nyelve. De napjainkig megmaradt sématervezõ eszköznek. Adatbáziskezelõ modell elméletben van, gyakorlatban nincs. Az ER szerint az egyed egy olyan objektum, amely létezik és különbözik minden más egyedtõl. Lehet konkrét vagy absztrakt. Az egyedet attribútumokkal reprezentálják, minden attribútum lényeges tulajdonsága, hogy értékeit mely tartományból veheti föl. Az attribútumok közös tulajdonsága, hogy egy tulajdonságtípusba tartoznak. Ha van két egyedtípus, akkor fontos, hogy legyenek közös egyedek. Az ER értelmezi a következõ fogalmakat : szuperkulcs, kulcs, kulcsjelölt, elsõdleges kulcs halmazértékû és összetett attribútum tárolt és származtatott attribútum ER-séma relációs sémára való leképezése: E erõs egyedtípusnak R relációs séma felel meg. E egyszerû attribútumai R attribútumaiként jelennek meg. Az összetett attribútumok helyett a komponens attribútumok jelennek meg az R attribútumaiként. A halmazértékû attribútumot külön kezeli. Az elsõdleges kulcs egyértelmû. WE gyenge egyedtípus esetén létrejön egy relációs séma, melynek attribútumai WE egyszerû és összetett attribútumai (az elõzõ értelemben) és a WE ehhez tartozó domináns egyedtípusának elsõdleges kulcsa, mint külsõ kulcs. (W elsõdleges kulcsa: külsõ kulcs + diszkriminátor ) Minden bináris 1:1 számosságú kapcsolattípus esetén: S T S-T összekötõ Válasszuk ki S és T közül bármelyiket, képezzük le a relációs sémára és vegyük ki az attribútumok közül T elsõdleges kulcsát, mint külsõ kulcsot, továbbá kapcsolattípus esetén a szükséges attribútumot. Bármely bináris 1:N kapcsolattípust jelentsünk meg egy olyan relációs sémával, amely N-hez tartozik. Ágyazzuk be a másik elsõdleges kulcsát és attribútumát. Bármely M:N számosságú kapcsolattípus egy olyan sémára képezhetõ le, melynek elsõdleges kulcsa a kapcsoló egyedtípus kulcsai együtt mint külsõ kulcsok, leíró attribútumai pedig a kapcsolattípusok. Minden halmazértékû attribútum esetén létre kell hozni egy olyan relációs sémát, amely tartalmazza ezt az attribútumot, továbbá külsõ kulcsként azon relációs séma elsõdleges kulcsát, melyre azt az egyedtípust képeztük le, amely eredetileg rendelkezett ezzel a halmazértékû attribútummal. Többszörös kapcsolattípus esetén létre kell hozni egy relációs sémát melyben külsõ kulcsként szerepelnek a kapcsolt egyedtípust reprezentáló sémák elsõdleges kulcsai, ezek együttesen alkotják a relációs séma elsõdleges kulcsát. A kapcsolattípus attribútumai leíró attribútumként jelennek meg. fefe@coffein.hu ( 25 / 117 )

26 4/C /2 Egy ER séma leképezése relációsra. Az ER a legjobb sématervezõ eszköz. Az ER egy új absztrakciós szintet képvisel a többihez képest, de ez még mindig elég alacsony - a kapcsolatok között nincs kapcsolat, az egyedtípusok között csak kapcsolat jellegû viszony van. Az ER egyetlen absztrakciós lehetõsége a többin kívül: összevonás/agregáció (agregation) név DOLGOZÓ TAJ óra Normán M M dolgozik normál N N PROJECT 2 egyedtípus között több kapcsolattípus van agregáció A séma felsõ részébõl csinál egyedtípust, melynek belsõ struktúrája van. d o lg o zik M no rm ál K gép azonosító K gép azo no sító fefe@coffein.hu ( 26 / 117 )

27 4/D Futtató rendszer. Programvégrehajtás A végrehajtási fázis jellemzõje, hogy a munkalépés programja aktív a rendszerben, a multiprogramozott környezetben versenyez az erõforrásokért. Egyáramú rendszerben a munka folyamatosan fut, a számlázandó idõ akár "faliórával" is mérhetõ. Multiprogramozott környezetben viszont a végrehajtási idõ és a felhasznált idõ szükségszerûen eltérõ. A végrehajtási idõ olykor lényegesen hosszabb lehet, mint multiprogramozás nélkül. Ez a felhasználó szempontjából veszteségidõ. Ezalatt azonban a munka nem állandóan aktív, és a számlázórendszer feladata, hogy csak azokat az idõket és erõforrásokat számítsa fel a felhasználónak, amit ténylegesen felhasznált. Elõfordul, hogy két olyan munka kerül össze a multiprogramozott környezetben, amelyek "egymást ütik". Tipikus példa erre az olyan eset, amikor két program ugyanazt a mágneslemezes adatállományt olvassa aszinkron módon. Ilyenkor a lemezegység olvasófeje oda-vissza rángatódzik, ami igen nagy idõveszteségeket okoz. Ha a két program eltérõ idõintervallumban futhat, akkor érthetõ okoknál fogva gyorsabban befejezõdhetnek, sõt a hardver igénybevétele is kedvezõbb. Az adott szituációt elég nehéz programozottan kiszûrni, ezért még mindig sok függ az alkalmazók odafigyelésétõl, és az üzemeltetés manuális ütemezési tevékenységétõl. Jellemzõ, hogy az említett szituációban az operációs rendszer a rossz hatásfokú mûködésbõl eredõ terheket könyörtelenül leszámlázza a két program indítójának, holott õk esetleg nem is tehetnek róla. Záró fázis Amikor egy program lefut, az operációs rendszernek még egy sereg teendõje marad. A program befejezõdése után vissza kell venni tõle a lefoglalt erõforrásokat, és különféle adminisztratív mûveleteket kell végrehajtani. Ezt vezérli a terminátor program. A további tipikus feladat a háttértárra vitt nyomtatókimenet átadása a nyomtató spooling rendszernek, azaz elhelyezés a kimeneti sorban. Ha a spooling rendszer végez a munka eredményének kilistázásával, akkor az operációs rendszer véglegesíti a munkára vonatkozó számlázási adatokat, és a munkához tartozó táblázatokat törli, hogy a már érdektelen információk ne terheljék a rendszer táblázatait. fefe@coffein.hu ( 27 / 117 )

28 5/A A tömb, mint adatszerkezet. Háromszög mátrixok és ritka mátrixok kezelése. Tömb: A legismertebb, a leggyakrabban alkalmazott statikus adatszerkezet. A tömb minden eleme egész számok sorozatán keresztül érhetõ el (ezek az egész számok a tömbindexek). Az indexek alkalmazása azt teszi lehetõvé, hogy egyelemû részhalmazokat képezhetünk. Ha az adatelemekbõl egy adott elem kiválasztását 1 index-szel meg tudom valósítani, akkor egydimenziós tömbrõl vagy vektorról beszélünk. Ha két index segítségével lehet kiválasztani minden elemet, akkor kétdimenziós tömbrõl, mátrixról beszélünk. A 3 dimenziós tömb lapokból áll. Mûveletek Létrehozás: A szerkezet létrehozása, nem az értékeké. Megmondom a dimenziók számát és minden dimenzióban az indextartományt. A szerkezetet hozom létre, így már az elején eldõl, hogy a tömb hány elemet tartalmaz (mivel statikus a szerkezet). Ebbe a szerkezetbe pakolom bele az elemek értékét. Bõvítés: Nincs olyan, hogy új helyre új elem bevitele, mivel a tömb statikus, az adatelemeket létrehozáskor fixáltam. Szûkebb változata az, hogy adatelemet viszek be az üres szerkezeti helyekre. Átvitt értelemben: megadom azoknak az adatelemeknek az értékét, amelyeket eddig még nem adtam meg. Törlés: Errõl sem beszélünk, mert az adatelemek számát nem tudom csökkenteni. Csak logikai törlésrõl beszélünk: az adatelemek értéket egy speciális értékre állítom. Csere: Indexek alapján bármelyik elemet kiválaszthatom és értékét felülírhatom. Elérés: közvetlen. Bármelyik elem a többitõl függetlenül megfogható, az indexekkel hivatkozom rá. Rendezés: Általában egydimenziós tömbnél foglalkozunk vele. Arra az összes rendezési módszer alkalmazható. Keresés: Értelmezhetõ mindenféle tömbnél. Értelmezése reprezentáció-függõ. Ha a feltételek adottak, akkor egy dimenziós tömbnél (itt van jelentõsége) az összes keresési algoritmus alkalmazható. Bejárás: Értelmezhetõ, reprezentáció-függõ. Többdimenziós tömböknél igazán érdekes. Feldolgozás: Az indexeken alapul, azon, hogy segítségükkel bármely elem közvetlenül elérhetõ, feldolgozható. Tárolás: A folyamatos és szétszórt tárolás egyaránt alkalmazható a tömböknél. Általában folytonos tárolást alkalmaznak. A tömb eképezése folytonos társzerkezetre as, as, t as, t 1 m a a s 1, t s 1, t 1 a a n, t n, t 1 a n, m Lehet sor vagy oszlopfolytonos. Sorfolytonosan: a s,t ; a s,t+1 ; a s,t+2 ; ; a n,m-1 ; a n,m Oszlopfolytonosan: a s,t ; a s+1,t ; a s+2,t ; ; a n-1,m ; a n,m Mátrixok kezelése: Abban az esetben, ha a mátrix háromszög mátrix, azaz a fõátló alatt vagy fölött minden elem 0, a 0 elem tárolását meg lehet spórolni. A mátrixot kezeljük vektorként, képezzük le egydimenziós tömbre, ez csak a nem nulla elemeket tartalmazza. Elemi száma: m=n*(n+1)/2 A a a n 0 a 22 a 2 n 0 0 a a nn fefe@coffein.hu ( 28 / 117 )

29 5/A /2 A tömb, mint adatszerkezet. Háromszög mátrixok és ritka mátrixok kezelése. A mátrix leképezése a következõ módon történik (sorfolytonos leképezés): Sokszor kell olyan mátrixot használni, hogy sok elem 0, vagy sok azonos elem van. Ezeket nevezzük ritka mátrixoknak. A kérdés az, hogy ezeket hogyan tudjuk kezelni. Három soros reprezentáció: A három egydimenziós tömb azonos elemei írnak le egy-egy elemet sorfolytonos ábrázolásban. Négy soros reprezentáció A mutató vektor dolga, hogy lerendezze az oszlopok kezelését. Értékét úgy állítjuk be, hogy a megfelelõ helyre beírjuk a soros reprezentáció azon indexét, amelyik megmondja, hogy mely indexnél található az oszlop következõ nem 0 eleme. (például: A 2. oszlopban a következõ nem 0 elem a négyes. A négyes elemet a sorvektorban a negyedik elem írja le, így valóban négy az index. Ugyanez látható a 6.oszlopnál.) Ennek oszlopfolytonos feldolgozásnál van jelentõsége, lehetõvé teszi, hogy ne kelljen végignézni szekvenciálisan az egészet, mert megmondja, hogy hol a következõ elem az adott oszlopban. A négy sorhoz még két vektort hozzáveszek, melyeket jelöljünk S-el és O-val. A két vektor úgy van megállapítva, hogy a vektor i-edik eleme megadja, hogy hol helyezkedik el az i-ik sor elsõ nem 0 eleme a SOR illetve az OSZLOP vektorban, így közvetlenül fel tudok dolgozni bármilyen mátrixot. Az S-bõl látható, hogy a 3.,4. sora csupa 0. Az S és O vektor egy adott eleme azt mutatja meg, hogy az adott sor, illetve oszlop következõ nem 0 eleme hol helyezkedik el a 4-soros reprezentációban. Értéke 0, ha abban az oszlopban nincs több nem 0 elem. Közvetlenül hozzáférhetek a sorhoz és oszlophoz. fefe@coffein.hu ( 29 / 117 )

30 5/B Kivételkezelés. A kivételkezelési eszközrendszer azt teszi lehetõvé, hogy az operációs rendszertõl átvegyük a megszakítások kezelését, felhozzuk azt a program szintjére. A kivételek olyan események, amelyek megszakítást okoznak. A kivételkezelés az a tevékenység, amelyet a program végez, ha egy kivétel következik be. Kivételkezelõ alatt egy olyan programrészt fogunk érteni, amely mûködésbe lép egy adott kivétel bekövetkezte után, reagálva az eseményre. Egyes kivételek figyelése letiltható vagy engedélyezhetõ. Egy kivétel figyelésének letiltása a legegyszerûbb kivételkezelés. Ekkor az esemény hatására a megszakítás bekövetkezik, feljön programszintre, kiváltódik a kivétel, de a program nem vesz róla tudomást, fut tovább. Természetesen nem tudjuk, hogy ennek milyen hatása lesz a program további mûködésére, lehet, hogy az rosszul, vagy sehogy sem tudja folytatni munkáját. A kivételeknek általában van neve (amely gyakran az eseményhez kapcsolódó üzenet szerepét játssza) és kódja (ami egy egész szám). A kivételkezelés a PL/I-ben jelenik meg és az Ada is rendelkezik vele. A két nyelv kétfajta kivételkezelési filozófiát vall. A PL/I azt mondja, hogy ha egy program futása folyamán bekövetkezik egy kivétel, akkor az azért van, mert a program által realizált algoritmust nem készítettük föl az adott esemény kezelésére, olyan szituáció következett be, amelyre speciális módon kell reagálni. Ekkor keressük meg az esemény bekövetkeztének az okát, szüntessük meg a speciális szituációt és térjünk vissza a program normál mûködéséhez, folytassuk a programot ott, ahol a kivétel kiváltódott. Az Ada szerint viszont, ha bekövetkezik a speciális szituáció, akkor hagyjuk ott az eredeti tevékenységet, végezzünk olyan tevékenységet, ami adekvát a bekövetkezett eseménnyel és ne térjünk vissza oda, ahol a kivétel kiváltódott. A kivételkezelési eszközrendszerrel kapcsolatban a nyelveknek a következõ kérdéseket kell megválaszolni: 1. Milyen beépített kivételek vannak a nyelvben? (általában igen) 2. Definiálhat-e a programozó saját kivételt? (általában igen) 3. Milyenek a kivételkezelõ hatásköri szabályai? 4. A kivételkezelés köthetõ-e programelemekhez (kifejezés, utasítás, programegység)? 5. Hogyan folytatódik a program a kivételkezelés után? 6. Mi történik, ha kivételkezelõben következik be kivétel? (filozófiától függ) 7. Van-e a nyelvben beépített kivételkezelõ? 8. Van-e lehetõség arra, hogy bármely kivételt kezelõ (általános) kivételkezelõt írjunk? (általában van) 9. Lehet-e parametrizálni a kivételkezelõt? (általában nem, de van olyan nyelv, amelyben lehet) Sem a PL/I-ben, sem az Adában nincs parametrizált és beépített kivételkezelõ, a részleteket illetõen pedig az alábbiakat mondják. A PL/I KIVÉTELKEZELÉSE A PL/I beépített kivételei a következõk: CONVERSION konverziós hiba FIXEDOVERFLOW fixpontos túlcsordulás OVERFLOW lebegõpontos túlcsordulás UNDERFLOW lebegõpontos alulcsordulás ZERODIVIDE nullával való osztás SIZE mérethiba fefe@coffein.hu ( 30 / 117 )

31 5/B /2 Kivételkezelés. A programozó saját kivételt tud deklarálni. CONDITION(név) A program szövegében bárhol elhelyezhetõ kivételkezelõ. A kivételkezelõ hatásköre egy adott programegységben attól az idõponttól kezdõdik, amikor a vezérlés áthaladt rajta, és tart egy másik ugyanerre a névre kiadott kivételkezelõig (mely fölülírja az elõzõ hatását), ugyanerre a névre kiadott REVERT kivételnév; utasításig (mely érvényteleníti a legutolsónak kiadott ON-utasítás hatását), vagy a programegység befejezõdéséig, beleértve a kivételkezelõ hatáskörén belül meghívott minden egyes programegységet is. A kivételkezelõ hatásköre tehát dinamikus. Ha egy programegységben bekövetkezik egy kivétel, akkor a futtató rendszer megnézi, hogy az adott kivétel figyelése engedélyezett-e vagy sem. Ha letiltott, akkor folytatódik tovább a programegység végrehajtása. Ha a kivétel figyelése engedélyezett, akkor megnézi a futtató rendszer, hogy ezen a ponton van-e olyan látható kivételkezelõ, amely az adott kivétel nevét tartalmazza. Ha van ilyen, akkor lefut a kivételkezelõ. A kivételkezelõ dinamikus hatáskörkezelésbõl problémák adódhatnak. A nevek hatáskörkezelése statikus, a kivételkezelõé dinamikus, ez ellentmondáshoz vezethet. A AZ ADA KIVÉTELKEZELÉSE Az Ada beépített kivételei általában eseménycsoportot neveznek meg. Ezek a következõk: - CONSTRAINT_ERROR: Olyan eseménycsoport, amely akkor következik be, ha valamilyen deklarációs korlátozást megpróbálunk túllépni. Például index határának átlépése. - NUMERIC_ERROR: Aritmetikai hibák, alul- ill. túlcsordulás, 0-val való osztás, stb. - STORAGE_ERROR: Tárhiba (minden allokálási probléma ide tartozik): a tárrész, amelyre hivatkoztunk nem áll rendelkezésre. - TASKING_ERROR: Az adott taszkkal nem jöhet létre randevú. - SELECT_ERROR: SELECT-utasítás hiba. Alaphelyzetben minden kivétel figyelése engedélyezett, de egyes események figyelése (bizonyos ellenõrzések) letiltható. Erre egy pragma szolgál, melynek alakja: SUPPRESS(név [,ON => { eszköznév típus }] ) A név a letiltandó esemény neve. Egyetlen eseményt azonosít, nem egyezik meg a beépített Ha egy programegységben kiváltódik egy kivétel, akkor a futtató rendszer megvizsgálja, hogy az adott kivétel figyelése le van-e tiltva. Ha igen, akkor a program fut tovább, különben a programegység befejezi mûködését. Ezek után a futtató rendszer megnézi, hogy az adott programegységen belül van-e kivételkezelõ. Ha van, akkor megnézi, hogy annak van-e olyan WHEN-ága, amelyben szerepel az adott kivétel neve. Ha van ilyen ág, akkor végrehajtja az ott megadott utasításokat. Ha ezen utasítások között szerepel a GOTO-utasítás, akkor a megadott címkén folytatódik a program. Ha nincs GOTO, akkor úgy folytatódik a program futása, mintha a programegység szabályosan fejezõdött volna be. Ha a kivétel nincs nevesítve, megnézi, hogy van-e WHEN OTHERS ág. Ha van, akkor az ott megadott utasítások hajtódnak végre és a program ugyanúgy folytatódik mint az elõbb. Ha nincs nevesítve a kivétel egyetlen ágban sem és nincs WHEN OTHERS ág, vagy egyáltalán nincs kivételkezelõ, akkor az adott programegység továbbadja a kivételt. Ez azt jelenti, hogy a kivétel kiváltódik a hívás helyén, és a fenti folyamat ott kezdõdik elõlrõl. Tehát a hívási láncon visszafelé lépkedve keres megfelelõ kivételkezelõt. Ha a hívási lánc elejére ér és ott sem talál kivételkezelõt, akkor a program a kivételt nem kezelte és a vezérlés átadódik az operációs rendszernek. Kivételkezelõben kiváltott kivétel azonnal továbbadódik. fefe@coffein.hu ( 31 / 117 )

32 5/C Funkcionális függés és jellemzõi. Két attribútumhalmaz közötti összefüggést/kapcsolatot írja le. Legyen X és Y az R reláció két attribútumhalmaza! Y funkcionálisan függ X-tõl ( vagy X funkcionálisan meghatározza Y-t), ha bármelyik két rekord esetén abból, hogy a két rekord X attribútum-értékei megegyeznek következik, hogy az Y attribútum-értékei is megegyeznek. Jelölés : X Y A funkcionális függés nem kétirányú kapcsolat! Ha X Y és Y X egyszerre áll fenn, akkor azt mondjuk, hogy X és Y kölcsönös funkcionális függésben áll egymással. Tulajdonságai: 1. Reflexivitás x y x y t 1 [x] = t 2 [x] t 1 [y] = t 2 [y] 2. Augmentivitás - bõvítés x y xz yz Indirekt módon bizonyítjuk : (1) t 1 [x] = t 2 [x] (2) t 1 [y] = t 2 [y] (3) t 1 [xz] = t 2 [xz] (4) t 1 [yz] t 2 [yz] - indirekt feltevés (1) és (3) t 1 [z] = t 2 [z] (5) (2) és (5) ellentmondást kapunk az indirekt feltétellel, azaz a bizonyítás kész 3. Tranzitivitás x y, y z x z A további funkcionális függés tulajdonságok az elõzõ hármat felhasználva könnyen felírhatók, származtathatók. 4. Dekompozíciós tulajdonság x yz x z xz y yz y x y tranzitivitás miatt 5. Additivitás x y, x z x yz x xy xx=x (A 2. tulajdonságot használtuk fel.) xy yz Ezekbõl következik a tranzitivitás miatt, hogy x yz 6. Pszeudotranzitivitás x y, wy z wx z Az elsõ három tulajdonságot szokás ARMSTRONG tulajdonságoknak/axiómáknak nevezni. Ezekbõl a többi levezethetõ. fefe@coffein.hu ( 32 / 117 )

33 5/D Folyamatok és szálak. Állapotok. Folyamatvezérlõ blokk. Hosszú és rövid távú ütemezés. Folyamatok kommunikációja és szinkronizációja. Folyamat (processzus) fogalma: végrehajtás alatt álló program. Processzus - vezérlõ blokk (Process Control Block PCB) processzus állapot (process state) : new, ready, running, waiting, halted, sleeping, Program címszámláló (PC) értéke CPU regiszterek tartalma memória foglalási adatok account/user adatok I/O státusz információ (a folyamathoz rendelt I/O erõforrások, állományok listája) Folyamat ütemezés (scheduling) Cél: mindig legyen legalább egy processzus, amelyik képes és kész a processzort lefoglalni. Processzus ütemezési sorok: job queue (munka sor) ready queue (készenléti sor) device queue (berendezésre váró sor) Folyamat migráció az egyes sorok között: Hosszútávú ütemezõ (long term scheduler, job scheduler): mi kerül a job queue-ba, lehet lassú, a multiprgramozás foka fefe@coffein.hu ( 33 / 117 )

34 5/D /2 Folyamatok és szálak. Állapotok. Folyamatvezérlõ blokk. Hosszú és rövid távú ütemezés. Folyamatok kommunikációja és szinkronizációja. Rövidtávú ütemezõ (short term scheduler, CPU scheduler): melyik folyamat kapja meg következõ alkalommal a CPU-t, gyorsaság lényeges Context switch (process context a processzus továbbindításához szükséges összes információ rendszerezve, struktúrálva kapcsolódó adatszerkezetek.) Folyamatokon végzett "mûveletek" (operációk) 1. Processzus létrehozása: (kezdeti betöltést kivéve processzust csak processzus hozhat létre!) Mechanizmusa: egy szülõ (parent) folyamat létrehozhat gyermek (child) folyamatokat, majd a gyermekek további gyermekeket fastruktúra 2. Erõforrás megosztás: Szülõ és gyermek közösen használ minden erõforrást. A gyermek a szülõ erõforrásainak egy részét használhatja. Nincs közös erõforráshasználat. 3. Végrehajtás: Szülõ és gyermek konkurens módon fut. (UNIX: parancs&) Szülõ a gyermekre vár. (UNIX: parancs ) Címtér (address space) A gyermek a szülõ duplikáltja. A gyermek betölt egy programot önmaga helyett. UNIX példák: fork, execve 4. Processzus megszün(tet)ése (termination): A folyamat végrehajtja az utolsó utasítását, majd megkéri az operációs rendszert, hogy törölje. A folyamat által használt erõforrásokat az operációs rendszer felszabadítja. A szülõ folyamat felfüggesztheti a gyermek folyamatok végrehajtását (abort). Az operációs rendszer (legtöbb esetben) nem engedi meg, hogy egy gyermek tovább éljen, mint a szülõ! Kaszkád termináció (A szülõvel együtt elhal az összes gyermeke). FOLYAMATOK EGYÜTTMÛKÖDÉSE, KOOPERÁCIÓJA Független folyamatok nem befolyásolnak más folyamatokat és nem befolyásolhatók más folyamatok által. Együttmûködõ folyamatok befolyásolhatnak más folyamatokat és befolyásolhatók lehetnek más folyamatok által. A kooperáció elõnyei: Információ megosztás Számítási folyamatok felgyorsítása Kényelem, kényelmi szempontok. Termelõ (producer) folyamat valamilyen adatot hoz létre. Fogyasztó (consumer) folyamat az adatot fel(el)- használja. Közös memória véges pufferrel megoldás fefe@coffein.hu ( 34 / 117 )

35 5/D /3 Folyamatok és szálak. Állapotok. Folyamatvezérlõ blokk. Hosszú és rövid távú ütemezés. Folyamatok kommunikációja és szinkronizációja. SZÁLAK (fonalak, könnyûsúlyú folyamatok, thread, lightweight process) A szál a CPU kiszolgálás egy alapegysége. Jellemzõi: program címszámláló regiszter készlet (tartalma) verem tartalma Egy szál megosztva használja a vele egyenrangú (társ)- szálakkal a kód szekcióját, adat szekcióját, az operációs rendszer által biztosított erõforrásait; ezek együttesét task-nak nevezzük. Egy hagyományos, vagy könnyûsúlyú processzus nem más, mint egy task egyetlen szállal. Egy több szálat tartalmazó task esetén míg az egyik szál várakozik (blokkolt), a másik futhat. Példák: fájl szerver, web - böngészõ. A szálak olyan mechanizmust szolgáltatnak, amely lehetõvé teszi a szekvenciális processzusoknak a rendszerhívások blokkolását, s közben a "párhuzamosság elérését". A szálak állapotaik, kezelésük, egyéb tulajdonságaik (kommunikáció, kooperáció) alapján a processzushoz állnak közel. PROCESSZUSOK KÖZÖTTI KOMMUNIKÁCIÓ (IPC) Az IPC olyan mechanizmust jelent, amely lehetõvé teszi, hogy folyamatok egymással kommunikáljanak, és akcióikat összehangolják, szinkronizálják. Üzenõ rendszer: a folyamatok úgy kommunikálnak, hogy nem rendelkeznek közösen használható memóriával. IPC két mûveletet nyújt: send(message) az üzenetek lehetnek fix, vagy változó hosszúak receive(message) A kommunikációs vonal implementációs kérdései: Fizikai implementáció: megosztott memória, hardver busz, hálózat,... Logikai implementáció: Hogyan épül fel a link? Tartozhat-e egynél több folyamathoz? Két folyamat között hány élõ link lehet?... üzenet mérete, mozgás iránya, stb Direkt kommunikáció send(p, message) küldj egy üzenetet P-nek (utasítás Q-ban) receive(q, message) fogadj egy üzenetet Q-tól (utasítás P-ben) A kommunikációs vonal ebben az esetben automatikusan épül fel a két folyamat között (PID ismerete szükséges!) A vonal pontosan két folyamat között létezik. Minden egyes folyamatpár között pontosan egy link létezik Egy, vagy többirányú is lehet. Termelõ-fogyasztó példa Szimmetrikus/asszimetrikus címzés Indirekt kommunikáció send(a, message) küldj egy üzenetet az A Mail-boxba (utasítás Q-ban) receive(a, message) olvass ki egy üzenetet az A Mail-boxból (utasítás P-ben) A kommunikációs vonal abben az esetben épül fel a két folyamat között ha közösen használhatják az A Mail-boxot (PID ismerete nem szükséges!) A vonal több folyamat között létezik (mindenki, aki A-hoz hozzáférhet!). Minden egyes folyamatpár között több link is létezik, létezhet (Mail-box-függõ) fefe@coffein.hu ( 35 / 117 )

36 5/D /4 Folyamatok és szálak. Állapotok. Folyamatvezérlõ blokk. Hosszú és rövid távú ütemezés. Folyamatok kommunikációja és szinkronizációja. Egy, vagy többirányú is lehet. Ki kapja az üzenetet? - probléma. Pufferelés (a link által egyidõben befogadott üzenetek száma) Zéró kapacitás (0 üzenetet tárol a link; szinkronizáció kell, rendezvous ) Korlátozott kapacitás ( n üzenet lehet a linken) Korlátlan kapacitás fefe@coffein.hu ( 36 / 117 )

37 6/A Soros, önátrendezõ és rendezett táblázatok. Táblázat: Asszociatív, dinamikus adatszerkezet, amelyben minden elem két részbõl áll. A kulcs és az érték típusa bármilyen lehet, de egy táblázaton belül a kulcsok, értékek típusa megegyezõ kell, hogy legyen. A kulcs és az érték típusa különbözõ lehet. Minden táblázati elem kulcsértéke egyediek, így ez a kiválasztási szempont. A táblázat nem más, mint egydimenziós tömb általánosítva, ahol bármely elem a kulcson keresztül érhetõ el. (pl: statikus helyett dinamikus). Reprezentációja lehet folytonos és szétszórt is (általában folytonos). Gyakran úgy tárolják, hogy a kulcsot, értéket leképezik egy-egy egydimenziós tömbre. Különbözõ szervezésû táblázatok vannak. 1. Soros A kezelés szempontjából ez a legegyszerûbb táblázat. Akkor érdemes soros táblázatot használni, ha az egyes elemek feldolgozási valószínûsége közel azonos. Mûveletek Létrehozás: Az elemek az érkezés sorrendjében kerülnek a táblázatba. Bõvítés: A táblázat végére lehet. Törlés: Meg lehet oldani logikai törléssel és a szabadhelyek elfogyása után szemétgyûjtéssel, és meg lehet oldani fizikai törléssel is. A fizikai törlés az, amikor a törlendõ elem mögött lévõ elemeket elõretolom. A baj csak az, hogy így sok elemet kellene mozgatni. Helyette azt alkalmazzák, hogy kitörlik az elemet és a legutolsó elemet a helyére írják. Így csak egy elemet kell mozgatni. Csere: Minden elem felülírható. Megkeresem az adott kulcsú elemet és felülírom az értékét. Soros táblázatnál nem jelent gondot, ha az értéket és a kulcsot is felül akarom írni, de figyelni kell, hogy a kulcs ne szerepeljen már elõzõleg. Rendezés: Nem értelmezett. Keresés: Kulcsra vonatkozó teljes keresés. Bejárás: Soros (az elhelyezés sorrendjében) Feldolgozás: Kulcs alapján. A strázsatechnika lényege: az elemek végére elhelyezem a keresett elemet, és így jutok a végére. A K-t így mindig megtalálom. Ha a legvégén találom meg, akkor az azt jelenti, hogy nincs benne a táblázatban, ha elõtte megtalálom, akkor benne van. A táblázat elemeinek a száma ezzel a manipulációval nem változott meg, ha jön egy új elem, a szabad helyre írom, így törlõdik a strázsa ( kulcs[n+1] ). fefe@coffein.hu ( 37 / 117 )

38 6/A /2 Soros, önátrendezõ és rendezett táblázatok. Soros táblázatok akkor alkalmazhatók jól, ha sok elemet akarunk feldolgozni. Ha feltesszük, hogy minden elemet ugyanolyan gyakorisággal dolgozunk fel, akkor ideális, de ez a gyakorlatban persze, hogy nincs így. Az lenne a jó, ha a gyakrabban feldolgozott elemet gyorsabban elérnénk, vagyis a táblázat elején lenne. Ezen okok miatt jött létre az önátrendezõs tábla. 2. Önátrendezõs tábla Az egyes elemek feldolgozási valószínûsége különbözõ. Azt a gondolatot valósítja meg, hogy a leggyakrabban használt elemek a tábla eljén legyenek. A megoldás nagyon egyszerû. Ha egy elemet feldolgozunk, akkor cseréljük ki az elsõ elemmel. Ez a folyamat sok lépés után ahhoz vezet, hogy a legelsõ helyen a leggyakrabban feldolgozott elem fog állni. Reprezentációjánál szétszórt ábrázolást alkalmaznak. Ha a tábla mérete nõ, vagy csak a tábla elemeinek egy részét dolgozzuk fel, akkor a soros tábla lassú. (a teljes keresés miatt). 3. Rendezett tábla Ez általában kulcs alapján történõ növekvõ rendezettséget jelent. A feldolgozást segíti a rendezés. Az elemeket nem azonos gyakorisággal dolgozom fel, és nem mindegyik elemet. Mûveletek Létrehozás: Beszúrásos rendezéssel történik. Bõvítés: Beszúrásos rendezéssel történik. Törlés: Meg lehet oldani logikai törléssel, és a szabadhelyek elfogyása után szemétgyûjtéssel, és meg lehet oldani fizikai törléssel is. A fizikai törlés folyamatos tárolásnál az, amikor a törlendõ elem mögött lévõ elemeket elõretolom. Szétszórt ábrázolásnál igen egyszerûen megoldható. Csere: Megkeresem és felülírom az adott elemet. A kulcs alapján cserélem az értékrészt, a kulcs cseréje nem engedélyezett. Ha azt is meg akarom cserélni, akkor fizikai törlést és bõvitést kell alkalmazni. Rendezés: Nincs, mert rendezetten jön létre. Keresés: Mindkét reprezentációnál alkalmazható a lineáris keresés, folytonosnál a bináris keresés is. Bejárás: Szekvenciális, logikai sorrend szerint. Feldolgozás: Kulcs alapján. A karbantartási mûveletek folyamatos ábrázolásnál lassabbak, míg a feldolgozás gyorsabb folyamatos ábrázolásnál a binári keresés miatt. Szétszórt ábrázolásnál a karbantartás (bõvítés, törlés) kellemes, de a feldolgozás nyûgös. fefe@coffein.hu ( 38 / 117 )

39 6/B Karakterkészlet, azonosítók, alapszavak, standard azonosítók, literálok, nevesített konstansok az egyes programozási nyelvekben Karakterkészlet Minden program forrásszövegének legkisebb alkotórészei a karakterek. A forrásszöveg összeállításánál alapvetõ a karakterkészlet, ennek elemei jelenhetnek meg az adott nyelv programjaiban, ezekbõl állíthatók össze a bonyolultabb nyelvi elemek. A programnyelvek általában a karaktereket a következõ módon kategorizálják: - betûk - számjegyek - egyéb karakterek Minden programnyelvben betû az angol ABC 26 nagybetûje. A nyelvek továbbá betû kategóriájú karakternek tekintik gyakran az _, $, karaktereket is. Ez viszont sokszor implementációfüggõ. Abban már eltérnek a nyelvek, hogy hogyan kezelik az angol ABC kisbetûit. A nyelvek túlnyomó többsége a nemzeti nyelvi betûket nem sorolja a betû kategóriába, néhány késõi nyelv viszont igen. Az egyéb karakterek közé tartoznak a mûveleti jelek, elhatároló jelek, írásjelek és a speciális karakterek. A program szövegében kitüntetett szerepet játszik a szóköz, mint egyéb karakter. A hivatkozási nyelv és az implementációk karakterkészlete eltérõ is lehet. Minden implementáció mögött egy-egy konkrét kódtábla (EBCDIC, ASCII, UNICODE) áll. Ez meghatározza egyrészt azt, hogy egyvagy több-bájtos karakterek kezelése lehetséges-e, másrészt értelmezi a karakterek sorrendjét. Ugyanis nagyon kevés olyan hivatkozási nyelv van (pl. Ada), amely definiálja a karakterek közötti sorrendet Lexikális egységek A lexikális egységek a program szövegének azon elemei, melyet a fordító a lexikális elemzés során felismer és tokenizál. Fajtái a következõk: - többkarakteres szimbólum - szimbolikus nevek - címke - megjegyzés - literálok Többkarakteres szimbólumok Olyan karaktersorozatok, amelyeknek a nyelv tulajdonít jelentést és ezek csak ilyen értelemben használhatók. Nagyon gyakran a nyelvben operátorok, elhatárolók lehetnek. Például a C-ben többkarakteres szimbólumok a következõk: ++, --, && Szimbolikus nevek Azonosító: Olyan karaktersorozat, amely betûvel kezdõdik, és betûvel vagy számjeggyel folytatódhat. Program írója a saját programozói eszközeit megnevezze vele, és ezután ezzel hivatkozzon rá a program szövegében bárhol. Kulcsszó (alapszó, fenntartott szó, védett szó, foglalt szó): Olyan karaktersorozat (általában azonosító jellegû felépítéssel), amelynek az adott nyelv tulajdonít jelentést, és ez a jelentés a programozó által nem megváltoztatható. A C-ben például alapszavak a következõk: if, for, case, break Standard azonosító: Olyan karaktersorozat, amelynek a nyelv tulajdonít jelentést, de ez az alapértelmezés a programozó által megváltoztatható, átértelmezhetõ. A C-ben például standard azonosító a nil Címke Az eljárásorientált nyelvekben a végrehajtható utasítások (l. 4. fejezet) megjelölésére szolgál, azért, hogy a program egy másik pontjáról hivatkozni tudjunk rá. Bármely végrehajtható utasítás megcímkézhetõ. fefe@coffein.hu ( 39 / 117 )

40 6/B /2 Karakterkészlet, azonosítók, alapszavak, standard azonosítók, literálok, nevesített konstansok az egyes programozási nyelvekben. A címke maga egy speciális karaktersorozat, amely lehet elõjel nélküli egész szám, vagy azonosító. A címke felépítése az egyes nyelvekben a következõ: - COBOL: nincs. - FORTRAN: maximum 5 jegyû elõjel nélküli egész szám. - Pascal: A szabvány Pascalban a címke maximum 4 számjegybõl álló elõ nélküli egész szám. - PL/I, C, Ada: azonosító. Eléggé általános, hogy a címke az utasítás elõtt áll és tõle kettõspont választja el. Az Adában viszont a címke az utasítás elõtt a «és» többkarakteres szimbólumok között szerepel Literálok (Konstansok) A literál olyan programozói eszköz, amelynek segítségével fix, explicit értékek építhetõk be a program szövegébe. A literáloknak két komponensük van: típus és érték. A literál mindig önmagát definiálja. FORTRAN: Egész literál: [{+ -}] számjegy [ számjegy ] Mögötte fixpontos belsõ ábrázolási mód áll. Valós literálok: Mögöttük lebegõpontos belsõ ábrázolási mód áll. Tizedestört valós literál E: rövid lebegõpontos, D: hosszú lebegõpontos. A hétnél több számjegyû számot hosszú lebegõpontos formában ábrázolja. Például: 1E3, -2.2D28. Komplex literál: (valós,valós) Hexadecimális literál: Zhexa_számjegy[ hexa_számjegy ] Logikai literál:.true..false. Szöveges literálok: nhkarakter[karakter] Sztring literál: karakter[karakter] Pascal: Egész literál: A FORTRAN egészének felel meg. Tizedestört: A FORTRAN tizedestörtje, de a tizedespont mindkét oldalán szerepelnie kell számjegynek. Exponenciális: Ugyanaz, mint a FORTRAN-ban, annyi különbséggel, hogy itt csak E betû van. Sztring: [karakter] C: Rövid egész literálok, Decimális egész: Oktális egész: Nyolcas számrendszerbeli egész, kötelezõen 0-val kezdõdik. Hexadecimális egész: Tizenhatos számrendszerbeli egész, 0X-el, vagy 0x-el kezdõdik. Hosszú egész literálok: egészl vagy egészl Valós literálok: Hosszú valós (kétszeres pontosságú valós): Megfelel a FORTRAN valósának, de nincs D. Rövid valós (egyszeres pontosságú valós), Hosszú valós, Kiterjesztett valós (háromszoros pontosságú valós) Karakter literál: karakter Sztring literál: "[karakter] " Ada: Numerikus literálok: Egész literál, Valós literál Bázisolt literál: Az alap a 2-16 számrendszer alapszámát adja meg decimálisan, az esetleges kitevõ részben a számjegyek decimálisak. A # jelek közötti számjegyek viszont az alap számrendszer számjegyei. fefe@coffein.hu ( 40 / 117 )

41 6/B /3 Karakterkészlet, azonosítók, alapszavak, standard azonosítók, literálok, nevesített konstansok az egyes programozási nyelvekben. Karakter literál: [karakter] Sztring literál: "[karakter] " 2.5. A nevesített konstans A nevesített konstans olyan programozási eszköz, amelynek 3 komponense van: név, típus, érték A nevesített konstanst deklarálni kell. A program szövegében a nevesített konstans a nevével jelenik meg, és az mindig az értékkomponenst jelenti. A nevesített konstans értékkomponense a deklarációnál eldõl és nem változtatható meg a futás folyamán. FORTRAN-ban és PL/I-ben nincs nevesített konstans, COBOL-ban pedig csak beépített van. A C-ben van beépített nevesített konstans és a programozó többféleképpen tud létrehozni sajátot. A legegyszerûbb az elõfordítónak szóló #define név literál makró használata. Ekkor az elõfordító a forrásprogramban a név minden elõfordulását helyettesíti a literállal. Pascalban és Adában van beépített nevesített konstans és a programozó is definiálhat saját nevesített konstanst, egyszerû és összetett típusút egyaránt. A Pascalban az értéket literállal, Adában kifejezés segítségével tudjuk megadni. fefe@coffein.hu ( 41 / 117 )

42 6/C Integritási megszorítások a relációs adatmodellben. Tartománymegszorítás : a relációs modellben bármely tartomány bármely elemének atominak kell lennie. Így pl. a TANTARGYFELVÉTEL közvetlenül nem írható fel rel. séma segítségével. A tartomány elemeinek típusaira megszorítás nincs. A rel. adatbáziskezelõ rendszerek néhány típust adnak a felhasználó segítségére, és az csak ezeket használhatja fel. Kulcsmegszorítások : A halmazszemlélet miatt egy rel. séma bármely relációjában szereplõ rekordok különbözõek. Nincs két olyan rekord, amelyben az összes attribútum érték megegyezik. Általában igaz viszont az, hogy az attribútumoknak van egy szûkebb részhalmaza, amelyikre szintén igaz az, hogy nincs két olyan rekord, amelyekben "ezen" attribútum értékek megegyeznek. Az ilyen tulajdonságú attribútumokat a rel. modell SZUPERKULCSnak nevezi. Szuperkulcs mindig van. (Mert az összes attribútum együtt garantáltan szuperkulcsot alkot.) Ha van egy szuperkulcs, ami nem tartalmazza az összes attribútumot, akkor hozzávéve még egy attribútumot, még mindig szuperkulcsot kapunk. Attribútumok egy olyan halmazát, amely szuperkulcsot alkot, és ha kiveszünk belõle egy attribútumot, akkor a maradék attribútum már nem alkot szuperkulcsot, KULCSnak nevezzük. A kulcs tehát minimális szuperkulcs. Egy relációs sémának több kulcsa is lehet, ezeket KULCSJELÖLTeknek szokták nevezni. Több kulcsjelölt esetén a modellezõ dolga, hogy közülük egyet kiválasszon, így ELSÕDLEGES KULCSot hozzon létre. - Egyed integritási megszorítás: elõírja, hogy elsõdleges kulcs egyetlen értéke sem lehet NULL értékû. Az adatbáziskezelõ rendszerek megkövetelik az elsõdleges kulcs létezését. - Hivatkozási integritási megszorítás : Egy relációs séma két relációja között értelmezzük. R 1 R 2 két reláció séma. R 1 egy FK-val jelölt attribútum együttesét az R 1 KÜLSÕ KULCSának hívjuk (Foreign Key), ha 1. FK attribútumának tartományai ugyanazok, mint R 2 elsõdleges kulcsát alkotó attribútumok tartománya. 2. Az R 1 -hez tartozó bármely t 1 rekord FK-n felvett értékei (t 1 [FK]), vagy elõfordulnak R 2 egy relációjához tartozó r={t 1,...,t m } rekord elsõdleges kulcsértékei között, vagy NULL értékûek. pl. ÓRAREND, TANTÁRGY - nem jelenhet meg olyan kód, ami a TANTÁRGYban nincs benne. A relációs adatmodellben ezek az integritási megszorítások vannak. Az egyes adatbáziskezelõk további megszorításokat vezetnek be, ezek a SZEMANTIKAI megszorítások egy halmaza. Egy relációs adatbázis séma nem más, mint relációs sémák egy halmaza és integritási megszorítások: S = {R 1, R 2,..., R k } IM (r i (R i )) Egy relációs adatbázis példány nem más mint relációk egy olyan halmaza, amelyben minden reláció (amelyek az adott sémán értelmezettek) teljesíti az integritási megszorításokat. fefe@coffein.hu ( 42 / 117 )

43 6/D Hálózatok, hálózati operációs rendszerek. Hálózatnak nevezzük azt a rendszert, mely során több, önállóan is használható számítógép van egymással kapcsolatban, mely számítógépek közösen használhatnak bizonyos hardver, szoftver erõforrásokat. (Hardver erõforrások: CPU, operatív memória, nagy kapacitású háttértárolók, nyomtatók stb. szoftver erõforrások pl.: programok, adatállományok. A hálózatok létrejöttének célja: erõforrásmegosztás, sebességnövelés, megbízhatóság növelése, kommunikáció A hálózati csomópontok (node) adatátviteli vonalakkal (line) vannak összekötve. Egy konkrét kapcsolat, felépített útvonal két csomópont között az áramkör (circuit). Kiterjedés szerint megkülönböztethetünk: LAN Lokális hálózat. HSLN (High Speed Local Network) kommunikációs hálózat kommunikációra képes berendezések közt (nem feltétlenül számítógép) Jellemzõ: nagy adatátviteli sebesség (0, millió bit/s) MAN (Metropolitan Area Network) WAN A hálózatba kötött számítógépek kapcsolódási módja szerint megkülönböztethetünk szerver-kliens típusú hálózatot, ahol van (egy vagy több) kitüntetett szerepû számítógép, és peer-to-peer típusú hálózatot, ahol a számítógépek egyenrangúak. A hálózat hardver elemei: Szerver (kiszolgáló) Szerver-kliens típusú rendszerekben a számítógépes munkaállomásokat és a központi erõforrásokat rendszerbe kapcsoló gép. Fontos a megbízhatósága, mert meghibásodása esetén leáll az egész rendszer, és a viszonylag nagy sebesség és kapacitás, mivel erõforrásait a munkaállomások is használják. (A megbízhatóság érdekében a kritikus hardver elemeket meg lehet duplázni, pl. merevlemez, RAM, esetleg a teljes szerver.) A szerver mûködhet dedikált módban: ilyenkor kizárólag a szerver funkciókat látja el, és nem dedikált üzemmódban: ekkor a szerverfunkciók mellett munkaállomási feladatokat is végez. Munkaállomások (kliensek): az egyes felhasználók itt dolgozhatnak. Önállóan is használható számítógépek, a hálózatba kapcsolva a szerver erõforrásait is igénybe vehetik. Összekötõ hardver: hálózati illesztõkártya, adatátviteli közeg (ez lehet vezetékes, vezeték nélküli), telefonvonalon való kapcsolódáshoz modem. A repeaterek feladata a fogadás, erõsítés és a továbbküldés. A megoldandó feladatok: adatbeszúrás, adatkivétel, adatcsomag eltávolítása. Az eltávolítás lehet a címzett dolga, vagy a küldõállomásé, ha visszaért a csomag. Igy egyszerre több címzettnek is elküldhetõ, megoldható az automatikus nyugtázás. A repeater lehet fülelõ állapotban: letapogatja az átmenõ bitsorozatot. Ha felismeri a hozzákapcsolt berendezés címét, másolatot készít róla a berendezésnek, és módosítja a nyugtabitet. Ha nem, kis késleltetéssel továbbítja. Átviteli állapotba akkor kerül, ha a kapcsolódó berendezésnek engedélye van a küldésre, ekkor információcsomagot tehet a vonalra. Ha a feltett csomag megtett egy kört, akkor leveszi (törli). (logikai gyûrûnél). Végzáró: sín topológia esetán feladatat az üzenetek "elnyelése". Az adatátvitel sebesség mértékegysége a bit/s (baud). Használatosak még a kilobit/s (1024 bit/s), megabit (1024 kilobit/s) mértékegységek is. Topológiák: A hálózatba kapcsolt számítógépek elrendezésének logikáját topológiának szokás nevezni. A hálózati topológiák lehetnek egyszerûek, vagy összetettek. A kombinált topológiákkal két egyszerû topológia elõnyeit kapcsolják össze oly módon, hogy közben igyekeznek kiküszöbölni hátrányaikat. Fajtái: teljes hálózat, részleges hálózat. A részleges hálózatok speciális esetei a csillag, gyûrû, sín.ú fefe@coffein.hu ( 43 / 117 )

44 6/D Hálózatok, hálózati operációs rendszerek. Protokollok: A hálózaton folyó kommunikáció "illemszabályait" értjük alatta:melyik állomás mikor, hogyan forgalmazhat üzenetet a közösen használt adatátviteli vonalon. Adási jog továbbításos, ütközésfigyeléses Vonal topológia jellemzõi: multipont konfiguráció, végelzáró berendezések. Az adatcsomag mindkét irányban szétterjed, az veszi le, aki kapja, vagy a végzárók nyelik el. Meg kell oldani a jelerõsítést.(repeaterek, pl. elágazásoknál, ha fa rendszerû) Valamilyen centralizált protokollt használ. Ethernet. 50 ohmos koaxiális kábel. Gyûrû topológia jellemzõi: pont-pont összeköttetés: mindig csak 2 berendezés van összekötve. Tulajdonképpen a repeaterek vannak összekötve, azokhoz kapcsolódik a berendezés. Token ring: (token: vezérjel) A gyûrû topológia általános protokollja. Logikai gyûrû is lehet: minden csomópontnak tudnia kell, hogy melyik az elõzõ és következõ állomás. A vezérjel lehet szabad és foglalt állapotban. Ha az állomás elfog egy szabad jelet, foglaltra állítja és ráteszi a csomagját. Ha foglalt, a repeater figyelõ állapotba kerül, és ha neki jön csomag, leveszi, szabadra állítja a vezérjelet. A csomópontok közti kommunikáció módjai: A csomagkapcsolt adattovábbítás lényege: a továbbítandó bitsorozatot kisebb, azonos méretû bitsorozatokra (csomagokra) bontva jut el a kibocsátótól a fogadóig. A csomagnak az üzenetrészen kívül tartalmaznia kell a feladó és a címzett csomópont címét, a csomag sorszámát (az üzenetnek hányadik darabja) és azt, hogy hány darabból áll a teljes üzenet. Ezek a csomagok nem feltétlenül ugyanazon az útvonalon jutnak a feladótól címzetthez., hanem a terheltségtõl is függõen minden továbbító állomás az optimális megoldást igyekszik választani. A fogadóállomás rakja össze az üzenetet. Ennek a továbbítási módnak egy ismert szabványa az X25. Vonalkapcsolt: két számítógép közt a kapcsolatnak még az adatok elküldése elõtt ki kell épülnie. A kapcsolat idejére a vonalat lefoglalja. Üzenetszórás: Az adatcsomagok minden állomásra eljutnak, a címzés alapján a munkaállomások döntik el, hogy fogadják-e az üzenetet vagy nem vesznek róla tudomást. Leginkább nem kábeles összeköttetés esetén használatos. A különbözõ típusú gépek közötti zavartalan információáramlás biztosítására alakította ki az ISO (International Standards Organization, Nemzetközi Szabványügyi Szervezet) az OSI (Open System Interconnection, nyílt rendszerek összekapcsolása) nevû modellt. Ez a 7 rétegû hálózati modell. Eszerint a kapcsolat 7 jól definiált rétegen keresztül jön létre. A legmagasabb szint a felhasználói (alkalmazási) réteg, a felhasználónak ezzel van közvetlen kapcsolata. A legalacsonyabb szint a fizikai réteg, itt történik a bitek átvivõközegre való kibocsátása, ill. fogadása. Az információ minden rétegen átjutva alakul át a hálózaton továbbítható bitsorozattá, ill. a felhasználó által értelmezhetõ adattá. Az egyes rétegek jól definiált feladatokat látnak el, az egyes rétegek között minimális szintû információcsere zajlik, így szabványosításra alkalmasak. A pontosan leírt feladatkörök biztosítják, hogy a különbözõ gyártók által elõállított hardver és szoftver termékek egymással fel tudják venni a kapcsolatot. Alkalmazási (Application) Megjelenítési (Presentation Layer) Együttmûködési (Session) Szállítási (Transport) Hálózati (Network) Adatkapcsolati (Data Link) Fizikai (Phisical) fefe@coffein.hu ( 44 / 117 )

45 7/A Kulcstranszformációs táblázatok, hash függvények. Kulcstranszformációs táblázatok Mindig folytonos tármegjelenése van. Kulcs: k; f(k) egy függvény, amelyik a k-t leképezi a címre (minden kulcshoz hozzárendel egy címet meghatározza az elemek helyét a táblában). Ez a hash függvény, a technika pedig a hashing. (randomizálás). Az lenne jó, ha a függvény kölcsönösen egyértelmû lenne, de ez a gyakorlatban ritka mint a fehét holló. Általában a függvények egyértelmûek, ami azt jelenti, hogy különbözõ kulcsokhoz ugyanazt a címet rendelik hozzá. Azon kulcsokat, amelyekhez ugyanazt a címet rendeli, szinonímáknak (túlcsordulásnak) nevezzük. A gyakorlatban általában az elvi lehetõségek töredékét használjuk fel. Ha az elvi és a gyakorlati lehetõségek száma megegyezik, vagy a gyakorlati lehetõségek száma egyenletesen oszlik meg az elvi lehetõségeken belül, akkor kölcsönösen egyértelmû leképezést alkalmazhatunk. Ez a ritkább, általában az elvi lehetõségek száma nagyságrendekkel nagyobb, mint a gyakorlati lehetõségek száma, és az elhelyezés sem egyenletes. (pl: a telefonszámok hatjegyûek. Egy körzetben lehet a telefonszámok száma, de ebbõl lehet vagy ténylegesen. Ezen belül hozzá kell számítani, hogy az elhelyezés sem egyenletes.) Ilyenkor egyértelmû hash függvényt alkalmazunk. Egy hash fv-tõl elvárjuk, hogy: 1. A kulcsokat be kell transzformálnia egy sorszámintervallumba, pontosan oda, ahova tárat lefoglalok. Ez egy 0-n intervallum. 2. A kulcsokat lehetõleg egyenletesen szórja szét, ne legyen sok szinoníma. A kulcs lehet numerikus vagy szöveges. Ha szöveges, akkor az elsõ lépésben hozzárendelünk numerikus értéket, pl: a karakterek belsõ kódját. Ha megválasztottuk a kulcs típusát, az elvi lehetõségek száma eldõl. A továbbiakban csak numerikus kulcsokkal foglalkozunk. A valóságban: 1. Minden kulcs elõ is fordul (vagy majdnem mind) 2. Nagyságrendi különbség van az elvi lehetõségek és a ténylegesen elõforduló alkalmazott kulcsok között. De a gyakorlatban elõforduló kulcsok valamilyen szabály szerint helyezkednek el az elvi lehetõségeken belül. Annyi helyet kell lefoglalnom, ahány kulcs a gyakorlatban elõfordul (becsülni), aztán biztosítani, hogy bármilyen elvi kulcsút le tujunk képezni erre a kisebb területre (más-más kulcshoz ugyanazt a tárhelyet rendeli hozzá) ld. vidéki telefonszámok 6 jegy. Az elviekben elõforduló bármely kulcshoz egy (0..m) közé esõ számot rendelek. Ebbe a 0..m tartományba viszonylag egyenletesen képezze le, szórja szét. Bármely hash függvény produkál szinonímákat, nincs univerzális hash függvény. A továbbiakban konkrét kulcstranszformációs módszereket fogunk megnézni. 1. Prímszámmal való osztás Legyen egy adott kulcs az: Ez azt jelenti, hogy az elvi intervallum a ig terjedhet. Tegyük fel, hogy a gyakorlatban lehetõség van. Ez azt jelenti hogy: (m: a gyakorlatban elõforduló kulcsok száma.) Így az intervallum : 0 - m. Válasszuk az m-nél kisebb legnagyobb prímszámot. Jelöljük p-vel. A transzformációnál a tényleges kulcsot osszuk el p-vel és sorszámnak tekintsük a maradékot. Így 0 (p-1) intervallumot kapjuk. Ez a módszer jól véletlenszerûsít, kevés a szinoníma. 2. A szorzás módszere Képezzünk le a 0 - m tartományra. Legyen a számjegyek db száma k, azaz a pl: esetén k=5. A transzformáció az, hogy vegyük az eredeti kulcsot és szorozzuk meg egy tetszõleges prímszámmal, vagy önmagával, vagy osszuk ketté és a két felet szorozzuk össze. Az n db szorzatnak veszem a k db jegyét és ezt tekintem sorszámnak. Ez a transzformáció jól véletlenszerûsít, kevés szinonímát produkál. fefe@coffein.hu ( 45 / 117 )

46 7/A /2 Kulcstranszformációs táblázatok, hash függvények. 3. Helyiérték kiválasztás módszere A legegyszerûbb módszer, de nem jól véletlenszerûsít. sok a szinoníma. Az eljárás lényege, hogy a kiindulási kulcsból véletlenszerûen kiválasztok k db számjegyet. 1 (2) (3) 9 (9) 9 (9) (1) 7 4. Hajtogatás 5. Eltolás 6. Bázistranszformáció módszere Legyen az eredeti kulcs a Válasszunk egy 10-nél nagyobb prímszámot, pl: 13. Ezt jelöljük p-vel. Tegyük fel, hogy az adott szám a p számrendszerben van fölírva. Ezután konvertáljuk át p-bõl a 10-es számrendszerbe. 7*136+6*135+1*134+3*133+4*132+5*131+0 = A kapott eredménybõl az utolsó k jegyet vesszük és az lesz a sorszám. (51314) Ez egy igen közkedvelt módszer. Adatbáziskezelõknél beépített hash függvények léteznek. Hogyan kezeljük a szinonímákat? 1. Nyílt címzés módszere Úgy kezeli a túlcsordult elemeket, mint a nem túlcsordultakat. Ha olyan elem érkezik, amelyiknek a helye már foglalt, akkor a túlcsordult elemet megpróbálja a táblázat utána következõ elsõ üres helyére bepakolni. Fontos, hogy a táblázatban helyezi el az elemeket. Nincs információ arról, hogy volt-e ott túlcsordult elem és ha volt, akkor az hova lett elhelyezve. Általában a nyílt címzés feltételezi, hogy létezik üres hely. Teljes keresést használunk. A keresést megállítja, ha megtaláltam az elemet, vagy ha üres helyet találtam. Egyik hibája ennek a módszernek, hogy túlcsordult elemek kiszoríthatnak más elemeket, amelyek nem lennének túlcsordultak. A túlcsordult elemeknek nincs közvetlen elérése. Így minden elemenek 3 állapota lehet: üres logikailag törölt (a táblázatban van, nem él) érvényes (a táblázatban van, él) Az új elemet a logikailag törölt és az üres elem helyére is írhatom. Fizikai törlés a táblázat újraszervezésével történik (újonnan létrehozom). A megoldás az, hogy több tárolóhelyet foglalok le, mint amennyire szükség lenne, marad majd üres hely a végén. fefe@coffein.hu ( 46 / 117 )

47 7/A /3 Kulcstranszformációs táblázatok, hash függvények. 2. Láncolás Információt helyez el a túlcsordulás helyén arról, hogy hol van a túlcsordult táblaelem. A KULCS, ÉRTÉK mezõ mellé egy harmadik kapcsolódik: a MUTATÓ mezõ. Ha az adott helyen nincs túlcsordulás: null. Ha van, beírjuk, hogy hol van a túlcsordult táblaelem. Kiküszöböli a teljes keresést, nem kell az összes elemet érinteni. 3. Túlcsordulási listát alkalmaznak A túlcsordult elemeket nem ugyanott helyezzük el, mint a nem túlcsordult elemeket. A MUTATÓ listafej szerepet játszik, az egy adott helyrõl túlcsordult elemek össze vannak fûzve egy egyirányban láncolt listába. A táblaelemeket saját jogon közvetlenül elérem. Egyszerûbb a karbantartás, a karbantartani a legbonyolultabb, ún. listaállományt kell kezelni. Kulcstranszformációs táblák kezelése Létrehozás: Meg kell becsülni, hogy a gyakorlatban ténylegesen hány kulcs fog elõfordulni (m). Ezt követõen le kell foglalnom legalább m tárhelyet, de általában 1.2*m tárhelyet biztosítanak, azért hogy az (1.) és (2.) túlcsordulási technika alkalmazásakor biztosan legyen üres hely. Kiválasztok valamilyen hash függvényt és valamilyen szinoníma kezelési technikát. Ezután bepakolom az elemeket. Létrehozás után léteznek üres helyek és élõ elemek. Bõvítés: A létrehozás technikájával kerülnek be a táblázatba az új elemek. Törlés: Nyílt címzésnél csak logikai, másik kettõnél fizikai törlés is. Csere: Kulcs alapján keresem, az értékrészt felülírom. Rendezés: Nincs. Keresés: Nincs. Kulcs alapján tudom az elemeket feldolgozni, mert nincs fizikai sorrend. Logikai sorrend sincs. A keresésnek nincs alapja, csak kulcs alapján. Bejárás: Nincs. Elérés: Az esetek többségében közvetlen. Feldolgozás: Kulcs alapján. A kulcstranszformációs táblák elõnyösek, ha viszonylag nagyméretûek, és viszonylag statikusak, azaz kevés a karbantartási mûvelet. A táblázat kevésbé érzékeny rá, hogy egy vagy több elemet dolgozok fel. A legjobb talán az a technika, amikor a táblázaton belül láncolok. Hátránya: nincs rendezettség, a feldolgozás és a karbantartás lassú. Dinamikus tábláknál jelentkezik ez a lassúság a legjobban, hiszen ott igen sok a karbantartási mûvelet. fefe@coffein.hu ( 47 / 117 )

48 7/B A funkcionális paradigma és programnyelvei. Deklaratív nyelvek: Nem algoritmikus nyelvek. - Nem kötõdnek olyan szorosan a Neumann-architektúrához, mint az imperatív nyelvek. A programozó csak a problémát adja meg, a nyelvi implementációkba van beépítve a megoldás megkeresésének módja. A programozónak nincs lehetõsége memóriamûveletekre, vagy csak korlátozott módon. Alcsoportjai: 1. Funkcionális (Applikatív) nyelvek: LISP 2. Logikai nyelvek Funkcionális nyelvek: - alapeszköze: függvény - alapmûveletek: rekurzió, fg.összetétel: fg. elõállítása más fg-ekbõl. - tiszta funkcionális nyelvek: nincs mellékhatása a fg-eknek - két alcsoportja van: 1. típusos 2. nem típusos (ilyen a többség: pl LISP) - rengeteg beépített fg. van újakat lehet definiálni a korábbiak segítségével LISP: - az elsõ és sokáig az egyetlen funk. nyelv - az imperatív nyelvek tagadásaként jött léttre. Tagadja az ALGOL-t. - alapelemek: atom numerikus számkonstans máshol szimbolikus egy karaktersorozat. Itt ez jelenti a változót. Van neve, de nincs típusa. Címhez nem férünk hozzá lista S-kifejezés (szimbolikus kifejezés) atomok és listák együtt S-kifejezés értéke: ha az S.kif numerikus atom konstans ha az S.kif szimbolikus atom változó ha az S.kif lista függvény - nem különböztethetõ meg az adat és a program - elhatárolojel: szóköz - fontosabb függvények: - SETQ értékadás - ADD1 a paramétert 1-el növeli - SUB1 - MAX, MIN kiválasztja a legnagyobbat is legkisebbet - paraméterátadás: értékszerinti, névszerinti, szövegszerinti - paraméterkiértékelés: sorrendi kötés, típusegyeztetés nincs, mert nincs típus, számszerinti - saját fg definiálása: DE - feltételes elág: COND - van neki: WHILE, DO - állománykezelés: minimális, fg-ekkel történik, kezeli a szeriális áll-t, fefe@coffein.hu ( 48 / 117 )

49 7/B /2 A funkcionális paradigma és programnyelvei. LISP fg-ek osztályozása: 1. paraméterkiértékelés szerint: - lehet kötött - nem kötött arg számú 2. paraméterátadás szerint: - EVAL típusú: - nem EVAL típusú paraméterkiértékelésnél: - sorrendi kötés mindig van - számbeli egyezt - típusegyezt fefe@coffein.hu ( 49 / 117 )

50 7/C Az adatbázis szemlélet kialakulása. Adatbázis, adatbázis-kezelõ rendszer, adatbázis rendszer. A 60'-as évek elején a programnyelvekbe beépített eszköztár arra volt elegendõ, hogy állományokat kezeljenek. (PL/1) A 60'-as évek második felében számos probléma merült fel: Ha az állomány szerkezete megváltozik, akkor át kell írni a programot. Ha valaki egy adott állományt használni akar, akkor az adott áll. kezelõprogramját kell használnia. Ha állományt akarok kezelni, akkor meg kell tanulnom egy adott programnyelv erre alkalmas eszközrendszerét. Csak minimális automatikus adatvédelem van. (Illetéktelen hozzáférés ellen - jogosultság, és adatsérülés ellen.) Az adatokhoz való konkurens hozzáférést az állománykezelõ nem biztosítja. A 60'-as évek második felében az IBM-nél kialakul egy új adatbázis-kezelési módszer és eszköz-tár, így születik meg az adatbázis-kezelés fogalma Az elsõ adatbázis-kezelõ rendszer : ISM A CODASYL-on belül megalakul egy csoport, a DBTG (Data Base Task Group), ami a felvetett problémákra dolgoz ki elveket. Ennek eredményeképp 1971-ben megszületik a CODASYL DBTG jelentés (Innen számítjuk ténylegesen az adatbázis-kezelés fogalmát.) Egy adatbázis-kezelõ szoftvernek összetett logikai adatrendszereket kell tudni kezelnie. Többet egyszerre! Megfogalmazza az irányított redundancia fogalma. (Redundancia: egy adatot többször tárolunk.) Redundáns tárolás konzisztencia-problémát okoz. Ha egy adathalmaz belsõ ellentmondásos, akkor inkonzisztens, egyébként konzisztens. A CODASYL tiltja a redundanciát, de a feldolgozás gyorsítása érdekében megengedi akkor, ha kézben lehet tartani. Konkurens hozzáférést kell biztosítania az adatbázis-kezelõ rendszernek. Lehessen programozni Támogassa az emberi logikát szemben a gépivel. A jogosultság biztosítása Adat-program függetlenség logikai és fizikai szinten. Logikai szinten: Ha az adatok szerkezete megváltozik, ne kelljen a program szerkezetét megváltoztatnom. Fizikai szinten: Egy adott program tudja feldolgozni az adathalmazt függetlenül attól, hogy hol van fizikailag. ADATBÁZISRENDSZER: A számítógép, az adatok, a kezelõ szoftver és az ember együttese. Adatbázisrendszer felépíthetõ tetszõleges platformon. Általános célú rendszerek alkothatják a hardver komponenst, de léteznek kimondottan adatbázisrendszerhez tervezett számítógép rendszerek. ADATBÁZIS: Fizikai adatbázis egyedelõfordulások Metaadatbázis / adatszótár Szerkezetre vonatkozó adatok. pl.: a séma leírása, adatkomponens szerkezetének leírása, kapcsolatok leírása SZOFTVER (DBMS): Az adatbázis-kezelõ rendszer. Konkrét operációs rendszer környezetben fut, gyakran sok adatkezelõ funkciót átvesz az operációs rendszertõl. Az adatbázis-kezelõ rendszernek van egy olyan komponense, mely lehetõvé teszi hogy programozási tevékenységet lehessen végezni. Ez alapján megkülönböztethetõk: - Saját nyelvû rendszerek : A szoftver része a programozási eszközrendszer. (Nem önálló nyelv, imperatív jellegû, eljárás-orientált) fefe@coffein.hu ( 50 / 117 )

51 7/C /2 Az adatbázis szemlélet kialakulása. Adatbázis, adatbázis-kezelõ rendszer, adatbázis rendszer. - Befogadó nyelvû rendszerek : A szoftveren belül olyan utasítások vannak, melyekkel az adatbázist manipulálni lehet, de programozni nem. Ezt valamilyen magasszintû programozási nyelv segítségével lehet megvalósítani. Írni kell egy befogadó nyelvû programot, és ezt beépíteni az adatbázis-kezelõ utasításai mellé. Ebben az esetben létezik elõfordító, amely a az adott nyelven írt programot lefordítja. FELHASZNÁLÓ Alkalmazás Alkalmazás Alkalmazás NÉZET 1 NÉZET 2 NÉZET N Koncepcionális séma Belsõ séma Külsõ szint Koncepcionális szint Belsõ /fizikai/ szint 11. ábra DDL, DML, DCL, DMCL, Az adatbázis kialakításának folyamata: elemzés tervezés implementálás 1. A szerkezet vázának meghatározása. 2. A sémát átültetjük az adatbázis kezelõbe. 3. Definiáljuk az adatbázist. 4. A meta adatbázis bevitele. A séma absztrakció, a szerkezetet határozza meg. Létrejön egy üres fizikai adatbázis, amit fel kell tölteni. 5. A fizikai adatbázis bevitele. (egyedelõfordulások!) 6. Lekérdezés: Az adatbázisban lévõ elemekhez való hozzáférés. fefe@coffein.hu ( 51 / 117 )

52 7/D Szövegszerkesztõk. Internetes kommunikáció. Az elsõ szövegszerkesztõk programszövegek bevitelére szolgáltak. A szövegszerkesztõk legfontosabb alapfunkciói már ezeknél is megvoltak: Karakterek bevitele, törlése. A dokumentum mentése. Tárolt dokumentum megnyitása, módosítása. A dokumentum nyomtatása A szövegszerkesztõ programokat két nagy csoportba szokás sorolni. A karakteres szövegszerkesztõk az alapfunkciókon kívül viszonylag kevés szolgáltatást nyújtanak. A professzionális szövegszerkesztõk az eddig említetteken kívül lehetõvé teszik a szöveg formázását. Különbözõ objektumok beillesztése (Képek, táblázatok, stb) Helyesírás ellenõrzés, makrók, rövidítések használata. Automatikus oldalszámozás, tartalomjegyzék készítés. Különbözõ szövegformátumok konvertálása (import, export ). Körlevélkészítés. WYSIWYG Elektronikus levelezõ rendszerek Hálózatok leggyakrabban igénybevett szolgáltatása. Az Internet hálózaton keresztül történõ levelezés esetén az elektronikus levélcím áll egy tetszõleges azonosítóból, amely a felhasználó postafiókját azonosítja a csomóponton belül, és a csomópont azonosítójából (domain). Pl. valaki@gep.intezmeny.hu. A postafiók lehet egy szolgáltatónál, mail-szerver, állandó üzemben kell lennie, ill. tükrözve kell lennie Léteznek ún. ingyenes postafiókok, pl. fre , hotmail, yahoo, nexus, stb. Ezeken a szervereken WEBes felületrõl lehet postafiókot létrehozni, és a levelezõszolgáltatásokat használni, meghatározott tárolóterület igénybevételével. Nem szükséges mindenáron a WEB-rõl levelezni. Az elektronikus levél részei: Fejléc: A címzett címét (To), a levél tárgyát (Subject), kik kapnak másolatot (CC, BCC), tartalmazza a feladó címét (From), a feladás dátumát. A levél törzse a tulajdonképpeni levél. Levelezõprogramok szolgáltatásai: fogadását, küldését, szétválogatását, (Reply) azonnal vagy késõbb, címlisták, (Forward), (signature), (attachment) A hibás címzésû, kézbesíthetetlen leveleket egy ún. "levelezõ démon" (háttérben futó segédprogram) szokta a feladóhoz visszajuttatni. fefe@coffein.hu ( 52 / 117 )

53 8/A A lista adatszerkezet. (list). Olyan dinamikus adatszerkezet, amelyiknek létezik elsõ és utolsó eleme (kivétel az üres lista) és minden adatelemnek létezik rákövetkezõje (kivétel az utolsó elem), továbbá minden elemnek létezik megelõzõje (kivétel az elsõ elem). A lista elemeinek rendezettsége van, amelyet az elhelyezés biztosít. Jelölése: q=[x 1,x 2,... x] Speciális listafogalmak, ill. mûveletek Üres lista: empty [ ] A lista feje: (head) Az elsõ elem. A lista farka: (tail) Lista, amely az elsõ elem elhagyásával keletkezik. A lista vége: (end) Az utolsó elem. A lista mérete: A lista elemeinek a száma. q =n. A lista alapmûveletei: (Lista alatt a q=[x 1,x 2,... x n ] t értjük.) Hozzáférés: (access) A lista elemei egyértelmû sorrendben vannak felfûzve. Megfogjuk valamely elemét. A listából az i-dik elem kiválasztása. q(i) x i Ha i nem eleme a [1..n] nek, vagyis i<1 vagy i>n, akkor a hozzáférés eredménye [], üres lista. Allista képzés mûvelete: (sublist) q[i..j] [x i,x i+1,... x j ] A listából tetszõleges részt választhatunk ki úgy, hogy megadjuk a kezdõ- és a végelemet (i<j). Ha i<1, vagy hiányzik, akkor az allista a lista elejétõl indul. Ha j hiányzik vagy j>n, akkor az allista a lista végéig megy. Konkatenació: (concetenation) Egyesítés. Adva van két lista: q=[x 1,x 2,... x n ] és r=[y 1,y 2,...,y m ]. Ekkor q&r=[x 1,x 2,... x n,y 1,y 2,...,y m ]. A szokásos adatszerkezeti mûveletek ezen alapmûveletek segítségével értelmezhetõek. Létrehozás: Üreslistából indulva konkatenációval rendeljük hozzá az elemeket mint egyelemû listákat. A hozzáfûzés sorrendje adja a sorrendet a listában. Bõvítés: A q listát a k-ik elem után bõviteni akarjuk az x elemmel. q'=q[...k]&[x]&q[k+1...] Allistával is bõvíthetek, ugyanúgy, ahogy egy elemmel. Törlés: Fizikai törlés. A k-ik elem törlése: q'=q[...k-1]&q[k+1...] Csere: A k-ik elemet cserélem x-re. q'=q[...k-1]&[x]&q[k+1...]. Rendezés: Értelmezhetõ abban az értelemben, hogy az adatelemek értéke szerint növekvõ vagy csökkenõ sorrendbe rendezem a saját helyén, bármely módszerrel, vagy létrehozáskor rendezett listát hozok létre. Keresés: Teljes keresés, vagy rendezett listánál lineáris vagy bináris. Elérés: Soros, szekvenciális, közvetlen. Feldolgozás: A definiált mûveletek alapján. Lényegesek azon mûveletek formái, amelyek a lista elejét, vagy végét érintik. Hat szélsõséges esetet különböztetünk meg (szélsõ elemek kezelése): 1) Acces head: Hozzáférés a legelsõ elemhez. q(1). 2) Push: Egy elemmel bõvitem a listát az elején. [x]&q 3) Pop: Törlöm az elsõ elemet q[2...] 4) Access end: q( q ) Hozzáférés az utolsó elemhez. 5) Inject: q&[x] A listát a végén bõvitem. 6) Eject: q[... q -1] Törlöm az utolsó elemet. A lista reprezentációja mind a kétféle módon történhet. Folytonos ábrázolást vektorral, a szétszórtat pedig egy kétirányba láncolt listával oldják meg. fefe@coffein.hu ( 53 / 117 )

54 8/B Paraméterkiértékelés, paraméterátadás az imperatív és a deklaratív programnyelvekben. Paraméterkiértékelés alatt értjük azt a folyamatot, amikor egy alprogram hívásánál egymáshoz rendelõdnek a formális- és aktuális paraméterek, és meghatározódnak azok az információk, amelyek a paraméterátadásnál a kommunikációt szolgáltatják. A paraméterkiértékelésnél mindig a formális paraméter lista az elsõdleges, ezt az alprogram specifikációja tartalmazza, egy darab van belõle. Aktuális paraméter lista viszont annyi lehet, ahányszor meghívjuk az alprogramot. Tehát az egymáshoz rendelésnél mindig a formális paraméter lista a meghatározó, mindig az aktuális paramétereket rendeljük a formálisakhoz. A paraméterkiértékelésnek három aspektusa van, ezek az alábbi kérdésekre adnak választ. 1. Melyik formális paraméterhez melyik aktuális paraméter fog hozzárendelõdni? Ez történhet sorrendi kötés vagy névszerinti kötés szerint. Sorrendi kötés esetén a formális paraméterekhez a felsorolás sorrendjében rendelõdnek hozzá az aktuális paraméterek: az elsõhöz az elsõ, a másodikhoz a második, és így tovább. Ezt a lehetõséget minden nyelv ismeri, és általában ez az alapértelmezés. A névszerinti kötés esetén az aktuális paraméter listában határozhatjuk meg az egymáshoz rendelést úgy, hogy megadjuk a formális paraméter nevét és mellette valamilyen szintaktikával az aktuális paramétert. Ilyenkor lényegtelen a formális paraméterek sorrendje. Néhány nyelv ismeri. Alkalmazható a sorrendi és névszerinti kötés kombinációja együtt is úgy, hogy az aktuális paraméter lista elején sorrendi kötés, utána névszerinti kötés van. 2. Hány darab aktuális paramétert kell megadni? Lehetséges, hogy a formális paraméterek száma fix, a formális paraméter lista adott számú paramétert tartalmaz. Ekkor a paraméterkiértékelés kétféle módon mehet végbe: Az aktuális paraméterek számának meg kell egyeznie a formális paraméterek számával. Az aktuális paraméterek száma kevesebb lehet, mint a formális paraméterek száma. Ez csak érték szerinti paraméterátadási mód esetén lehetséges. Azon formális paraméterekhez, amelyekhez nem tartozik aktuális paraméter, alapértelmezett módon rendelõdik érték. Lehet olyan eset, amikor a formális paraméterek száma nem rögzített, tetszõleges. Ekkor az aktuális paraméterek száma is tetszõleges. Létezik olyan megoldás is, hogy a paraméterek számára van alsó korlát, tehát legalább ennyi aktuális paramétert szerepeltetni kell. 3. Mi a viszony a formális és aktuális paraméterek típusai között? A nyelvek egyik része a típusegyenértékûséget vallja, ekkor az aktuális paraméter típusának azonosnak kell lennie a formális paraméter típusával. A nyelvek másik része a típuskényszerítés alapján azt mondja, hogy az aktuális paraméter típusának konvertálhatónak kell lennie a formális paraméter típusára. Paraméterátadás A paraméterátadás a programegységek közötti kommunikáció egy formája. A paraméter a programegységek közötti kommunikáció egyik eszköze. A paraméterátadásnál mindig van hívó, ez tetszõleges programegység és egy hívott, amelyik mindig alprogram. Kérdés, hogy melyik irányban és milyen információ mozog? A nyelvek a következõ paraméterátadási módokat ismerik: Az érték szerinti paraméterátadás esetén a formális paramétereknek van címkomponensük a hívott alprogram területén. Az aktuális paraméternek rendelkeznie kell értékkomponenssel a hívó oldalon. Ez az érték meghatározódik a paraméterkiértékelés folyamán, majd átkerül a hívott alprogram területén lefoglalt címkomponensre. A formális paraméter kap egy kezdõértéket, és az alprogram ezzel az értékkel dolgozik a saját területén. fefe@coffein.hu ( 54 / 117 )

55 8/B /2 Paraméterkiértékelés, paraméterátadás az imperatív és a deklaratív programnyelvekben. Az információáramlás egyirányú, a hívótól a hívott felé irányul. A hívott alprogram semmit sem tud a hívóról, a saját területén dolgozik. Mindig van egy értékmásolás, és ez az érték tetszõleges bonyolultságú lehet. Ha egy egész adatcsoportot kell átmásolni, az hosszadalmas. Lényeges, hogy a két programegység egymástól függetlenül mûködik, és egymás mûködését az érték meghatározáson túl nem befolyásolják. Az aktuális paraméter kifejezés lehet. A cím szerinti paraméterátadásnál a formális paramétereknek nincs címkomponensük a hívott alprogram területén. Az aktuális paraméternek viszont rendelkeznie kell címkomponenssel a hívó területén. Paraméterkiértékeléskor meghatározódik az aktuális paraméter címe és átadódik a hívott alprogramnak, ez lesz a formális paraméter címkomponense. Tehát a meghívott alprogram a hívó területén dolgozik. Az információátadás kétirányú, az alprogram a hívó területérõl átvehet értéket, és írhat is oda. Az alprogram átnyúl a hívó területre. Idõben gyors, mert nincs értékmásolás, de veszélyes lehet, mivel a hívott alprogram hozzáfér a hívó területén lévõ információkhoz, és szabálytalanul használhatja föl azokat. Az aktuális paraméter változó lehet. Az eredmény szerinti paraméterátadásnál a formális paraméternek van címkomponense a hívott alprogram területén, az aktuális paraméternek pedig lennie kell címkomponensének. Paraméterkiértékeléskor meghatározódik az aktuális paraméter címe és átadódik a hívott alprogramnak, azonban az alprogram a saját területén dolgozik, és a futás közben nem használja ezt a címet. A mûködésének befejeztekor viszont átmásolja a formális paraméter értékét erre a címkomponensre. A kommunikáció egyirányú, a hívottól a hívó felé irányul. Van értékmásolás. Az aktuális paraméter változó lehet.az érték-eredmény szerinti paraméterátadásnál a formális paraméternek van címkomponense a hívott területén és az aktuális paraméternek rendelkeznie kell értékés címkomponenssel. A paraméterkiértékelésnél meghatározódik az aktuális paraméter értéke és címe és mindkettõ átkerül a hívotthoz. Az alprogram a kapott értékkel, mint kezdõértékkel kezd el dolgozni a saját területé és a címet nem használja. Miután viszont befejezõdik, a formális paraméter értéke átmásolódik az aktuális paraméter címére. A kommunikáció kétirányú, kétszer van értékmásolás. Az aktuális paraméter változó lehet. Név szerinti paraméterátadásnál az aktuális paraméter egy, az adott szövegkörnyezetben értelmezhetõ tetszõleges szimbólumsorozat lehet. A paraméterkiértékelésnél rögzítõdik az alprogram szövegkörnyezete, itt értelmezésre kerül az aktuális paraméter, majd a szimbólumsorozat a formális paraméter nevének minden elõfordulását felülírja az alprogram szövegében és ezután fut le az. Az információáramlás iránya az aktuális paraméter adott szövegkörnyezetbeli értelmezésétõl függ. A szöveg szerinti paraméterátadás a név szerintinek egy változata, annyiban különbözik tõle, hogy a hívás után az alprogram elkezd mûködni, az aktuális paraméter értelmezõ szövegkörnyezetének rögzítése és a formális paraméter felülírása csak akkor következik be, amikor a formális paraméter neve elõször fordul elõ az alprogram szövegében a végrehajtás folyamán. Alprogramok esetén típust paraméterként átadni nem lehet. Egy adott esetben a paraméterátadás módját az alábbiak döntik el: - a nyelv csak egyetlen paraméterátadási módot ismer (pl. C) - a formális paraméter listában explicit módon meg kell adni a paraméterátadási módot (pl. Ada) - az aktuális és formális paraméter típusa együttesen dönti el (pl. PL/I) - a formális paraméter típusa dönti el (pl. FORTRAN) fefe@coffein.hu ( 55 / 117 )

56 8/B /3 Paraméterkiértékelés, paraméterátadás az imperatív és a deklaratív programnyelvekben. Az alprogramok formális paramétereit három csoportra oszthatjuk: Input paraméterek: ezek segítségével az alprogram kap információt a hívótól (pl. érték szerinti paraméterátadás). Output paraméterek: a hívott alprogram ad át információt a hívónak (pl. eredmény szerinti paraméterátadás). Input-output paraméterek: az információ mindkét irányba mozog (pl. érték-eredmény szerinti paraméterátadás). fefe@coffein.hu ( 56 / 117 )

57 8/C Magasabb normálformák, többértékû függés. ( 57 / 117 )

58 8/D Folyamat ütemezése. Ütemezési kritériumok és algoritmusok. Preemptív ütemezés, prioritás, éhezés. Ütemezési sorok, visszacsatolás. Ütemezés A folyamatok tárgyalása közben már többször szó esett az ütemezés problémájáról. Az ütemezés az a mechanizmus, amely meghatározza, hogy az operációs rendszer milyen módon (és milyen esemény hatására) választja ki azt a folyamatot, amely a központi egységet fogja birtokolni - ezáltal aktív folyamat lesz. Az ütemezési politikák általában több, különbözõ szempont figyelembevételével választják ki az aktiválandó folyamatot azonban minden körülmények között optimálisan mûködõ ütemezési algoritmus nem létezik. A multiprogramozott rendszerek egyik kulcskérdése az ütemezés a folyamatoknak és a rendszer erõforrásainak (elsõdlegesen a központi egységnek) a dinamikus összerendelése. Az ütemezésnek négy fajtáját ismerjük: hosszú távú folyamatok hozzáadása a végrehajtásra váró folyamatok csoportjához ütemezés Közép távú ütemezés folyamatok (részbeni) betöltése a központi memóriába, illetve a teljes folyamat eltávolítása a központi memóriából (swapping) rövid távú ütemezés folyamat-processzor összerendelés I/O ütemezés Az erõforrásra várakozó folyamatok és az erõforrás összerendelése (melyik folyamat kérését elégítsük ki korábban). Az I/O ütemezést egy késõbbi fejezetben tárgyaljuk, ebben a fejezetben csak a processzor ütemezésével foglalkozunk (a táblázat elsõ három sora). Az ütemezés fajtái A processzor ütemezésének célja a folyamatok és a központi egység összerendelése oly módon, hogy a rendszer mûködése megfeleljen bizonyos elõzetes elvárásoknak (válaszidõ, átbocsátó képesség, a központi egység kihasználtsága). Sok rendszerben az ütemezési feladatot három alrendszer látja el: a hosszú távú a közép távú és a rövid távú ütemezõ. Az ütemezõk neve a döntések hatására és a ütemezõ rendszer mûködésének gyakoriságára utal. Hosszú távú ütemezõ A hosszú távú ütemezõ feladata a feldolgozandó folyamatok hozzáadása a rendszerhez. Ez az ütemezõ szabályozza a rendszerben a feldolgozandó folyamatok számát és ezáltal a párhuzamosság fokát. Hosszú távú ütemezõt kötegelt rendszerekben használunk (illetve általános rendszerek kötegelt mûködésû részében), mert az interaktív folyamatokat a felhasználó adja hozzá a rendszerhez. Kötegelt rendszerek esetében a feldolgozásra átadott job elõször egy várakozó sorba kerül (kötegelt sor), és feldolgozása csak akkor kezdõdik meg, ha a hosszú távú ütemezõ hozzáadja a rendszerhez. Minél több folyamat vár feldolgozásra a rendszerben, annál kisebb az esély, hogy egy folyamat processzoridõhöz jusson így a folyamatok számának limitálása szükséges a rendszerben. Azonban ha túl kevés folyamat várakozik a rendszerben, akkor a központi egység kihasználtsága nem lesz megfelelõ. A hosszú távú ütemezõ általában a processzor hihasználtságát veszi figyelembe. A hosszú távú ütemezõ a folyamatok kiválasztására általában FCFS (korábban jött - korábban kiszolgálva) algoritmust használ, de lehetõség van a folyamat jellemzõi (különbözõ erõforrásokkal szembeni igény) alapján történõ választásra is ezzel a megoldással a rendszer terheltségét közel egyenletes szinten lehet tartani (ehhez természetesen ismerni kell a folyamat igényeit). fefe@coffein.hu ( 58 / 117 )

59 8/D /2 Folyamat ütemezése. Ütemezési kritériumok és algoritmusok. Preemptív ütemezés, prioritás, éhezés. Ütemezési sorok, visszacsatolás. Interaktív rendszerek esetén hosszú távú ütemezõt nem szoktak alkalmazni, mert a válaszra váró felhasználók folyamatait az indításuk után rögtön be kell vinni a rendszerbe (a felhasználókat - természetesen - nem igazán érdekli a teljes rendszer hatékonysága, számukra a saját munkájuk hatékonysága lényeges). Interaktív felhasználók esetén ha a rendszer nagyon túlterhelt, akkor az operációs rendszer megtagadja az új folyamat indítását. Közép távú ütemezõ A középtávú ütemezõ a swap funkció végrehajtásában vesz részt, így bõvebb tárgyalására a memóriakezeléssel foglalkozó fejezetben fog sor kerülni. Rövid távú ütemezõ A hosszú távú ütemezõ (ha létezik a rendszerben) meglehetõsen ritkán aktivizálódik, így csak nagyon durva ütemezésre alkalmas. A legfinomabb ütemezést az rövid távú ütemezõ (továbbiakban ütemezõ) végzi. A rövid távú ütemezõ olyan esetekben aktivizálódik, amikor az aktuális folyamat megszakítódik, és új folyamat aktivizálása válik lehetségessé (adott esetben a döntés lehet az a megszakított folyamat folyatatása is). Ilyen események: Idõzítõ által generált megszakítás I/O tevékenység befejezõdését jelzõ megszakítás szolgáltatás kérése az operációs rendszertõl stb. A fejezet további részében csak a rövid távú ütemezõvel foglalkozunk. Ütemezõ algoritmusok A rövid távú ütemezés peremfeltételei Az ütemezõ fõ feladata a központi egység és a folyamatok összerendelése úgy, hogy a rendszer mûködése megfeleljen a megadott elvárásoknak. A peremfeltételek halmazától függõen különbözõ ütemezési politikákat határozhatunk meg. Az ütemezõvel szembeni elvárásokat két fõ halmazra bonthatjuk, ezek: a felhasználó- és a rendszerközpontú elvárások. Míg felhasználó szintû elvárások az egyes folyamatok szintjén fogalmazódnak meg, addig a rendszer szintû elvárások a teljes rendszer egészével szembeni elvárásokat fogalmazzák meg. Általában a felhasználói és a rendszer szintû elvárások egymással ellentmondóak. Az elvárásokat felbonthatjuk teljesítmény központú és egyéb elvárásokra is. A következõkben áttekintjük a legfontosabb elvárásokat. A fenti elvárások egymástól nem függetlenek, sok esetben egymásnak ellentmondóak. Például rövid válaszidõ biztosításához az ütemezõnek sûrûn kell a folyamatok között átkapcsolnia ami viszont jelentõsen megnöveli az operációs rendszer által igényelt processzor-idõt, és így csökkenti az átbocsátóképességet. A megfelelõ ütemezõ algoritmus kidolgozása (kiválasztása) során mindig kompromisszumok sorozatát kell kötnünk, szemünk elõtt tartva, hogy az adott rendszer esetében mely jellemzõk a legfontosabbak. Prioritások használata Az ütemezés egyik fontos jellemzõje a prioritás alkalmazása. Sok rendszerben minden egyes folyamathoz prioritást rendelünk, és az ütemezõ mindig a legnagyobb prioritású folyamatot választja ki futásra. Technikailag az ütemezõ annyi független várakozósort kezel, amennyi különbözõ prioritási szint van a rendszerben. fefe@coffein.hu ( 59 / 117 )

60 8/D /3 Folyamat ütemezése. Ütemezési kritériumok és algoritmusok. Preemptív ütemezés, prioritás, éhezés. Ütemezési sorok, visszacsatolás. Ameddig egy magasabb prioritású várakozósor nem üres, a rendszer nem fogja az alacsonyabb prioritású sorokban várakozó folyamatokat kiválasztani. A leírt egyszerû vagy statikus prioritási algoritmusnak a legnagyobb hátránya az, hogy az alacsony prioritású folyamatok esetén fennáll a kiéheztetés veszélye. A probléma megoldása lehet, ha a folyamatok prioritása a korukkal együtt változik. Erre a késõbbiekben látunk megoldást. Alternatív ütemezési politikák Az ütemezési politikák egyik fontos jellemzõje, hogy az adott folyamat felfüggeszthetõ-e vagy sem. Nem felfüggeszthetõ (nonpreemptive) esetben a folyamat mindaddig birtokolja a processzort amíg terminál, illetve I/O igény vagy operációs rendszertõl való szolgáltatás kérés miatt önmagát blokkolja. Felfüggeszthetõ (preemptive) ütemezés esetén az aktív folyamatot az ütemezõ megszakíthatja és várakozó állapotba viheti. A felfüggesztési döntés különbözõ események hatására születhet: új folyamat kerül a rendszerbe, blokkolt folyamat újra várakozó állapotba kerül, illetve a rendszer idõzítõjének a hatására. A felfüggeszthetõ politikák költsége nagyobb, azonban használatukkal egyetlen folyamat sem monopolizálhatja a processzort. Megfelelõ hardver támogatás segítségével a felfüggesztés költségei viszonylag alacsony szinten tarthatóak. FCFS - First Come, First Served vagy FIFO - First In, First Out A legegyszerûbb ütemezési algoritmus, a korábban jött - korábban kiszolgálva algoritmus. Amikor egy folyamat várakozó állapotba kerül, akkor a várakozó sor végére helyezzük. Az algoritmus mindig a legrégebbi folyamatot választja ki a várakozósorból. Az FCFS algoritmus a hosszabb folyamatok számára sokkal kedvezõbb, mint a rövidebbek számára. Amennyiben egy rövid futási idejû folyamat azonnal követ egy hosszabb futási idejût, a rövid futási idejû folyamat rendszerben töltött ideje irreálisan magas lesz az összes futási idejéhez képest. Az FCFS másik problémája, hogy a CPU igényes folyamatokat favorizálja az I/O igényesekkel szemben. Képzeljünk el egy folyamat-halmazt. Egy folyamat CPU igényes, a többi pedig erõforrás igényes. Amíg a CPU igényes folyamat fut, az összes I/O igényes folyamat várakozásra kényszerül. Amikor a futó folyamat elhagyja a futó állapotot, az I/O igényes folyamatok gyorsan átszaladnak az I/O állapotukon, és blokkolt állapotban várják az I/O esemény végeztét. Amennyiben az I/O igényes folyamat szintén blokkolt állapotban van, a processzor tétlenül fog várakozni. Így az FCFS algoritmus mind az I/O eszközök, mind a processzor szempontjából rossz erõforrás kihasználást eredményez. Önmagában az FCSF ütemezés nem túl vonzó megoldás, azonban más algoritmusokkal kombinálva használják. Round-Robin Az FCFS ütemezés hátrányainak leküzdését szolgáló megoldások egyike az, ha idõzítõ alapú felfüggesztést alkalmazunk. A megoldás legegyszerûbb megvalósítási formája a Round-Robin algoritmus. Adott idõintervallumonként a rendszeróra megszakítást generál, melynek hatására az éppen futó folyamatot várakozó állapotba helyezzük, és a várakozósorból FCFS algoritmus alapján választjuk ki a soron következõ folyamatot. Az algoritmus másik néven idõszeletelési (time slicing) algoritmusnak is szokták nevezni. Az algoritmus implementálásakor a legfontosabb döntés az idõszelet méretének meghatározása. Ha az idõszelet nagyon rövid, akkor a rövid futási idejû folyamatok gyorsan végrehajtódnak, azonban az ütemezés költségei meglehetõsen magasak lesznek. Általánosságban az idõszelet hosszát a rendszerbeli átlagos interakció hosszánál egy kicsivel hosszabbra szokták venni. fefe@coffein.hu ( 60 / 117 )

61 8/D /4 Folyamat ütemezése. Ütemezési kritériumok és algoritmusok. Preemptív ütemezés, prioritás, éhezés. Ütemezési sorok, visszacsatolás. Az idõszeleteléses ütemezés általánosságban hatékony megoldás az idõosztásos rendszerek esetén. Az algoritmus egyetlen hátránya az I/O igényes folyamatok relatív hátrányos helyzete a CPU igényes folyamatokhoz képest. Általánosságban az I/O igényes folyamatok a rájuk jutó processzor idõszeletnek csak egy kis részét használják, többnyire blokkolt állapotban vannak. Ezzel szemben a CPU igényes folyamatok a rendelkezésükre teljes CPU idõszeletet kihasználják, majd rögtön a várakozó folyamatok közé kerülnek. Az algoritmusnak egy finomított változata a Virtual Round Robin algoritmus, amely két várakozósort különböztet meg. A blokkolt folyamatok a blokkolódás megszûnte után egy másodlagos várakozósorba kerülnek. Az ütemezõ új folyamat kiválasztásakor elõször mindig a másodlagos várakozósort vizsgálja, és ha abban van folyamat, akkor azt fogja aktivizálni azonban ez a folyamat csak akkora idõszeletet kap, amennyi az elõzõ idõszeletbõl maradt (tehát a blokkolódás és az idõszelet vége között eltelt idõt). Feedback A megoldás lényege egy felfüggeszthetõ (idõszeleteken alapuló), dinamikus prioritáson alapuló algoritmus. Definiáljunk n darab várakozósort (prioritási szintenként egyet). Minden új folyamat a legmagasabb prioritási sorban kezdi meg a futását. Amennyiben a folyamat futó állapotból visszakerül várakozó állapotba, akkor nem abba a várakozósorba kerül ahonnan kiválasztották, hanem eggyel alacsonyabb prioritású sorba (az n-dik sorban található folyamatok kivételével). Az újabb, rövidebb folyamatok elõnybe részesülnek a hosszú, öregebb folyamatokkal szemben. Az algoritmus fontos jellemzõje, hogy minél kisebb egy sor prioritása annál nagyobb a rendelkezésére álló idõszelet hossza (általában kettõ hatványai szerint növekszik). A prioritással együtt változó idõszelet nem jelent tökéletes védekezést a kiéheztetés ellen ezért egy bizonyos idõ eltelte után a legalsó sorban található folyamatokat magasabb prioritású sorba helyezzük át. fefe@coffein.hu ( 61 / 117 )

62 9/A A sztring mint adatszerkezet, mintaillesztés. A sztring olyan lista, amelynek elemeit az abc szimbólumok alkotják. Mi olyan sztringekkel foglalkozunk, amelyeknek elemei karakterek. Sok terület van, ami a sztringekkel foglalkozik: Formális nyelvek, Automaták, Szövegszerkesztõk: A sztring formája a lényeges. Hipertext rendszerek: A sztringben elõforduló szavakat vissza-, ill. kikereshetjük. A sztringnél van elérés, minden karakterhez hozzá tudunk férni. Allista: rész sztring Konkatenáció (egyesítés): A sztringek összefûzése. Length: A sztring hossza, a sztring karaktereinek a száma. Lényeges az üressztring kiemelkedõ szerepe. Mûveletek Létrehozás: Megadom a sztring összes karakterét. Bõvítés: Bárhol a sztringben részsztringgel bõvíthetek, a listánál megbeszélt konkatenáció mûvelettel. Törlés: Fizikai törlés, részsztring törlése. Csere: sztring részsztringjét cserélem egy másik részsztringre, azonosra, rövidebbre vagy hosszabbra. Rendezés, elérés, bejárás: nem értelmezett. Elérés: közvetlen. Keresés: Értelmezett, de részsztringet keresek. Feldolgozás: késõbb látjuk. Reprezentáció: Mindkettõ megjelenik. Sztringek ábrázolása A. Folyamatos ábrázolás Ahány karakter, annyi bájt, belsõ kód alapján. Egy sztring esetén triviális. A kérdés több sztring tárolásánál a lényeges: 1. Fix hosszon tárolunk. Kezelése igen kényelmes. Akkora terület kell hogy legyen a fix hossz, hogy a leghosszabb sztring is elférjen. Ez azt jelenti, hogy a többi sztringet ki kell egészíteni szóközökkel. Ez nagyon nagy helyett foglal el, és kihasználatlan tárterületek maradnak. 2. Változó hosszúságon tárolok. Minden sztringnek annyi bájtot foglalok le, amennyi bájtból áll, csak a szükséges helyet foglalom le. Probléma, hogy nem tudom, melyik meddig tart. Jelölni kell, hogy hol kezdõdnek az egyes sztringek, így a sztring elõtt letárolom a hosszát. Kezelése sokkal nyûgösebb mint az elõzõé, mert tudnom kell, hogy hol vannak a sztring hosszjelzõk, és meg kell tudnom különböztetni a tényleges karakterektõl. A Pascal ezt vallja. Egy vátozata, amikor a sztring hosszát nem elõtte tárolom, hanem a folyamatosan egymásután írt sztringrõl létrehozok egy információs táblázatot, amely megmondja, hogy az egyes sztringek hol kezdõdnek. Egy másik változata az, amikor végjelt alkalmazok. Egy sztring végjeltõl végjelig tart. Egyegy sztringbeli elem jelzi a sztring végét. fefe@coffein.hu ( 62 / 117 )

63 9/A /2 A sztring mint adatszerkezet, mintaillesztés. Mindegyik megvalósítást alkalmazzák. (Pascal: Text) B. Szétszórt ábrázolás 1. Minden láncoltlista elem egy-egy karaktert tartalmaz: A sok mutató miatt ez igen nagy helyet foglalna el, ezért ez csak egy elméleti megoldás, a gyakorlatban nem alkalmazzák. 2. Az elõzõ helyett azt alkalmazzák, amikor karakter helyett részsztringet ábrázolnak. Itt probléma a tördelés, mi van, ha n-nel nem osztható hosszúságú a sztring ( tört) Pattern matching (minta illesztés) Van egy sztringem és ebben keresem, hogy egy adott másik sztring elõfordul-e benne, és ha igen, akkor hol. Sok helyen elõfordulhat. Ennek jelentõsége például a képfeldolgozásban és szövegben való keresés és csere esetén van. Az illesztési algoritmusok 1. Veszük a mintát és lépésenként végigmegyünk rajta. Nem jó ha az lassú algoritmus, az összes lehetséges esetet végigvizsgálja. 3. Dömölki Bálint féle algoritmus Ez nem sztringkezelõ algoritmusnak született meg, hanem az automata elméleti algoritmusnak. ( A 60-as években született). Hatékonyabb algoritmus, mint az elõzõek, és könnyebben programozható. Dömölki Magyarországon dolgozott, így bár ez az algoritmus könnyebben kezelhetõ, mégsem tudott úgy elterjedni, mint a nyugaton fejlesztettek. Dömölki vezetésével írtak fordítóprogramot az MPrológ-hoz. A magyar számítástechnika történetében szinte egyedülállóan, Dömölki állami díjat kapott. Az algoritmus Legyen a két sztring: a: ABAFBADC p: BAD Elsõ lépésben hozzunk létre egy logikai mátrixot, B-t. A B sorait cimkézzük, vagy azonosítsuk azokkal a karakterekkel, amelyek elõfordulhatnak a két sztringben. Oszlopai a minta szerinti karakterek. B i,j =1, ha az adott karakter az adott helyen elõfordul, egyébként 0. Az algoritmus használ 3 db M elemû logikai vektort: Q, U, V, amelyek induló értékei a következõk: Q=(00...0) U=(10...0) V=(00...1) Az algoritmus használ egy vermet, ami a mintaillesztéshez nem feltétlenül szükséges. Mi a példánkban alkalmazni fogjuk. Jelöljük a vermet S-el. Az alapsztring karaktereit egyenként dolgozom fel. Elhelyezem õket a veremben, miközben vizsgálom, hogy van-e egyezés az alap sztring és a minta sztring elemei között. A Q vektor az illesztés adminisztrálására szolgál úgy, hogy Q l :=1, ha a verem tetején lévõ l db karakter megegyezik a minta elsõ l db karakterével. Nyílván, ha Q M =1, akkor a verem tetején megvan a minta. fefe@coffein.hu ( 63 / 117 )

64 9/A /3 A sztring mint adatszerkezet, mintaillesztés. Az alap sztring minden egyes karaktere kiválaszt a B-bõl egy sort, ami legyen B i. Értelmezve van egy olyan mûvelet, amely R:(a 1..a M ) (0,a 1..a M-1 ), azaz nem csinál mást, mint jobbra shift-tel eggyel. Veszem az alapsztring karaktereit, pakolom a verembe, közben Q értéke a következõ lesz: Minden lépés után vizsgálom, hogy, ha igen, akkor a minta a verem tetején van. Példa: Ha Q értéke (100), akkor az azt jelenti, hogy a verem tetején lévõ karakter megegyezik a minta elsõ karakterével. A verembe a köv. elemet rakjuk, és közben Q-t számoljuk úgy, hogy Q=(000)v(100)&(010)=(000). Q=(000)v(100)&(100)=(100). Ha Q=(001), akkor a verem tetején ott a minta. Ez nem implementáció, hanem algoritmus. Gépi kódban könnyû implementálni. Ez az algoritmus hosszú sztringeknél is kitûnõen mûködik. Egyik elõnye az, hogy míg a többinél ha több mintát akarok keresni, annyiszor végig kell menni az alapsztringen, míg itt egyszerre akárhány mintát illeszthetünk. fefe@coffein.hu ( 64 / 117 )

65 9/B Ciklusok és megvalósításuk az egyes programozási nyelvekben. Ciklusszervezõ utasítások: A ciklusszervezõ utasítások lehetõvé teszik, hogy a program egy adott pontján egy bizonyos tevékenységet akárhányszor megismételjünk. Egy ciklus általános felépítése a következõ:, fej, mag, vég Az ismétlésre vonatkozó információk vagy a fejben vagy a végben szerepelnek. A mag az ismétlendõ végrehajtható utasításokat tartalmazza. A ciklusok mûködésénél megkülönböztetünk két szélsõséges esetet. Az egyik az, amikor a mag egyszer sem fut le, ezt hívjuk üres ciklusnak. A másik az, amikor az ismétlõdés soha nem áll le, ez a végtelen ciklus. A mûködés szerinti végtelen ciklus a programban nyilván szemantikai hibát jelent, hiszen az sohasem fejezõdik be. Feltételes ciklus: Ennél a ciklusnál az ismétlõdést egy feltétel igaz vagy hamis értéke szabályozza. A feltétel maga vagy a fejben vagy a végben szerepel. Szemantikájuk alapján beszélünk kezdõfeltételes és végfeltételes ciklusról. Kezdõfeltételes ciklus: A feltétel a fejben jelenik meg. Mûködése: Kiértékelõdik a feltétel. Ha igaz, végrehajtódik a ciklusmag, majd újra kiértékelõdik a feltétel, és a ciklusmag mindaddig újra és újra lefut, amíg a feltétel hamissá nem válik. Tehát, ha egyszer beléptünk a magba, akkor ott kell valamikor olyan utasításnak végrehajtódnia, amely megváltoztatja a feltétel értékét. A kezdõfeltételes ciklus lehet üres ciklus, ha a feltétel a legelsõ esetben hamis. Lehet végtelen ciklus is, ha a feltétel a legelsõ esetben igaz és mindig igaz is marad. Végfeltételes ciklus: A feltétel általában a végben van, de vannak nyelvek, amelyekben a fej tartalmazza azt. Mûködése: Elõször végrehajtódik a mag, majd ezután kiértékelõdik a feltétel. Általában ha a feltétel hamis, újra végrehajtódik a mag. Tehát az ismétlõdés mindaddig tart, míg a feltétel igazzá nem válik. Vannak viszont olyan nyelvek, amelyek igazra ismételnek. Nyilván itt is a magban kell gondoskodni a feltétel értékének megváltoztatásáról. A végfeltételes ciklus soha nem lehet üres ciklus, a mag egyszer mindenféleképpen lefut. Végtelen ciklus viszont lehet, ha a feltétel értéke a második ismétlés után nem változik meg.. Elõírt lépésszámú ciklus: Ennél a ciklusfajtánál az ismétlõdésre vonatkozó információk (az ún. ciklusparaméterek) a fejben vannak. Minden esetben tartozik hozzá egy változó, a ciklusváltozó. A változó által felvett értékekre fut le a ciklusmag. A változó az értékeit egy tartományból veheti föl. Ezt a tartományt a fejben adjuk meg kezdõ- és végértékével. A ciklusváltozó a tartománynak vagy minden elemét fölveheti (beleértve a kezdõ- és végértéket is), vagy csak a tartományban szabályosan (ekvidisztánsan) elhelyezkedõ bizonyos értékeket. Ekkor meg kell adni a tartományban a felvehetõ elemek távolságát meghatározó lépésközt. A változó az adott tartományt befuthatja növekvõleg, illetve csökkenõleg, ezt határozza meg az irány. Az elõírt lépésszámú ciklussal kapcsolatban a nyelveknek a következõ kérdéseket kell megválaszolniuk: 1. Milyen típusú lehet a ciklusváltozó? Minden nyelv megengedi az egész típust. Egyes nyelveknél sorszámozott típusú lehet. Van néhány nyelv, amelyik megengedi a valósat is. A kezdõérték, a végérték és a lépésköz típusa meg kell, hogy egyezzen a ciklusváltozó típusával, vagy arra konvertálhatónak kell lennie. fefe@coffein.hu ( 65 / 117 )

66 9/B /2 Ciklusok és megvalósításuk az egyes programozási nyelvekben. 2. Milyen formában lehet megadni a kezdõértéket, végértéket és a lépésközt? Minden nyelv esetén megengedett a literál, változó és nevesített konstans. Késõbbi nyelveknél kifejezéssel is megadható. 3. Hogyan határozódik meg az irány? A lépésköz elõjele dönti el ha pozitív, akkor növekvõ, ha negatív, akkor csökkenõ. Általában azok a nyelvek vallják ezt, melyekben a ciklusváltozó csak numerikus típusú lehet. Külön alapszót kell használni. 4. Hányszor értékelõdnek ki a ciklusparaméterek? Általában egyszer, amikor a vezérlés a ciklushoz ér, és a ciklus mûködése alatt nem változnak. Minden ciklusmag-végrehajtás elõtt újra meghatározódnak. 5. Hogyan fejezõdhet be a ciklus? Szabályos lefutás - a ciklusparaméterek által meghatározott módon. - a ciklus magjában külön utasítással. GOTO-utasítással, általában nem tekintjük szabályos befejezésnek. 6. Mi lesz a ciklusváltozó értéke a ciklus lefutása után? Ha GOTO-val ugrunk ki a ciklusból, akkor a ciklusváltozó értéke az utoljára felvett érték lesz. Szabályos befejezés esetén a hivatkozási nyelvek egy része nem nyilatkozik errõl a kérdésrõl, másik része azt mondja, hogy a ciklusváltozó értéke határozatlan. Az implementációk viszont a következõket mondják: - A ciklusváltozó értéke az az érték, amelyre utoljára futott le a ciklus. - A ciklusváltozó értéke az az érték, amire már éppen nem futott le a ciklus. - A ciklusváltozó értéke határozatlan. Felsorolásos ciklus: A felsorolásos ciklus az elõírt lépésszámú ciklus egyfajta általánosításának tekinthetõ. Van ciklusváltozója, amely explicit módon megadott értékeket vesz fel és minden felvett érték mellett lefut a mag. A ciklusváltozót és az értékeket a fejben adjuk meg, ez utóbbiakat kifejezéssel. A ciklusváltozó típusa tetszõleges. Nem lehet sem üres, sem végtelen ciklus. Végtelen ciklus: A végtelen ciklus az a ciklusfajta, ahol sem a fejben, sem a végben nincs információ az ismétlõdésre vonatkozóan. Mûködését tekintve definíció szerint végtelen ciklus, üres ciklus nem lehet. Használatánál a magban kell olyan utasítást alkalmazni, amelyik befejezteti a ciklust. Nagyon hatékony lehet eseményvezérelt alkalmazások implementálásánál. Összetett ciklus: Az elõzõ négy ciklusfajta kombinációiból áll össze. A ciklusfejben tetszõlegesen sok ismétlõdésre vonatkozó információ sorolható föl, szemantikájuk pedig szuperponálódik. Nagyon bonyolult mûködésû ciklusok építhetõk fel a segítségével Ciklusszervezõ utasítások az egyes nyelvekben FORTRAN: Elõírt lépésszámú ciklus: DO címke változó = k, v [,l] végrehajtható_utasítások címke utasítás A változó, k, v, l típusa csak egész lehet. A k, v, l (kezdõérték, végérték, lépésköz) csak literál vagy változó lehet, kifejezés nem. Ha nincs megadva az l, akkor a lépésköz alapértelmezett értéke 1, és az irány növekvõ. Ha adott az l, akkor az irányt annak elõjele adja meg. Implementációi általában hátultesztelõek. A ciklus végén nem lehet vezérlõ utasítás, ilyenkor üres utasítást kell oda írni. A késõbbi verziókba bekerülnek a kezdõ- és végfeltételes ciklusok is. fefe@coffein.hu ( 66 / 117 )

67 9/B /3 Ciklusok és megvalósításuk az egyes programozási nyelvekben. PL/I: Benne minden ciklusfajta létezik. Kezdõfeltételes ciklus: DO WHILE(kifejezés); Végfeltételes ciklus: DO UNTIL(kifejezés); Elõírt lépésszámú ciklus: DO változó = k TO v [BY l] PASCAL: Kezdõfeltételes ciklus: WHILE feltétel DO utasítás; Végfeltételes ciklus: REPEAT utasítások UNTIL feltétel; Elõírt lépésszámú ciklus: FOR változó = k { TO DOWNTO } v DO utasítás; Elõltesztelõ. Irányt az alapszó dönti el, TO esetén növekvõ, DOWNTO esetén csökkenõ. A lépésközt a Pascal nem értelmezi. ADA: Kezdõfeltételes ciklus: WHILE feltétel LOOP mag END LOOP; Elõírt lépésszámú ciklus: FOR változó IN [ REVERSE ] tartomány LOOP mag END LOOP; C: Kezdõfeltételes ciklus: WHILE(feltétel) utasítás; A feltétel integrális típusú. Ha értéke nem 0, akkor ismétel. Végfeltételes ciklus: DO utasítás WHILE(feltétel); Akkor ismétel, ha a feltétel értéke nem 0. FOR-ciklus: FOR([kifejezés1]; [kifejezés2]; [kifejezés3]) utasítás; Ez a ciklus megfelel a következõ kódnak: kifejezés1; WHILE(kifejezés2) {utasítás; kifejezés3;} A kifejezés1 inicializáló kifejezés, kifejezésutasításként a ciklus mûködése elõtt értékelõdik ki. A kifejezés2 felelõs a ciklus befejezéséért, feltételként értelmezõdik A kifejezés3 kifejezésutasításként minden cikluslépés végén kiértékelõdik. Ha a kifejezés2 nem szerepel, akkor végtelen ciklus lesz. A végtelen ciklusból szabályosan a BREAK utasítással tudunk kilépni. fefe@coffein.hu ( 67 / 117 )

68 9/C Az adatmodellezés alapfogalmai: egyed, tulajdonság, kapcsolat, séma. A lépések tehát a következõk: ANALÍZIS, TERVEZÉS, IMPLEMENTÁLÁS Az adatmodellezés 3 szinten történik: Koncepcionális szint - teljesen absztrakt, számítógép független, azaz nem függ sem a szoftvertõl, sem pedig az operációs rendszertõl Logikai szint - a logikai tervezésnél kerül be konkrétan az adatbázis kezelõ rendszer Fizikai szint - a teljes fizikai megvalósítás Tranzakció: Valamilyen értelemben összetartozó mûveletsorozat, melyeket adatokon hajtunk végre. EGYED: a valós világ elemeinek absztrakciója. A fontos és lényeges tulajdonságok teszik egyeddé. pl.: Egyetem rendszerben HALLGATÓ( NÉV, LAKCÍM, SZÜLETÉSI_HELY, SZAK) EGYEDTÍPUS: egy absztrakció. A tulajdonságtípusok határozzák meg. EGYED-ELÕFORDULÁS: Egyed konkrétan megadva. Rögzített számú tulajdonságot tartalmaznak. Fontos a konkrétság. Két egyedtípus akkor különbözik, ha legalább egy tulajdonságtípusuk különbözik, egyébként azonosak. Két egyed-elõfordulás akkor különbözik, ha legalább egy tulajdonság-elõfordulásukban különböznek. Azon tulajdonságtípusok együttesét, amelyek elõfordulásai minden egyed-elõfordulásnál mások / egyediek, az adott egyedtípus AZONOSÍTÓjának nevezzük. Kötelezõ, hogy létezzen azonosító. Az azonosító lehet egyszerû és összetett. KAPCSOLAT: egyedtípusok közötti viszony leírása. Két egyedtípus kapcsolatban van egymással, ha van közös tulajdonságtípusuk. Ez a KAPCSOLÓ TULAJDONSÁGTÍPUS. Azok a tulajdonságtípusok, amelyek nem kapcsolók és nem azonosítók, azok a LEÍRÓ TULAJDONSÁGTÍPUSOK. Koncepcionális adatmodell: Véges sok egyedtípus, melyek mindegyikét véges sok tulajdonságtípus határoz meg - a közöttük állókapcsolatok együttese ez az adatmodell. Tulajdonságok / Attributumok Osztályozásai: 1.a. Egyszerû (atomi) atomic, single - Az elõfordulások skalárértékûek. b. Összetett composite - Strukturált típusú értékekkel rendelkezõ elõfordulások. 2.a. Egyértékû single-valued - Minden egyes elõfordulásnál csak egy értéket vehet föl. (pl.: születési_hely) b. Többértékû vagy halmazértékû multivalued - minden elõfordulásnál akárhány értéket felvehet. (pl.: nyelvvizsga) 3.a. Tárolt stored - Az egyes elõfordulások értékei megjelennek a fizikai adatbázisban. b. Származtatott derived - Értékei nem kerülnek bele a fizikai állományba, más attribútumokkal határozhatjuk meg õket. NULL-ÉRTÉKÛ TULAJDONSÁGTÍPUS : Ha egy adott elõfordulásnál nincs értéke, (a tulajdonságtípusnak) akkor mondjuk, hogy NULLértékû. fefe@coffein.hu ( 68 / 117 )

69 9/C /2 Az adatmodellezés alapfogalmai: egyed, tulajdonság, kapcsolat, séma. A NULL-értékû tulajdonságtípus többféle módon elõállhat: Van érték, csak még nem ismerjük. Nem tudjuk, hogy van-e egyáltalán értéke az elõfordulásnak. Az adott elõfordulásnak az adott helyen nem lehet elõfordulása. A NULL-értéket nem lehet összehasonlítani semmilyen értékkel! A tulajdonságtípusok rendelkeznek értéktartománnyal, ahonnan az értéküket fölvehetik. KAPCSOLATOK FOK (degree): hány egyedtípus vesz részt a kapcsolatban. A fok lehet: - bináris - ternális - sokszoros SZÁMOSSÁG (cardinality): Az egyik oldal elõfordulásaihoz a kapcsolatban hány neki megfelelõ elõfordulás van a másik oldalon. Kapcsolatban az egyed-elõfordulások száma adja a kapcsolat számosságát. 1:1, 1:N, N:M SZOROSSÁG: Az egyik vagy másik oldalon az elõfordulások közül mennyi vesz részt a kapcsolatban. Kötelezõ jellegû, ha mindkét oldalon, minden elõfordulásnak részt kell vennie a kapcsolatban. Félig kötelezõ, ha az egyik oldalon minden elõfordulásnak részt kell vennie a kapcsolatban, a másik oldalon viszont nem. Opcionális, ha mindkét oldalon lehetnek olyan elõfordulások, amelyek nem vesznek részt a kapcsolatban. REKURZÍV KAPCSOLAT: Speciális bináris kapcsolat. Az egyedtípus önmagával áll kapcsolatban. A modellt egy sémával írom le formálisan. Sémaelemek: Egyszerû, egyszintû hierarchia: (5.ábra) Összetett, többszintû hierarchia: (6.ábra) Kapcsoló tulajdonságtípusok jelölése : 1:1 számosság 1:N számosság N:M számosság 5. ábra 6. ábra fefe@coffein.hu ( 69 / 117 )

70 9/D Az operációs rendszer grafikus felhasználói interfésze (GUI) és mûködése. Windows alapú rendszerek A számítástechnika társadalmasodása maga után vonta az igényt a minél könnyebben kezelhetõ, ún. felhasználóbarát programok gyártására. Az operációs rendszereket is elérte a változás szele, a bonyolultan paraméterezhetõ sokféle parancs kiváltására megjelentek elõbb a menüvezérelt, majd a grafikus segédprogramok. A Windows grafikus felületû segédprogram, újabb verziói önálló operációs rendszerként üzemelnek. Egyszerû segédprogramnál már eleinte is több volt, mivel képes volt az Intel processzorokat multitask üzemmódban használni (az operációs rendszerrel szemben). Ablakok Programfuttatási lehetõségek fefe@coffein.hu ( 70 / 117 )

71 10/A Fa, bináris fa, bejárások. Nem bináris fák kezel. HIERARCHIKUS ADATSZERKEZETEK Olyan adatszerkezetek, amelyek valamilyen értelemben a lista általánosításainak tekinthetõek. A hierarchikus szerkezeteben egy elemnek akárhány rákövetkezõje lehet, de minden elemnek csak egyetlen megelõzõje van. Van egy kitüntetett eleme, amelynek nincs megelõzõje, és több olyan eleme, amelynek nincs rákövetkezõje. FA (tree) Dinamikus, homogén adatszerkezet, amelyben minden elem megmondja a rákövetkezõjét. Alapfogalmak: Gyökérelem: A fa azon eleme, amelynek nincs megelõzõje. A legegyszerûbb fa egyetlen gyökérbõl áll. Mindig csak egy gyökérelem van, üres fában egy sem. Levélelem: A fa azon elemei, amelyeknek nincs rákövetkezõjük. Bármennyi lehet belõlük. Úgy érhetõek el, hogy a gyökérelembõl indulva veszem a gyökérelem rákövetkezõjét, majd annak a rákövetkezõjét, stb. Közbensõ elem: A fa nem gyökér- ill. levélelemei, hanem az összes többi eleme. Út: A gyökérelemtõl kiinduló, különbözõ szinteken átmenõ, és levélelemben végetérõ egymáshoz kapcsolódó élsorozat (lista). Az út hosszán az adott útban szereplõ élek számát értjük. Minden levélelem a gyökértõl pontosan egy úton érhetõ el, út helyett szokás beszélni a a fa ágairól is. Egy fában az utak száma megegyezik a levélelemek számával. A fán belül vannak szintek, egy elem szintje megegyezik az elem gyökérelemtõl vett távolságával.. A nulladik szinten a gyökérelem helyezkedik el, az elsõ szinten a gyökérelem rákövetkezõi (a gyökértõl egy élnyi távolságra lévõ elemek), a második szinten ezeknek a rákövetkezõi, és így tovább. A maximális szintszámot a fa magasságának vagy mélységének (a lenti példában 3) nevezzük. Részfa: Minden közbensõ elem egy részfa gyökereként tekinthetõ, így a fa részfákra bontható. Beszélhetünk üresfáról is, ez a fáknak az szélsõséges esete, amikor a fának egyetlen eleme sincs. A fát tekinthetjük rendezett vagy rendezetlen módon. Ha rendezetlen módon vizsgáljuk, akkor az egy elembõl kiinduló ágaknak nem tulajdonítunk rendezettséget, felcserélhetõek, azaz a sorrendjük tetszõleges. Ha egy fa rendezett, akkor az egy elembõl kiinduló éleknek a sorrendje kötött. Tekintsük ezt a két fát: Ha rendezetlen módon vizsgáljuk, akkor a két fa megegyezik, ha viszont feltesszük, hogy rendezettek, akkor a két fa nem ekvivalens. Bináris fa: A számítástechnikában kitüntetett szerepe van a bináris fának. A bináris fa olyan fa, amelyben minden elemnek legfeljebb két rákövetkezõje lehet. Szigorú értelemben vett bináris fáról akkor beszélünk, amikor minden elemnek 0 vagy pontosan 2 rákövetkezõ eleme van. Rendezett bináris fáknál a rendezettség miatt az egyértelmûség kedvéért beszélhetünk baloldali és jobboldali részfákról. Tetszõleges nem bináris fa reprezentálható bináris fa segítségével a következõ módon: fefe@coffein.hu ( 71 / 117 )

72 10/A /2 Fa, bináris fa, bejárások. Nem bináris fák kezel. Az binárisan ábrázolandó fa gyökéreleme a bináris fában is gyökérelem lesz. Ezek után a bináris fa baloldali részfájának gyökéreleme legyen az következõ szinten lévõ legbaloldalibb elem. Ehhez láncoljuk hozzá az azonos szinten lévõ, közös gyökerû elemeket egymás jobboldali részfáiként. Ezt a folyamatot ismételni kell az egész fára, minden szinten. A bináris fában az eredeti fa levélelemei nem feltétlenül maradnak levélelemek, viszont felismerhetõek arról, hogy nincs baloldali részfájuk. Bármely fa kezelhetõ bináris faként. A továbbiakban bináris fákról beszélünk. Mûveletek Létrehozás: Létrehozzuk az üresfát, majd egy elemet viszünk be (a gyökérelemet), ezután a létrehozás nem más, mint a fa bõvítése. Bõvités: Bõvíteni általában levélelemmel szoktunk, ritkábban részfával. Általában csak a levélelemmel való bõvítést értelemzzük, de tetszõleges helyen való bõvítés is értelmezhetõ, a fa átstruktúrálásával jár. Törlés: Bináris fából bármikor törölhetek egy részfát, közbensõ elemet nem. Ez fizikai törlés, logikai törlést bármikor végezhetek. Csere: A megfelelõ adatelemet bejárással elérem és az értékét bármikor fölülírhatom. Rendezés, keresés, elérés: Nincs, legalábbis a korábbi értelemben. Elérés helyett egy speciális famûvelet, a bejárás értelmezhetõ: Bejárás: A bejárás az a tevékenység, amikor a fát, mint hierarchikus adatszerkezet egy sorra, lineáris adatszerkezetre képezzük le. A fa elemeit a bejárás folyamán egyszer, és pontosan egyszer érintjük, az elemek között valamilyen sorrendet állapítunk meg, attól függõen, hogy hogyan járjuk be a fát. Három bejárási mód van, ezek közötti különbség abban rejlik, hogy a bejárás folyamán a gyökérelemet mikor dolgozzuk fel. preorder bejárás: Ha a fa üres, akkor vége a bejárásnak, egyébként vegyük a gyökérelemet és dolgozzuk fel (vagy képezzük le a sor elsõ elemére). Ezután járjuk be preorder módon a baloldali, majd a jobboldali részfát. inorder bejárás: Ha a fa üres, akkor a bejárás befejezõdik. Egyébként járjuk be inorder módon a baloldali részfát, majd dolgozzuk fel a gyökérelemet, és járjuk be ugyanezen módszerrel a jobboldali részfát. postorder bejárás: Üresfánál vége, egyébként járjuk be postorder módon a baloldali, majd a jobboldali részfát, végül dolgozzuk fel a gyökérelemet. Feldolgozás: Alapja a bejárás. A bináris fáknál a leggyakoribb ábrázolás a szétszórt ábrázolás, majdnem kizárólagosan ezt alkalmazzák. Egy fa eleme egy adatrészbõl és két mutatórészbõl áll, ezek egyike a bal, a másik a jobb oldali részfát címzi. A gyökérmutató fej jellegû, egy fán kívüli információ. Ha a fej NULL, akkor a fa üres. fefe@coffein.hu ( 72 / 117 )

73 10/B Alprogram és blokk az egyes programnyelvekben. Alprogramok Az alprogram az eljárásorientált nyelvekben a procedurális absztrakció elsõ megjelenési formája, alapvetõ szerepet játszik ebben a paradigmában, sõt meghatározója annak. Az alprogram mint absztrakciós eszköz egy bemeneti adatcsoportot képez le egy kimeneti adatcsoportra úgy, hogy egy specifikáció megadja az adatok leírását, de semmit nem tudunk magáról a tényleges leképezésrõl. Ismerjük a specifikációt, de nem ismerjük az implementációt. Az alprogram, mint programozási eszköz az újrafelhasználás eszköze. Akkor alkalmazható, ha a program különbözõ pontjain ugyanaz a programrész megismétlõdik. Ez az ismétlõdõ programrész kiemelhetõ, egyszer kell megírni, és a program azon pontjain, ahol ez a programrész szerepelt volna, csak hivatkozni kell rá az alprogram az adott helyeken meghívható, aktivizálható. Az alprogram attól lesz absztrakciós eszköz, hogy a kiemelt programrészt formális paraméterekkel látjuk el, vagyis általánosabban írjuk meg, mint ahogyan az adott helyeken szerepelt volna. Formálisan az alprogram a következõképpen épül fel: - fej - törzs - vég Az alprogram, mint programozási eszköz négy komponensbõl áll: név formális paraméter lista törzs környezet A név egy azonosító, amely mindig a fejben szerepel. A formális paraméter lista is a specifikáció része. A formális paraméter listában azonosítók szerepelnek, ezek a törzsben saját programozási eszközök nevei lehetnek, és egy általános szerepkört írnak le, amelyet konkretizálni kell az aktuális paraméterek segítségével. A korai nyelvekben a formális paraméter listán csak a paraméterek nevei szerepelhettek, a késõbbi nyelvekben viszont itt megadhatók további olyan információk, melyek a paraméterek futás közbeni viselkedését szabályozzák. A formális paraméter lista kerek zárójelek között áll. A nyelvek egy része szerint a zárójelek a formális paraméter listához, mások szerint a névhez tartoznak. A formális paraméter lista lehet üres is, ekkor paraméter nélküli alprogramról beszélünk. A törzsben deklarációs és végrehajtható utasítások szerepelnek. A nyelvek egy része azt mondja, hogy ezeket el kell különíteni egymástól, tehát a törzsnek van egy deklarációs és egy végrehajtható része. Más nyelvek szerint viszont a kétféle utasítás tetszõlegesen keverhetõ. Az alprogramban deklarált programozási eszközök az alprogram lokális eszközei, ezek nevei az alprogram lokális nevei. A lokális nevek az alprogramon kívülrõl nem láthatók, azokat az alprogram elrejti a külvilág elõl. Ezzel szemben léteznek a globális nevek, melyeket nem az adott alprogramban deklaráltunk, hanem valahol rajta kívül, de a törzsben szabályosan hivatkozhatunk rájuk. Egy alprogram környezete alatt a globális változók együttesét értjük. Az alprogramoknak két fajtája van: eljárás és függvény. Az eljárás olyan alprogram, amely valamilyen tevékenységet hajt végre. A hívás helyén ezen tevékenység eredményét használhatjuk fel. Az eljárás a hatását a paramétereinek vagy a környezetének megváltoztatásával illetve a törzsben elhelyezett végrehajtható utasítások által meghatározott tevékenység elvégzésével fejti ki. fefe@coffein.hu ( 73 / 117 )

74 10/B /2 Alprogram és blokk az egyes programnyelvekben. A függvény olyan alprogram, amelynek az a feladata, hogy egyetlen értéket határozzon meg. Ez az érték tetszõleges típusú lehet. A függvény visszatérési értékének a típusa egy további olyan információ, amely hozzátartozik a függvény specifikációjához. A függvény visszatérési értékét mindig a neve hordozza, formálisan az közvetíti vissza a hívás helyére. A függvény törzsének végrehajtható utasításai a visszatérési érték meghatározását szolgálják. Azt a szituációt, amikor a függvény megváltoztatja paramétereit, vagy környezetét, a függvény mellékhatásának nevezzük. A mellékhatást általában károsnak tartják. Egy eljárást aktivizálni utasításszerûen lehet, azaz az eljáráshívás elhelyezhetõ bárhol, ahol végrehajtható utasítás állhat. Egyes nyelvekben van külön eljáráshívásra szolgáló alapszó ( ez nagyon gyakran a CALL). Más nyelvekben nincs külön alapszó. Híváskor a vezérlés átadódik az eljárásra. Formálisan a hívás a következõképpen néz ki: [alapszó] eljárásnév(aktuális_paraméter_lista) Egy eljárás szabályosan befejezõdhet a különbözõ nyelvekben, ha elérjük a végét, külön utasítással befejeztetjük, ez bárhol kiadható az eljárás törzsében. Szabályos befejezõdés esetén a program a hívást követõ utasításon folytatódik. Általában nem szabályos befejezésnek tekintjük a következõket: Minden nyelv megengedi, hogy az eljárásból GOTO-utasítással kilépjünk, a megadott címkén folytatva a programot. Minden nyelvben van olyan eszköz, amely hatására a teljes program befejezõdik, ekkor nyilván az eljárás maga is véget ér, és a vezérlés az operációs rendszerhez kerül vissza. Függvényt meghívni csak kifejezésben lehet, a hívás alakja: függvénynév(aktuális_paraméter_lista) A függvényhívás után normális befejezõdést feltételezve a vezérlés a kifejezésbe tér vissza. Egy függvény a következõ módokon határozhatja meg a visszatérési értékét: A függvény törzsében változóként használható a függvény neve (l. FORTRAN). A törzsben tetszõlegesen felhasználható és változtatható annak értéke. A visszatérési érték a legutoljára kapott érték lesz. A függvény törzsében a függvény nevéhez értéket kell hozzárendelni. A függvény neve azt az értéket hordozza, amit utoljára kapott. Külön utasítás szolgál a visszatérési érték meghatározására, amely egyben be is fejezteti a függvényt. A függvény szabályosan befejezõdhet, ha elérjük a végét és már van visszatérési érték, befejeztetõ utasítást alkalmazunk és már van visszatérési érték, olyan befejeztetõ utasítást alkalmazunk, amely egyben meghatározza a visszatérési értéket is. Szabályos befejezõdés esetén a vezérlés visszatér a kifejezés kiértékeléséhez. Nem szabályos a befejezõdés, ha elérjük a végét és nem határoztuk meg a visszatérési értéket, olyan befejeztetõ utasítást alkalmazunk, amely nem határozza meg a visszatérési értéket és más módon sincs megadva az, GOTO-utasítással lépünk ki. fefe@coffein.hu ( 74 / 117 )

75 10/B /3 Alprogram és blokk az egyes programnyelvekben. Az utolsó esetben a vezérlés a címkére adódik, tehát egyáltalán nem térünk vissza a kifejezés kiértékeléséhez. Kerülendõ megoldás, nem biztonságos kódot eredményez. Az elsõ két esetben a vezérlés visszatér a kifejezés kiértékeléséhez, azonban a függvény visszatérési értéke határozatlan. Egyes nyelvekben (pl. C) ez bizonyos szituációkban nem jelent problémát, általában viszont szemantikai hiba. Az eljárásorientált programozási nyelvekben megírt minden programban kötelezõen lennie kell egy speciális programegységnek, amit fõprogramnak hívunk. Ez alprogram jellegû, a betöltõ neki adja át a vezérlést és az összes többi programegység mûködését õ koordinálja. Egy program szabályos befejezõdése a fõprogram befejezõdésével történik meg, ekkor a vezérlés visszakerül az operációs rendszerhez. A blokk A blokk olyan programegység, amely csak más programegység belsejében helyezkedhet el, külsõ szinten nem állhat. Formálisan a blokknak van kezdete, törzse és vége. A kezdetet és a véget egy-egy speciális jelsorozat vagy alapszó jelzi. A törzsben lehetnek deklarációs és végrehajtható utasítások. Ugyanúgy mint az alprogramoknál, ezek az utasítások vagy tetszõlegesen keverhetõk, vagy van külön deklarációs rész és végrehajtható rész. A blokknak nincs paramétere. A blokknak egyes nyelvekben lehet neve. Ez általában a kezdet elõtt álló címke. A blokk bárhol elhelyezhetõ, ahol végrehajtható utasítás állhat. Blokkot aktivizálni vagy úgy lehet, hogy szekvenciálisan rákerül a vezérlés, vagy úgy, hogy GOTOutasítással ráugrunk a kezdetére. Egy blokk befejezõdhet, ha elértük a végét, vagy GOTO-utasítással kilépünk belõle, vagy befejeztetjük az egész programot a blokkban. A blokkot az eljárásorientált nyelveknek csak egy része ismeri. Szerepe a nevek hatáskörének elhatárolásában van. fefe@coffein.hu ( 75 / 117 )

76 10/C SQL DDL. SQL DDL (Data Definition Language, adatdefiníciós nyelv) Feladata létrehozni, megszüntetni, módosítani a definíciókat. Kevés parancs, a paraméterek adják meg, mit definiálunk. CREATE : létrehozás (adatbázis, tábla) DROP: törlés, megszüntetés (adatbázis, tábla, (indexek is törlõdnek)) ALTER: módosítás (tábla, csak új oszlopok hozzáadása esetleg oszlopmódosítás lehetséges, adatvesztés nélkül) Minden létrehozást a magasabb szinten kell kezdeni (addig nem lehet táblát, amíg nincs adatbázis, és területfoglalás, indexet, amíg nincs tábla) pl: CREATE TABLE SPACE (Táblaterületet lefoglalása) CREATE TABLE táblanév (oszlopdefiníciók) oszlopdefiníciók: oszlopmegszorítás: oszlopnév típus (méret) [DEFAULT kifejezés] [oszlopmegszorítás] I [táblamegszorítás] [AS kérdés] pl. NOT NULL, CHECK feltétel, PRIMARY KEY, UNIQUE, REFERENCES táblanév [(oszlop)] CREATE INDEX indexnév ON táblanév (oszloplista) fefe@coffein.hu ( 76 / 117 )

77 10/D Operációs rendszerek fõbb funkciói. Az operációs rendszerek feladatai és funkciói Az operációs rendszer egy program, mely felügyeli az alkalmazói programok (alkalmazások) végrehajtását és interfészként mûködik a számítógép felhasználója és a hardver között. Az operációs rendszereknek három elvárásnak kell megfelelniük: Az operációs rendszereknek a számítógép használatát egyszerûbbé kell tenniük Az operációs rendszereknek biztosítaniuk kell a számítógép erõforrásainak hatékony kihasználását Az operációs rendszereknek képesnek kell lenniük a fejlõdésre. Új eszközök, lehetõségek megjelenésekor az operációs rendszert ki kell tudni bõvíteni anélkül, hogy annak eredeti funkcióiban változás történne Vizsgáljuk meg az operációs rendszereket a fenti három nézõpont alapján. Az operációs rendszer, mint felhasználó/számítógép interfész A számítógépes rendszert a hardvertõl a rajta futó alkalmazói programig egy réteges struktúrában szemlélhetjük. A végfelhasználó általában nem foglalkozik a rendszer felépítésével - õt csak az alkalmazások érdeklik. Az alkalmazásokat a programozók készítik, valamilyen programnyelvet használva. A legfontosabb rendszerprogram az operációs rendszer, amely elfedi a tényleges hardvert a programozók elõl, és egy egyszerûbb, kényelmesebben használható interfészt nyújt számukra. Végfelhasználó Programfejlesztõ Alkalmazások Segédprogramok Operációs rendszer fejlesztõ Operációs rendszer Hardver Az operációs rendszereknek a következõ területeken kell szolgáltatásokat nyújtaniuk: Program futtatása I/O eszközökhöz való hozzáférés Fájlokhoz való kontrollált hozzáférés Rendszerhez való hozzáférés szabályozása Hiba detektálás és elhárítás Erõforrások kihasználtságának mérése Az operációs rendszer, mint erõforrás kezelõ A számítógépet erõforrások halmazának is tekinthetjük, amely az adatok tárolásáért, mozgatásáért és feldolgozásáért felelõs. Ebben az esetben az operációs rendszer feladata ezen erõforrások kezelése. Az operációs rendszer ugyanúgy utasítások sorozatából áll, mint bármely más program. Az alkalmazások szempontjából az operációs rendszer futásával töltött idõ haszontalan - hiszen nem a feladat elvégzését célozza, hanem háztartási feladatokat lát el, és ugyanazokat az erõforrásokat használja, mint az alkalmazói programok. Az operációs rendszer központi részének (mag, kernel) mindig a memóriában kell lennie. Ez a programkomponens felelõs az összes erõforrás kezeléséért - és így speciális jogokkal rendelkezik (system mód). fefe@coffein.hu ( 77 / 117 )

78 10/D /2 Operációs rendszerek fõbb funkciói. Az operációs rendszer a következõ erõforrások kezeléséért felelõs: memória - a memóriát megfelelõ szabályok szerint szét kell osztani az alkalmazói programok között processzor - egy idõpillanatban a processzor csak egyetlen programot futtathat, az operációs rendszer feladata a futtatandó program kiválasztása. Többprocesszoros rendszerek esetén a helyzet analóg, bár a feladatot tovább bonyolítja, hogy a processzorok közel azonos terheltségét is biztosítani kell. I/O eszközök - az I/O igények kielégítése, az eszközök kezelése A fejlõdés biztosítása Az operációs rendszerek továbbfejlesztésének a következõ okai lehetnek Az operációs rendszernek követnie kell tudnia a hardverek fejlõdését, új technológiák megjelenését A felhasználók igényeinek kielégítése Hibajavítások - hibátlan program nem létezik, így az operációs rendszerek is tartalmaznak olyan rejtett hibákat, amelyek csak a használat során kerülnek felszínre. fefe@coffein.hu ( 78 / 117 )

79 11/A Tökéletesen kiegyensúlyozott, kiegyensúlyozott és keresõfák. Minimális magasságú fa: Legyen adva egy adott elemszám. Ez alapján fel lehet építeni egy olyan fát, amelynek a magassága az adott elemszám mellett a lehetõ legkisebb. Ezt megtehetjük úgy, hogy a legalsó szint kivételével minden szintre a lehetõ legtöbb elemet helyezzük el. Jelentõsége az, hogy az utak minimálisak, bármely levélelem a legrövidebb úton érhetõ el. Tökéletesen kiegyensúlyozott fa: Egy fa akkor tökéletesen kiegyensúlyozott, ha minden elem bal- illetve jobboldali részfájában elhelyezett elemek száma legfeljebb eggyel tér el. Mindig minimális magasságú. Létrehozása: Ha adott elemszám mellett a fát úgy építem fel, hogy bármely elemére igaz, hogy az elem baloldali részfájában az összes eleme kulcsa kisebb, a jobboldali részfájában az összes eleme kulcsa pedig nagyobb az adott elem kulcsánál, akkor keresõfáról (vagy rendezõfáról) beszélünk. A keresõfa jelentõsége abból áll, hogy ha van egy adott elemünk, amelyet meg akarunk keresni a fában, akkor a gyökértõl kiindulva bármelyik kulcsú elem megkereshetõ úgy, hogy vizsgáljuk, hogy a gyökérelem kulcsa, megegyezik-e a keresett elem kulcsával. Ha igen, megállunk, ha nem megnézzük, hogy attól kisebb vagy nagyobb. Ha nagyobb, akkor a jobboldali részfán (ha van), ha kisebb, akkor a baloldali részfán (ha van) haladok tovább ugyanezzel a módszerrel, mindaddig, míg az elemet meg nem találom, vagy nem jutok el egy olyan elemhez, amelyiknél az adott irányban nincs több elem, ekkor a keresett kulcsú elem nem szerepel a fán. A keresõfából fizikilag bármely elem törölhetõ. Hogyan tudom realizálni? A keresés eredménye szerint két eset lehet: I. A törlendõ elem nincs a fában. Ez az eset a legegyszerûbb, mert nincs dolgunk. II. Az adott kulcsú elem benne van a fában. Ekkor három alapeset lehetséges: 1. A törlendõ elemnek nincs rákövetkezõje (levélelem): Nincs gond, simán megkeressük és töröljük. 2. A törlendõ elemnek egy rákövetkezõje van: Az elemet törlöm és a baloldali vagy jobboldali részfát (amelyik van) felcsúsztatom a törölt elem helyére (átállítom a mutatóját). 3. A törlendõ elemnek két rákövetkezõje van (van bal- és jobboldali részfája): Ebben az esetben fölülírom a törlendõ elemet: vagy a baloldali részfa legjobboldalibb elemét, vagy a jobboldali részfa legbaloldalibb elemét írom a helyére. Ez is mutatóátállítást jelent. fefe@coffein.hu ( 79 / 117 )

80 11/A /2 Tökéletesen kiegyensúlyozott, kiegyensúlyozott és keresõfák. A keresõfák jelentõsége, hogy nagyon gyors keresést tesznek lehetõvé. Ez igazán nagy adathalmaz esetén lényeges. Ha a keresõfa tökéletesen kiegyensúlyozott lenne (ez lenne az optimális eset, a minimális magasságú fa), akkor lenne a leggyorsabb a keresés (a keresés maximum annyi lépésig tart, amennyi a fa magassága), de a módosítások miatt nehéz lenne kezelni, mert mindig át kellene szervezni, hogy tökéletesen kiegyensúlyozott legyen. Nem éri meg tökéletesen kiegyensúlyozni õket, ezért kiegyensúlyozott fákat alkalmaznak. (AVL-fa). Egy fa kiegyensúlyozott, ha bármely elem esetén a bal és jobb oldali részfák magasságának különbsége legfeljebb eggyel tér el. Kezelése egyszerûbb, mint a tökéletesen kiegyensúlyozott fáké. Ezután kiegyensúlyozott fákkal foglalkozunk. Bõvítés: A Keres eljárást használva megkeressük, hogy hova szúrjam be az új elemet. Levélelemmel bõvítünk. Tegyük fel, hogy a beszúrás után a baloldali részfa magassága nõtt meg. Ekkor három lehetõség van: 1. Balra bõvítünk, amikor a jobboldali részfa magassága eggyel nagyobb volt (m bal < m jobb a beszúrás elõtt). A fa kiegyensúlyozódik. 2. Úgy szúrunk be, hogy korábban tökéletesen ki volt egyensúlyozva a fa (m bal = m jobb a beszúrás elõtt). A fa méf a beszúrás után is kiegyensúlyozott. 3. Balra bõvítünk, de a baloldali részfa volt a magasabb (m jobb < m bal a beszúrás elõtt), a kiegyensúlyozottság, így ki kell egyensúlyozni a fát mutatócserével. Egy-egy ilyen kiegyensúlyozási lépés két vagy három elemet érint, ezeket forgatni kell. Át kell szervezni a fát, a túl hosszú ágat helyre kell billenteni. Piros fekete fa: Speciális keresõfa, minden elemének van egy színe. Ezeknek a színeknek a kiosztásának szabályával biztosítható, hogy a fában minden, a gyökértõl levélelemig vezetõ út maximum kétszer olyan hosszú, mint a legrövidebb út hossza. Egy ilyen fában pluszként megjelenik a szín mezõ a reprezentációban. Egy keresõfa akkor lesz piros-fekete, ha a következõ tulajdonságok teljesülnek: 1. a fa minden elemének színe piros vagy fekete, 2. minden levélelem színe fekete, 3. minden piros színû elemnek mindkét rákövetkezõje fekete, bármely két azonos elembõl induló és levélig vezetõ úton ugyanannyi fekete elem van. fefe@coffein.hu ( 80 / 117 )

81 11/B A két- és többirányú elágaztatás szerepe és megjelenési formáik a programozási nyelvekben. Kétirányú elágaztató utasítás (feltételes utasítás) A kétirányú elágaztató utasítás arra szolgál, hogy a program egy adott pontján két tevékenység közül válasszunk, illetve egy adott tevékenységet végrehajtsunk vagy sem. Az ALGOL 60 óta meglehetõsen általános a feltételes utasítás következõ szerkezete: IF feltétel THEN tevékenység [ ELSE tevékenység ] A feltétel egy logikai (vagy annak megfelelõ típusú) kifejezés. Kérdés, hogy egy nyelv mit mond a tevékenység megadásáról. Egyes nyelvek (pl. Pascal) szerint itt csak egyetlen végrehajtható utasítás állhat. Ha viszont a tevékenység olyan összetett, hogy csak több utasítással tudjuk leírni, akkor utasítás zárójeleket kell alkalmazni. Az utasítás zárójel a Pascal esetén BEGIN és END. Egy ilyen módon bezárójelezett utasítássorozatot hívunk utasítás csoportnak. Az utasítás csoport formálisan egyetlen utasításnak tekintendõ. Más nyelvek (speciális szintaktikájuk miatt) megengedik, hogy a tevékenység leírására tetszõleges végrehajtható utasítássorozatot alkalmazzunk (pl. Ada). Végül a nyelvek harmadik csoportja azt mondja, hogy a tevékenység helyén vagy egyetlen utasítás, vagy egy blokk (l alfejezet) állhat (pl. C). A kétirányú elágaztató utasításnál beszélünk rövid (nem szerepel az ELSE-ág) és hosszú (szerepel az ELSE-ág) alakról. A kétirányú elágaztató utasítás szemantikája a következõ: Kiértékelõdik a feltétel. Ha az igaz, akkor végrehajtódik a THEN utáni tevékenység, és a program az IFutasítást követõ utasításon folytatódik. Ha a feltétel értéke hamis, és van ELSE-ág, akkor az ott megadott tevékenység hajtódik végre, majd a program az IF-utasítást követõ utasításon folytatódik, végül ha nincs ELSE-ág, akkor ez egy üres utasítás. Az IF-utasítások tetszõlegesen egymásba ágyazhatók és természetesen akár az IF-ágban, akár az ELSEágban újabb feltételes utasítás állhat. Ilyenkor felmerülhet a csellengõ ELSE problémája, amikoris a kérdés a következõ: egy IF... THEN IF... THEN... ELSE... konstrukciójú feltételes utasítás esetén melyik IF-hez tartozik az ELSE-ág? Vagyis itt egy olyan rövid IFutasítás áll, amelybe be van ágyazva egy hosszú, vagy pedig egy hosszú IF-utasítás THEN-ágában szerepel egy rövid? A válasz többféle lehet: a. A csellengõ ELSE probléma kiküszöbölhetõ, ha mindig hosszú IF-utasítást írunk fel, úgy, hogy abban az ágban, amelyet elhagytunk volna, üres utasítás szerepel. b. Ha a hivatkozási nyelv errõl nem mond semmit, akkor a dolog implementációfüggõ. Az implementációk többsége azt mondja, hogy egy szabad ELSE a legközelebbi, ELSE-el még nem párosított THEN-hez tartozik, vagyis az értelmezés bentrõl kifelé történik. Eszerint a fenti példánkban egy rövid IFutasításba ágyaztunk egy hosszút. c. A nyelv szintaktikája olyan, hogy egyértelmû a skatulyázás. Az Ada feltételes utasítása a következõ: IF feltétel THEN utasítások [ ELSEIF feltétel THEN utasítások ] [ ELSE utasítások ] END IF; Végül megjegyezzük, hogy a C-ben A feltétel zárójelek között szerepel és nincs THEN alapszó. fefe@coffein.hu ( 81 / 117 )

82 11/B /2 A két- és többirányú elágaztatás szerepe és megjelenési formáik a programozási nyelvekben. Többirányú elágaztató utasítás A többirányú elágaztató utasítás arra szolgál, hogy a program egy adott pontján egymást kölcsönösen kizáró akárhány tevékenység közül egyet végrehajtsak. A tevékenységek közötti választást egy kifejezés értékei szerint tehetjük meg. Szintaktikája és szemantikája nyelvenként különbözõ. Nézzük a lehetséges megoldásokat. Turbo Pascal: CASE kifejezés OF konstanslista : tevékenység [ konstanslista : tevékenység ] [ ELSE tevékenység ] END; A konstanslista literálok, vagy intervallumok vesszõvel elválasztott sorozata. Egy literál csak egy konstanslistában szerepelhet. A kifejezés és ennek megfelelõen a konstanslista sorszámozott típusú lehet. Nem kötelezõ a kifejezés minden lehetséges értékére elõírni tevékenységet. A tevékenység egy utasítás vagy egy utasításcsoport lehet. Mûködése: A kifejezés kiértékelõdik, és az értéke a felírás sorrendjében hasonlításra kerül a konstansokkal. Ha van egyezés, végrehajtódik a megfelelõ konstanslista utáni tevékenység, majd a CASE-utasítást követõ utasítással folytatódik a program. Ha egyetlen konstanssal sincs egyezés, de van ELSE-ág, akkor végrehajtódik az abban magadott tevékenység, majd a CASE-utasítást követõ utasítással folytatódik a program. Ha nincs ELSE-ág, akkor ez egy üres utasítás. Ada: CASE kifejezés1 IS WHEN { kifejezés tartomány OTHERS } => végrehajtható_utasítások [ WHEN { kifejezés tartomány OTHERS } => végrehajtható_utasítások ] END CASE; A WHEN-ágakban szereplõ kifejezések és a tartományok értékeinek különbözniük kell. OTHERS-ág bárhol szerepelhet, de legfeljebb egy lehet belõle. A kifejezés1 skalár típusú lehet. A kifejezés1 minden lehetséges értékére elõ kell írni valamilyen tevékenységet. Mûködése: A kifejezés1 kiértékelõdik, és értéke a felírás sorrendjében hasonlításra kerül a WHEN-ágakban megadott kifejezések és tartományok értékeihez. Ha van egyezés, akkor végrehajtódnak a WHEN-ágban lévõ utasítások, és a CASE-utasítást követõ utasítással folytatódik a program. Ha nincs egyezés sehol, de van OTHERS-ág, akkor az abban megadott utasítások hajtódnak végre és a CASE-utasítást követõ utasítással folytatódik a program. Ha nincs OTHERS-ág, akkor viszont futási hiba (kivétel) következik be. Ha valamely értékekre nem akarunk csinálni semmit, akkor egy olyan OTHERS-ágat kell szerepeltetnünk, amely egy üres utasítást tartalmaz. fefe@coffein.hu ( 82 / 117 )

83 11/B /3 A két- és többirányú elágaztatás szerepe és megjelenési formáik a programozási nyelvekben. C: SWITCH (kifejezés) { CASE egész_konstans_kifejezés : [ utasítás ] [ CASE egész_konstans_kifejezés : [ utasítás ] ] [ DEFAULT: tevékenység ] }; A kifejezés típusának egészre konvertálhatónak kell lennie. Mûködése: Kiértékelõdik a kifejezés, majd értéke a felírás sorrendjében hasonlításra kerül a CASE-ágak értékeivel. Ha van egyezés, akkor végrehajtódik az adott ágban megadott tevékenység, majd a program a következõ ágakban megadott tevékenységeket is végrehajtja. Ha nincs egyezés, de van DEFAULT-ág, akkor az ott megadott tevékenység hajtódik végre, és a SWITCH-utasítást követõ utasítással folytatódik a program. Ha nincs DEFAULT-ág, akkor ez egy üres utasítás. Tehát a C-ben külön utasítás kell ahhoz, hogy kilépjünk a SWITCH-utasításból, ha egy CASE-ág tevékenységét végrehajtottuk (l. BREAK-utasítás alfejezet). PL/I: SELECT [ (kifejezés1) ] ; WHEN (kifejezés [,kifejezés ] ) tevékenység [ WHEN (kifejezés [,kifejezés ] ) tevékenység ] [ OTHERWISE tevékenység ] END; A kifejezések típusa tetszõleges. A tevékenység egy utasítás, egy utasításcsoport, vagy egy blokk lehet. Mûködése: Ha szerepel a kifejezés1, akkor mûködése megegyezik az Adáéval. Tehát a PL/I-ben is a kifejezés1 minden lehetséges értékére elõ kell írni valamilyen tevékenységet. Ha nem szerepel, akkor a WHENágakban megadott kifejezések értékét bitlánccá konvertálja és az elsõ olyan ágat választja ki, amelynek a bitjei nem csupa nullák. Ha nincs ilyen, akkor ez egy üres utasítás. A FORTRAN és a COBOL nem tartalmaz ilyen utasítást. fefe@coffein.hu ( 83 / 117 )

84 11/C Az ER modell felépítése. Entry-Relationship (ER) 1967-ben CHEN írja le ezt a modellt. Maga a modell egy sématervezõ eszközként jött létre, növelvén a séma absztrakciós szintjét a hálós és relációs modellel szemben. Ez az elsõ szemantikus modell. A vele létrehozott koncepcionális sémát le lehet képezni vele hálós vagy relációs sémává, és innen kezelni lehet ezt hálós vagy relációs kezelõ nyelvvel. Az ER szerint az egyed egy olyan objektum, amely létezik és különbözik minden más egyedtõl. Lehet konkrét vagy absztrakt. Az egyedet attribútumokkal reprezentálják, minden attribútum lényeges tulajdonsága, hogy értékeit mely tartományból veheti föl. Az attribútumok közös tulajdonsága, hogy egy tulajdonságtípusba tartoznak. Ha van két egyedtípus, akkor fontos, hogy legyenek közös egyedek. Az ER értelmezi a következõ fogalmakat : szuperkulcs, kulcs, kulcsjelölt, elsõdleges kulcs halmazértékû és összetett attribútum tárolt és származtatott attribútum Az ER-ben a kapcsolatnak lehetnek attribútumai. Pl.: Ügyfél és számla mint egyedtipus között értelmezhetünk egy Ügyfélszáml nevû kapcsolattípust. Az Ügyfélszáml kapcsolatai megmutatják, hogy mely ügyfél milyen számlát nyitott. Minden ügyfélnek van egy számlája. (Egy számla akkor létezik, ha ügyfél létezik hozzá.) Kérdések : Lehet-e egy számlának több tulajdonosa? Lehet-e egy ügyfélnek több számlája? Lényeges a kapcsolat foka - az ER akárhányadfokú kapcsolatot tud kezelni. Explicit módon tudja modellezni a kapcsolatot. A kapcsolatban az egyedek nem biztos, hogy azonos erõsségûek ( azonos funkcióban vannak ), ezért az ER bevezette a szerepkör fogalmát. Ez különösen lényeges akkor, amikor a kapcsolat rekurzív. A kapcsolat számosságáról a szokásosat mondja : bármely számosságot explicit módon kezel. Azt az egyedtípust amelynek nincs elsõdleges kulcsa, az ER gyenge egyedtípusnak nevezi, amelyiknek van azt pedig erõs egyedtípusnak. Pl.: Ha a tranzakciónál a tranzakció száma csak számlánként egyedi, akkor az gyenge egyedtípus. Az ügyfél erõs egyedtípus (ott az azonosító). Ügyfél - számla kapcsolatot lásd elõbb. ( Számla nem létezhet ügyfél nélkül, tranzakció pedig csak egy számlához kapcsolódóan létezet.) Ha két egyedtípus között van kapcsolat, és az egyik egyedtípus egyedi és csak akkor létezhet, ha a másik egyedtípusban létezik megfelelõje, akkor azt mondjuk, hogy a két egyedtípus között létezés függõség áll fenn. Amely egyedei nem léteznek a másik nélkül azok az alárendelt egyedek, a többi a domináns egyedek. Létezés függõség fennállhat két erõs egyedtípus között is, pl.: ügyfél-számla. Létezés függõség gyenge és erõs egyedtípus között mindig van, mert egy gyenge egyedtípus kötelezõen kapcsolódik egy erõs egyedtípushoz. Gyenge egyedtípusnak mindig léteznie kell egy ún. diszkriminátorának, mely nem más mint azon attribútum együttes, melynek értékei különböznek azon alárendelt egyedeknél, amelyek létezésfüggõen kapcsolódnak ugyanahhoz a domináns egyedhez. (Pl.: számla - tranzakció, a tranzakció diszkriminátora a tranzakció_szám.) Egy gyenge egyedtípus elsõdleges kulcsa nem más, mint a hozzátartozó domináns egyedtípus, és a diszkriminátora. Egy kapcsolattípus attribútumait a kapcsolt egyedtípusok elsõdleges kulcsa és a saját leíró attribútumai együttesen adják. Ha a kapcsolattípusnak nincs leíró attribútuma, akkor ha a kapcsolat számossága: M:N, akkor az összes attribútuma adja meg az elsõdleges kulcsot. Pl.: Ügyfelszaml - ügyfél_azonosító, számlaszám 1:N, akkor a többoldali egyedtípus elsõdleges kulcsa lesz az elsõdleges kulcs. Különben az elõbbi módon képzett elsõdleges kulcshoz még hozzá kell venni valamelyik leíró attribútumot. fefe@coffein.hu ( 84 / 117 )

85 11/D Az operációs rendszerek fejlõdésének fõbb állomásai: kötegelt, multiprogramozott, idõosztásos, valós idejû, személyi számítógépes, hálózati rendszerek. Korai rendszerek "pucér" gép (1950-es évek eleje) Soros feldolgozás. Nagyméretû gépet a konzolról irányítják, egy felhasználós rendszer, a programozó egyben operátor is, lyukszalagos és/vagy lyukkártyás adatbevitel és kivitel. Korai szoftver: Drága erõforrások rossz hatékonyságú kihasználása alacsony CPU kihasználtság, jelentõs mennyiségû "beállítási idõ" (setup time). A kötegelt feldolgozás rendszerei (Simple Batch) I. Redukáljuk a beállítási idõt a (hasonló) munkák (job) kötegelésével. Automatikus soros munka végrehajtás (job sequencing): a vezérlés egyik jobról (a job vége után) automatikusan kerül át a következõre. (Az elsõ elemi oprációs rendszer megjelenése). Rezidens monitor (felügyelõprogram) mûködési elve: kezdetben a vezérlés a monitornál van, a vezérlés átadódik a job-nak, ha a job befejezõdött a job vissza kerül a monitorhoz. A kötegelt feldolgozás rendszerei (Simple Batch) II. Egy tipikus job szerkezete és a számítógépes problémamegoldás folyamata, job lépés (jobstep). Problémák: 1. Hogyan szerezhet a monitor tudomást az adott job természetérõl (pl. FORTRAN vagy ASSEMBLY), vagy melyik programot kell végrehajtani? 2. Hogyan tudja a monitor megkülönböztetni egyik job-ot a másiktól? az adatot a programtól? Megoldás: Vezérlõ kártyák, pozicionálás Speciális kártyák, amelyek megmondják a monitornak, mely programot kell futtatni ($JOB, $FTN, $RUN, $DATA, $END) Speciális karakterek különböztetik meg az adat és program kártyákat. (//, $, 7-2 lyukasztás) A kötegelt feldolgozás rendszerei (Simple Batch) III. A rezidens monitor funkcionális részei Vezérlõ kártya interpreter felelõs a vezérlõkártyák beolvasásáért és értelmezéséért. Betöltõ (loader) háttértárból betölti az egyes rendszer és felhasználói programokat az operatív memóriába. Készülék meghajtó programok (device drivers) ismerik a rendszer az egyes I/O berendezéseinek tulajdonságait és mûködtetésük logikáját. Elõny: csökken a beállítási idõ (setup time)! Probléma: Alacsony teljesítmény mivel az I/O és a CPU mûveletek nem fedhetik át egymást (párhuzamosság!) és a kártyaolvasó nagyon lassú! Megoldás: Off-line elõ- és utófeldolgozás a jobokat egy másik gép segítségével szalagra másoljuk, ill. az eredményeket szalagra írjuk, majd egy másik gép nyomtatja ki. (Absztrakt periféria fogalom igénye megfogalmazódik!) Simultaneous Peripheral Operation On-Line (SPOOL): IBM704, 1960 fefe@coffein.hu ( 85 / 117 )

86 11/D /2 Az operációs rendszerek fejlõdésének fõbb állomásai: kötegelt, multiprogramozott, idõosztásos, valós idejû, személyi számítógépes, hálózati rendszerek. Mialatt egy job végrehajtódik, az operációs rendszer: beolvassa a következõ jobot a kártyaolvasóról a lemezre (job queue) egy elõzõ job által nyomtatni szánt adatokat lemezrõl printerre továbbítja Job pool olyan adatszerkezet, amelynek segítségével az operációs rendszer kiválaszthatja a következõ job-ot, CPU kihasználtság növelése. A kötegelt feldolgozás multiprogramozott rendszerei. (Multiprogramming Batched Systems) Alapelv: néhány job(step) futtatható kódja állandóan az operatív memóriában helyezkedik el és készen áll arra, hogy utasításokkal lássa el a CPU-t. Vigyázat! Nem párhuzamosan futó programokról van szó! Az operációs rendszer valamilyen stratégia szerint adja oda a CPU-t a futásra kész programoknak. A multiprogramozás által az operációs rendszerekkel szemben támasztott követelmények Az I/O-nak az operációs rendszer részérõl történõ teljes körû felügyelete. (adatvédelem!) Az I/O-t az operációs rendszer nem egyszerûen támogatja, hanem végrehajtásához elkerülhetetlen. Hardver feltételek! (kernel/supervisor mode, privileged operations) Memória gazdálkodás a rendszernek fel kell osztania a memóriát a futó jobok között. Hardver feltételek! (kernel/supervisor mode, privileged operations, segmentation) CPU ütemezés a rendszernek választani kell tudni a futásra kész jobok között. Készülékhozzárendelés Nem jut minden jobnak, printer, lemez, stb. Idõosztásos (time-sharing) rendszerek interaktivitás A kötegelt rendszerek hátránya: nincs interaktivitás! TS esetén a CPU váltakozva áll olyan joboknak a rendelkezésére, amelyek a memóriában, vagy lemezen találhatók. (Természetesen a CPU-t csak olyan job kaphatja meg, amely éppen a memóriában van.) Egy job a lemezrõl a memóriába, ill. a memóriából a lemezre betölthetõ/kimenthetõ az ütemezési stratégiának (idõosztás!) megfelelõen. Új fogalom: folyam (process)! A rendszer és a felhasználó között on-line kommunikációt tételezünk fel; ha az operációs rendszer befejezi egy parancs végrehajtását, a következõ vezérlõ utasítás -t nem a kártyaolvasóról, hanem a felhasználó klaviatúrájáról várja. Egy adatokat és utasításkódokat tároló on-line fájl-rendszer kell, hogy a felhasználók rendelkezésére álljon. Személyi számítógépes rendszerek. Személyi számítógépek a teljes számítógép rendszer egy egyszerû felhasználónak kizárólagos rendelkezésére áll. Tipikus konfigurációjú I/O berendezések klaviatúra, egér, képernyõ kijelzõ, kis teljesítményû nyomtató. Elõtérben a felhasználó (személy) kényelme és felelõssége. Sokszor adaptál eredetileg nagygépes operációs rendszerekre kidolgozott információ technológiai megoldásokat. (migráció!) példa: MULTICS (MIT, ) Þ UNIX (Bell Labs, 1970) A felhasználó személy sokszor a számitógép kizárólagos tulajdonosa, felhasználója, és így nincs szüksége fejlett CPU kiszolgáló és adatvédõ szolgáltatásokra. fefe@coffein.hu ( 86 / 117 )

87 11/D /3 Az operációs rendszerek fejlõdésének fõbb állomásai: kötegelt, multiprogramozott, idõosztásos, valós idejû, személyi számítógépes, hálózati rendszerek. Párhuzamos rendszerek multiprocesszoros rendszerek több mint egy szoros kommunikációs kapcsolatban levõ CPU-val Szorosan kapcsolt/csatolt rendszerek a processzorok közösen használják a memóriát és a rendszer órát. A kommunikáció a közös memória segítségével történik. Párhuzamos rendszerek elõnyei: Megnövelt átbocsátó képesség, Gazdaságosság, Növekvõ megbízhatóság, Redundancia, Graceful degradation, Fail-soft rendszerek. Sok processz futhat egyszerre teljesítménycsökkenés nélkül. Szimmetrikus multiprocesszálás / Aszimmetrikus multiprocesszálás (master-slave modell) Minden egyes processzor a hozzárendelt specifikus feladatot (task) oldja meg. A feladatot a mester határozza meg! Ezek a taskok egymással szükség szerint kommunikálhatnak. Nagyon nagy rendszerekben elterjedtebb megoldás. Elosztott rendszerek a számításokat több processzor között osztják meg. Lazán kapcsolt/csatolt rendszerek a processzorok saját lokális memóriát és rendszer órát használnak. A kommunikáció nagy kapacitású adatvonalak, vagy telefon vonalak segítségével történik. Elosztott rendszerek elõnyei: Erõforrás megosztás (printer, stb.), Számítási teljesítmény növelés, túlterhelés védelem (load sharing), Növekvõ megbízhatóság, Valós idejû (real-time) rendszerek Gyakran úgy jelenik meg, mint valamilyen dedikált alkalmazás (pl. tudományos kisérlet támogatása, orvosi képfeldolgozás, ipari kontroll, kijelzõ rendszerek) irányító-felügyelõ rendszere. A kiszolgálás azonnal megkezdõdik! Jól definiált, rögzített idejû korlátozások. Hard ("merev" valós idejû) rendszerek. A másodlagos tár korlátozott, vagy teljesen hiányzik; az adatokat az operatív memóriában (RAM), vagy akár ROM-ban tárolják. Konfliktus az idõosztásos rendszerekkel. Korlátozott szolgáltató programok az ipari kontroll, a robotika területén. A fejlett oerációs rendszer szolgáltatásokat igénylõ alkalmazásoknál (Multimédia, VR) igen hasznosak. fefe@coffein.hu ( 87 / 117 )

88 12/A B-fák. B-fák (balanced): Speciális keresõfák. A kiegyensúlyozott fák, a keresõ fák és a lapra történõ felosztás elvét viszik tovább. Viszonylag könnyû karbantartani, és gyors a keresés. Jelentõségük az állományoknál vannak. Mindig adott egy n szám, amely a B-fa rendje. Úgy kell felépíteni a fát, hogy minden lapon legalább n és legfeljebb 2n db elem legyen. Az aktuális elemszám egy olyan m szám, melyre teljesül, hogy n<=m<=2n. Ha összesen k db elemem van, legrosszabb esetben n / logk hivatkozással meg tudom keresni az adott elemet. Általában akkor használjuk, ha van kulcs az adatoknál. Kulcsos elemeknél érdekes, a B-fák a memóriában kulccsal rendelkezõ adatelemek keresésére hasznos. Definíciója: A B-fa elemi lapok összessége. Minden lap maximum 2n db elemet tartalmaz, és minden lap, kivéve a gyökérlapot, legalább n db elemet tartalmaz, a gyökérlap legalább egyet. A B-fában minden levéllap ugyanazon a szinten van. Egy lap vagy levéllap, vagy m+1 rákövetkezõje van (m a lapon elhelyezett adatok száma). Másodrendû B-fa példája: A lapokon 2,3,4 elem (kulcs) helyezkehet el. A fa háromszintû, a levélelemek azonos szinten vannak. Minden elemnek eggyel több rákövetkezõje van, mint amennyi elhelyezkedik a lapon. A lapon az elemek kulcsuk szerint növekvõ sorrendben helyezkednek el, rendezettek. Ha a fát összenyomnánk, akkor az elemeknek rendezett sorozatát kapnánk. Egy nem levéllap esetén a lappon kulcsok és mutatók helyezkednek el, a kulcsok nagyság szerint rendezve. Levéllapon a mutatók NULL értékûek. Egy lap szerkezete: A fa szerkezete (kulcsok elhelyezkedése a fában): Adott fában az x kulcsot keressük, a gyökérelembõl indulva. Tegyük fel, hogy valamelyik lap benne van a tárban. A kulcsokra vonatkozóan a lapon a kulcsokat végig kell keresnünk, sok elemnél binárisan. Ha megtaláljuk, rendben van. Ha nem találjuk meg, akkor a lehetséges esetek a következõk: 1. k i <x<k i+1 : Az x a lapon elhelyezett két kulcs közé esik. Abban a részfában kell keresnünk, amelyre a p i mutat. 2. x<k 1 : A keresett kulcs kisebb a lapon lévõ legkisebb kulcsnál. A p 0 -al címzett, legbaloldalibb részfa gyökerét kell megnéznem. 3. k m <x: A keresett kulcs nagyobb a legnagyobb kulcsnál. A p n -el címzett, legjobboldalibb lapon kell keresnem. Elindulok a gyökérlapon és behatárolom, hogy hol kell keresnem az elemet. Addig keresek, amíg meg nem találom vagy levéllaphoz nem jutok, és azon sem találom. A B-fa szemléletesen úgy adja a kulcsok sorozatát, hogy összenyomjuk a szinteket. Ha a levélelemekrõl indulunk, be tudjuk rakni a részfa gyökerébõl (eggyel magasabb szintrõl) az elemeket, amelyek beillenek az alattuk lévõ lapok közötti résbe. Mûveletek Létrehozás: Üres fa bõvítése. fefe@coffein.hu ( 88 / 117 )

89 12/A /2 B-fák. Bõvítés: Mindig levéllapon történik. Megkeresem a bõvítendõ elem helyét. Egyszerû esete az, amikor olyan lapra akarok bõvíteni, ahol az elemek száma kisebb mint a megengedett maximális érték (m<2n). pl: 23 kulcsú adatot akarom bevinni. Ha nem találom meg, akkor levéllapra kell beilleszteni. A helye a 22 és a 24 között van. Ezen a lapon az elemek száma kisebb, mint 2n, így a 23 bevihetõ. Az elõbbi keresési módon megkeresem a kulcs helyét. 22, 24 22, 23, 24 Ha olyan lapra kellene bõvíteni, amelyik tele van (2n eleme van), akkor új lapot kell létrehozni. Ha az új elemet is felviszem a lapra, akkor 2n+1 elemem lesz. Ezen elemek közül a középsõ elemet fölviszem a részfa gyökérlapjára, majd ott a megfelelõ helyre beillesztem. A maradék 2n elsõ felét az elsõ, második felét a második lapra viszem. Ez a vágás. Így részfa gyökérlapon bõvítettünk. Ha a felvitt elem befért, akkor nincs probléma, ha nem fért be, akkor ezen a szinten is vágni kell ugyanezzel az algoritmussal. Elõfordulhat, hogy a gyökérelemen nem tudunk bõvíteni, ezért itt is vágni kell, így a fa magassága eggyel nõ, lesz egy új, egyelemû gyökerünk. Ez a egyetlen eset, hogy a fa magassága változhat egy szinttel, egyébként nem változik. Pl. 41-el akarok bõviteni. 30, , 40 30, 40, 43 42, 43, 45, 46 41, 42, 43, 45, 46 41, 42 45, 46 Törlés: Bármely lapról lehet. 1. Meg kell keresni az adott kulcsú elemet. Ha a törlendõ elemet levéllapon találtuk meg, akkor fizikailag törlöm, a mutatókkal nem kell foglalkoni. Ha nem levéllapon találtuk meg, akkor a törlendõ elemet felülírom a rendezettségben az õt megelõzõ vagy a rákövetkezõ elemmel, és azt törlöm. 2. Ha az adott lapon az elemek száma minimálisan n marad, akkor nincs baj. Elem törlése annyit jelent, hogy a tõle jobbraállókat ráhúzom. Lehet, hogy kevesebb lesz az elemek száma mint n, ilyenkor a szomszédos lapból kölcsönkérünk elemet. Ez csak akkor lehetséges, amikor a szomszéd lapon több mint n db elem van, és ekkor az eggyel fentebbi lapon keresztül áthúzom az adott elemet.. Gyakorlatilag ez az elõbbi vágás inverze. 3. Ha két szomszédos lapon az elemek száma 2n-1, akkor összevonjuk a két szomszédos lap elemeit, megszüntethetjük az egyik (az üres) lapot, és a gyökérbõl hozzávesszük a középsõ elemet. Ilyenkor az elõzõ szintet is csökkentjük egy elemmel. Lehet, hogy magasabb szinteken is kevés elem van, itt is hasonlóan járunk el. Végiggyûrûzhet a fán, lehet, hogy a gyökérlapot is meg kell szüntetni, ekkor a fa magassága csökken eggyel. Pl. 45 törlése. 30, 40, 43 30, 40 Rendezés: Nincs. Feldolgozás: Alapja a keresés. 41, 42 45, 46 41, 42, 43, 46 fefe@coffein.hu ( 89 / 117 )

90 12/A /3 B-fák. B + -fa Adatbázis kezelési rendszerek mögött B + -fák indexelési módszere áll. A B + -fa a B-fák olyan módosított változata, melyet állományok indexelésére használnak. Az alapállomány szekvencális és szeriális is lehet (adatszint). Erre épül fel egy teljes indexelésû, elsõdleges indexszint. A B + -fák adott méretû lapokból állnak, a lapokon indexek, azaz a kulcsok szerepelnek Az indexek elsõdleges indexszinten lapokon vannak elhelyezve. Többszintû teljes indexelést tudunk megvalósítani (elsõdleges kulcsra), a további indexeknél a lapméret lehet más. Elõírhatjuk, hogy lérehozáskor a lapokon legyenek üres helyek minden szinten. Manapság az összeláncolás is jellemzõ tulajdonság. A lapon maximum a B + -fa rendje darab mutató helyezkedhet el és eggyel kevesebb kulcs. A gyökérlapon kívül minden lap legalább [p/2] mutatót tartalmaz. A gyökérlap legalább 2 mutatót tartalmaz. B * -fa: Csak annyiban különbözik a B + -fáktól, hogy a minimális szám [2/3 p]. Minden lap kétharmad részig fel van töltve, és meg lehet adni százalékosan is (50-100%) a létrehozáskor. fefe@coffein.hu ( 90 / 117 )

91 12/B A csomag szerepe egyes programozási nyelvekben. A csomag az a programegység, amely egyaránt szolgálja a procedurális és az adatabsztrakciót. A procedurális absztrakció oldaláról tekintve a csomag programozási eszközök újrafelhasználható gyûjteménye. Ezek az eszközök: típus változó nevesített konstans alprogram csomag Ezek az eszközök a csomag hatáskörén belül mindenhonnan tetszõlegesen hivatkozhatók. A csomag az Adában jelenik meg, és egyre több nyelv veszi át. Az Ada csomagnak két része van: specifikáció és törzs. Formálisan a specifikáció a következõképpen néz ki: PACKAGE név IS látható_deklarációs_rész [PRIVATE privát_deklarációs_rész] END [név]; A látható_deklarációs_rész a csomagspecifikáció látható része. Az itt deklarált programozási eszközök hivatkozhatók a csomagon kívülrõl. Alprogramok esetén itt csak azok specifikációja állhat. A hivatkozás a csomag nevével való minõsítéssel történik. A privát_deklarációs_ rész kívülrõl nem elérhetõ, a csomag az itt deklarált eszközöket bezárja, elrejti a külvilág elõl. A csomag törzse opcionális. Ha viszont a specifikációban szerepel alprogramspecifikáció, akkor kötelezõ a törzs, és az alprogram implementációját itt kell megadni. A törzs a külvilág számára nem elérhetõ. A csomag törzs alakja: PACKAGE BODY név IS deklarációs_rész [ BEGIN végrehajtható_utasítások] END [név] ; Az Adában a csomag fordítható önállóan, vagy elhelyezhetõ lokákisan egy másik programegység deklarációs részében. Az utóbbi esetben a láthatóságát a statikus a hatáskörkezelésnek megfelelõen a tartalmazó programegység szabályozza. Ha önállóan fordítjuk a csomagot, akkor a program más részei számára explicit módon kell láthatóvá tenni (l alfejezet). A következõ példa egy olyan csomag vázlatát mutatja be, amely a törtekkel való számolást teszi lehetõvé. A csomag specifikációjának csak látható része van. Ebben szerepel egy saját típus definíció (RACIONALIS), amely a törtek értékeinek kezelésére való. A törtszámok reprezentációja egy rekord segítségével történik, a számlálót és a nevezõt egy-egy mezõben tároljuk. A reprezentáció meghatározza a tartományt is (a nevezõ pl. csak pozitív egész lehet). Van továbbá öt függvényspecifikáció, ezek adják meg a mûveletek specifikációját. Érdekességként jegyezzük meg, hogy az Ada lehetõvé teszi, hogy a függvény neve ne csak azonosító legyen. A beépített operátorok túlterhelhetõek. Az Adában ugyanis idézõjelek közé tett speciális karaktereket is használhatunk a függvénynév megadásához. Példánkban a szokásos aritmetikai operátorokat terheltük túl. fefe@coffein.hu ( 91 / 117 )

92 12/B /2 A csomag szerepe egyes programozási nyelvekben. A csomag specifikációjában van alprogramspecifikáció, tehát kötelezõ a törzs. Abban a teljes alprogram deklarációkat meg kell adni. A mûveleteket úgy kell implementálni, hogy azok a megfelelõ törtaritmetikára jellemzõ viselkedésmódot tükrözzék. Ezért szükséges a kívülrõl nem elérhetõ KOZOS_NEVEZO eljárás. A fenti példánkban a RACIONALIS típus nem absztrakt adattípus. Mûveleteinek implementációját ugyan elrejti, de a reprezentációját nem. A programozó önfegyelmére van bízva, hogy az ilyen típusú eszközök értékeit csak a csomagbeli függvények segítségével kezeli, vagy pedig a reprezentáló rekord mezõire külön-külön hivatkozik. Például a SZAMLALO-hoz minden további nélkül hozzá tudok adni egy számot, a NEVEZO-tõl függetlenül. Nézzük ezután, hogy a csomag hogyan szolgálja az adatabsztrakciót. A csomag mint programegység megvalósítja a bezárást, ezért alkalmas absztrakt adattípus implementálására. Az Adában a bezárást a privát (PRIVATE) típus és a csomag specifikációs részének kívülrõl nem látható része együttesen teszi lehetõvé. A látható részben szerepelhet a privát típusmegjelölés. A privát típusúnak deklarált objektumokra a nyelvbe beépített mûveletek közül csak az egyenlõségvizsgálat (=), és az értékadás (:=) alkalmazható. Tehát az így deklarált eszközök értékeit kezelõ mûveleteket a programozónak kell implementálnia. A privát típus reprezentációjáról nem tudunk semmit. Ha van a látható részben privát típussal deklarált eszköz, akkor kötelezõ a nem látható rész szerepeltetése. Itt kell megadni a reprezentációra vonatkozó összes információt. Korábbi példánkban a RACIONÁLIS típusból csináljunk absztrakt adatípust. Ehhez a törzs változatlanul hagyása mellett a specifikációt kell átalakítanunlk a következõ módon: fefe@coffein.hu ( 92 / 117 )

93 12/C RELÁCIÓS ADATMODELL Codd 1971-ben kidolgozott egy relációs adatmodellezési eszközt. Az elméletére alapozva jött létre a relációs adatmodell, és erre épülve jöttek létre a relációs adatmodellen alapuló relációs adatbáziskezelõk. ORACLE - a világ legnépszerûbb relációs adatbáziskezelõje. További relációs adatbáziskezelõk : SYSBASE, INFORMIX, INGRES A relációs modell is tudja kezelni a hálót. Ennek a modellezésnek teljesen más a fogalomrendszere. A koncepcionális-logikai-fizikai szint teljesen szétválik. Élesen elválnak az absztrakt kezelõ nyelvek és a konkrét adatbáziskezelõ rendszerek kezelõ nyelve. Több absztrakt kezelõ nyelv létezik. D tartomány : atomi értékek egy halmaza. Minden tartomány bármely értékéhez hozzátartozik egy jól definiált atomi adattípus, és egy formátum. Formátum : ahogy az elemek literál formában megjelennek. D - a tartomány neve. Egy reláció séma alatt: R(A 1,...,A n ) értjük, ahol R a reláció séma neve, A 1,...,A n pedig attribútumok. Minden attribútum értékeit egy adott tartományból veheti fel. Jele: dom(a i ) Eddigiek alapján: R-egyedtípusnév, A i -tulajdonságtípus. A relációs séma egy absztrakció, egy reláció leírására szolgál. A relációs séma foka az attribútumok száma. (A fenti példa n-edfokú.) Az R(A 1,...,A n ) relációs séma alatt azt a r(r)-rel jelölt halmazt értjük, amely halmaz elemei n-esek: r={t 1,...,t m } Mindegyik t i n db értéknek egy rendezett együttese: t i = <v 1,...,v n > méghozzá úgy, hogy v i dom(a i ) i=1,..., n, vagy NULL érték. t - tuple (magyarul rekord) Bármely relációs sémához tetszõleges számú reláció értelmezhetõ. r(r) - R reláció séma r relációja nem más, mint az attribútumok tartományaiból alkotott Descartesszorzat egy részhalmaza. r(r) (dom(a 1 )... dom(a n )) Különbözõ attribútumok ugyanazon a tartományon lehetnek értelmezve, de más-más sémában más-más szerepet játszanak. A reláció rekordok halmaza, közöttük sorrend nem értelmezhetõ, de nem is ismételhetõ egy sem többször. Ez a koncepcionális szint. A logikai szintû dolgokkal a kezelõrendszer foglalkozik. Logikai szinten a relációk táblákban jelennek meg. A tábláknak egyedi nevû van. A relációk oszlopait az attribútumok címzik, a tábla soraiban helyezkednek el a rekordok. A tábla sorait tetszõlegesen megcserélhetjük, a sorok száma nem kötött. (Ezek a halmazszemlélet miatt vannak.) A logikai modellben már értelmezhetünk logikai sorrendet, tehát a sorokat bizonyos szempontok szerint rendezhetjük. Fizikai modell : a táblát a reláció valamilyen állományszerkezetben jeleníti meg. (Jell. a szeriális állomány.) A relációs adatbáziskezelõk mindig indexelnek, a kedvenc indexelési mód a B+ fa. Az attribútumok sorrendje kötött. Létezik olyan megfogalmazás, ahol az R relációs séma az attribútumok egy halmaza: R{A 1,..., A n } Ekkor a megfelelõ reláció séma relációja alatt egy olyan halmazt értünk ahol t i : R D=dom(A 1 )... dom(a n ) egy leképezés, és ekkor egy rekord az <attribútum> <érték> párok halmazaként tekinthetõ. A továbbiakban annál maradunk, hogy az oszlopok sorrendje kötött, így azokra hivatkozhatunk sorszámukkal. INTEGRITÁSI MEGSZORÍTÁSOK fefe@coffein.hu ( 93 / 117 )

94 12/D Az integrált programfejleszõi környezet (IDE). Programozási környezet. Integrált keretrendszerek. A programfejlesztés szakaszai: probléma elemzés, tervezés (adatszerkezetek, algoritmusok) modulokra bontás programírás modultesztelés modulok összeépítése dokumentálás Az operációs rendszerek szolgáltatási közé tartozik a programozási környezet biztosítása. Az egyes szakaszokhoz különbözõ operációs rendszerek különbözõ mértékû támoghatást nyújtanak. A probléma elemzése, a tervezés és a dokumentálás azok a szakaszok, amelyekhez viszonylag kevesebb a támogatás. A modulokra bontás egyedül a fejlesztõ felelõssége, ehhez az operációs rendszerek nem adnak segítséget. A probléma elemzést segítõ CASE eszközök általában nem szerves részei az operációs rendszereknek, de pl. a VMS op. rsz. ad lehetõséget képernyõtervezésre (FMS) és közös adatszótár (CDD) létrehozására operációs rendszer szinten. A program elõfordító funkciót tartalmaz az adatbázis funkciók beépítéséhez. A definíciók felhasználását nyilvántartja, ha ez adatdefiníciót változtatják, listát tud adni a módosítandõ programokról. Algoritmusok programgenerátorral is elõállíthatók, sok szoftver támogatja, de nem kimondottan op. rsz. feladat. A programírást mindegyik operációs rendszer támogatja. A szûkebb értelemben vett programkészítés fázisai: 1. A forrásprogram elõállítása valamilyen szövegszerkesztõvel. A szövegszerkesztõnek az alapvetõ funkciókat kell biztosítania. 2. A forrásszöveg fordítása a megfelelõ nyelvi compiler (fordító) programmal. A compiler inputja a forrásszöveg, outputja a tárgykód (object kód, gépi kódú program). A fordítóprogram mellékesen elõállít néhány segédinformációt, amely a tesztelést segíti: kiadja a szintaktikai hibák listáját, ha a forrásszöveget nem tudta sikeresen lefordítani. (Az összeset, az elsõt, vagy beállítható, hogy hányat. A továbbiak lehetnek következményhibák) Külön beállíthatóan szimbólumtáblát állít elõ a használt változókról, ill. keresztreferencialistát készít, amelybõl megállapítható, hogy melyik objektum hol, melyik sorban lett használva. 3. A tárgykódban a külsõ hivatkozások feloldása, külön fordított programrészek összeszerkesztése: a futtatható program elõállíùása a szerkesztõprogram (linker) feladata. Ennek inputja a tárgykód, outputja a végrehajtható, futtatható program. A szerkesztõprogram az operációs rendszer segédprogramjai közt mindig megtalálható, nyelvfüggetlen. Támogatja a modulonkénti programozást: egyszer már megírt, mûködõ moduloknak a rendszerbe illesztését. Egyes rendszereknél kimondott programkönyvtárak állnak a programozók rendelkezésére. (Pascal unit) 4. A futtatható program betöltése, futtatása az operciós rendszer alapvetõ feladata, a végleges betöltési címet a betöltõ (loader) adja, a programbeli relatív tárcímek ehhez viszonyítva kerülnek kiosztásra. (op. rsz. magja tartalmazza a funkciót) A tesztelést támogató eszközök: DUMP: a tár tartalmának kiíratása egy adott végrehajtási fázisban. DEBUG: nyomkövetés. A program lépésenkénti végrehajtása (TRACE), változók tartalmának figyelése. Szimbólikus címek kiíratása, hívási lánc megjelenítése. Az integrált keretrendszerek a szövegszerkesztés, fordítás, tesztelés folyamatát támogatják egyazon program keretén belül. (Pl. Tpascal). A VMS operációs rendszer rendelkezik ún. nyelvérzékeny szövegszerkesztõvel (LSEDIT), amely több programozási nyelv szintaktikáját ismeri, a dokumentum kiterjesztésébõl felismeri, hogy melyik nyelvrõl van szó. fefe@coffein.hu ( 94 / 117 )

95 12/D /2 Az integrált programfejleszõi környezet (IDE). A VMS a kész szövegfájlok fordítását külön is támogatja, pl. PASCAL prog1. A szerkesztés: LINKER prog1, futtatás: RUN prog1. A programfordítás és végrehajtás speciális módja az interpreteres végrehajtás. Az értelmezõprogram (interpreter) nem készít tárgykódot, a forráskódot egységenként (többnyire utasításonként) értelmezi és ha sikerül értelmezni, megpróbálja végrehajtani. Ha nem sikerül az értelmezés, legtöbb esetben választani lehet a hibás utasítás kihagyása (ignored), a hibás utasítás felfüggesztése(suspend) és késõbbi ismételt végrehajtása, ill. az értelmezés abbahagyása (cancel) közt. Az értelmezés során nem képzõdik tárgykód, minden futtatásnál újra kell értelmezni a forrásprogramot, sõt a programban a végrehajtás elõtt is minden utasítást újra kell értelmezni, akkor is, ha az ciklusban van. Interpreteres végrehajtásnál mindig szükség van az értelmezõprogram jelenlétére. Az interpreter csak azokat az utasításokat értelmezi, amelyekre a vezérlés ténylegesen rákerül, így a program szövegében maradhat hiba. Az interpreterek elõnye mindamellett az interaktív végrehajtás. Az utasításokat a gép környezetüktõl függetlenül hajtja végre, ezért a végrehajtás bármely pontján el tud fogadni felhasználói parancsokat.(pl. a program felfüggesztett állapotában értéket adhatunk változóknak, megnyithatunk állományokat). Az értelmezõk hibajelzési képessége hatékony, mert a hiba mindig egy utasításra lokalizálható. (De elõfordulhat, hogy egy utasításban jelentkezõ hiba a program elõzõ részében elkövetett hibának vagy mulasztásnak az eredménye.) Elõnyös az interpreter használata akkor is, ha egy magasszintû utasítás olyan sokat 'tud', olyan bonyolult mûveletsor elvégzésére írták, hogy az értelmezés ideje elenyészõ a végrehajtáshoz képest.. A programintegrálás támogatása A programok összeépítése modulokból tartogat még egy olyan munkafázist, amellyel foglalkozni kell. Ez az úgynevezett integrációs teszt. Ennek halovány támogatását jelenti maga a szerkesztõprogram, amely hibajelzést ad, ha valamely modul hiányzik a komplett program összeállításához. A program algoritmushibáinak kiszûrésében, a hivatkozott változókban és adatstruktúrákban felmerülõ ütközések kiderítésében azonban nem sokat segít. Az integrációs tesztben rendszerint újra kell kezdeni a nyomkövetést. A problémákon igyekeznek segíteni az integrált programfejlesztõ rendszerek, melyek megpróbálják megõrizni az adatok és adatszerkezetek konzisztenciáját. Az algoritmushibák kivédésére programhelyesség bizonyítási (verifikálási) módszereket, programgenerátorokat, és programstruktúra visszafejtõ, automatikus programdokumentáló programokat használnak. Ez utóbbiak tulajdonképpen alkalmazói szintû funkciók. A programfejlesztési támogatás fõ funkcióinak összefoglalása A programfejlesztési támogatás fõ funkciói tehát a következõk: * rendszerhívások: a programokból alacsony szintû operációsrendszeri funkciók aktivizálására, * szövegszerkesztõk: a programok és dokumentációk írására, * programnyelvi eszközök: fordítóprogramok és interpreterek a nyelvek fordítására vagy értelmezésére, * szerkesztõ- és betöltõprogramok: a programmodulok összefûzésére illetve tárba töltésére (végcímzés), * programkönyvtári funkciók: a különbözõ programkönyvtárak használatára, és * nyomkövetési rendszer: a programok belövésére. Ezek részben vagy egészben megtalálhatók az integrált programfejlesztõ rendszerekben. fefe@coffein.hu ( 95 / 117 )

96 13/A A rekord, mint adatszerkezet. A hálós adatszerkezet. A rekord, mint a tárban létezõ adatszerkezet, statikus. Kötött számú és kötött sorrendû mezõkbõl áll, az egyes mezõk más-más, tetszõleges típusú értékeket tartalmaznak. A rekordban minden mezõt megnevezünk, és rá közvetlenül a mezõnevével tudunk hivatkozni. Tárolása lehet folytonos és szétszórt is. Általában folytonos a jellemzõ, bár ez a kérdés implementáció-, rendszerfüggõ (részben hardverfüggõ is). A folytonos tárolás esetén a mezõk egymás után helyezkednek el. Mûveletek Létrehozás: Lérehozom a szerkezetet a név, a típus megadásával. Fontos a mezõk sorrendje! Az egyes mezõkhöz a nevük alapján értéket rendelek. Elõfordulhat az az eset is, hogy nem minden mezõhöz rendelek értéket. Bõvítés: Szûkebb értelemben nem létezik, mert a rekord statikus. Bõvítés olyan értelemben létezhet, hogy azon mezõkhöz, melyekhez a létrehozáskor nem rendeltem értéket, most hozzárendelek. Törlés: Nincs, legfeljebb logikai, olyan hogy a mezõnek speciális értéket adok. A fizikai törlés realizálható cserével. Csere: Bármely mezõ értékét felülírhatom. Rendezés, keresés, bejárás: Nem értelmezhetõ. Feldolgozás: A mezõnevek alapján. Az itt leírtak a tárban lévõ rekordok jellemzõi, jelentõségük az állományoknál mutatkozik meg. Egyes nyelvek megengedik, hogy a rekord ne statikus, hanem dinamikus legyen. (pl: Pascal) Az összes homogén adatszerkezet elemeinek az értékei vagy atomiak (tovább nem oszthatók, skalár típusúak), vagy rekordok; tágabb értelemben egy adatszerkezet elemei adatszerkezetek lehetnek. A rekordok mezõinek értéke vagy atomi (a rendszerek nagyobb részében), vagy, modernebb rendszerekben, tetszõleges adatszerkezet típusú lehet (pl: másik rekord). Így a rekord dinamikussá válik, ha a egyetlen mezõje dinamikus. Adatbáziskezelõ rendszereknél ez a definíció van elõtérben (ortogonalitás) A rekordok egymásba ágyazhatóak. A relációs adatbáziskezelõ rendszerek rekordja a tuple. HÁLÓS ADATSZERKEZETEK (HÁLÓ) A fák általánosítása, olyan adatszerkezet, amelyben az elemeknek akárhány megelõzõjük és rákövetkezõjük lehet, beleértve azt is, hogy két elem között olyan kapcsolat van, hogy az egyik a másik megelõzõje és rákövetkezõje és viszont (kölcsönösen). Egy elem akár önmaga megelõzõje és rákövetkezõje is lehet. Nincs kitüntetet eleme. ÖSSZEFÜGGÕ IRÁNYÍTOTT GRÁF Hálózatok modellezésére használható. Reprezentálni irányított gráf segítségével lehet. A szûkebben vett számítástechnikában csak a hálózatoknál jelenik meg. Pl: a c e b d f Gráfok reprezentációjára a szomszédossági listát vagy a szomszédossági mátrixot használják. fefe@coffein.hu ( 96 / 117 )

97 13/A /2 A rekord, mint adatszerkezet. A hálós adatszerkezet. A szomszédossági mátrix (csúcsmátrix) egy logikai mátrix, amelynek elemei: 0,1. Ha a gráfnak n db eleme van, akkor ez a mátrix n n-es. Az oszlopokat és a sorokat is az elemekkel címkézzük fel. A mátrix kitöltésének szabálya: ha az adott elemek között nincs rákövetkezõ vagy megelõzõ viszony, akkor 0-t kell írni, különben 1-t. Nem szabad elfelejteni, hogy c saját magának a rákövetkezõje. A fenti gráf szomszédossági mátrixa: Ábrázolására alkalmazható a szétszórt ábrázolás, ahol általában a gráfnak egy multilista felel meg. Mutatótömböket veszek fel az adatelemek mellé. Kezeléshez lehet sorszámozni. Annyi elemû mutatótömböt építek fel, ahány eleme van a hálónak. E tömb elemei mutatótömbök, a mutatótömb elemei a rákövetkezõkre mutatnak. A fenti gráf szomszédossági listája: Alapfogalmak: A gráfon belül útnak nevezzük az olyan elemösszességet, amelyek listát alkotnak. (pl: d-a-b-c) A gráfban körútnak nevezzük az olyan listát, amikor az utolsó elem az elsõre mutat. (pl: d-a-b) A gráfok szerepe A következõ kérdéseket érdemes feltenni: Létezik-e olyan út a gráfban, amelyben az összes elem benne van (maximális út)? Egyes csomópontokból melyik másik csomópontokba vezett út? Van-e körút a gráfban? Melyik a maximális körút? Van-e olyan körút, amelyik az összes elemet tartalmazza? Hogyan lehet olyan algoritmust találni, amely a gráf elemeit csak egyszer érinti? (bejárás) A gráf egy homogén, dinamikus adatszerkezet, a mûveleteket speciálisan lehet értelmezni. Mûveletek: Létrehozás: Az üres háló létrehozása, ezután bõvítjük. A szomszédossági mátrixban ez egy új sor és egy új oszlop felvételét jelenti, amelyeket megfelelõen ki kell tölteni. Törlés: Egy elem törlése esetén az elemet reprezentáló sort és oszlopot ki kell törölni. Csere: Rendezés, keresés: Nincs. Bejárás (keresés, háló): Ezen alapszik a gráf feldolgozása. Létezik szélességi és mélységi bejárás. Szélességi keresés: Kiválasztok egy elemet (s). Az s-rõl indulva szisztematikusan megkeresem a rákövetkezõit, és felépítek egy szélességi fát. Ennek elsõ szintjén az s rákövetkezõi állnak, erreépítem rá a második szintet, ahol az s rákövetkezõinek rákövetkezõi lesznek. A fa egyszer fogja tartalmazni az elemeket, és egy másik elem a legrövidebb úton lesz elérhetõ. Az elemekhez színt rendelek: fehér, fekete, szürke. Alaphelyzeben minden elem fehér, fokozatosan fognak szürkévé, majd feketévé válni. Egy elem elérhetõ s-bõl, ha az elõbbi bejárásnál elértem az elemet, színe nem lehet fehér.egy fekete elem minden megelõzõje fekete, és minden rákövetkezõ szürke, esetleg fekete. A szürke elemnek minden megelõzõje fekete, de lehet fehér rákövetkezõje. Amikor egy elem feketévé váik, akkor felvesszük a fába. A keresés folyamán ha az s-bõl elérhetõ elem feldolgozott, de van még fehér elem, akkor az eljárást megismételjük a fehér elemekre, amíg minden elem fekete nem lesz. Kezdõpontnak (s-nek) azt az elemet érdemes választani, amely a legtöbb rákövetkezõvel rendelkezik. Mélységi keresés: A színezés ugyanígy történik, de alapvetõ különbség az, hogy a fát szintenként építem fel. fefe@coffein.hu ( 97 / 117 )

98 13/B Hatáskör, hatáskörkezelés, láthatóság az egyes programozási nyelvekben. A hatáskör a nevekhez kapcsolódó fogalom. Egy név hatásköre alatt értjük a program szövegének azon részét, ahol az adott név ugyanazt a programozási eszközt hivatkozza, tehát jelentése, felhasználási módja, jellemzõi x:integer; azonosak. A hatáskör szinonimája a láthatóság. A név hatásköre az eljárásorientált programnyelvekben a programegységekhez illetve a fordítási egységekhez kapcsolódik. Egy programegységben deklarált nevet a programegység lokális nevének nevezzük. Azt a nevet, amelyet nem a programegységben deklaráltunk, de ott hivatkozunk rá, szabad névnek hívjuk. Azt a tevékenységet, mikor egy név hatáskörét megállapítjuk, hatáskörkezelésnek hívjuk. Kétféle hatáskörkezelést ismerünk, a statikus és a dinamikus hatáskörkezelést. STATIKUS HATÁSKÖRKEZELÉS: fordítási idõben történik, a fordítóprogram végzi. Alapja a programszöveg programegység szerkezete. Ha a fordító egy programegységben talál egy szabad nevet, akkor kilép a tartalmazó programegységbe, és megnézi, hogy a név ott lokális-e. Ha igen vége a folyamatnak, ha nem, akkor tovább lépked kifelé, egészen addig, amíg meg nem találja lokális névként, vagy el nem jut a legkülsõ szintre. Ha kiért a legkülsõ szintre, akkor két eset lehetséges: A nyelvek egy része azt mondja, hogy a programozónak minden nevet deklarálni kell. Így ha egy név nem volt deklarálva, az fordítási hiba. A nyelvek másik része ismeri az automatikus deklarációt, és a névhez hozzárendeli az automatikus deklaráció szabályainak megfelelõ attribútumokat. A név ilyenkor tehát a legkülsõ szint lokális neveként értelmezõdik. Statikus hatáskörkezelés esetén egy lokális név hatásköre az a programegység, amelyben deklaráltuk és minden olyan programegység, amelyet ez az adott programegység tartalmaz, hacsak a tartalmazott programegységekben a nevet nem deklaráltuk újra. A hatáskör befele terjed, kifele soha. Egy programegység a lokális neveit bezárja a külvilág elõl. Azt a nevet, amely egy adott programegységben nem lokális név, de onnan látható, globális névnek hívjuk. A globális név, lokális név relatív fogalmak. Ugyanaz a név az egyik programegység szempontjából lokális, egy másikban globális, egy harmadikban pedig nem is látszik. Példa: int x; float Az ábrán egymásba skatulyázott programegységek láthatók. A 1-es programegységben deklaráltunk egy x nevû int típusú változót, amely itt lokális. A 2-es, 4-es és 5-ös programegységben hivatkozhatunk az x névre, amely itt globális név. Az x nevet a 3-as programegységben újradeklaráltuk float típusúként. Így ez az újradeklarált név a 3-as programegységben már egy másik változót jelöl, ez itt lokális és másik programegységben nem látszik. Viszont a 3-as programegységben nem tudunk hivatkozni az int típusú x nevû változóra, mert az új deklaráció elfedi azt. Szemléletesen azt mondjuk, hogy az 1-es programegységben deklarált x hatáskörében lyuk keletkezik. fefe@coffein.hu ( 98 / 117 )

99 13/B /2 Hatáskör, hatáskörkezelés, láthatóság az egyes programozási nyelvekben. DINAMIKUS HATÁSKÖRKEZELÉS: futási idejû tevékenység, a futtató rendszer végzi. Alapja a hívási lánc. Ha a futtató rendszer egy programegységben talál egy szabad nevet, akkor a hívási láncon keresztül kezd el visszalépkedni mindaddig, amíg meg nem találja lokális névként, vagy a hívási lánc elejére nem ér. Ez utóbbi esetben vagy futási hiba keletkezik, vagy automatikus deklaráció következik be. Dinamikus hatáskörkezelésnél egy név hatásköre az a programegység, amelyben deklaráltuk, és minden olyan programegység, amely ezen programegységbõl induló hívási láncban helyezkedik el, hacsak ott nem deklaráltuk újra a nevet. Újradeklarálás esetén a hívási lánc további elemeiben az újradeklarált név látszik, nincs lyuk a hatáskörben szituáció. Statikus hatáskörkezelés esetén a programban szereplõ összes név hatásköre a forrásszöveg alapján egyértelmûen megállapítható. Dinamikus hatáskörkezelésnél viszont a hatáskör futási idõben változhat és más-más futásnál más-más lehet. Az eljárásorientált nyelvek a statikus hatáskörkezelést valósítják meg. Általánosságban elmondható, hogy az alprogramok formális paraméterei az alprogram lokális eszközei, így neveik az alprogram lokális nevei. Viszont a programegységek neve a programegység számára globális. A kulcsszavak, mint nevek a program bármely pontjáról láthatók. A standard azonosítók, mint nevek azon programegységekbõl láthatók, ahol nem deklaráltuk újra õket N y e l v e k: A PL/I a statikus hatáskörkezelést vallja ADA: A hatáskörkezelés statikus, de az Ada kezeli a lyuk a hatáskörben problémát. Ezt úgy oldja meg, hogy a globális eszközök nevét azon programegység nevével minõsíti, amely programegységnek az lokális neve. A C a hatáskör és élettartam szabályozására bevezeti a tárolási osztály attribútumokat, melyek a következõk: extern: A fordítási egység szintjén deklarált nevek alapértelmezett tárolási osztálya, lokális neveknél explicit módon meg kell adni. Az ilyen nevek hatásköre a teljes program, élettartamuk a program futási ideje. auto: A lokális nevek alapértelmezett tárolási osztálya. Hatáskörkezelésük statikus, de csak a deklarációtól kezdve láthatók. Élettartamuk dinamikus. Nincs automatikus kezdõértékük. register: Speciális auto, amelynek értéke regiszterben tárolódik, ha van szabad regiszter, egyébként nincs különbség. static: Bármely névnél explicit módon meg kell adni. Hatáskörük a fordítási egység, élettartamuk a program futási ideje. Van automatikus kezdõértékük. fefe@coffein.hu ( 99 / 117 )

100 13/C Egy adatbázis-kezelõ rendszer architektúrája, komponensei. ADATBÁZISRENDSZER: A számítógép, az adatok, a kezelõ szoftver és az ember együttese. Adatbázisrendszer felépíthetõ tetszõleges platformon. Általános célú rendszerek alkothatják a hardver komponenst, de léteznek kimondottan adatbázisrendszerhez tervezett számítógép rendszerek. ADATBÁZIS: Fizikai adatbázis egyedelõfordulások Metaadatbázis / adatszótár Szerkezetre vonatkozó adatok. pl.: a séma leírása, adatkomponens szerkezetének leírása, kapcsolatok leírása SZOFTVER (DBMS): Az adatbázis-kezelõ rendszer. Konkrét operációs rendszer környezetben fut, gyakran sok adatkezelõ funkciót átvesz az operációs rendszertõl. Az adatbázis-kezelõ rendszernek van egy olyan komponense, mely lehetõvé teszi hogy programozási tevékenységet lehessen végezni. Ez alapján megkülönböztethetõk: - Saját nyelvû rendszerek : A szoftver része a programozási eszközrendszer. (Nem önálló nyelv, imperatív jellegû, eljárás-orientált) - Befogadó nyelvû rendszerek : A szoftveren belül olyan utasítások vannak, melyekkel az adatbázist manipulálni lehet, de programozni nem. Ezt valamilyen magasszintû programozási nyelv segítségével lehet megvalósítani. Írni kell egy befogadó nyelvû programot, és ezt beépíteni az adatbázis-kezelõ utasításai mellé. Ebben az esetben létezik elõfordító, amely a az adott nyelven írt programot lefordítja. Az ISO 3 szintû szabványa: FELHASZNÁLÓ Alkalmazás Alkalmazás Alkalmazás NÉZET 1 NÉZET 2 Koncepcionális séma NÉZET N Külsõ szint Koncepcionális szint Belsõ séma Belsõ /fizikai/ szint 11. ábra NÉZET: adott felhasználó egyszerre nem láthatja a teljes adatbázist, csak egy részét. A külsõ és koncepcionális szint szétválasztása biztosítja a logikai adat-program függetlenséget. A koncepcionális és belsõ szint biztosítja a fizikai adat-program függetlenséget. Van olyan embercsoport, amely kevésbé szorosan kapcsolódik az adatbázisrendszerhez: Elemzõk tervezõk alkalmazásfejlesztõk fefe@coffein.hu ( 100 / 117 )

101 13/C /2 Egy adatbázis-kezelõ rendszer architektúrája, komponensei. Akik szorosan kapcsolódnak: DBA /Adatbázis adminisztrátor/ Felügyeli az egész adatbázisrendszert, felelõs az erõforrások elosztásáért. Õ adja a jogosultságokat, neki minden jogosultsága megvan, a jog tovább adható. A felhasználókkal tartja a kapcsolatot. Az adatbázisrendszer gazdája. FELHASZNÁLÓK Eseti felhasználók ad hoc kérdéseket tesznek fel. Interaktív, interpreteres, deklaratív eszközrendszernek kell léteznie, amit az eseti felhasználó használ. Parametrikus (naiv) felhasználók Azok, akik kész (jól definiált problémát megoldó) alkalmazásokat futtatnak. Ezek az alkalmazások parametrizálhatók. Eljárásorientált, fordítóprogramos eszközrendszer áll a felhasználók rendelkezésére. Szakemberek /kutatók/ Általában nagyon nagy méretû adathalmazzal dolgoznak. vagy õk írnak alkalmazásokat, vagy már meglévõ alkalmazásokat írnak át. (Funkcionális, vagy objektumorientált eszközrendszer áll rendelkezésre.) Hibrid kategória. Egy adatbázisrendszeren belül a legfontosabb erõforrás az adat. Cél: a felhasználók optimális kiszolgálása az adatbázisrendszeren belül. ADATBÁZIS-ÉPÍTÉS LÉPÉSEI 1. Elemzés, tervezés, modellezés megtörténik, így elõáll egy séma. 2. A megfelelõ eszközrendszerrel leírom a sémát, ez az info az adatszótárba kerül. Ez megadja az üres fizikai adatbázis szerkezetét. Típusszinten dolgozunk, a típusszintû információk kerülnek be a metaadatbázisba. 3. Fizikai adatbázis feltöltése a szerkezetnek megfelelõen. (Betesszük az egyed-elõfordulásokat.) A karbantartás ugyanazzal az eszközrendszerrel történik, amivel feltöltöttük. 4. Lekérdezés. Az adatbáziskezelõ-rendszernek van egy KEZELÕ NYELVe. Ezen belül vannak alnyelvek / utasításcsoportok. DDL = adatdefiníciós nyelv (Data Definition Language) Azon utasítások, amelyekkel a sémát le tudjuk írni, azaz kezelni tudjuk a metaadatbázist. DML = adatkezelõ nyelv (Data Manipulation Language) Azon utasítások, melyek a fizikai adatbázist kezelik. (Bõvítés, törlés, módosítás, csere, lekérdezés) DCL = vezérlõ nyelv (Data Control Language) Tranzakciós és jogosultságokkal kapcsolatos utasítások. Az adatbázissal kapcsolatos alkalmazások vezérlését valósítja meg. DMCL = eszközvezérlõ nyelv A fizikai szint közvetlen vezérlését teszi lehetõvé. Manapság nem létezik, de a régi rendszereknél megtalálható. fefe@coffein.hu ( 101 / 117 )

102 13/D A programok feldolgozási módjai: fordítás, szerkesztés, futtatás, nyomkövetés. Programkönyvtárak. Fordítók, interpreterek. A fordítás vezérlése. A különbözõ programozási nyelveken írt forrásszövegbõl a gépi kódot a fordítóprogram (compiler) állítja elõ. A compiler inputja egy szövegfájl, outputja a tárgymodul (object kód, gépi kódú utasításokat tartalmazó fájl.). A tárgykód önmagában még nem futtatható, mivel tartalmazhat külsõ hivatkozásokat is, ezek feloldása (a programban hivatkozott külsõ eljárások hozzászerkesztése a programhoz) a szerkesztõprogram (linker, link editor) feladata. A linker inputja a tárgykód, outputja a végrehajtható program. A lefordított programban szereplõ címhivatkozások többnyire relatív címek, a tényleges cím csak a futtatáskor derül ki, ezért betöltésekor kerül a betöltési cím a megfelelõ regiszterbe. Ez a betöltõ program (loader) feladata. Az értelmezõprogram (interpreter) nem készít tárgykódot, a forráskódot egységenként (többnyire utasításonként) értelmezi és ha sikerül értelmezni, megpróbálja végrehajtani. Ha nem sikerül az értelmezés, legtöbb esetben választani lehet a hibás utasítás kihagyása (ignored), a hibás utasítás felfüggesztése(suspend) és késõbbi ismételt végrehajtása, ill. az értelmezés abbahagyása (cancel) közt. Az értelmezés során nem képzõdik tárgykód, minden futtatásnál újra kell értelmezni a forrásprogramot, sõt a programban a végrehajtás elõtt is minden utasítást újra kell értelmezni, akkor is, ha az ciklusban van. Interpreteres végrehajtásnál mindig szükség van az értelmezõprogram jelenlétére. Az interpreter csak azokat az utasításokat értelmezi, amelyekre a vezérlés ténylegesen rákerül, így a program szövegében maradhat hiba. Az interpreterek elõnye mindamellett az interaktív végrehajtás. Az utasításokat a gép környezetüktõl függetlenül hajtja végre, ezért a végrehajtás bármely pontján el tud fogadni felhasználói parancsokat.(pl. a program felfüggesztett állapotában értéket adhatunk változóknak, megnyithatunk állományokat). A fordítóprogramok a forráskódban az összes szintaktikai hibát kijelzik, hiszen az egész forráskódot végigolvassák. Korszerû fordítóprogramok az interpreterhez hasonlóan, megállnak a hibát tartalmazó utasításnál. Némely fordítóprogramnál beállítható, hogy hány hibát jelezzen ki egyszerre. A lefordított, szerkesztett program önmagában futtatható állomány (továbbiakban nincs szükség a fordítóra). Bizonyos esetekben van lehetõség mindkét fajta végrehajtásra. Pl.: befogadó nyelvû adatbáziskezelõknél egy elõfordító alakítja átvehetõ formára az "idegen" utasításokat. A részekre bontásból további elõny származik, ha észrevesszük, hogy a részfeladatok többször felhasználható programjaiból programkönyvtárakat hozhatunk létre. A késõbbi feladatokban már e könyvtárakra támaszkodhatunk, mert belõlük a szükséges elemek átvehetõk az új program(ok)ba. Kevesebb kódot kell a fordítóval generáltatni, mert a programhoz a félig fordított programrészek tárolására használt tárgyprogram-könyvtárból hozzá lehet másoltatni a program mûködéséhez szükséges kész, további modulokat (az elsõ ilyen modulok a perifériakezelõ szubrutinok voltak). A tárgyprogramkönyvtárban tárolt, tárgykódú, lefordított modulok jóval kisebb helyet igényelnek, mint a forrás-szövegek, ami újabb elõny. Eleinte ezek a tárgyprogram-könyvtárak egy-egy fordítóprogramhoz kapcsolódtak, és a fordítóprogram maga vette elõ a szükséges modulokat. Hamarosan rájöttek arra is, hogy a programkönyvtári programok (szubrutinok) belsõ formátumát uniformizálni kell, mert akkor egy program különbözõ moduljait a részfeladathoz legjobban illõ programnyelven lehet megírni. A különbözõ nyelveken írt modulok lefordítása után keletkezõ tárgymodulok az azonos formátum miatt egyetlen monolit programmá fûzhetõk össze. fefe@coffein.hu ( 102 / 117 )

103 13/D /2 A programok feldolgozási módjai: fordítás, szerkesztés, futtatás, nyomkövetés. Programkönyvtárak. Az összeállításhoz új program kellett: a programszerkesztõ, amelyet az angol linkage editor elnevezés alapján kapcsolatszerkesztõnek is hívnak -- a szövegszerkesztõktõl megkülönböztetendõ. Ez az egyes programmodulokat (fõ- és alprogramokat, szubrutinokat) egyetlen (vagy néhány) végrehajtható programmá fûzi össze. A korai rendszerekben ezt a végrehajtható modult végcímzett programnak is hívták, mert a program a végrehajtásakor a fõtárnak pontosan arra a helyére került, amit a szerkesztõ kijelölt neki. Ezen a multiprogramozás kialakulása után változtatni kellett, mert ott az a célszerû, ha a programok a fõtár bármely helyén mûködõképessé tehetõk. Ezért a mai programszerkesztõk nem készítenek végcímzett programokat, hanem a végrehajtható programban megtartják a tárgymodulokban található, átcímzéshez szükséges (relokációs) adatokat. Az összeszerkesztett programok futás elõtti átcímzéséhez pedig egy újabb program kellett: az ún. betöltõprogram. Ez teszi lehetõvé, hogy a végrehajtandó program a kijelölt tárhelyen mûködõképes legyen. Ezt nevezzük dinamikus áthelyezésnek. A programszerkesztõnek, a betöltõprogramnak és a tárkezelõnek nyilvánvalóan egyeztetett formátummal kell dolgoznia. Ezért, bár ezek a programok eredendõen a nyelvi szinthez csatlakoznak, központi szerepük miatt a szûkebb értelemben vett operációs rendszer részének tekintik õket, tehát operációsrendszeri funkciók. A betöltõ olykor ténylegesen az operációs rendszer magjában helyezkedik el (kézenfekvõ módon a tárkezelés részeként). A programozói munka legszorgosabb része a programbelövés. Ezért ehhez a munkához a programozó szeretne minél több támogatást kapni. A programbelövést az operációs rendszerek és a programozási nyelvek a nyomkövetési (angolul debug, trace) funkciókkal támogathatják. Nyomkövetés több szinten végezhetõ. A legkézenfekvõbb megoldást már korán megtalálták: a programba -- az algoritmushoz funkcionálisan hozzá nem tartozó -- speciális kimeneti ("tesztprint") utasításokat, úgynevezett nyomkövetõ utasításokat lehet beépíteni az adott programnyelv szabályai szerint. További bonyodalmak adódhatnak akkor, amikor a végleges programból ki kell hagyni ezeket a kimeneti formátumot rendszerint igen erõsen zavaró utasításokat. A nyomkövetés kihagyása újabb belövési igényt támaszt. A nyomkövetõ utasítások mellékhatása ugyanis ideiglenesen kiküszöbölheti a program algoritmushibáit, ezért a korábbi hiba a nyomkövetés eltávolítása után ismét elõjöhet. A nyomkövetõ utasításokkal majdnem minden belövési probléma megoldható, de olykor csak igen fáradságosan. A nyomkövetõ utasítások nyelvi szintû eszközök. Már a korai idõkben rendelkezésre állt egy másik módszer: hibás futás esetén az operációs rendszer tárkivonatot (vagy az elterjedt angol kifejezéssel dumpot) készít, ami nem más, mint az operatív tárban található programok és adatok tárcellánként számokkal kódolt, formázott listája. A tárkivonat készítése operációsrendszeri funkció, mert alkalmazói szintrõl az operációs rendszer védelmi rendszerén át csak így lehet hozzáférni a keresett információkhoz. A legkorszerûbb nyomkövetési technika nem tesz további terheket a programozó vállára, hanem a meglevõket is igyekszik levenni. A nyomkövetési eszközöket két nagy csoportba sorolhatjuk: hardver- és szoftver nyomkövetési támogatások. A hardver nyomkövetési támogatás azon alapul, hogy a hardver speciális utasítás(ok) végrehajtása esetén megszakítja a program futását, és ebben a pillanatban elemezhetõ a program állapota. Ezt a támogatást fõként a korábbi dumpelemzés helyettesítésére lehet használni, ezért ugyanolyan mély ismereteket igényel, mint a dumpfejtés, így fõ alkalmazási területe az alapszoftver-gyártás. Ezt a funkciót az operációs rendszer speciális megszakítás-kezelõ alrendszerrel szokta támogatni, de a lebonyolításhoz magasabb szinten mûködõ monitor, debugger programra is szükség van. fefe@coffein.hu ( 103 / 117 )

104 13/D /3 A programok feldolgozási módjai: fordítás, szerkesztés, futtatás, nyomkövetés. Programkönyvtárak. A szoftver nyomkövetési támogatás nyelvi szinten áll rendelkezésre. Az interpreterrel értelmezett nyelvek például eleve tartalmaznak beépített nyomkövetési alrendszert. A fordítóprogramoknál a helyzet egy kicsit más, mert az eddig említett nyomkövetési technikák legjobban interaktív környezetben érvényesülnek (ezért említettük elõször az interpreteres lehetõségeket). Persze a fordítóprogramokba is be lehet építeni hasonló automatikus nyomkövetési funkciókat. Ilyenkor az elõbb említettekhez képest más lehetõségek is adódnak. Például elég korán bevezették az úgynevezett feltételes kommentárokat. Ezek olyan megjegyzésként kódolt programutasítások, amelyeket a fordító egy adott opció bekapcsolt állapota esetén a forrásprogram részének tekint, egyébként nem. Így ezekbe a feltételes megjegyzésekbe helyezhetjük el a korábban már említett nyomkövetõ utasításokat. fefe@coffein.hu ( 104 / 117 )

105 14/A Összetett állományszerkezetek. Van egy egyszerû szerkezetû alapállomány, és erre rakódik rá egy másik állomány. Minden esetben a feldolgozást segítik. Kialakításuknál két technika van, láncolás és indexelés. 1. Láncolás: Az információhordozó adatok az állományon belül jelennek meg (a rekord mellett mutatómezõk jelennek meg egyirányba, kétirányba láncolás, multilista). 2. Indexelés: Az állományon kívül jelennek meg az információhordozó adatok. Mindkét technikának az alapja egy egyszerû szerkezetû állomány, amit alapállománynak nevezünk. Erre rakódnak rá a plusz szerkezethordozó információk. Az ilyen állományok (az alapállományok) általában szeriálisak vagy szekvenciálisak. Az indexelés esetén létrejön egy ún. információs tábla: Két oszlopból áll és annyi sorból, ahány rekordja van az elsõdleges állománynak. Az elsõ oszlopban az alapállomány rekordjainak azonosítói vannak növekvõ sorrendben. A második oszlop az adott rekord lemezcímeit tartalmazza vagy olyan információ, amibõl a lemezcím egyértelmûen meghatározható. Ez az elsõdleges kulcsra vonatkozó egyszintû, teljes indexelés. Erre azért van szükség, hogy a szeriális, vagy szekvenciális állományra közvetlen elérést alkalmazhassunk. Az indextáblában a kulcs szerint keresek, így rögtön tudom a helyét. Kereséskor az indextáblában, a tárban binárisan keresek. Az indextáblában a kulcs szerint keresek, így rögtön tudom a helyét. Ha benne van a keresett elem kulcsa, akkor a lemezcím alapján közvetlenül meg tudom fogni. Többszintû indexelés: a tábla egy szekvenciális állomány, indexelhetõ, tehát e fölé felépíthetek egy indextáblát. A 2. és annál magasabb szinteken nem teljes indexelés van. Ennek a módszernek nagyméretû állománynál van értelme, elõsegíti a hatékonyabb keresést. Nem teljes indexelés: az indextáblában nem az összes, csak bizonyos rekordazonosítókat tüntetek fel. pl: minden 20.-t. Célja az indextábla méretének csökkentése. Ennek a módszernek azért van jelentõsége, mert ha keresünk egy rekordot, akkor az indextábla alapján be tudjuk határolni az állomány egy részét, hogy melyik intervallumban keressük. Az adott intervallumon pedig már lehet szekvenciális keresést alkalmazni. Hardveres indexelés alkalmazása: Pl. nem minden azonosítót tüntetem fel, csak a sávok utolsó rekordjainak azonosítóját. Így a keresés egy sávra csökken, a sávon belül pedig sorosan keresek. Ennek igen gyakori alkalmazása van. Másodlagos kulcsra épülõ indexelés: Az indextáblát felépíthetem úgy, hogy nem elsõdleges, hanem másodlagos kulcs szerint indexelek. Így az összes olyan rekord címe is szerepel a 2. oszlopban, annyi, amennyi rendelkezik az adott másodlagos kulcsértékkel. Itt csak teljes indexelésnek van értelme az elsõ szinten. Terminológia: Az elsõdleges kulcsra felépített indextáblákat és a (szeriális, vagy szekvenciális) alapállományt úgy hívjuk, hogy indexelt (szeriális, vagy szekvenciális) állomány. A másodlagos kulcsra felépített indextábla és állomány együtt az invertált állomány. 1. Láncolt szeriális állomány: Adva van a szeriális állomány. Erre építünk rá egy láncszerkezetet, amely a szeriális állomány szekvenciális feldolgozását segíti. Ezt úgy valósítjuk meg, hogy minden rekord mellé az elsõdleges állományban beépítünk egy mutatómezõt, melyet arra használunk, hogy növekvõ vagy csökkenõ azonosító sorrend szerint fûzzük fel a rekordokat. Egyirányú láncolt listát hozunk létre, a fej a legkisebb azonosítójú rekordra fog mutatni. Egyesítjük a szeriális állomány könnyû karbantarthatóságát a szekvenciális állomány könnyû feldolgozásával. fefe@coffein.hu ( 105 / 117 )

106 14/A /2 Összetett állományszerkezetek. Bõvítés: Szeriális állomány bõvítése, az alapállomány jellemzõi miatt az állomány végére bõvíthetünk, a fizikai sorrend változatlan. Az új rekordot be kell illeszteni a láncba, ez egy rendezett egyirányba láncolt lista bõvítése. Törlés: Az alapállományban csak logikai törlés van. A logikai törlést kihasználhatom a láncban is, viszont innen fizikailag is törölhetünk. 2. Indexelt (szeriális állomány): A szeriális állomány mellé, tõle függetlenül felépítek egy indexszerkezetet (közvetlen elérési lehetõséget) az elsõdleges kulcsra. Ez az egyik leggyakoribb, hatékony állományszerkezet. Az elsõdleges szinten itt csak teljes indexelés jöhet szóba, de egyaránt lehet egy- vagy többszintû indexelést is alkalmazni. Többszintes indexelés esetén sokkal bonyolultabb a kezelés. Bõvítés: Fizikailag az alapállomány végére bõvíthetünk, a szeriális állományszerkezet tulajdonsága szerint. Bármely bõvítõ rekord esetén aktualizálni kell az indextáblát. 1. Egyszintû indexelés esetén: a) Ha az indextábla befér a tárba, a bõvítés index szintû kezelése egyszerû, nem jelent problémát, mert egy rendezett táblázatba való beszúrást kell elvégezni. b) Ha nem fér el a tárba, akkor az indextábla, mint szekvenciális állomány bõvítését kell alkalmazni. Csak újraszervezéssel történhet. 2. A többszintû indexelés esetén bucket technikát alkalmazunk, az összes indexszintet át kell szervezni. A bucketek kialakításánál a szekvenciális állományt több szekvenciális állományra osztunk. Az indextáblát is azonos méretû részekre osztják fel, ezek a bucket-ek (pl: 50-50). A második szint ezeket a bucketeket indexeli. Az elsõ szinten nem töltjük ki ezeket az indexeket, lesznek bejegyzések és üres helyek. Innentõl kedve a bucketek átszervezésérõl lesz szó. Törlés: Alapállomány szinten csak logikai törlés van. A felsõbb szinteken, az indextáblában fizikai törlést is alkalmazok, úgy hogy törlöm a megfelelõ rekordot. Az tehát a további feldolgozásban nem vesz részt. Indexelt (szekvenciális állomány): Bõvítés: a) Újraszervezéssel bõvítek b) Független túlcsordulási terület alkalmazása - Láncolás. Elválik a logikai és a fizikai sorrend, a bõvítést mint túlcsordulásnak a kezelését valósítják meg. - Csoportok Csoportosítás az alapállomány rekordjainál. - Osztott szabad helyek módszere (cillinder-túlcsordulási terület alkalmazása) Itt van fejmozgás, a rekordok egy fejmozgással elérhetõek, így ezzel a módszerrel gyors elérés valósítható meg. - Mutatótömb Van túlcsordulási terület, amely vagy független, vagy cillinder túlcsordulási terület. fefe@coffein.hu ( 106 / 117 )

107 14/A /3 Összetett állományszerkezetek. Törlés: Az indexelt szekvenciális állománynál az alapállomány miatt általában logikai törlés van. Lehetne fizikai törlés is, de nem minden technika teszi lehetõvé (ld. csoportosítás), ezért általában nem realizálják.. Másodlagos kulcsra épülõ összetett állományszerkezetek Ez a multilista állományszerkezet. A rekordok mellett megjelenik egy mutatómezõ. Kiválasztom azt a másodlagos kulcsot, amire építeni akarok. Van egy alapállomány, valamilyen szerkezettel, és van a rekoroknak egy olyan mezõje, amely alapján fel akarom dolgozni az állományt. Hogy ezt megtehessem, minden rekordnak rendelkeznie kell ezzel a mezõvel. Így olyan kérdésekre is válaszolhatunk, hogy pl: a rekordok között hány van, amelyikben szerepel a lila szín? Minden rekordnak van egy mutatómezõje, mely segítségével az azonos másodlagos kulcsértékû rekordokat egy láncba fûzzük. Az alapállományra olyan szerkezetet húzok rá, amely annyi részláncból áll, ahány különbözõ másodlagos kulcsérték szerepel az állományban. Egy részlánc egy asszociatív csoport, minden részláncnak van feje. Minden egyes rekord pontosan egy részláncban szerepel, és annyi részlánc van, ahány másodlagos kulcsérték elõfordul az alapállományban (a másodlagos kulcs értéke bármennyi rekordban lehet azonos). A listafejeket az állománytól külön adom meg: felépül egy olyan táblázat, amely a részlistafejeket tartalmazza. A táblázatnak 3 oszlopa, és annyi sora van, amennyi különbözõ másodlagos kulcsérték elõfordul az állományban. 1.oszlop: A listafejek a másodlagos kulcsértékkel vannak azonosítva. A másodlagos kulcsértékek az elõfordulás sorrendjében vagy a másodlagos kulcs szerint kerülnek be a táblázatba. 2.oszlop: Az adott részlánc elsõ elemének a címét adja meg az állományon belül 3.oszlop: Kiegészítõ információ, az adott részlánchoz tartozó rekordok száma. A feldolgozásnál fontos. Az invertált állomány bitmátrixszal történõ megvalósítása A bitmátrixnak annyi oszlopa van, ahány rekord van az alapállományban. Az oszlopokat az elsõdleges állomány rekordjai címével azonosítjuk (vagy az ennek elõállításához szükséges információval). Az oszlopok sorrendje igazából lényegtelen, csak az egyértelmûség a fontos. Annyi sora van, ahány különbözõ másodlagos kulcsérték elõfordul. A sorokat ezzel a másodlagos kulcsértékkel azonosítjuk, a másodlagos kulcsértékek sorrendje nem lényeges. Feltöltésénél 1 kerül oda, ahol az illetõ rekord tartalmazza az adott másodlagos kulcsot, a többi helyre 0. Egy sorban akárány egyes lehet, de egy oszlopban csak egy. fefe@coffein.hu ( 107 / 117 )

108 14/B A párhuzamos programozás programnyelvi eszközei. A Neumann-architektúrán felépülõ gépek szekvenciálisak: a processzor a programnak megfelelõ sorrendben hajtja végre az utasításokat elemi lépésenként. Egy processzor által épen végrehajtott gépi kódú programot folyamatnak vagy szálnak hívunk. Ha ezek a mûködõ kódok az erõforrásokat kizárólagosan birtokolják, akkor folyamatról, ha bizonyos erõforrásokat közösen birtokolhatnak, akkor szálakról beszélünk. A párhuzamos programozás alapfogalmai: Kommunikáció: A folyamatok kommunikálnak egymással, adatcserét folytatnak. Szinkronizáció: A párhuzamosan futó folyamatoknak bizonyos idõpillanatokban találkozniuk kell. Elõfordul, hogy a szinkronizációs ponton keresztül történik adatcsere, a szinkronizációs ponton keresztül zajlik a kommunikáció. Például olyan információt vár az egyik a másiktól, ami nélkül nem tud továbbhaladni. Konkurencia: A folyamatok vetélkednek az erõforrásokért. Kölcsönös kizárás: Mivel a folyamatok kizárólagosan birtokolják az erõforrásokat, biztosítani kell, hogy amíg az egyik folyamat módosítja az adatot, addig a másik folyamat ne használhassa fel azt. A párhuzamos programozási eszközrendszer elõször a PL/I-ben jelent meg. Létezik a Pascalnak és a C- nek is olyan változata, amely ebben az irányban bõvíti tovább a nyelvet. Azok az algoritmusok, amelyeket ismerünk, mind szekvenciális algoritmusok, de léteznek párhuzamos algoritmusok a problémák megoldására. Az algoritmusokon belül az egyszerre elvégezhetõ mûveleteket egyszerre végezzük el. A programozási nyelveknek a párhuzamos programozás megvalósításához rendelkezniük kell eszközzel: - a folyamatok kódjának megadására, - a folyamatok elindítására és befejeztetésére, - a kölcsönös kizárásra, - a szinkronizációra, - a kommunikáció megvalósítására, - a folyamatok mûködésének felfüggesztésére, - a folyamatok prioritásának meghatározására, - a folyamatok ütemezésére. fefe@coffein.hu ( 108 / 117 )

109 14/C SQL DML. SQL DML (Data Manipulation Language, adatmanipulációs nyelv) Lehetõvé teszi az adatokon végzett karbantartási mûveleteket: új adatrekord bevitele, adatrekord törlés, módosítás. Ide szokták sorolni a lekérdezõ nyelvet is. Karbantartási mûveletek parancsai: INSERT INTO táblanév [oszlopnévlista] ] VALUES [kifejezéslista] I kérdés (kérdés: egy lekérdezés) DELETE FROM táblanév [WHERE feltétel] UPDATE táblanév SET oszlop1=kif1 [, oszlop2=kif2] ] I oszlop1 [, oszlop2] = kérdés [WHERE feltétel] Lekérdezési parancs: SELECT [ALL I DISTINCT] (minden rekordot vagy az azonos értékûekbõl csak egyet) [* I táblanév.* I kif1 [alias1] [, kif2 [alias2]] (minden rekord vagy tábla minden oszlopa v kif.) FROM táblanév1[alias1][, táblanév2 [alias2] ] [WHERE feltétel] (sorok szûkítése) [ORDER BY feltétel] [GROUP BY kif1 [, kif2] ] [HAVING feltétel] (csak feltételnek megfelelõ csoportok) fefe@coffein.hu ( 109 / 117 )

110 14/D Lapozás és szegmentálás. Laptáblák. Virtuális tárkezelés. Egyszerû lapozási technika (Simple Paging) Mint láttuk sem a kötött méretû sem a dinamikus memória felosztás nem alkalmas a memória hatékony használatára. Lényegesen hatékonyabb megoldást nyújt a lapozási technika bár járulékos igényei az elõzõ technikáknál sokkalta magasabbak. A lapozási technika lényege a következõ: osszuk fel a memóriát egyforma méretû darabokra, melyeknek mérete meglehetõsen kicsi (a memória méretéhez képest). A programokat osszuk fel a memória felosztásánál használt méretû darabokra - ún. lapokra. Ezután a folyamathoz rendeljünk hozzá annyi memóriadarabot (lapkeret), amennyi lapra a folyamatot felosztottuk. Ez a megoldás a kötött méretû felosztáshoz hasonlít, így csak belsõ felaprózódással kell számolnunk azonban ez a lapkeretek kis mérete miatt nem lesz jelentõs (csak a folyamat utolsó lapja esetén lép fel). A lapozási technika leglényegesebb jellemzõje a folyamat által használt memóriacímek és a valós (fizikai) címek különválasztása. Amíg a folyamat által használt címzés (virtuális címzés) mindig egy összefüggõ memóriaterületet feltételez, addig a valóságban a lapok elhelyezkedése a memóriában tetszõleges lehet (a szabad lapkereteket rendeljük hozzá a lapokhoz). A program által használt virtuális címet két részre oszthatjuk: a cím felsõ l bitje mondja meg, hogy a cím hányadik m bit méretû lapon található. a cím alsó m bitje a lapon belüli címet határozza meg. Mivel a program szempontjából az egész címtér összefüggõ, a program maximum m+l bit méretû memóriát tud címezni. A fizikai címek felosztása szintén az elõzõ címzési mechanizmussal azonos (mivel a lapok mérete és a lapkeretek mérete megegyezik). A legfontosabb jellemzõ az, hogy nem lehet algoritmikus megfeleltetést alkalmazni a virtuális címben található lapsorszám és a fizikai lapkeret sorszáma között. A két lap közötti megfeleltetést (címtranszformációt) egy, a folyamathoz tartozó leíró, az ún. laptábla segítségével végezzük (Page Table). A folyamat betöltésekor az operációs rendszer a laptáblába feljegyzi, hogy az adott lapsorszámhoz a fizikai memóriában milyen lapkeret sorszám tartozik (hol volt üres lap a központi memóriában). A fizikai cím kiszámítása ezek után a következõ lépésekbõl áll: a virtuális címet két részre osztjuk a cím felsõ l bitje a logikai lap sorszáma, amelyhez a laptáblában tartozik egy bejegyzés, amely a fizikai lapkeret sorszámát adja vissza ez fogja képezni a fizikai cím felsõ l bitjét. A fizikai cím alsó m bitje a logikai cím alsó m bitjével megegyezõ, így a fizikai címet a lapkeret sorszám és a lapon belüli cím összevonásával kapjuk. Mivel a fent vázolt címfordítási folyamatot utasításonként akár többször is el kell végezni (memóriaregiszter ill. memória-memória adatmozgató utasítások esetén), a központi egységnek a számítást megfelelõen hatékony hardver eszközökkel kell támogatnia. Egyszerû szegmentáció A felhasználói program részekre bontásának másik útja a szegmentáció. Az eljárás során a programot és a hozzá tartozó adatokat változó (de maximált) méretû szegmensekre osztjuk. A megoldás a dinamikus memória felosztásra hasonlít és hozzá hasonlóan belsõ felaprózódásra nem kell számítani. Mivel a szegmensek egymástól függetlenül kezelhetõk, a programnak nem szükséges folyamatos címtéren elhelyezkednie így a külsõ felaprózódás is kisebb mértékû, mint a dinamikus memória felosztásnál. A szegmentáció lényege azonban az, hogy a programozó számára eszközt ad a program, és a hozzá tartozó adatok megfelelõ szervezésére (a szegmentáció a programozó számára is látható módszer). A cím két részbõl épül fel: Szegmenscím Szegmensen belüli eltolás címe (offset) fefe@coffein.hu ( 110 / 117 )

111 14/D /2 Lapozás és szegmentálás. Laptáblák. Virtuális tárkezelés. Mivel szegmentáció alkalmazása esetén a fizikai és a logikai címek ismételten különválnak, a fizikai címek meghatározásához szintén címfordításra van szükség (hardver támogatás). A lapozással ellentétben a címek a szegmens kezdõcímének és az offsetcímnek az összegébõl adódnak (mivel a szegmens tetszõleges memóriacímtõl kezdõdhet, nem lehet a lapozásnál megismert egyszerû címszámítási módszert alkalmazni). Összegezve a fent bemutatott módszerek közül a lapozás nyújtja a leghatékonyabb memóriakezelési megoldást. A szegmentáció legfõbb elõnye a program moduláris felépítésének támogatása. A mai rendszerekben az egyszerû lapozás továbbfejlesztett változatait használják, nem ritkán szegmentációval kombinálva. Virtuális memóriakezelés Az egyszerû particionáláshoz képest a lapozás és a szegmentálás minõségi elõrelépést jelentett, azonban a technikában az eddig elmondottaknál sokkalta nagyobb lehetõségek rejlenek. A lapozás és a szegmentáció elválasztotta a program által látott címeket a tényleges, fizikai memóriacímektõl. Mivel a címtranszformáció futási idõben történik, a program memóriaterületei a futás alatt áthelyezhetõek (pl. swap folyamat után máshova is visszatölthetjük a folyamatot). A valódi átütést azonban nem ez a lehetõség hozta meg. A cache memória ismertetésénél már említettük, hogy a programok a végrehajtásuk alatt általában hosszabb idõn keresztül egy kis címtartományban mozognak. A folyamat programkódjának és adatterületének nagy része a futás alatt nincs használatban (illetve az idõk során mindig más részt használunk). Mivel a program lapokra (vagy szegmensekre) van osztva, megoldhatjuk, hogy egy adott idõpillanatban az éppen használt lapokat tartsuk a fizikai (elsõdleges) memóriában a többit pedig a másodlagos memóriában tároljuk. Amennyiben a soron következõ utasítás és az általa használni kívánt változó a fizikai memóriában van, a folyamat végrehajtása akadálymentes lesz. Amennyiben valamelyik szükséges lap nincs a memóriában, a folyamat futtatása nem lehetséges ilyenkor a hardvernek és az operációs rendszernek együtt kell gondoskodnia a szükséges lap memóriába töltésérõl (amely I/O utasítás végrehajtását igényli, így meglehetõsen idõigényes és ezért az adott folyamat blokkolt állapotba kerül). Rögtön felmerülhet bennünk egy kérdés: az eljárás alkalmazásával a folyamat futása tõle kívül álló indokok miatt is blokkolódhat így az adott folyamat végrehajtása több idõt fog igénybe venni, mint virtuális memória használata nélkül. Globálisan szemlélve a rendszert, virtuális memória használatával sokkal több folyamatot tarthatunk egy idõben a memóriában így a teljes rendszerünk teljesítménye lényegesen megnövekedhet. A virtuális memóriakezelés azon megoldások egyike, amely egy adott folyamatra nézve ugyan kedvezõtlen hatású lehet, de a teljes rendszer mûködését szemlélve a hatása egyértelmûen pozitív. A virtuális memóriakezelésnek van még egy nagyon lényeges tulajdonsága. A folyamat által látott memóriatartomány és a fizikai memória különválasztásával a programozónak nem kell törõdnie azzal, hogy az adott számítógép mennyi fizikai memóriát tartalmaz. A programja méretét csak a címtér mérete határozza meg. fefe@coffein.hu ( 111 / 117 )

112 15/A Egyszerû állományszerkezetek. Egy fileszerkezet egyszerû, ha a fizikai file csak a logikai file adatelemeit tartalmazza, nem tartalmaz szerkezethordó információkat. (pl. indextábla, mutatók) Szervezési mód szerint az alábbi egyszerû fileszerkezeteket különböztetjük meg. Az osztályozás alapja, hogy van-e kapcsolat 1. a logikai rekord azonosítója és a rekord háttértárolón elfoglalt helye között 2. az egymást követõ rekordazonosítók között - Szeriális (soros): 1. nincs, 2. nincs. Szerkezet nélküli, a rekordok sorrendje közömbös, a feldolgozás a file elejétõl történik. A rekordok fix vagy változó hosszúak. Adatbevitel a file végére történik. Soros elérésû tárolón is megvalósítható. - Szekvenciális: 1. nincs, 2. van. A logikai rekordok közti kapcsolatot a fizikai elhelyezkedés teremti meg. Soros elérésû tárolón is megvalósítható. - Direkt: 1. van, 2. van. Feltétele a címezhetõ, közvetlen hozzáférésû tárolóeszköz. A rekord címe és a rekordazonosító között kölcsönösen egyértelmû a megfeleltetés. A rekordazonosítóból kiszámítható a rekord tárolási címe. A rekordok közti kapcsolat kifejezõdik a rekordazonosítók sorrendjáben. - Random: 1. van, 2. nincs. A rekord címe és a rekordazonosító között nem kölcsönösen egyértelmû a megfeleltetés. Ugyanarra a címre több rekord is leképezhetõ (hash függvények). Hozzáférés szerint az adatállomány lehet közvetlen és soros. Erõsen kötõdik a szervezési módhoz. Sorosan bármelyik itt felsorolt szervezésû file elérhetõ. Direkt hozzáférés szükséges a direkt és random állományszervezés megvalósításához. Mûveletek: Keresés: Soros szervezésnél csak teljes keresés használható, az elsõtõl az utolsó rekordig. Szekvenciális szervezésû fileokban lineárisan is lehet keresni, az elejétõl kezdve amíg megtaláljuk vagy a keresett kulcsot meghaladja az aktuális rekord kulcsa. Direkt és random állományokban bináris keresés is lehetséges az eddigieken kívül. Törlés, bõvítés: Szerialis: Bõvítés: új rekord az állomány végére íródik.törlésnél fix rekordformátum esetén lemezes háttértárnál lehet fizikai törlés: az utolsó rekorddal felülírom a törlendõt. Szekvencialis: Bõvítés nem hajtható végre közvetlenül, csak újraszervezéssel. Csak logikai törlést realizál, fizikait csak újraszervezéssel. Direkt: Az adott rekordhely bitkombinációját a fentebb leírt bitkombinációra állítom. Ez egy speciális keveréke a fizikai és a logikai törlésnek, hiszen tárhely nem szabadul fel Random: Bõvítés: Üres rekordhelyre rekord bevitele a rekord kulcsa és a hash függvényében. Törlés: Logikai törlésrõl beszélhetünk, bármely rekord felülírható csupa nullával. Láncolás esetén (ld. szinonímák kezelése) kitörlöm a láncból fizikailag is. Soros és szekvenciális állománynál ezeket a mûveleteket körülményessé teszi, ha az eszköz egyszerre csak írásra vagy csak olvasásra nyitható meg, mert a keresett kulcsú elem megtalálása olvasást igényel, a módosítás viszont írást. A bõvítés és törlés továbbá az állomány méretváltozását is jelenti. Ezért ezekhez a mûveletekhez egy ideiglenes állományt szokás használni, amelybe egyszerûen átmásolódnak az eredeti file azon rekordjai, amelyekben nincs változás. Ha elértük azt a kulcsot, ahol változás van, törlésnél a rekord kimarad, beszúrásnál beíródik az új rekord fileba, cserénél a megváltozott adattartalommal íródik ki a rekord. Egy-egy rekord változása így elég sok munkát okoz. fefe@coffein.hu ( 112 / 117 )

113 15/A /2 Egyszerû állományszerkezetek. Szekvenciális állományoknál az ilyen jellegû feldolgozásoknál a változásokat egy módosító (update) file-ba gyûjtik, és idõszakosan egyszerre végzik el a szükséges változtatásokat. A módosító filenak az eredetivel azonos kulcs szerint rendezettsége esetén a két file párhuzamos végigolvasása után egy új állományban elõáll a javított tartalom. Direkt és random szervezésnél a direkt állományhozzáférés miatt a csere mûvelete egyszerûbb. Bármely adatelemre lehet pozicionálni, tartalmát módosítani. Direkt állományba beszúrni nem lehet, mert az azonosítók fixen hozzá vannak rendelve a tárcímhez. Törölni igazából nem lehet, logikai törlés lehetséges.. Random file-ba lehetséges beszúrás. Ha a rekordok száma nem több, mint rendelkezésre álló hely, nyílt címzés alkalmazható. Törlés: logikai. A törölt és a még nem használt területet meg kell különböztetni. (Külsõ láncolás esetén túlcsordulási területet lehet fenntartani azoknak a rekordoknak, amelyeknek a kiszámított címe már foglalt, de az akkor már szerkezethordozó információ.) fefe@coffein.hu ( 113 / 117 )

114 15/B Adattípusok az egyes programozási nyelvekben. PL/1 típusok egyszerû összetett felhasználói programvezérlõ tömb rekord (struktúra) aritmetikai lánc címke pointer kódolt numerikus karakterlánc bitlánc aritmetikai karakterlánc fixpontos bináris decimális lebegõpontos bináris decimális Pascal típusok egyszerû összetett mutató valós sorszámozott string[n] rekord objektum tömb állomány halmaz elõredefiniált felsorolásos intervallum logikai egész karakteres Ada típusok skalár összetett mutató privát valós egész logikai karakteres felsorolásos tömb rekord C típusok aritmetikai származtatott integrális valós tömb struktúra union mutató függvény float egész karakteres double int char long short unsigned fefe@coffein.hu ( 114 / 117 )

115 15/C SQL DCL. SQL DCL (Data Control Language, adatvezérlõ nyelv) Két alapvetõ célja a tranzakciókezelés, illetve a privilégiumok, hozzáférési jogok kezelése. Tranzakció: valamilyen szempontból logikailag összetartozó SQL utasítássorozat. Ha ezek végrehajtása közben hiba lép fel, ellentmondõ adatok kerülhetnek az adatbázisba. Ezért a tranzakció elõtti állapot rögzítésre kerül, amíg a tranzakció sikeresen be nem fejezõdik. COMMIT: A tranzakció lefutása után rögzíti az új állapotot (ezt automatikussá lehet tenni) ROLLBACK: Visszaállítja a tranzakció elõtti állapotot. SAVE POINT: Ha ilyeneket iktatunk a tranzakcióba, a ROLLBACK az utolsó SAVE POINT-ra tér vissza. (A könyvben a tranzakció kezdetét jelzi COMMIT WORK vagy BEGIN WORK vagy BEGIN TRANSACTION) Privilégiumok: a rendszer használatával kapcsolatos jogok Szintjei: connect: resource: DBA: bejelentkezhet, betekinthet azokba a táblákba, amelyekhez SELECT joga van. (PUBLIC táblákba bármelyik bejelentkezett felhasználónak van ilyen joga) összes connect joggal rendelkezik. Táblákat indexeket hozhat létre, törölhet. Visszenézheti, hogy adott táblával ki mit csinált. (auditing) rendelkezik minden resource joggal. Minden felhasználó minden adatába belenézhet. Jogokat adhat, visszavonhat. Export-inport funkciók felügyelete, rendszerfigyelés joga. GRANT privilégium TO felhasználó IDENTIFIED BY jelszó (Privilégiumott ad) CREATE ROLE szerepkör (Ezek csoportok) REVOKE privilégium I ALL FROM felhasználó (Elveszi) Hozzáférési jogok: a táblák használatával kapcsolatos jogok SELECT, INDEX, INSERT, UPDATE, DELETE, ALTER parancsokra vonatkozhat. GRANT hozzáférés ON táblanév TO felhasználó [WITH GRANT OPTION] REVOKE hozzáférés I ALL ON táblanév FROM felhasználó A hozzáférés mezõkre szûkíthetõ. (Hozzáférések adása) (Hozzáférések elvétele) fefe@coffein.hu ( 115 / 117 )

116 15/B Az elektronikus számítógép funkcionális felépítése és mûködése: megszakítási rendszer, duál módú mûködés. A megszakításkezelés fogalmai A megszakítás (interrupt) átadja a vezérlést a megszakítás feldolgozó rutinnak. Ez általában a megszakítási vektor segítségével történik, amelynek megfelelô elemei tartalmazzák a megszakítási osztályokhoz tartozó feldolgozó rutin elsô végrehajtandó utasításának címét. A megszakítási rendszernek tárolnia kell a megszakított utasítás címét. Egy megszakítás feldolgozása idején jelentkezô további megszakítások letilthatók (mask out, disable), hogy el ne "vesszenek" (lost interrupt). A megszakítási jel forrását tekintve egy megszakítás lehet külsô (pl. I/O, Timer, Hardver, ), vagy belsô (szofver megszakítás, angolul: trap). Az operációs rendszer (megszakítás feldolgozó rutin) közvetlen feladatai: a CPU állapotának megôrzése (a hardver ehhez minimális kezdeti támogatást nyújt); a megszakítás okának, körülményeinek részletesebb elemzése; "maszkolás"; a megszakított programhoz történô "visszatérés" megszervezése. I/O struktúra Az I/O folyamat elindult, a felhasználói program a vezérlést csak az I/O befejezése után kapja vissza. "wait" utasítások a következô megszakításig; "wait loop" az adat megérkezéséig (hand-shaking, ready bit!); csak egyetlen egy I/O lehet egyszerre folyamatban. Az I/O folyamat elindult, a (felhasználói) program a vezérlést azonnal visszakapja tekintetet nélkül az I/O befejezôdésére. rendszer hívás (system call); az I/O-t a felügyelô program indítja; készülék - státusz táblázat (device state); a felügyelô program kezeli - gazdálkodás, ütemezés. fefe@coffein.hu ( 116 / 117 )