Iványi Antal PÁRHUZAMOS ALGORITMUSOK ELTE Eötvös Kiadó, Budapest, 2005 március Ez az elektronikus könyv az Oktatási Minisztérium támogatásával, a Felsőoktatási Tankönyvés Szakkönyvtámogatási pályázat keretében készült. © Iványi Antal, ELTE Eötvös Kiadó, 2005 Lektorok: Horváth Zoltán, Kása Zoltán, Pécsy Gábor, Szűcs László Kiadja az ELTE Eötvös Kiadó 1051 Budapest, Szerb utca 1. Telefon: 411-6740, Fax: 485-52-26 Honlap: http://www.elte.hu/szervezet/eotvos kiado 7.html Elektronikus cím: eotvoskiado@ludens.elte.hu Felelős kiadó: Pándi András Tartalomjegyzék Előszó1. Bevezetés1.1. Alapfogalmak1.2. Hatékonysági mértékek1.3. Pszeudokód1.4. Számítási modellek1.4.1. Számítógépek1.4.2. Párhuzamos gépek1.4.3. Hálózatok1.5. Rekurzió1.6. Véletlenített algoritmusok (*)1.6.1. Egyenlőtlenségek1.6.2. Példák1.7. Alsó korlátok1.7.1. Egyszerű számolás1.7.2. Leszámlálás1.7.3. Döntési fák1.7.4. Tanácsadói érvelés1.7.5. Információelméleti érvelés1.7.6. Gráfelméleti érvelés1.8. Anomália1.8.1. Lapcsere1.8.2. Ütemezés1.8.3. Párhuzamos feldolgozás átfedéses memóriával1.8.4. Párhuzamos korlátozás és szétválasztás1.8.5. Az anomália elkerülése2. Párhuzamos gépek2.1. Alapvető módszerek2.1.1. PrefixszámításPrefixszámítás CREW PRAM modellenPrefixszámítás EREW PRAM modellenPrefixszámítás munkaoptimálisan2.1.2. Tömb elemeinek rangsorolásaDeterminisztikus tömbrangsorolásVéletlenített listarangsorolás (*)2.2. Kiválasztás2.2.1. Kiválasztás négyzetes számú processzoron2.2.2. Kiválasztás p2.2.3. Kiválasztás egész számok között2.2.4. Az általános kiválasztási feladat megoldása n/logn2.2.5. Munkaoptimális véletlenített algoritmus (*)2.3. Összefésülés2.3.1. Logaritmikus idejű algoritmus2.3.2. Páratlan-páros összefésülő algoritmus2.3.3. Munkaoptimális algoritmus2.3.4. Egy még gyorsabb algoritmus2.4. Rendezés2.4.1. Páratlanpáros algoritmus2.4.2. Egy véletlenített algoritmus (*)2.4.3. Preparata algoritmusa2.4.4. Reischuk véletlenített algoritmusa (*)2.5. Gráfalgoritmusok2.5.1. Minmátrix2.5.2. Tranzitív lezárt2.5.3. Összefüggő komponensek2.5.4. Minimális feszítőfa2.5.5. Konvex burok3. Rácsok3.1. Számítási modellek3.2. Csomagirányítás3.2.1. Csomagirányítás láncon3.2.2. Egy mohó algoritmus a PPR megoldására rácson3.2.3. Egy kis várakozási sort használó véletlenített algoritmus (*)3.3. Alapfeladatok3.3.1. Üzenetszórás3.3.2. PrefixszámításPrefixszámítás láncon3.3.3. Adatkoncentráció3.3.4. Ritka rendezés3.4. Kiválasztás3.4.1. Véletlenített algoritmus az p=n(*)3.4.2. Véletlenített algoritmus, ha a processzorsám kicsi (*)3.4.3. Determinisztikus algoritmus kis processzorszámra3.5. Összefésülés3.5.1. Rangon alapuló összefésülés láncon3.5.2. Páratlan-páros összefésülés láncon3.5.3. Páratlan-páros összefésülés négyzeten3.6. Rendezés3.6.1. Rendezés lánconRangsoroló rendezés lánconPáratlan-páros felcserélő rendezés lánconPáratlan-páros összefésülő rendezés láncon3.6.2. Rendezés négyzetenSchearson rendező algoritmusaPáratlan-páros összefésülő rendezés3.7. Gráfalgoritmusok3.7.1. KockaMinmátrix számításaIrányított gráf tranzitív lezártjaÖsszefüggő komponensek meghatározása3.7.2. NégyzetTranzitív lezártLegrövidebb utakKonvex burok4. Hiperkocka4.1. Számítási modellek4.1.1. Hiperkocka4.1.2. Pillangó hálózat4.1.3. Hálózatok beágyazásaGyűrű beágyazásaTórusz beágyazásaBináris fa beágyazása4.2. Csomagirányítás4.2.1. Mohó algoritmus4.2.2. Véletlenített algoritmus4.2.3. Az első fázis elemzéseA sorméret elemzése4.3. Alapvető algoritmusok4.3.1. Üzenetszórás fában4.3.2. Prefixszámítás fán4.3.3. Adatkoncentráció4.3.4. Kisszámú elem rendezése hiperkockán4.4. Kiválasztás4.4.1. Véletlenített algoritmus, ha p és n megegyezik (*)4.4.2. Véletlenített algoritmus kis processzorszámhoz (*)4.4.3. Determinisztikus algoritmus kis processzorszámhoz4.5. Összefésülés4.5.1. Páratlan-páros összefésülés4.5.2. Biton összefésülés4.6. Rendezés4.6.1. Páratlan-páros összefésülő rendezés4.6.2. Biton rendezés4.7. Gráfalgoritmusok4.7.1. Minmátrix meghatározása4.7.2. Tranzitív lezárt4.7.3. Összefüggő komponensek4.7.4. Legrövidebb utak4.7.5. Konvex burok5. Szinkronizált hálózat5.1. Számítási modell5.2. Vezető választása5.2.1. Vezetőválasztás megoldhatatlansága gyűrűben5.2.2. Vezetőválasztás gyűrűbenLeLann algoritmusaChang és Roberts algoritmusaHirschberg és Sinclair algoritmusaIDŐSZELET algoritmusAlsó korlát az üzenetszámra5.2.3. Vezetőválasztás fában5.2.4. Vezetőválasztás általános hálózatbanMAX-TERJED algoritmusOPT-MAX-TERJED algoritmus5.2.5. Alsó korlát az üzenetek számára5.3. Megegyezés5.3.1. Megegyezés vonalhibák esetében5.3.2. Megegyezés processzorhibák esetében5.3.3. -megegyezésk5.3.4. Közelítő megegyezés6. Hagyományos és elektronikus irodalom6.1. Megjegyzések az 1. fejezethez6.2. Megjegyzések a 2. fejezethez6.3. Megjegyzések a 3. fejezethez6.4. Megjegyzések a 4. fejezethez6.5. Megjegyzések az 5. fejezethezJelölésekAngol szakkifejezésekMagyar szakkifejezésekFolyóiratok a hazai könyvtárakbanIrodalomjegyzékTárgymutatóNévmutató Előszó Ez az elektronikus tankönyv az ELTE programtervező matematikus szakának I/2B sávjában a Párhuzamos algoritmusok tantárgy, valamint az Informatikai Doktori Iskolában a Párhuzamos és osztott algoritmusok elemzése tantárgy keretében tartott előadások anyagát tartalmazza. A könyv hat fejezetből (Bevezetés, Párhuzamos gép, Rács, Kocka, Szinkronizált hálózat, Hagyományos és elektronikus irodalom) és nyolc további részből (Jelölések, Angol szakkifejezések, Magyar szakkifejezések, Irodalomjegyzék, Lelőhelyjegyzék, Névmutató, Tárgymutató, Megoldások) áll. A második fejezetet Horváth Zoltán, a harmadikat Szűcs László, a negyediket Pécsy Gábor, a könyv többi részét Kása Zoltán lektorálta. Köszönöm a könyv lektorainak a sok hasznos észrevételt. Lényeges segítséget jelentett, hogy a lektorok nem csak a saját részüket nézték át. Kollégáim közül köszönöm Balogh Ádám (ELTE), Dózsa Gábor (SZTAKI), Fábián (ELTE) Mária, Miletics Edit (Széchenyi István Egyetem), Pethő Attila (Debreceni Egyetem), Rét Anna (Műszaki Könyvkiadó), Scharnitzky Viktorné (ELTE), Sima Dezső (BMF), Simon Péter (ELTE) és Szili László (ELTE) javaslatait. A korábbi változatok alapján vizsgázó hallgatók közül pedig Balázs Gábor (ELTE), Baksa Klára (ELTE), Dévai Gergely (ELTE), Hajdu Tamás (ELTE), Hegyessy Tamás (ELTE), Hermann Péter (ELTE), Kapinya Judit (ELTE), Kovács Péter (ELTE), Metykó Beáta (ELTE) és Szalai Róbert (ELTE) segítettek. A könyv ábráit Locher Kornél rajzolta. A könyv kézirata a HLA T E X kiadványszerkesztővel készült, amelyet az elmúlt években fejlesztettünk ki Belényesi Viktorral és Locher Kornéllal. Az irodalomjegyzéket Iványi Anna tette élővé. A párhuzamos algoritmusok szakirodalma nagyon gyorsan fejlődik. Ezért a könyvnek az ELTE Informatikai Kara http://elek.inf.elte.hu címen lévő elektronikus könyvtárában lévő honlapján folyamatosan karbantartjuk a külföldi és hazai hivatkozások aktuális listáját (hiperszöveg formájában, így a honlap látogatói kattintással közvetlenül elérhetik az idézett művek szerzőinek honlapját, és olyan elektronikus könyvtárakat, ahonnan az idézett cikkek letölthetők). Ugyanitt a beérkezett észrevételek alapján a nyomtatott könyv szövegében javasolt változtatások listáját is karbantartjuk. Az elektronikus címek aláhúzása azt jelzi (itt az előszóban, az irodalomjegyzékben és a lelőhelyjegyzékben), hogy a könyv honlapján lévő PDF és DVI változatban a címek élnek, a PS változatban pedig kék színnel ki vannak emelve. Kérem a könyv Olvasóit, hogy észrevételeiket és javaslataikat írják meg a tony@inf.elte.hu címre. Különösen köszönöm a témával kapcsolatos új feladatokat. Budapest, 2005. április 10. Iványi Antal 1. Bevezetés A számítógépes feladatmegoldás természetes és hagyományos világa a soros adatfeldolgozás. A különböző alkalmazási területek nagy teljesítményigényének és környezetünk párhuzamos jellegének hatására azonban rohamosan fejlődik a párhuzamos feldolgozás is. Párhuzamos adatfeldolgozás. Egy feladat párhuzamos megoldása ugyanúgy 3 lépésből áll, mint a soros megoldás. Először meg kell érteni és pontosan meg kell fogalmazni a feladatot – ez a lépés hasonló a soros feldolgozás első lépéséhez. Mivel a soros adatfeldolgozás számára ismert feladatokat oldunk meg, a problémák megértése – az eddigi tapasztalatok szerint – az olvasók többsége (például harmadéves programtervező és informatika szakos hallgatók) számára nem jelent gondot. A második lépésben választunk egy ismert architektúrát (esetleg tervezünk egy újat) és ahhoz tervezünk egy megoldási algoritmust . Ez vagy új algoritmus, vagy egy soros algoritmus párhuzamosított változata. Könyvünk tárgya a párhuzamos adatfeldolgozásnak ez a része, azaz a párhuzamos algoritmusok tervezése és elemzése. Végül a harmadik lépésben az algoritmust a meglévő programozási módszerek valamelyikével párhuzamos program formájában megvalósítjuk (itt is szóba jön új programozási módszer alkalmazása). Párhuzamos algoritmusok. Ha egy feladatot együttműködő processzorok segítségével oldunk meg, akkor a számítási idő rendszerint csökken, mivel bizonyos műveletek egyidejűleg elvégezhetők. Ennek a csökkenésnek az ára a nagyobb beruházásigény és az elvégzendő munka mennyiségének növekedése. A párhuzamos algoritmusokat különböző szempontok szerint szokták osztályozni. Az egyik szempont a processzorok működésének időzítése. Eszerint vannak összehangoltan dolgozó, ún. szinkronizált processzorok és egymástól függetlenül dolgozó, ún. aszinkron processzorok. Emellett vannak hibrid megoldások, ahol a processzorok részben összehangoltan dolgoznak. Egy másik osztályozási szempont az együttműködő processzorok közötti információcsere módja, azaz a kommunikációs modell. Ez az információcsere történhet a közös memória segítségével és/vagy üzenetek küldésével és fogadásával. Fontos a rendszer megbízhatóságával kapcsolatos felfogásunk: hibátlan működést tételezünk fel vagy megengedünk bizonyos típusú hibákat (például a processzorok vagy az adatátviteli vonalak meghibásodását). Lényeges az az architektúra, amelyre algoritmusainkat tervezzük. A második fejezetben röviden áttekintjük a párhuzamos számítógépek főbb típusait, az elemzésekhez azonban a számítási modelleknek nevezett absztrakt számítógépeket használjuk. A párhuzamos algoritmusok közül csak a szinkronizált modelleken megvalósíthatókat tárgyaljuk. Eközben feltételezzük, hogy a processzorok, adatátviteli vonalak, közös és saját memória – azaz a rendszer minden eleme – megbízhatóan működnek. Előismeretek. A tárgyalt anyag nagy része az informatikai képzés alapvető kurzusait (adatszerkezetek, algoritmusok, analízis, diszkrét matematika, programozás) sikeresen elvégző hallgatók számára érthető. A véletlenített algoritmusok elemzése a binomiális eloszlás néhány tulajdonságán alapul, ezért ezekben az alfejezetekben a valószínűségszámítási ismeretekre is támaszkodunk. Ezeket a részeket a címekben és a tartalomjegyzékben csillaggal ( * ) jelöltük. A feladatok egy részének megoldásához hasznosak az operációkutatással, optimalizálással és szimulációval kapcsolatos ismeretek. A fejezetek egymásra épülése. Bár helyenként felhasználunk a könyv korábbi részeiben bemutatott algoritmusokat, a bevezető első fejezet elolvasása után a többi fejezet egymástól függetlenül is érthető. Ha azonban az Olvasót például a konvex burok hiperkockán való meghatározása érdekli, célszerű a párhuzamos gépen és a rácson alkalmazott algoritmusokkal is megismerkedni (a tartalomjegyzék és a tárgymutató segít a visszalapozásban. ) Tartalom. A könyv hat fejezetből és hét további részből áll. Az első fejezetben (Bevezetés) előkészítjük a további anyagot: megadjuk az alapvető meghatározásokat, ismertetjük a felhasznált számítási modelleket és pszeudokódot, foglalkozunk a rekurzív algoritmusokkal és a rekurzív egyenletekkel, a véletlenített algoritmusokkal, az alsó korlátokkal és az anomáliával. A további négy fejezetben párhuzamos algoritmusokat ismertetünk és elemzünk – az algoritmusok megvalósítására használt számítási modellek (és az azok alapjául szolgáló architektúrák) szerint csoportosítva: a szinkronizált processzorok kapcsolatát párhuzamos közvetlen hozzáférésű gépek (Párhuzamos gép), rácsok (Rács) kockák (Kocka) és tetszőleges gráfok (Szinkron hálózat) segítségével adjuk meg. A hatodik fejezetben (Hagyományos és elektronikus irodalom) a könyv írásához felhasznált és az egyes témák részletesebb megismeréséhez ajánlott – nyomtatott és elektronikus formában, magyar és idegen nyelveken hozzáférhető – dokumentumok tartalmát és lelőhelyi adatait foglaljuk össze. Módszertan. A könyv felépítésével és az alkalmazott tipográfiai eszközökkel igyekeztünk megkönnyíteni az anyag megértését. A szövegben gyakran alkalmaztunk magyarázattal ellátott ábrákat és példákat. Az egyes fejezetek végén gyakorlatok és feladatok vannak. A gyakorlatok a fejezet anyagának jobb megértését segítik elő és az anyag ismeretében rendszerint gyorsan megoldhatók. A feladatok megoldása önálló gondolkodást és esetenként több matematikai ismeretet igényel. Az algoritmusok elemzését nem törtük meg hivatkozásokkal, viszont a hatodik fejezetben témakörönként összefoglaltuk az elsősorban ajánlott szakkönyvek és cikkek adatait, és alternatív megoldásokra is utaltunk. A könyv végén összefoglaltuk az alkalmazott jelöléseket (Jelölések), és megadtuk az angol szakkifejezések (Angol szakkifejezések) magyar, valamint a magyar szakkifejezések (Magyar szakkifejezések) angol megfelelőjét. A bizonyítások végét †, a példák végét † jelzi. A definíciókban az új fogalom nevét kék félkövér dőlt betűkkel írtuk. A sorszámozott képletek tördelésénél az Olvasók kényelmét szolgáló amerikai stílust követtük (azaz minden relációjel új sorba kerül – az ilyen képletek sorfolytonosan olvasandók). Mivel a vesszőnek gyakran van a szövegben nyelvtani szerepe, a számokban tizedespontot használunk. A gyakorlatok egy részének megoldását megadtuk. Az irodalomjegyzékben együtt adjuk meg a hazai és külföldi forrásokat. Az idegen nyelvű szakirodalomból csak a klasszikus és a viszonylag friss műveket soroljuk fel. A magyar nyelvű anyag összeállítása során – az algoritmusok elemzésével foglalkozó műveket tekintve – teljességre törekedtünk. Az elektronikus formában elérhető dokumentumoknál megadtuk a hálózati címet is. Minden dokumentumnál feltüntettük azoknak a szövegrészeknek az azonosítóját, amelyekből hivatkozás van az adott dokumentumra (pl. 2.7. a megfelelő alfejezetre, 113 pedig az irodalomjegyzék 113-as sorszámú elemében lévő hivatkozásra utal). A névmutató a könyvben előforduló neveket tartalmazza – teljességre törekedve. A tárgymutatóban dőlt számok jelzik az egyes fogalmak definiálásának helyét. Az előfordulási helyek felsorolásánál megelégedtünk a lényegesnek tartott helyekre való utalással. A gyakorlatokban, feladatokban, ábrákban előforduló fogalmakat az oldalszám melletti rövidítések (gy, fe, áb) jelzik. 1.1. Alapfogalmak A párhuzamos algoritmusok tárgyalása a soros algoritmusokra épül, ezért a szokásos fogalmak mellett a soros algoritmusokkal kapcsolatos definíciókat is megadjuk. Az algoritmusok elemzése – a helyesség bizonyítása mellett – a végrehajtáshoz szükséges erőforrások (ez számítógépen megvalósított algoritmus esetében lehet processzoridő, memóriakapacitás – számítási modellen futó algoritmus esetében pedig memóriarekesz, kommunikációs üzenet, műveleti lépés) mennyiségének meghatározását is jelenti. Gyakran nem tudjuk vagy nem akarjuk az igényelt erőforrás mennyiségét pontosan megadni. Ilyenkor megelégszünk az igény nagyságrendjének jellemzésével. Ennek a jellemzésnek a jól bevált eszközei az Ω,O,Θ,o és ω jelölések. Mivel az igények általában nemnegatívak, ezért az alábbi meghatározásokban mindenütt feltesszük, hogy az f és g függvények a pozitív egészek halmazán vannak értelmezve, az f(n) és g(n) függvényértékek pedig nemnegatív valós számok. Az O jelöléssel aszimptotikus felső, az Ω jelöléssel aszimptotikus alsó korlátot tudunk adni, míg a Θ jelöléssel pontosan meg tudjuk adni a vizsgált függvény aszimptotikus viselkedését. O(g(n)) (nagy ordó) azon f(n) függvények halmazát jelenti, amelyekhez léteznek olyan c pozitív valós és n0 pozitív egész állandók, hogy ha nn0,f(n)cg(n).(1.1)Ω(g(n)) (nagy omega) azon f(n) függvények halmazát jelenti, amelyekhez léteznek olyan c pozitív valós és n0 pozitív egész állandók, hogy ha nn0, akkor f(n)cg(n).(1.2)Θ(g(n)) (nagy teta) azon f(n) függvények halmazát jelenti, amelyekhez léteznek olyan pozitív valós c1,c2 és pozitív egész n0 állandók, hogy ha nn0, akkor c1g(n)f(n)c2g(n).(1.3) Az elemzésekben arra törekszünk, hogy Θ típusú becsléseket adjunk, amihez azonos argumentumfüggvényt tartalmazó O és Ω típusú becslésekre van szükség. Ha egy becslésben hangsúlyozni akarjuk, hogy a becslés nem éles, akkor hasznos a o és a ω jelölés. o(g(n)) (kis ordó) azon f(n) függvények halmazát jelenti, melyekre teljesül, hogy minden pozitív valós c állandóhoz megadható egy pozitív egész n0 úgy, hogy ha nn0, akkor f(n)cg(n).(1.4)ω(g(n)) (kis omega) azon f(n) függvények halmazát jelenti, melyekre teljesül, hogy minden pozitív valós c állandóhoz megadható egy pozitív egész n0 úgy, hogy ha nn0, akkor f(n)cg(n).(1.5) Ha f(n)=o(g(n)) , akkor limnf(n)g(n)=0,(1.6) és ha f(n)=ω(g(n)) , akkor limnf(n)g(n)=.(1.7) Az 1.1. táblázatban összefoglaltuk a függvények növekedésével kapcsolatban leggyakrabban használt jelöléseket és kifejezéseket. A táblázatban szereplő korlátok tetszőleges erőforrással kapcsolatban használhatók – elemzéseinkben azonban elsősorban lépésszámokra vonatkoznak. A táblázatban a szub kifejezést kisebb, a szuper kifejezést pedig nagyobb értelemben használtuk. Érdemes megemlíteni, hogy szokás a kisebb vagy egyenlő, illetve a nagyobb vagy egyenlő értelmű használat is. A könyvben a szuperpolinomiális kifejezés szinonimájaként fogjuk használni az exponenciális jelzőt. Ezzel az exponenciális futási időt a matematikában szokásosnál tágabban definiáltuk: ha egy algoritmus futási ideje felülről nem korlátozható polinommal, akkor exponenciálisnak nevezzük. 1.2. Hatékonysági mértékek Sorszám Növekedési korlát képlettel Korlát típusa szóval 1 Θ(1)konstans 2 Θ(log*n)majdnem konstans 3 o(logn)szublogaritmikus 4 Θ(logn)logaritmikus 5 Θ(logΘ(1)n)polilogaritmikus 6 ω(logn)szuperlogaritmikus 7 o(n)szublineáris 8 Θ(n)lineáris 9 ω(n)szuperlineáris 10 Θ(n2)négyzetes 11 Θ(n3)köbös 12 o(nΘ(1))szubpolinomiális 13 Θ(nΘ(1))polinomiális 14 ω(nΘ(1))szuperpolinomiális 1.1. ábra. Függvények növekedésének leggyakoribb korlátai. Az algoritmusok elemzése során az igényelt erőforrások mennyiségét abszolút és relatív mennyiségekkel jellemezzük. Ezeknek a mennyiségeknek a célszerű megválasztása attól is függ, hogy az algoritmus konkrét gépen vagy absztrakt gépen (számítási modellen) fut. Jelöljük W(n,π,A)-vel, illetve W(n,π,p,P)-vel azt az időt (azoknak a lépéseknek a számát), amely alatt a π problémát az A soros, illetve a P párhuzamos algoritmus – (utóbbi p processzort felhasználva) – n méretű feladatokra legrosszabb esetben megoldja. Hasonlóképpen jelöljük B(n,π,A)-vel, illetve B(n,π,p,P)-vel azt az időt (azoknak a lépéseknek a számát), amely alatt a π problémát az A soros, illetve a P párhuzamos algoritmus (utóbbi p processzort felhasználva) – n méretű feladatokra legjobb esetben megoldja. Jelöljük N(n,π)-vel, illetve N(n,π,p)-vel azoknak a lépéseknek a számát, amelyekre az n méretű π feladat megoldásához mindenképpen szüksége van bármely soros, illetve bármely párhuzamos algoritmusnak – utóbbinak akkor, ha legfeljebb p processzort vehet igénybe. Tegyük fel, hogy minden n-re adott a π feladat n méretű konkrét előfordulásainak D(n,π) eloszlásfüggvénye. Ekkor legyen E(n,π,A), illetve E(n,π,p,P) annak az időnek a várható értéke, amennyi alatt a π problémát n méretű feladatokra megoldja az A soros, illetve a P párhuzamos algoritmus – utóbbi p processzort felhasználva. A tankönyvekben az elemzések során gyakori az a feltételezés, hogy az azonos méretű bemenetek előfordulási valószínűsége azonos. Ilyenkor átlagos futási időről beszélünk, amit A(n,A)-val jelölünk. A W,B,N,E és A jellemzők függnek attól a számítási modelltől is, amelyen az algoritmust megvalósítjuk. Az egyszerűség kedvéért feltesszük, az algoritmus egyúttal a számítási modellt is egyértelműen meghatározza. Amennyiben a szövegkörnyezet alapján egyértelmű, hogy melyik problémáról van szó, akkor a jelölésekből π -t elhagyjuk. Ezek között a jellemzők között érvényesek az N(n)B(n,A)(1.8)E(n,A)(1.9)W(n,A)(1.10) egyenlőtlenségek. Hasonlóképpen a párhuzamos algoritmusok jellemző adataira az N(n,p)B(n,P,p)(1.11)E(n,P,p)(1.12)W(n,P,p)(1.13) egyenlőtlenségek teljesülnek. Az átlagos futási időre pedig a B(n,A)A(n,A)(1.14)W(n,A),(1.15) illetve B(n,P,p)A(n,P,p)(1.16)W(n,P,p)(1.17) áll fenn. Hangsúlyozzuk, hogy ezek a jelölések nem csak futási időre, hanem az algoritmusok más jellemzőire – például memóriaigény, küldött üzenetek száma – is alkalmazhatók. Ezután relatív jellemzőket, úgynevezett hatékonysági mértékeket definiálunk. A gyorsítás (vagy relatív lépésszám) azt mutatja, hányszor kisebb a párhuzamos algoritmus futási ideje a soros algoritmus futási idejénél. A P párhuzamos algoritmusnak az A soros algoritmusra vonatkozó gyorsításag(n,A,P)=W(n,A)W(n,p,P).(1.18) Ha a gyorsítás egyenesen arányos a felhasznált processzorok számával, akkor lineáris gyorsításról beszélünk. Ha a P párhuzamos és az A soros algoritmusra W(n,A)W(n,p,P)=Θ(p),(1.19) akkor PA -ra vonatkozó gyorsítása lineáris. Ha a P párhuzamos és az A soros algoritmusra W(n,A)W(n,p,P)=o(p),(1.20) akkor PA -ra vonatkozó gyorsítása szublineáris. Ha a P párhuzamos és az A soros algoritmusra W(n,A)W(n,p,P)=ω(p),(1.21) akkor PA -ra vonatkozó gyorsítása szuperlineáris. A párhuzamos algoritmusok esetében fontos jellemző az m(n,p,P) munka, amit a futási idő és a processzorszám szorzatával definiálunk. Akkor is ez a szokásos definíció, ha a processzorok egy része csak a futási idő egy részében dolgozik: m(n,p,P)=pW(n,p,P).(1.22) Érdemes hangsúlyozni, hogy – különösen az aszinkron algoritmusok esetében – a ténylegesen elvégzett lépések száma lényegesen kevesebb lehet, mint amit a fenti (1.22) képlet szerint kapunk. Egy P párhuzamos algoritmusnak az ugyanazon problémát megoldó soros algoritmusra vonatkozó h(n,p,P,A) hatékonysága a két algoritmus munkájának hányadosa: h(n,p,P,A)=W(n,A)pW(n,p,P).(1.23) Abban a természetes esetben, amikor a párhuzamos algoritmus munkája legalább akkora, mint a soros algoritmusé, a hatékonyság nulla és egy közötti érték – és a viszonylag nagy érték a kedvező. Központi fogalom a párhuzamos algoritmusok elemzésével kapcsolatban a munkahatékonyság és munkaoptimalitás. Ha a P párhuzamos és A soros algoritmusra pW(n,p,P)=O~(W(n,A)),(1.24) akkor PA-ra nézve munkahatékony. Ez a meghatározás egyenértékű a pW(n,p,P)W(n,A)=O(1)(1.25) egyenlőség előírásával. Eszerint egy párhuzamos algoritmus csak akkor munkahatékony, ha munkája nagyságrendileg nem nagyobb, mint a soros algoritmus munkája. Ha a P párhuzamos és A soros algoritmusra pW(n,p,P)=O(W(n,A)),(1.26) akkor PA -ra nézve munkaoptimális. Ez a meghatározás egyenértékű a pW(n,p,P)W(n,A)=O(logkn)(1.27) egyenlőség előírásával. Eszerint egy párhuzamos algoritmus csak akkor munkaoptimális, ha van olyan k érték, hogy a párhuzamos algoritmus munkája nagyságrendileg nem nagyobb, mint a soros algoritmus munkájának (logkn) -szerese. Egy párhuzamos algoritmus csak akkor munkahatékony, ha a gyorsítása legalább lineáris. Egy munkahatékony párhuzamos algoritmus hatékonysága Θ(1). Ha egy algoritmus egy feladat megoldásához adott erőforrásból csak O(N(n)) mennyiséget használ fel, akkor az algoritmust az adott erőforrásra, számítási modellre (és processzorszámra) nézve aszimptotikusan optimálisnak nevezzük. Ha egy A(P) algoritmus egy feladat megoldásához adott erőforrásból a bemenet minden lehetséges n1 mérete esetében csak az okvetlenül szükséges N(n,A) – illetve (N(n,p,A)) – mennyiséget használja fel, azaz W(n,A)=N(n,A),(1.28) illetve W(n,p,P)=N(n,p,P),(1.29) akkor az algoritmust az adott erőforrásra (és az adott számítási modellre) nézve abszolút optimálisnak nevezzük és azt mondjuk, hogy a vizsgált feladat pontos bonyolultsága N(n)(N(n,p)). Két algoritmus összehasonlításakor a W(n,A)=Θ(W(n,B))(1.30) esetben azt mondjuk, hogy a A és B algoritmus futási idejének növekedési sebessége aszimptotikusan azonos nagyságrendű. Amikor két algoritmus futási idejét (például a legrosszabb esetben) összehasonlítjuk, akkor gyakran találunk olyan helyeket, melyeknél kisebb méretű bemenetekre az egyik, míg nagyobb méretű bemenetekre a másik algoritmus futási ideje kedvezőbb. A formális definíció a következő: ha a pozitív egész helyeken értelmezett f(n) és g(n) függvényekre, valamint a v0 pozitív egész számra teljesül, hogy 1. f(v)=g(v); 2. (f(v1)g(v1))(f(v+1)g(v+1))<0, akkor a v számot az f(n) és g(n) függvények váltási helyének nevezzük. Például két mátrix szorzatának a definíció alapján történő és a Strassenalgoritmussal történő kiszámítását összehasonlítva (lásd például Cormen, Leiserson, Rivest és Stein többször idézett új könyvét) azt kapjuk, hogy kis mátrixok esetén a hagyományos módszer, míg nagy mátrixok esetén a Strassen-algoritmus az előnyösebb – egy váltási hely van, melynek értéke körülbelül 20. Az idő mellett algoritmusok számos más erőforrást is használnak – például memóriát, üzeneteket. Utóbbira például W üzenet (n,p, P ) módon hivatkozhatunk. 1.3. Pszeudokód Az algoritmusok formális leírására a következő, a Pascal és a C++ nyelvek elemeiből összeállított pszeudokódot használjuk. 1. Az algoritmus blokkszerkezetét elsősorban a tagolás tükrözi. Ezt a megoldást a programozási nyelvekben is használják – bár a használat szabályai nyelvenként változnak. A pszeudokódot lényegesen egyszerűsíti és áttekinthetőbbé teszi – értelmezése tapasztalataink szerint nem okoz gondot. 2. A változók neve betűvel kezdődik. A változók típusát külön nem deklaráljuk, mert az a környezetből látszik. Egyszerű adattípusok (mint egész, lebegőpontos, karakter, logikai stb.) fognak szerepelni. 3. A változók értékadó utasításokkal kapnak értéket: változónév kifejezés 4. Két logikai érték van, az IGAZ és a HAMIS. Ezek a logikai értékek az és (),vagy () és a nem (¬) logikai operátorokkal, valamint a <,,=, és > relációs operátorokkal állíthatók elő. 5. A többdimenziós tömbök elemei szögletes zárójelek közé tett indexekkel érhetők el, például A[i,j]. Az indexek nullától kezdődnek. A tömb egy részére az indextartomány megadásával hivatkozhatunk: például A[3..n].6. A következő két ciklusszervező utasítást alkalmazzuk: while és for. A while ciklus alakja a következő: Amíg a feltétel IGAZ, az u (u1) utasítás végrehajtódik. Amikor a feltétel HAMIS lesz, kilépünk a ciklusból. A for ciklus alakja a következő: Ha például a ciklusváltozó i , a kezdőérték k és a befejező érték b, akkor az u utasítás egymás után végrehajtódik az i=k,k+1,...,b értékekre. 7. A feltételes utasítás lehetséges alakjai: vagy 8. A bevitel/kivitel a read és write utasításokkal történik. Pontos formájuk számítási modellenként változó. 9. Egyetlen eljárás van, amely fejből és törzsből áll. A fej Az eljárás típusa lehet soros eljárás,soros rekurzív eljárás,párhuzamos eljárás és párhuzamos rekurzív eljárás. Az eljárások törzse sorszámozott utasításokból áll. Az utolsó utasítást kivéve az egyes utasítások végét a következő sorszám, a törzs végét a tagolás jelzi. Ezek a számozott utasítások gyakran az algoritmus nagy (több lépésből álló) részét tükrözik. Ilyenkor az elemzésben ezeket a részeket szakasznak vagy fázisnak nevezzük. Más esetekben több számozott lépést együtt nevezünk az algoritmus szakaszának vagy fázisának. 10. Az eljárások hívásának alakja: ELJARAS NEVE (paraméterek listája) A soros és a párhuzamos eljárások esetén egyaránt ezt a hívó utasítást használjuk. 11. A megjegyzések a jellel kezdődnek és az adott sor végéig tartanak. 12. A párhuzamosságot egy p processzoros PRAM vagy lánc esetében a következőképpen írjuk le: Egy m1×m2×...×mk méretű, k dimenziós rács esetében a hasonló utasítás a Pi1,i2,...,ik in parallel for i11 to m1,...,ik1 to mk sorral kezdődik. 1.4. Számítási modellek Az algoritmusokat absztrakt vagy konkrét gépeken hajthatjuk végre. Ebben az alfejezetben először röviden bemutatjuk a párhuzamos számítógépek főbb típusait, azután az absztrakt gépek közül a párhuzamos közvetlen hozzáférésű gépekkel és a hálózatokkal foglalkozunk. 1.4.1. Számítógépek Az elmúlt évtizedekben sok különböző párhuzamos számítógépet építettek, és számos próbálkozás történt rendszerezésükre. Flynn 1972-ben az utasításáram és az adatáram alapján 4 csoportot különböztetett meg: 1. SISD ( Simple Instruction Stream – Simple Data Stream); SISD 2. SIMD ( Simple Instruction Stream – Multiple Data Stream); 3. MISD ( Multiple Instruction Strem – Single Data Stream); 4. MIMD ( Multiple Instruction Stream – Multiple D ata Stream). Eszerint a SISD a klasszikus soros, Neumann-elvű számítógép. A SIMD típusú számítógépben lépésenként egyféle művelet hajtódik végre, de az egyszerre több adaton. Az ILLIAC-IV számítógép példa erre a típusra. A MISD típusú gépben egy adaton egyszerre többféle művelet hajtódik végre. A csővezeték-elvű számítógépek példák erre a típusra. A legtöbb párhuzamos számítógép a MIMD típushoz tartozik: ebben az esetben több processzor dolgozik párhuzamosan, és rendszerint különböző adatokkal. 1.4.2. Párhuzamos gépek A párhuzamos számítási modellek alapja a soros számításokhoz széles körben használt RAM ( Random Access Machine = közvetlen hozzáférésű gép ) általánosítása, a PRAM ( Parallel Random Access Machine = párhuzamos közvetlen hozzáférésű gép. ) A PRAM modell tartalmaz p szinkronizáltan dolgozó processzort (P1,P2,...,Pp) és az M[1],M[2],...,M[m] rekeszekből álló közös memóriát, ahogy azt az 1.2. ábra mutatja (az ábrán a memóriarekeszeknek csak az indexét tüntettük fel). A modell szerint minden processzor rendelkezik saját memóriával: a Pi processzor esetében ez az M[i,1],M[i,2],...,M[i,m] rekeszekből áll. Nem jelent megszorítást, hogy a közös memória és a saját memóriák méretét ugyanúgy jelöltük (szokás ezeket a memóriákat végtelen méretűnek is tekinteni). Feltesszük, hogy a rekeszek tetszőleges egész szám tárolására alkalmasak. 1.2. ábra. Párhuzamos közvetlen hozzáférésű gép (PRAM). A párhuzamos közvetlen hozzáférésű gép helyett rendszerint a rövidebb párhuzamos gép kifejezést fogjuk használni. Típusok írás/olvasás alapján: 1. EREW ( Exclusive Read – Exclusive Write: kizárólagos olvasás – kizárólagos írás) 2. ERCW ( Exclusive Read – Concurrent Write) 3. CREW ( Concurrent Read – Exclusive Write) 4. CRCW ( Concurrent Read – Concurrent Write) Ugyanabba a memóriarekeszbe egyidejűleg csak írás vagy olvasás van megengedve. A 1.3. ábra (a) része arra példa, hogy minden rekeszből legfeljebb egy processzor olvas (ER), a (b) részében minden rekeszbe legfeljebb egy processzor ír (EW), a (c) részében több processzor olvas párhuzamosan (CR), végül a (d) részében több processzor ír egyidejűleg ugyanabba a rekeszbe (CW). 1.3. ábra. Számítási modellek típusa az írás és olvasás tulajdonságai alapján. Ha több processzor írhat egyidejűleg (ERCW vagy CRCW), akkor több eset van: az írás közös: a processzorok csak a közös, azonos értéket írhatják; tetszőleges: nem tudjuk, melyik processzor beírása marad meg a rekeszben, vagy esetleg a beírásoktól független érték; prioritásos: a legnagyobb prioritású processzor ír; kombinált: az egyes processzorok által beírt értékek valamilyen függvénye kerül a memóriarekeszbe. A következő példákban a párhuzamos olvasást, párhuzamos írást, illetve egy logikai érték párhuzamos kiszámítását mutatjuk be. Először egy 4 processzoros gépben minden processzor a közös M[1] rekeszből olvas. Ebben az esetben mind a 4 processzor saját memóriájának első rekeszébe bekerül az M[1] tömbelem. A következő példában egy 16 processzoros gépben minden processzor a közös M[1] rekeszbe ír. Ebben az esetben a 16 processzor párhuzamosan beírja az A[1] tömbelembe saját memóriája első rekeszének tartalmát. Legyen az A[1:16] tömb A[1],...,A[n] elemeiben tárolt n bit logikai összege (diszjunkciója) A[0]=A[1]A[2]A[n]. Ekkor a következő ERCW algoritmus O(1) időben dolgozik. 1.1. példa. Logikai összeg kiszámítása n processzoron. 1.1. tétel (logikai összeadás művelet elvégzése). A LOGIKAI-ÖSSZEAD algoritmus az n bites műveletet egy ERCW PRAM -en O(1) lépés alatt elvégzi. Most a párhuzamos gépek néhány mennyiségi tulajdonságát mutatjuk be. Feltesszük, hogy egy p processzoros gép bármely lépése szimulálható egy soros processzor p lépésével (vannak olyan valódi gépek, amelyekre ez a feltétel nem teljesül). Ebből adódik a következő állítás. 1.2. tétel (Brent tétele). Ha egy feladatot a P párhuzamos algoritmus p processzoron t lépésben old meg, eközben az i-edik (i=1,2,...,t) lépésben xi műveletet végez, akkor ez a feladat q<p processzoron megoldható t+xq(1.31) lépésben, ahol x=i=1txi.(1.32) Ebből a tételből adódik a következő egyszerű állítás. 1.3. következmény (lassulás). Ha a P párhuzamos algoritmus egy p processzoros gépen t lépést tesz, akkor P minden q<p processzort tartalmazó gépen végrehajtható O(pt/q) lépésben. Bizonyítás. A p processzoros G gépen futó P párhuzamos algoritmus minden lépése szimulálható egy q processzoros H gépen, legfeljebb p/q lépést végezve. Ezért a H szimulációs futási ideje legfeljebb tp/q, és így H munkája legfeljebb qtpqpt+qt(1.33)=O(ptq)(1.34) lesz. A következő 3 állítás az elérhető gyorsítás mértékével kapcsolatos. 1.4. tétel (Amdahl törvénye a maximális gyorsításról). Ha egy π feladat megoldásának nem párhuzamosítható hányada s(π), akkor egy p processzoros PRAM -on elérhető gmax(π,s,p) legnagyobb gyorsítás gmax(π,s,p)=1s+1sp.(1.35) 1.5. tétel (Gustafson törvénye a maximális gyorsításról). Ha egy π feladat megoldásának nem párhuzamosítható hányada s, akkor egy p processzoros PRAM -on elérhető gmax(π,s,p) legnagyobb gyorsítás gmax(π,s,p)=s+p(1s)s+(1s)=s+p(1s).(1.36) Amdahl és Gustafson tételének bizonyítását meghagyjuk feladatnak. Amdahl szerint s reciproka korlátot szab az elérhető gyorsításnak, míg Gustafson szerint a gyorsítás a processzorszámmal arányosan növelhető. 1.6. tétel (van-e p -nél nagyobb gyorsítás). A p processzorszámnál nagyobb gyorsítás nem érhető el. Bizonyítás. Tegyük fel, hogy egy π problémára W(n,A) a legjobb ismert soros végrehajtási idő. Ha van olyan P párhuzamos algoritmus, melynek gyorsítása p -nél nagyobb, akkor pW(n,P,p)<W(n,A). Mivel egy p processzoros gép egy lépésének szimulálása az 1 processzoros gépen legfeljebb p lépést igényel, ezért P munkája sorosan szimulálható legfeljebb pW(n,P,p) idő alatt, ami feltételünk szerint kisebb, mint W(n,A). Ez ellentmond annak, hogy A a π megoldására ismert legjobb soros algoritmus. 1.4.3. Hálózatok A számítási modellek másik típusát a hálózatok adják. Ezekben a processzorok nem a közös memórián keresztül érintkeznek, hanem adatátviteli vonalakon keresztül, amelyek jól szemléltethetők gráfok segítségével. A processzor és a csúcs szavakat szinonimaként használjuk – általában a szövegkörnyezethez jobban illeszkedőt választva. Ez a tény egyúttal ad egy jó szempontot a hálózatok osztályozására: síkba rajzolható és síkba nem rajzolható hálózatokat különböztetünk meg. A gráfelmélet ismert eredménye, hogy minden véges gráf ábrázolható a 3dimenziós euklideszi térben. Ezt beláthatjuk például úgy, hogy a G=(V,E) véges gráf Vi(i=1,2,...,|V|) csúcsát az x - y sík (i,0) pontjába rajzoljuk, majd a síkot az x -tengely körül rendre elforgatjuk 360j/|V|(j=1,2,...,|V|1)(1.37) fokkal. Az így kapott Sj(j=1,2,...,|V|1) síkokban rendre a Vj csúcsot a nála nagyobb indexű csúcsokkal összekötő éleket rajzoljuk meg. A rövidség kedvéért a síkba rajzolható gráfokat síkgráfoknak, a síkba nem rajzolható gráfokat pedig térgráfoknak fogjuk nevezni. Ennek megfelelően beszélhetünk síkhálózatról és térhálózatról. A legismertebb hálózatok közül a síkhálózatokhoz tartozik például a csillag, fa, lánc, gyűrű, négyzet és a henger. A p processzoros csillagban kitüntetett szerepe van a P1 processzornak: ez van minden további processzorral összekötve. Az 1.4. ábra egy 9 processzoros csillagot ábrázol. 1.4. ábra. 9 processzoros csillag. Egy d szintes (teljes) bináris fában p=2d1 processzor van: P1,P2,...,Pp. Az adatszerkezetekkel kapcsolatos terminológia szerint a P1 processzort gyökérnek, a P(p1)/2,P(p1)/2+1,...,Ppprocesszorokat levélnek, a többi processzort belső processzornak nevezzük. Ha Pi nem levél, akkor össze van kötve a gyerekeinek nevezett P2i és P2i+1 processzorokkal. Ha Pj nem a gyökér, akkor össze van kötve a szülőjének nevezett Pj/2 processzorral. A negyedik fejezetben lévő 4.8. ábra egy háromszintes bináris fa hálózatot ábrázol. Hasonlóképpen lehetne m -áris fákat és nem teljes fákat is definiálni. A p processzoros gyűrűs hálózatot a negyedik fejezetben ismertetjük. A 4.4. ábra egy 6 processzoros gyűrűt mutat. A térhálózatok közül megemlítjük a k -dimenziós rácsot, kockát, tóruszt, piramist, pillangót, permutációs hálózatot, de Bruijn-hálózatot és a hiperkockát. A k dimenziós (k1) rács egy olyan m1×m2××mk(m1,m2,...,mk2) méretű háló, amelynek minden egyes metszéspontjában van egy processzor. Az élek a kommunikációs vonalak, melyek kétirányúak. A rács minden processzorát megcímkézzük egy (i1,i2,...,ik)k assal – erre a processzorra a Pi1,...,ik jelöléssel hivatkozunk. Minden processzor egy RAM, amely rendelkezik saját (helyi) memóriával. A Pi1,...,ik processzor saját memóriája az M[i1,...,ik,1] , M[i1,...,ik,2],...,M[i1,...,ik,m] rekeszekből áll. Minden processzor végre tud hajtani egyetlen lépésben olyan alapvető műveleteket, mint az összeadás, kivonás, szorzás, összehasonlítás, saját memória elérése és így tovább. A processzorok működése szinkron módon történik, azaz minden processzor egy globális óra ütemére egyszerre hajtja végre az aktuális feladatát. A legegyszerűbb rács a k=1 értékhez tartozó lánc (lánc alakú rács). Egy 6 processzoros lánc látható a harmadik fejezetben lévő 3.1. ábrán. Ha egy lánc P1 és Pp processzorát összekötjük, akkor gyűrűt kapunk. Ha k=2 , akkor téglalapot (téglalap alakú rácsot) kapunk. Ha most m1=m2=2p, akkor a×a méretű négyzetet kapunk. Egy 4×4 méretű négyzet látható a harmadik fejezetben lévő 3.2. ábrán. A lánc és a négyzet a síkhálózatokhoz tartoznak. Ha k=3 és m1=m2=m3, akkor téglát kapunk. Ha ennek a hálózatnak a 3 mérete azonos, akkor kockának nevezzük. A 3.3. ábra egy 2×2×2 méretű kockát ábrázol. Ha egy rácsot további élekkel kiegészítünk, akkor összetett rácsot kapunk. Ha egy láncban a P1 és Pp processzorokat összekötjük, akkor gyűrűt kapunk, amely már csak két dimenzióban ábrázolható A negyedik fejezetben lévő 4.4. ábra egy 6 processzoros láncot ábrázol. Ha egy téglalapban a sorok első (j=1) és utolsó (j=m2) elemeit összekötjük, akkor az ugyancsak 2-dimenziós hengert kapjuk. Az 1.5. ábra egy 4×4 méretű hengert ábrázol. 1.5. ábra.4×4 méretű henger. Az ILLIAC-IV megépült változata olyan 2-dimenziós rácsból származtatható, amelyben m1=m2=8 és a Pi,j processzor szomszédai rendre a Pi,j1,Pi,j+1Pi+1,j,Pi1,j, ahol az indexek (mod 8) értendők. Az ILLIAC-IV architektúrájának ábrázolásához már három dimenzióra van szükség. A tórusz például úgy származtatható egy kétdimenziós rácsból, hogy a belső élek mellett az egyes sorok első és utolsó processzorait, valamint az egyes oszlopok első és utolsó oszlopait is összekötjük. A negyedik fejezetben lévő 4.6. ábra egy 5×5 méretű tóruszt mutat. Egy d szintes piramis i -edik (1id) szintjén 4di1 processzor van, amelyek az 1.6. ábra szerint vannak összekötve. Eszerint a piramis i -edik szintje egy 2di×2di méretű rács. A piramis az egyes szinteken lévő processzorok számát tekintve hasonló a ternáris fához, azonban a fa azonos szinten lévő processzorai között nincs kapcsolat. 1.6. ábra. Háromszintes piramis. A d dimenziós pillangó hálózat (d+1)2d processzorból áll, amelyek d+1 – egyenként 2d processzort tartalmazó – sorban vannak elrendezve, ahogy azt a negyedik fejezetben lévő 4.2. ábra mutatja. A (d+1)×2d méretű pillangó kifejezést is használni fogjuk. Természetes architektúra a teljes hálózat, amelyben minden processzor pár össze van kötve. Egy teljes hálózatot ábrázol az 1.7. ábra. 1.7. ábra. 8 processzoros teljes hálózat. A (d,k) -paraméterű de Bruijn-hálózat dk processzort tartalmaz, amelyek a d betűs {0,1,...,d1} ábécé feletti k hosszúságú szavakkal címezhetők. Az a1a2...ak nevű processzorból az a2a3...akq című processzorokba vezet irányított él – ahol q az ábécé tetszőleges eleme. Eszerint minden processzorból d él indul, és minden processzorban d él végződik. Az 1.8. ábra egy (2,3)-paraméterű de Bruijn-hálózatot mutat. Az ábra alapján ez kétdimenziós. 1.8. ábra.2×3 paraméterű de Bruijn-hálózat. A d dimenziós permutációs hálózatban a processzorok a d -betűs {0,1,...,d1} ábécé elemeinek különböző permutációival címezhetők. Ezért a hálózatban p=d! processzor van. A Pi processzor pontosan azokkal a processzorokkal van összekötve, amelyek címkéje előállítható úgy, hogy Pi címkéjében az első betűt a j -edik (2jd) betűvel cseréljük ki. A 1.9. ábra egy 4 paraméterű permutációs hálózatot ábrázol. Ebben minden processzor fokszáma d1=3 és a processzorok száma 4! = 24. 1.9. ábra. 24 processzoros permutációs hálózat. A d dimenziós hiperkockában2d processzor van, amelyek d hosszúságú bináris sorozatokkal címezhetők. Minden Pi processzor pontosan azokkal a processzorokkal van összekötve, amelyek címe pontosan egy bitben tér el Pi címétől. A 3-dimenziós hiperkockában a 0,1,0 csúcs szomszédjai az 1,1,0, 0,0,0 és a 0,1,1 című csúcsok. Mivel a 2×2×2 méretű kocka egyúttal 3-dimenziós hiperkocka is, a negyedik fejezetben lévő 3.3. ábra egyúttal egy 3-dimenziós hiperkockát is bemutat. Az ugyancsak a negyedik fejezetben lévő 4.1. ábra pedig egy 4-dimenziós hiperkockát mutat. A d -dimenziós rácsok, permutációs hálózatok és hiperkockák természetes módon elképzelhetők és ábrázolhatók d dimenzióban. A korábban említett tétel szerint ugyanakkor tetszőlegesen nagy d esetében is ábrázolhatók a 3-dimenziós euklideszi térben úgy, hogy az élek ne metsszék egymást. A hálózatok jellemzésére sokféle adatot használnak. Ha a H hálózatot H=(V,E) formában, a csúcsok és élek halmazával adjuk meg, akkor természetes adat a processzorok száma(|V|) és az adatátviteli vonalak száma(|E|). Az adatátviteli vonalak lehetnek egyirányúak és kétirányúak. Az eddigi példák közül csak a de Bruijn-hálózat tartalmazott egyirányú éleket (ezért a hálózatot irányított gráffal ábrázoljuk), míg a többi esetben kétirányú éleket tételeztünk fel. További jellemző a csúcsok maximális, minimális és átlagos fokszáma, a csúcsok maximális, minimális és átlagos távolsága. A csúcsok maximális távolságát a hálózat átmérőjének nevezik. Ha egy H=(V,E) összefüggő hálózat csúcsait X és Y halmazra osztjuk, akkor a hálózat adott felbontáshoz tartozó vágási száma a legkisebb olyan élhalmaz elemszáma, amelynek eltávolításával a hálózat elveszti Hálózat Paraméter Csúcsszám Élszám Átmérő Lánc ppp1p1Gyűrű pppp2Csillag ppp12 Fa d2d12d22d2Négyzet a=2pa22d(d1)2d2Kocka a=32pa33(a1)a23a3Piramis d4d+1132d2d2Permutációs dd22dd(d1)!2De Bruijn d2d2d+1dHiperkocka d2dd2d1dTeljes ppp(p1)/21 1.10. ábra. Hálózatok mennyiségi jellemzői. összefüggőségét. Hálózatok felezési száma azon élek minimális száma, amelyek eltávolításával a hálózat két azonos részre bontható. Ha egy hálózat processzorainak száma páros (p=2k), akkor a hálózat biztosan felbontható két azonos részre (például két, egyenként k izolált csúcsot tartalmazó hálózatra). Ha p=2k+1, akkor a hálózat nem bontható két azonos részre. Ha 2p páros, akkor egy 2p×2p méretű rács vágási száma 2p. Az 1.10. táblázat az ismertetett hálózatok néhány alapvető adatát tartalmazza. A táblázat Paraméter oszlopában p a processzorszámot jelöli. d a fa és a piramis esetében a szintek számát, permutációs hálózat, de Bruijn hálózat és hiperkocka esetében a dimenziót jelöli. Négyzet és kocka esetében az oldalhosszúság a paraméter. 1.5. Rekurzió Az algoritmusok megadásának gyakran alkalmazott módja az, hogy a végrehajtás során – változó paraméterekkel – újra és újra alkalmazzuk magát az algoritmust. Egy algoritmusnak önmaga segítségével való megadását rekurziónak az így megadott algoritmust pedig rekurzív algoritmusnak nevezzük. Példaként oldjunk meg egy népszerű, 1883-ból származó, Hanoi híres tornyairól szóló feladatot, melyben korongok és 3 rúd szerepel. Brahma tornya 64 – közepén lyukas – arany korongból áll, melyet Brahma egy gyémánt rúdra tett. A korongok mérete alulról felfelé csökken. Az 1.11. ábra a kiinduló helyzetet mutatja 5 koronggal, melyek az A rúdon vannak. A B és C rudakon kezdetben nincs korong. 1.11. ábra. Hanoi tornyai 3 rúddal és 5 koronggal. A Világ teremtésével egyidejűleg Brahma megbízott szerzeteseket azzal, hogy az egyik rúdon lévő korongokat helyezzék át egy másik rúdra – egy harmadik rúd felhasználásával. A szerzetesek munkájának egy lépése egy korong áthelyezése egyik rúdról egy másik rúdra – azzal a megszorítással, hogy korongot csak üres rúdra vagy nála nagyobb korongra szabad helyezni. A történet szerint amikor a szerzetesek végeznek a munkával, a torony összeomlik és vége a világnak. Mennyi időnk van hátra, ha a szerzetesek a lehető legkevesebb lépésben elvégzik a munkát – és egy lépés egy másodpercig tart. Jelöljük fK(n) -nel az n korong áthelyezéséhez szükséges lépések számát egy K korong-áthelyező algoritmus esetében. Minden K algoritmusra igaz, hogy fK(1)1.(1.38)n korongot csak úgy tudunk áthelyezni, hogy előbb a felső n1 korongot áthelyezzük egy másik rúdra, ezután a legalsó korongot áthelyezzük, és végül az n1 kisebb korongot ráhelyezzük a legnagyobb korongra. Eszerint minden K algoritmusra fK(n)2fK(n1)+1.(1.39) Az ehhez hasonló egyenleteket – amelyekben egy függvény adott helyen felvett értékét más helyen vagy helyeken felvett értékei segítségével adjuk meg – rekurzív egyenletnek nevezzük. Tegyük fel, hogy a szerzetesek a következő rekurzív program szerint dolgoznak, melyben az ÁTHELYEZ( k , végez ) eljárás feladata az, hogy a k nevű rúdon lévő legfelső korongot áthelyezze a végez nevű rúdra. Eszerint a szerzetesek először – fSz(1) lépés alatt – átrakják a legkisebb korongot a B rúdra, majd – fSz(2)=2fSz(1)+1=3 lépés alatt – átrakják a két legkisebb korongot a C rúdra, majd – fSz(3)=2fSz(2)+1 lépés alatt – átrakják a három legkisebb korongot a B rúdra és így tovább. Ebből következik, hogy fSz(n)=2fSz(n1).(1.40) Mivel a szerzetesek minden részfeladatot a lehető legkevesebb lépésben megoldanak, algoritmusuk optimális. Módszerük futási idejét egyszerűen f(n) -nel jelölve a következő kezdeti feltételt és rekurzív egyenletet kapjuk: f(1)=1(1.41) és ha n2, akkor f(n)=2f(n1)+1.(1.42) Függvényeknek kezdeti feltétel (vagy feltételek) és rekurzív egyenlet segítségével történő megadását rekurziónak nevezzük. Eszerint a rekurzió szót kétféle – egymással összefüggő – jelentéssel használjuk. Megjegyezzük, hogy bizonyos esetekben a kezdeti feltételt nem akarjuk vagy tudjuk megadni – ilyenkor a rekurzív egyenlet rendszereint csak a megfelelő függvény nagyságrendjét határozza meg. Teljes indukcióval és a rekurziótétellel (lásd például Halmos könyvét) bebizonyíthatjuk, hogy ennek a rekurzív egyenletnek a megoldása az f(n)=2n1(1.43) függvény. Eszerint a világ élettartama Tehát a korongok átrakása a szerzeteseknek körülbelül ötszáz milliárd évig tart. Eszerint még akkor is sok időnk lenne hátra a világ végéig, ha a szerzetesek 4,6 milliárd évvel ezelőtt (amikor a geológusok szerint a Föld és a világegyetem az ősrobbanással létrejött) kezdték volna el a korongok átrakását. Ez a példa több szempontból nagyon érdekes. Mutatja, hogy – legalábbis bizonyos esetekben – elemi eszközökkel meg tudjuk határozni a rekurzív algoritmusok futási idejét. Tegyük fel, hogy sok szerzetes dolgozik a korongok átrakásán, és s szerzetes már 1/s másodperc alatt átrak egy korongot, vagy pedig a lépéseket egyenletesen fel tudják egymás között osztani. Ekkor az algoritmus futási ideje az f(n,s)=2n1s(1.49) értékre csökken. Ezzel elvben tetszőleges kicsire csökkenthető az átrakási idő. De hogyan tud a sok szerzetes hozzáférni a korongokhoz? A kérdés rávilágít arra, hogy egy feladat részfeladatokra bontásának lehetőségeit gyakran korlátozzák a feladat sajátosságai. Ha például megengedjük, hogy a szerzetesek felemeljék a felső n1 korongot és a legalsót körcikkekre vágva áthelyezzék, akkor megfelelő számú szerzetes esetében lineáris (vagy akár konstans) futási idejű algoritmust kaphatunk. Ezzel a megközelítéssel a könyvben nem foglalkozunk: a párhuzamos processzorok csak olyan műveleteket végezhetnek, amelyet a soros is végre tud hajtani. Másik kérdés, mit érünk azzal, ha a gyakorlatilag végtelen futási időt például század vagy ezred részére csökkentjük? Ez a kérdés pedig arra világít rá, hogy a sokprocesszoros rendszerek és párhuzamos algoritmusok lehetőségei is korlátozottak. A feladat megoldása azt is mutatja, hogy ha csak a futási időre van szükségünk, az (1.43) képletet levezetve és alkalmazva nagyon gyorsan meg tudjuk mondani. 1.6. Véletlenített algoritmusok (*) A véletlenített algoritmusok bizonyos helyzetekben több döntés közül választanak – ezek valószínűsége pontosan adott. Két típusuk van. A Las Vegas algoritmusok mindig helyes eredményt adnak – futási idejük azonban nem állandó, hanem egy valószínűségi változóval jellemezhető. A Monte Carlo algoritmusok adhatnak hibás eredményt is. A Las Vegas algoritmusok futási ideje tág határok között változhat, míg a Monte Carlo algoritmusoké viszonylag állandó. A véletlenített algoritmusokat tekinthetjük algoritmushalmaznak. Adott bemenet esetében bizonyos algoritmusok futhatnak sokáig vagy adhatnak hibás választ. A tervezés célja, hogy az ilyen rossz algoritmusok algoritmusok hányada kicsi legyen. Ha meg tudjuk mutatni, hogy bármilyen bemenetre az algoritmusoknak legalább 1ε hányada (ahol a pozitív ε elég kicsi) gyors (illetve helyes eredményt ad), akkor a halmazból véletlenül választott algoritmusra igaz, hogy legalább 1ε valószínűséggel gyors (helyes eredményt ad). Ekkor ε -t hibavalószínűségnek nevezzük. Az alábbi definíciókban a d,v és g függvények a pozitív egészek halmazán vannak értelmezve, a d(n),v(n) és g(n) függvényértékek pedig nemnegatív valós számok. Egy D determinisztikus algoritmusnak adott erőforrásból d(n) egységre van szüksége, míg a V véletlenített algoritmusnak v(n) egységre – ahol v(n) valószínűségi változó. Egy n -től függő ε esemény nagy valószínűséggel bekövetkezik, ha tetszőleges α értékre a bekövetkezés valószínűsége legalább 1nα. Az α számot valószínűségi paraméternek nevezzük. O¯(g(n)) (ejtsd: nagy valószínűséggel nagy ordó ) azon v(n) függvények halmazát jelenti, amelyekhez létezik olyan c pozitív állandó, hogy tetszőleges α esetében nagy valószínűséggel teljesül P[v(n)cαg(n)]11nα.(1.50) 1.6.1. Egyenlőtlenségek Ebben a részben olyan egyenlőtlenségeket adunk meg, amelyek azt jellemzik, hogy a valószínűségi változók ritkán térnek el lényegesen a várható értéküktől. Ezek az egyenlőtlenségek majd hasznosak lesznek a véletlenített algoritmusok várható viselkedésének elemzése során. 1.7. lemma( Markov-egyenlőtlenség). Ha X nemnegatív valószínűségi változó, melynek várható értéke μ, akkor P[Xx]μx.(1.51) A Bernoulli-kísérletnek 2 lehetséges eredménye van: p valószínűséggel sikeres, 1p valószínűséggel sikertelen a kísérlet. Ha X jelöli azt, hogy n kísérletből hány sikeres, akkor X eloszlása binomiális: 1.8. lemma(Csernov-egyenlőtlenségek). Ha X(n,p) paraméterű binomiális eloszlású valószínűségi változó és m>np egész szám, akkor P[Xm](npm)memnp.(1.53) Továbbá minden 0<ε<1 számra P[X(1ε)pn]eε2np/2(1.54) és P[X(1+ε)np]eε2np/3.(1.55) 1.6.2. Példák Ebben a pontban két példát mutatunk véletlenített algoritmusra. 1.2. példa.Ismétlődő tömbelem meghatározása. Tegyük fel, hogy n páros, az A[1:n] tömb elemei között az 1,2,...,n/2+1 számok egyike (n/2) -ször fordul elő, a többi szám pedig egyszer. Határozzuk meg a többször előforduló elemet. Bármely determinisztikus algoritmusnak legrosszabb esetben legalább n/2+2 lépésre van szüksége. Ugyanis bármely determinisztikus algoritmushoz megadható úgy a bemenet, hogy az első n/2+1 vizsgált elem különböző legyen. Most megadunk egy Las Vegas algoritmust, amely legrosszabb esetben O¯(logn) ideig fut. Az algoritmus bemenete egy n szám és egy n-elemű A tömb, kimenete az egyik ismételt elem indexe. Ebben az algoritmusban felhasználjuk a VÉLETLEN (n) eljárást, amely minden hívásakor a [1:n] intervallumból vett egyenletes eloszlású, véletlen egész számot ad kimenetként. Most megmutatjuk, hogy az algoritmus futási ideje O¯(logn). A while ciklus bármely végrehajtása sikeres, ha i az n/2 azonos elem valamelyikének indexe és j egy tőle különböző helyen lévő azonos elem indexe. Ennek az eseménynek a P valószínűsége P=n2(n21)n2,(1.56) ami n>10 esetében kisebb, mint 1/5. Tehát annak valószínűsége, hogy az algoritmus egy adott lépésben nem fejeződik be, (1/5)-nél kisebb. Ezért annak valószínűsége, hogy az algoritmus 10 lépés alatt nem fejeződik be, (4/5)10-nél kisebb, ami kisebb 0.1074-nél. Ezért az algoritmus 10 lépés alatt legalább 0.8926 valószínűséggel befejeződik. Annak valószínűsége, hogy 100 lépés alatt sem fejeződik be, kisebb (4/5)100-nál, ami pedig kisebb 2.04*1010nél. Általában annak az ε eseménynek a valószínűsége, hogy az algoritmus az első cαlogn (ahol a c konstans rögzített érték) lépésben nem fejeződik be, P[ε]<(45)cαlogn,(1.57) és ha c1log54, akkor (45)cαlogn<nα.(1.58) Tehát az algoritmus legalább 1nα valószínűséggel befejeződik legfeljebb αlognlog54(1.59) lépésben. Mivel minden iteráció O(1) ideig tart, ezért az algoritmus futási ideje valóban O¯(logn). Mivel algoritmusunk mindig helyes eredményt ad, ezért Las Vegas típusú. Megmutattuk, hogy nagy valószínűséggel gyorsan befejeződik. Ha például kétmillió elemünk van, akkor bármely D determinisztikus algoritmushoz megadhatunk olyan bemenetet, amelyre D legalább egymillió lépést végez, Az ISMÉTELLT-ELEM algoritmusnak viszont bármely bemenetre – nagy valószínűséggel – legfeljebb száz lépésre van szüksége. Ugyanakkor az ISMÉTELT-ELEM algoritmus – igaz, csak kis valószínűséggel – egymilliónál lényegesen több lépést is végezhet. Az adott problémát másképp is megoldhatjuk: először rendezünk, azután lineárisan keresünk – ekkor Ω(n) időre van szükség. Vagy hármas csoportokra osztjuk a tömböt – ekkor Θ(n) a futási idő. 1.3. példa.Pénzérme ismételt feldobása. Dobjunk fel egy szabályos pénzérmét ezerszer. Mekkora annak valószínűsége, hogy legalább hatszázszor fejet dobunk? A Markov-egyenlőtlenség szerint legfeljebb 5/6. Az (1.55) képletet, azaz a harmadik Csernov-egyenlőtlenséget is alkalmazhatjuk az n=1000,p=1/2,ε=0.2 értékekkel. Eszerint P[X600]e(0,2)2(500/3)(1.60)=e20/3(1.61)0.001273.(1.62) Meghagyjuk gyakorlatnak az ennél pontosabb becslést. 1.7. Alsó korlátok Az algoritmusok elemzése során számos korábbi tankönyv szerzői (a múlt század hetvenes és a nyolcvanas éveiben) megelégedtek azzal, hogy többé-kevésbé pontos felső korlátokat adtak az adott algoritmus által igényelt erőforrások legnagyobb és átlagos mennyiségére. Ezeknek a becsléseknek a pontossága azonban gyakran homályban maradt. Pedig e nélkül megválaszolatlan marad az a fontos kérdés, hogy érdemes-e jobb algoritmust keresni. Különösen fontos az erőforrásigény pontos ismerete a párhuzamos algoritmusok vizsgálata során, hiszen e nélkül nem tudjuk eldönteni, hogy adott párhuzamos algoritmus munkahatékony-e, munkaoptimális-e. A munkahatékonyság és munkaoptimalitás bizonyításához a párhuzamos algoritmus igényét felülről, a feladat jellegéből fakadó igényt pedig alulról kell becsülnünk. A munkahatékonyság cáfolásához pedig elég egy jó soros algoritmus igényének felülről, a párhuzamos algoritmus igényének pedig alulról való becslése. Ebben az alfejezetben olyan módszereket mutatunk be, melyek segítségével alsó korlátokat bizonyíthatunk. Ez az alfejezet bevezető jellegű. A későbbiekben a számítási modellekhez és problémákhoz kapcsolódva további alsó korlátokat adunk meg. 1.7.1. Egyszerű számolás Tegyük fel, hogy adott egy n méretű L[1..n] lista és feladatunk a lista legnagyobb elemének megkeresése úgy, hogy elempárok összehasonlítása a megengedett művelet. Ha A(n) -nel jelöljük az A kereső algoritmus által elvégzett összehasonlítások számát, akkor tetszőleges A összehasonlítás alapú algoritmusra teljesül, hogy A(n)N(n)(1.63)n2.(1.64) Megmutatjuk, hogy ennél több is igaz. Az egyszerűség kedvéért tegyük fel, hogy a lista különböző elemeket tartalmaz. Amikor egy A összehasonlítás alapú algoritmus összehasonlítja az X és Y elemet, akkor az X>Y esetben azt mondjuk, hogy X megnyerte az összehasonlítást – ellenkező esetben pedig azt mondjuk, hogy X elvesztette az összehasonlítást. Tehát minden összehasonlítás egy vereséget eredményez. Mivel mindazon elemeknek, amelyek nem a legnagyobbak, legalább egy összehasonlítást el kell veszíteniük, ezért n elem legnagyobbikának meghatározásához BA(n)n1(1.65) összehasonlításra van szükség. Ennek szigorú bizonyításához tegyük fel, A úgy fejezi be a keresést, hogy az L[1..n] lista két különböző eleme, például L[i] és L[j], egyetlen összehasonlítást sem veszítettek el. Feltehetjük, hogy A az L[i] elemet adta meg legnagyobbként. Most tekintsük azt az L[1..n] bemenő listát, amely csak annyiban különbözik az előzőtől, hogy abban L[j] nagyobb, mint L[j]. Mivel A összehasonlítás alapú, ezért ugyanolyan összehasonlításokat végez L és L esetében. Ez következik abból, hogy különbség legfeljebb akkor fordulhatna elő, amikor L[j] is részt vesz az összehasonlításban. L[j] azonban minden összehasonlítást megnyert és L[j]>L[j]. Tehát az A algoritmusnak ismét az L[i]=L[i] elemet kell a legnagyobbnak nyilvánítania, ami ellentmondás. Például az alábbi közismert program nemcsak legjobb, hanem legrosszabb esetben is n1 összehasonlítással meghatározza az L[1:n] lista maximális elemét. Tehát beláttuk, hogy MAX az összehasonlítás alapú maximumkeresést a feladat megoldásához okvetlenül szükséges számú összehasonlítással megoldja. Azokat az algoritmusokat, amelyekre a legjobb és a legrosszabb futási idő megegyezik, azaz amelyekre W(n)=B(n),(1.66) stabilnak nevezzük. Megállapításainkat a következőképpen összegezhetjük. 1.9. tétel (MAX abszolút optimális). Ha különböző elemeket tartalmazó, n hosszúságú lista maximális elemét összehasonlítás alapú algoritmussal határozzuk meg, akkor ennek a problémának az időbonyolultsága legjobb, legrosszabb és átlagos esetben is n1. A feladat megoldására MAX abszolút optimális algoritmus. Érdemes megemlíteni, hogy a pontos bonyolultságot csak nagyon ritkán tudjuk meghatározni. 1.7.2. Leszámlálás A leszámlálási módszereket leggyakrabban az átlagos jellemzők meghatározására használjuk. Minden I bemenethez hozzárendelünk egy α(I) jellemző adatot, majd leszámláljuk, hogy mennyi lesz ezen jellemző adatok összege az összes lehetséges bemenetre nézve. Tekintsük például azt a feladatot, hogy az 1,2,...,n számok különböző permutációit kell rendeznünk úgy, hogy a permutációban szomszédos elemek összehasonlítása (és egyúttal cseréje) a felhasználható művelet. Minden I permutációhoz α(I) -ként hozzárendeljük a benne lévő inverziók számát és leszámláljuk, hogy összesen hány inverzió van a permutációkban. 1.10. tétel. Ha A egy különböző elemekből álló sorozatot a szomszédos elemek összehasonlításával rendező algoritmus, akkor N(n,A)n(n1)4.(1.67) Bizonyítás. Ha n=1, akkor igaz az állítás. Ha n2, akkor rendeljük minden permutációhoz az inverzét, azaz azt a sorozatot, amelyben az elemek fordított sorrendben következnek. Mivel tetszőleges i és j indexre (1i,jn) igaz, hogy az i-edik és a jedik elem az egymáshoz rendelt permutációk közül pontosan az egyikben van inverzióban, ezért minden párra igaz, hogy bennük együttesen annyi inverzió van, ahány pár (külön-külön), azaz n(n1)/2. Ezért n elem permutációiban összesen inverzió van. Ha ezt a számot elosztjuk n elem permutációinak számával, megkapjuk a kívánt alsó korlátot. 1.7.3. Döntési fák Egy döntési fa segítségével modellezhetjük az összes döntést, amelyet egy determinisztikus algoritmus végezhet. Egy adott bemenethez tartozó döntések megadnak egy irányított utat a döntési fa gyökerétől valamelyik leveléig, amely megadja az algoritmusnak az adott bemenethez tartozó kimenetét. A döntési fa csak azokat a csúcsokat tartalmazza, amelyekbe legalább egy bemenet esetében eljutunk. A belső csúcsok megfelelnek az algoritmus döntéseinek és az ahhoz tartozó alapműveleteknek (mint például két elem összehasonlítása vagy egy mátrix két elemének összeszorzása). Mivel minden belső csúcshoz legalább egy elvégzendő művelet tartozik, ezért a fa magassága alsó korlát N(n,A)-ra. Hasonlóképpen a levelek átlagos szintje alsó korlát A(n,A)-ra. Bizonyítás nélkül idézünk néhány közismert eredményt, amelyek például döntési fák segítségével igazolhatók. 1.11. tétel (alsó korlát a bináris keresés futási idejére). Ha BINÁRISAN-KERES a rendezett sorozatban binárisan kereső algoritmus, akkor minden pozitív n számra 1.12. tétel (alsó korlát az összehasonlítás alapú rendező algoritmusok futási idejére). Ha ÖSSZEHASONL összehasonlítás alapú rendező algoritmus, akkor 1.7.4. Tanácsadói érvelés Ennél a módszernél úgy jutunk alsó korláthoz, hogy dinamikusan olyan bemenetet állítunk elő, amely az algoritmust lehetőleg nagyszámú művelet elvégzésére kényszeríti. Ez a módszer olyan játékhoz hasonlít, amelyben egy tanácsadónak feltett kérdésekkel juthatunk információhoz, és a tanácsadó arra törekszik, hogy a válaszaival minél kevesebb információt adjon. A W(n,A) futási idő alsó becsléséhez úgy jutunk, hogy összeszámoljuk, hány műveletet kellett az adott bemenetre a vizsgált algoritmusnak elvégeznie. 1.7.5. Információelméleti érvelés Ez a módszer azon alapul, hogy az egy művelettel nyerhető információra felső, a feladat megoldásához szükséges információ mennyiségére pedig alsó korlátot adunk. Ha például egy összehasonlítás lehetséges eredményei IGAZ és HAMIS, akkor n összehasonlítással legfeljebb 2n lehetőséget tudunk megkülönböztetni. Mivel egy n elemet rendező, összehasonlítás alapú algoritmusnak n! lehetőséget kell megkülönböztetnie, ezzel a módszerrel is bizonyíthatjuk a 1.12. tételt. 1.7.6. Gráfelméleti érvelés Mivel a hálózatokat rendszerint gráfokkal modellezzük, ezért természetes, hogy az alsó korlátok bizonyításában is gyakran szerepelnek gráfok. Erre a későbbiek során több példát is mutatunk. 1.8. Anomália A számítógépes rendszerekben anomáliának nevezzük azt a jelenséget, amikor egy feladat megoldásához több erőforrást felhasználva rosszabb eredményt kapunk. Négy konkrét példát említünk. Az egyik a virtuális memória lapjait párhuzamosan használó FIFO (First In – First Out) lapcserélési algoritmussal, a másik a processzorok ütemezésére használt Listásan-ütemez algoritmussal, a harmadik az átfedéses memóriájú számítógépekben folyó párhuzamos programvégrehajtással, végül a negyedik a Párh-korlátoz-szétválaszt optimalizációs algoritmussal kapcsolatos. 1.8.1. Lapcsere Legyenek m,M,n és p pozitív egészek (1mMn<),k nemnegatív egész, A={a1,a2,...,an} egy véges ábécé. Ak az A feletti, k hosszúságú, A* pedig az A feletti véges szavak halmaza. Legyen m egy kis , M pedig egy nagy számítógép fizikai memóriájában lévő lapkeretek száma, n a háttérmemóriában lévő lapok száma (mindkét számítógépben), A a lapok halmaza. A lapcserélési algoritmusokat automatákként kezeljük, melyekre m és M a memória mérete, A a bemenő jelek halmaza, Y=A{ε} a kimenő jelek halmaza. Ezek az automaták a bemenő jelek R=(r1,r2,...,rp) vagy R=(r1,r2,...) sorozatát dolgozzák fel. Az St(t=1,2,...,) memóriaállapot a t időpontban (azaz az rt bemenő jel feldolgozása után) a memóriában tárolt bemenő jelek halmaza. A lapcserélési algoritmusok S0={} üres memóriával kezdik a feldolgozást. Egy konkrét P lapcserélési algoritmust a P=(QP,q0,gP) hármassal definiálunk, ahol QP a vezérlő jelek halmaza, q0QP a kezdeti vezérlő jel, gP az állapot-átmenet függvény, S az új memóriaállapot, q az új állapot és y a kimenő jel, S a régi memóriaállapot, q a régi vezérlőállapot és x a bemenő jel. Az F = FIFO (First In First Out) algoritmus definíciója: q0=() és ahol q=(y1,y2,...,yk),q=(y1,y2,...,yk,x) és q=(y2,y3,...,ym,x). A laphibáknak (a memóriaállapot változásainak) a számát fP(R,m) -vel jelöljük. Anomáliának nevezzük azt a jelenséget, amikor M>m és fP(R,M)>fP(R,m). Ekkor az fP(R,M)/fP(R,m) hányados az anomália mértéke. A P algoritmus hatékonyságát az EP(R,m) lapozási sebességgel jellemezzük, amit R=(r1,r2,...,rp) véges hivatkozási sorozatra az EP(R,m)=fP(R,m)p,(1.73)R=(r1,r2,...) végtelen hivatkozási sorozatra pedig a EP(R,m)=liminfkfP(Rk,m)k(1.74) módon definiálunk, ahol Rk=(r1,r2,...,rk). Legyen 1m<n és C=(1,2,...,n)* egy végtelen ciklikus hivatkozási sorozat. Ekkor E FIFO (C,m)=1. Ha végrehajtjuk a R = (1,2,3,4,1,2,5,1,2,3,4,5) hivatkozási sorozatot, akkor m=3 esetében 9, m=4 esetében pedig 10 laphibát kapunk, így f FIFO (R,M)/f FIFO (R,m)=10/9. Bélády, Nelson és Shedler a következő szükséges és elégséges feltételt adták az anomália létezésére. 1.13. tétel. Akkor és csak akkor létezik olyan hivatkozási sorozat, amelyre a FIFO lapcserélési algoritmus anomáliát okoz, ha m<M<2m1. Az anomália mértékével kapcsolatban pedig a következőt bizonyították. 1.14. tétel. Ha m<M<2m1 , akkor tetszőleges ε>0 számhoz létezik olyan R=(r1,r2,...,rp) hivatkozási sorozat, amelyre f FIFO (R,M)f FIFO (R,m)>2ε.(1.75) Bélády, Nelson és Shedler a következőt sejtették. 1.15. sejtés. Tetszőleges R hivatkozási sorozatra és M>m1 memóriaméretekre f FIFO (R,M)f FIFO (R,m)2.(1.76) Ezt a sejtést cáfolja Fornai Péter és Iványi Antal következő tétele, amely szerint az anomália mértéke tetszőlegesen nagy lehet. 1.16. tétel. Tetszőlegesen nagy L számhoz megadhatók olyan m,M és R paraméterek, melyekre f FIFO (R,M)f FIFO (R,m)>L.(1.77) 1.8.2. Ütemezés Tegyük fel, hogy n programot akarunk végrehajtani egy p processzoros láncon. A végrehajtásnak figyelembe kell vennie a programok közötti megelőzési relációt. A processzorok mohók, és a végrehajtás egy adott L lista szerint történik. E. G. Coffman jr. 1976-ban leírta, hogy a p processzorszám csökkenése, az egyes programok végrehajtásához szükséges lépések ti számának csökkenése, a megelőzési korlátozások enyhítése és a lista változtatása külön is anomáliát okozhat. Legyen a programok végrehajtásának futási ideje τ , a megelőzési reláció < , a lista L és a programok közös listás végrehajtásához szükséges lépések száma p azonos processzorból álló láncon ω(p,L,<,τ). Az L lista, << megelőzési reláció, ττ futási idő vektor és pp processzorszám esetén a futási idő legyen ω(p,L,<,τ). Az anomália mértékét ezúttal a gyorsítással jellemezzük. 1.17. tétel (ütemezési korlát). Az előbbi feltételek esetében 0ωω1+m1m.(1.78) A korlát pontosságát jellemzi a következő állítás. 1.18. tétel (ütemezési korlát élessége). A relatív sebességre adott korlát az m,t,< és L paraméterek mindegyikének változására nézve (külön-külön is) aszimptotikusan éles. 1.8.3. Párhuzamos feldolgozás átfedéses memóriával Népszerű formában fogalmazzuk meg az átfedéses memóriájú számítógépek működését modellező párhuzamos algoritmust. A T0,T1,...,Tr törpék n különböző fajtájú gombócot főznek. Ezeket az egyszerűség kedvéért az 1, 2, ...,n számokkal jelöljük. Mindegyik törpe végtelen gombócsorozatot állít elő. Ezeket a gombócokat Of óriások eszik meg – ahol az f paraméter azt mutatja, hogy az adott óriás az egyes gombócfajtákból legfeljebb hányat ehet meg egy falatban. Az Of óriás a következőképpen eszik. Első falatához a T0 törpe sorozatának elejéről a lehető legtöbb gombócot kiválasztja (de egy-egy fajtából legfeljebb f darabot). Ezt a falatot még a T1,...,Tr törpék sorozatának elejéről kiegészíti – az f korlátot betartva. A további falatokat hasonlóan állítja össze. Legyen h1(f),h2(f),... valószínűségi változók sorozata, melyben a hi(f) elem az óriás i -edik harapásában lévő gombócok száma. Ekkor az Of óriás Sf gombócevési sebességét az Sf=liminftM(i=1thi(f)t)(1.79) határértékkel definiáljuk. Könnyen belátható, hogy ha 1fg , akkor a gombócevési sebességekre fennáll fSffn,gSggn,(1.80) a két óriás relatív gombócevési sebességére pedig fgnSfSgfng.(1.81) Most megmutatjuk, hogy a kis óriás gombócevési sebessége akárhányszor nagyobb lehet, mint a nagy óriásé . 1.19. tétel. Ha r1,n3,g>f1, akkor léteznek olyan gombócsorozatok, amelyekre egyrészt SgSf=gfn,(1.82) másrészt SgSf=gnf.(1.83) Bizonyítás. A természetes korlátokat megadó (1.81) egyenlőtlenségben szereplő alsó korlát élességének belátásához tekintsük az 1f22f+11*(1.84) és 1f+1(23...n)*(1.85) sorozatokat. A felső korlát élességét a 122f+11*(1.86) és 1f132f1f(23...n)*(1.87) sorozatok,,megevésével” láthatjuk be. Az alsó korlát élessége azt fejezi ki, hogy a kis óriás ehet sokkal kevesebbet – ami természetes. Az n növelésével tetszőlegesen naggyá tehető felső korlát élessége azonban erős anomália. 1.8.4. Párhuzamos korlátozás és szétválasztás A korlátozás és szétválasztás gyakran alkalmazott optimalizációs módszer. A módszer alkalmazása során olyan x=(x1,x2,...,xn) vektort keresünk, amely minimalizál egy f(x) függvényt – figyelembe véve korlátozások K halmazát. A korlátozások lehetnek explicitek vagy implicitek. Az implicit korlátozások az xi értékek kapcsolatát jellemzik, például i=1naixib,(1.88)a1x12a2x1x2+a3x34=6.(1.89) Az explicit korlátozások az xi értékekre adnak korlátokat, például xi{0,1},xi0.(1.90) Az explicit korlátozásokat kielégítő vektorok alkotják a megoldási teret . Ezek a vektorok rendszerint egy fát alkotnak, melyeket megoldási fának nevezünk. A fa gyökerétől bizonyos levelekhez vezető utak a megoldási tér egy elemét határozzák meg. Az ilyen csúcsokat megengedett megoldás csúcsnak nevezzük. Egy ilyen csúcs költsége az f függvény értéke az adott csúcsban. Az optimalizálás célja a minimális költségű csúcs meghatározása. Az állapotfa minden N csúcsához hozzárendeljük az min{f(Q)|Q megengedett megoldás az N csúcshoz tartozó részfában } értéket, melyet fmin(N) -nel jelölünk (ha nincs ilyen Q, akkor fmin(N)=). A továbbiakban az LCBB ( Least- Cost Branch-and- Bound) korlátozó-szétválasztó módszerrel foglalkozunk, melyben a következő tulajdonságokkal rendelkező g() heurisztikus függvényt alkalmazzuk: 1. g(N)fmin(N) az állapottér minden N csúcsára. 2. g(N)=f(N) a válaszcsúcsokra. 3. g(N)= a megengedett megoldásokra. 4. g(N)g(P), ha N a P csúcs gyereke. g() -t korlátozó függvénynek nevezzük. LCBB az állapottérhez tartozó csúcsokat állít elő – g() felhasználásával. Az olyan előállított csúcsot, amelynek gyerekeit még nem állítottuk elő, és megengedett megoldásokhoz vezethet, élő csúcsnak nevezzük. Az élő csúcsok listáját karbantartjuk – rendszerint kupacként. LCBB minden iterációs lépésben kiválaszt egy N élő csúcsot, amelynek g() értéke minimális. Ezt a csúcsot aktuális E-csúcsnak nevezzük. Ha N válasz csúcs, akkor minimális költségű válasz csúcs. Ha N nem válasz csúcs, akkor előállítjuk a gyerekeit. Azokat a gyerekeket, amelyek nem vezethetnek minimális költségű válaszhoz, eldobjuk (ezeket a csúcsokat bizonyos heurisztikával választjuk ki). A megmaradó gyerekeket hozzáadjuk az élő csúcsokhoz. Az LCBB módszer többféleképpen párhuzamosítható. Az egyik lehetőség, hogy minden iterációs lépésben több E-csúcs is kiterjeszthető. Ha a processzorok száma p , q=min{p, élő csúcsok száma } csúcsot választunk, mint E -csúcsot (azt a q élő csúcsot, melyekre a legkisebb a g() függvény értéke). Legyen gmin ezen csúcsok g() értékeinek minimuma. Ha ezen E csúcsok bármelyike válaszcsúcs, és a g() -értéke gmin , akkor az a csúcs minimális költségű válaszcsúcs. Egyébként mind a q csúcsot kiterjesztjük (minden processzor egy csúcsot terjeszt ki), és gyerekeit hozzáadjuk az élő csúcsok listájához. q darab E -csúcs minden ilyen kiterjesztése a párhuzamos LCBB egy iterációja. Adott I -re és g -re jelöljük I(p) -vel a p processzor esetében szükséges iterációk számát. Ekkor természetesnek látszanak I(p) következő tulajdonságai: 1. ha p1<p2 , akkor I(p1)I(p2); 2. I(p1)I(p2)p2p1. Az első tulajdonság szerint a processzorok számának növelésekor nem nőhet az iterációk száma. A második tulajdonság szerint a teljesítmény nem lehet nagyobb, mint a felhasznált erőforrások mennyisége. Lai és Sahni 1984-ben megmutatták, hogy egyik tulajdonság sincs biztosítva – még akkor sem, ha g() eleget tesz a (1)–(4) korlátozásoknak. 1.8.5. Az anomália elkerülése Az anomáliát általában igyekeznek elkerülni. A lapcserélésnél például az elkerülés elégséges feltétele az, ha a cserélési algoritmus rendelkezik a verem tulajdonsággal: ha ugyanazt a hivatkozási sorozatot m és m+1 méretű memóriájú gépen futtatjuk, akkor minden hivatkozás után igaz az, hogy a nagyobb memória mindazokat a lapokat tartalmazza, amelyeket a kisebb tartalmaz. A vizsgált ütemezési feladatnál elegendő az, ha nem követeljük meg az ütemező algoritmustól a lista alkalmazását. Gyakorlatok 1.8–1. Az A és B párhuzamos algoritmusok megoldják a kiválasztási feladatot. Az A algoritmus n0.5 processzort használ és a futási ideje Θ(n0.5). A B algoritmus n processzort használ és a futási ideje Θ(logn). Határozzuk meg az elvégzett munkát, a gyorsítást és a hatékonyságot mindkét algoritmusra. Munkahatékonyake ezek az algoritmusok? 1.8–2. Elemezzük a következő két állítást. a. Az A algoritmus futási ideje legalább O(n2) . b. Mivel az A algoritmus futási ideje O(n2) , a B algoritmus futási ideje pedig O(nlogn) , ezért a B algoritmus a hatékonyabb. 1.8–3. Terjesszük ki a váltási hely definícióját nem egész v értékekre és párhuzamos algoritmusokra. 1.8–4. Becsüljük meg annak valószínűségét, hogy egy szabályos pénzérmét ezerszer feldobva legalább hatszázszor dobunk fejet. Útmutatás. A Pr[X=600] valószínűséget a Stirling-képlettel, a Pr [X=601],..., Pr [X=1000] valószínűségeket pedig geometriai sorral becsüljük. 1.8–5. Egészítsük ki a hálózatok adatait tartalmazó 1.2. táblázatot további adatokkal és hálózatokkal. Feladatok 1-1. Variációk O-ra és Ω -ra Az Ω és O különböző definíciói ismertek. Az egyikre a Ω (olvasd: omega végtelen) jelölést használjuk. Azt mondjuk, hogy f(n)=Ω(g(n)), ha létezik c pozitív valós állandó úgy, hogy f(n)cg(n)0 teljesül végtelen sok egész n -re. a. Egy függvényt aszimptotikusan nemnegatívnak nevezünk, ha minden elég nagy n -re nemnegatív. Mutassuk meg, hogy bármely két aszimptotikusan nemnegatív f(n) és g(n) függvény esetében vagy f(n)=O(g(n)), vagy f(n)=Ω(g(n)), vagy mindkettő teljesül, ha azonban Ω helyett Ω -t használunk, akkor nem igaz az állítás. b. Mik a lehetséges előnyei és hátrányai annak, ha a programok futási idejének jellemzésére Ω-t használunk Ω helyett? Néhány szerző a O -t is kissé másképp definiálja; használjuk az O jelölést erre az alternatív definícióra. Azt mondjuk, hogy f(n)=O(g(n)) akkor és csak akkor, ha |f(n)|=O(g(n)).c. Ismert, hogy f(n)=Θ(g(n)) akkor és csak akkor teljesül, ha f(n)=Ω(g(n)) és f(n)=O(g(n)). Mit mondhatunk, ha Ω helyett Ω szerepel? Szokásos a O -n (olvasd: gyenge ordó) szimbólumot a logaritmikus tényezők elhanyagolásával kapott O -jelölésre használni. Azt mondjuk, hogy O(g(n))=f(n), ha léteznek olyan c pozitív valós, k és n0 pozitív egész állandók úgy, hogy, ha nn0, akkor 0f(n)cg(n)logk(n).d. Definiáljuk hasonló módon Ω -t és Θ -t. Bizonyítsuk be a c. részben kimondott állítás ennek megfelelő változatát. 1-2. A gyorsítás korlátai Ebben a feladatban a gyorsítás elméleti és gyakorlati korlátait vizsgáljuk. a. Bizonyítsuk be Amdahl és Gustafson törvényét. b. Magyarázzuk meg, hogy a két törvény közötti ellentmondás látszólagos. c. A gyakorlatban milyen korlátai vannak a gyorsításnak? 1-3. Hanoi tornyai általánosan Általánosítsuk a Hanoi tornyaira vonatkozóan kapott eredményt. a. Mit mondhatunk a lépésszámról akkor, ha négy rudat használhatunk? b. Mit mondhatunk a lépésszámról akkor, ha 2+k(k1) rudat használhatunk? c. Mit mondhatunk a lépésszámról akkor, ha korlátozzuk a rudak közötti mozgatás lehetőségeit, például az A rúdról a B rúdra és a B rúdról az A rúdra nem szabad korongot áthelyezni? d. Mennyire csökkenthető a lépésszám konstans számú rúd esetén? e. Mennyi rúd elegendő a lépésszám O(n) -re csökkentéséhez? f. Mit mondhatunk a lépésszámról akkor, ha s szerzetes párhuzamosan dolgozhat? Feltételezzük, hogy minden lépésben minden rúdról legfeljebb egy korongot szabad elvenni és minden rúdra legfeljebb egy korongot szabad ráhelyezni, továbbá minden szerzetes legfeljebb egy korongot mozgathat? g. Mit mondhatunk a lépésszámról akkor, ha az s szerzetes párhuzamos munkáját paraméteresen értelmezzük: az m -párhuzamos olvasás jelentse azt, hogy a szerzetesek egy lépésben rudanként legfeljebb az m legfelső koronghoz férnek hozzá; az m -párhuzamos írás pedig jelentse azt, hogy minden korongra külön legfeljebb m korongot helyezhetnek egyidejűleg. 1-4. Anomália Tervezzünk egy algoritmust (és valósítsuk is meg), amely azt bizonyítja, hogy egy adott feladatot q>p processzoron megoldani tovább tart, mint p>1 processzoron. 1-5. Párhuzamossággal a hírnévért és dicsőségért 1997-ben Andrew Beale dallasi bankár 50 ezer dollár díjat tűzött ki annak, aki bizonyítja vagy cáfolja sejtését. Eszerint ha aq+bp=cr,(1.91) akkor az a,b és c számoknak van egynél nagyobb közös osztója (az egyenletben mind a hat betű egész számot jelent és a kitevők értéke legalább három). Hogyan használhatók fel a párhuzamos algoritmusok a díj megszerzésére? 1-6. Rangsorolás Tekintsük az összehasonlítás alapú rendezés következő általánosítását. n elemet – például n sportolót – páronként összehasonlítunk, és a győztesnek 1 pontot, a vesztesnek pedig 0 pontot adunk. Legyen pi az i -edik játékos pontszáma (győzelmeinek száma). a. Tervezzünk párhuzamos algoritmust, amely adott q=q1,q2,...,qn sorozatról eldönti, hogy lehet-e az előbb leírt verseny pontsorozata. Útmutatás. Használjuk fel Landau tételét, amely szerint q akkor és csak akkor lehet pontsorozat, ha a következő két feltétel mindegyike teljesül: b. Oldjuk meg a feladatot akkor, ha minden összehasonlításnál k1 pontot osztunk ki az összehasonlított sportolók között, és a k pont minden lehetséges módon felosztható (azzal a megszorítással, hogy mindkét játékosra a kapott pontok száma nemnegatív egész). c. Oldjuk meg a feladatot akkor, ha minden összehasonlításnál k(1akb) pontot osztunk ki az összehasonlított sportolók között, a k pont minden lehetséges módon felosztható (azzal a megszorítással, hogy mindkét játékosra a kapott pontok száma nemnegatív egész), az a és b számok pozitív egészek. d. Elemezzük a feladatnak azt az általánosítását, amelyben az összehasonlításoknak csak egy részét végeztük el. Lényeges-e annak ismerete, hogy mely összehasonlításokat végeztük el? 2. Párhuzamos gépek Ebben a fejezetben először két alapvető módszert (a prefixszámítást és a tömbelemek rangsorolását), (2.1. alfejezet), azután a kiválasztást (2.2. alfejezet), összefésülést (2.3. alfejezet), rendezést (2.4. alfejezet), végül pedig néhány gráfalgoritmust (. alfejezet) mutatunk be. 2.1. Alapvető módszerek Ebben az alfejezetben két, a feladatok párhuzamos megoldásában gyakran használt módszert mutatunk be. Az asszociatív műveletek gyors elvégzését a prefixek számítására, a mutatóugrást pedig a listarangsorolási feladat megoldására használjuk fel. 2.1.1. Prefixszámítás Legyen Σ egy alaphalmaz, melyen definiáltuk a bináris asszociatív operátort. Feltesszük, hogy a művelet egy lépéssel elvégezhető és a Σ halmaz zárt erre a műveletre nézve. Egy bináris operátor asszociatív a Σ alaphalmazon, ha minden x,y,zΣ esetében teljesül (xy)z=x(yz).(2.1) Legyenek az X=x1,x2,...,xp sorozat elemei a Σ alaphalmaz elemei. Ekkor a prefixszámítás bemenő adatai az X sorozat elemei, a prefixszámítási feladat pedig az x1,x1x2,...,x1x2x3xp elemek meghatározása. Ezeket a meghatározandó elemeket prefixeknek hívjuk. Érdemes megjegyezni, hogy más területeken inkább az X sorozat x1,x2,...,xk kezdősorozatait hívják prefixeknek. 2.1. példa.Asszociatív műveletek. Ha Σ az egészek halmaza, az összeadás és a bemenő adatok sorozata a 3, -5, 8, 2, 5, 4, akkor a prefixek 3, -2, 6, 8, 13, 17. Ha az ábécé és a bemenő adatok ugyanazok, de a művelet a szorzás, akkor a kimenő adatok (prefixek) 3, -15, -120, -240, -1200, -4800. Ha a művelet a minimum (ez is asszociatív), akkor a prefixek 3, -5, -5, -5, -5, -5. Az utolsó prefix megegyezik a bemenő számok legkisebbikével. A prefixszámítás sorosan megoldható O(p) lépéssel. Bármely A soros algoritmusnak N(p, A )=Ω(p) lépésre szüksége van. Vannak olyan párhuzamos algoritmusok, amelyek különböző párhuzamos modelleken megoldják a munkahatékony prefixszámítást. Először a CREW-PREFIX CREW PRAM algoritmust mutatjuk be, amely p processzoron Θ(logp) lépéssel számítja ki a prefixeket. Azután az EREW-PREFIX algoritmus következik, amelynek mennyiségi jellemzői hasonlóak az előző algoritmuséhoz, azonban EREW PRAM számítási modellen is végrehajtható. Ezekkel az algoritmusokkal a prefixszámítást a soros megoldás Θ(p) lépésszámánál lényegesen gyorsabban meg tudjuk oldani, de sok az elvégzett munka. Ezért is érdekes az OPTIMÁLIS-PREFIX CREW PRAM algoritmus, amely p/logp processzort használ és Θ(logp) lépést tesz. Ennek elvégzett munkája csak O(p), ezért a hatékonysága Θ(1) és az algoritmus munkaoptimális. Ennek az algoritmusnak a gyorsítása Θ(n/logn). A továbbiakban – a jelölések egyszerűsítése érdekében – a p/logp típusú kifejezések helyett általában csak (p/logp) -t írunk. Az algoritmusok tervezéséhez az oszd-meg-és-uralkodj elvet alkalmazzuk. A bemenő adatok legyenek X=x1,x2,...,xp. Az általánosság megszorítása nélkül feltehető, hogy p a 2 egész kitevőjű hatványa. Prefixszámítás CREW PRAM modellen Először egy p processzoros algoritmust mutatunk be, melynek lépésszáma Θ(logp) . 2.2. példa.8 elem prefixeinek számítása 8 processzoron. Legyen n=8 és p=8. A prefixszámítás bemenő adatai 12, 3, 6, 8, 11, 4, 5 és 7, az asszociatív művelet az összeadás. Az első szakaszban az első 4 processzor 12, 3, 6, 8 bemenethez a 12, 15, 21, 29 prefixeket számolja ki. A másik 4 processzor pedig a 11, 4, 5, 7 bemenethez számolja ki a 11, 15, 20, 27 prefixeket. A második szakaszban az első 4 processzor nem dolgozik, a második 4 pedig 29-et ad minden prefixhez és a 40, 44, 49, 56 eredményt kapja. Mi ennek az algoritmusnak a T(p) lépésigénye? Az első lépés T(p/2) ideig, a második pedig O(1) ideig tart. Ezért a következő rekurziót kapjuk: T(p)=T(p2)+O(1),(2.2)T(1)=1.(2.3)Ennek a rekurzív egyenletnek a megoldása T(p)=O(logp). 2.1. tétel. A CREW-PREFIX algoritmus p CREW PRAM processzoron Θ(logp) lépésben számítja ki p elem prefixeit. Ez az algoritmus nem munkaoptimális, mivel Θ(plogp) munkát végez, és ismert olyan soros algoritmus, amely O(p) lépést tesz. Munkaoptimális algoritmust kaphatunk például úgy, ha a felhasznált processzorok számát lecsökkentjük (p/logp) -re, miközben a lépésszám nagyságrendje ugyanaz marad. A processzorszámot úgy csökkentjük, hogy a bemenet méretét csökkentjük (p/logp) -re, alkalmazzuk az előző algoritmust, majd végül minden prefixet kiszámolunk. Prefixszámítás EREW PRAM modellen A következő algoritmusban a párhuzamos olvasás helyett elég a soros olvasás lehetősége. 2.2. tétel. Az EREW-prefix algoritmus p EREW PRAM processzoron Θ(logp) lépésben számítja ki p elem prefixeit. Bizonyítás. A lépésszám nagyságrendjét az határozza meg, hányszor hajtódik végre az utolsó sorban lévő utasítás. Az 1–4. lépések O(1) idő alatt, az 5–8. lépések Θ(logp) idő alatt hajtódnak végre. Prefixszámítás munkaoptimálisan Az algoritmus lépésszáma logaritmikus. Ennek belátását megkönnyíti a következő két képlet: z(i1)logp+k=j=(i1)logp+1ilogpxj(k=1,2,...,logp)(2.4) és wilogp=j=1izjlogp(i=1,2,...),(2.5) ahol az összegzés a megfelelő asszociatív művelet segítségével történik. 2.3. tétel (párhuzamos prefixszámítás Θ(logp) lépéssel). Az OPTIMÁLIS-PREFIX algoritmus (p/logp) CREW PRAM processzoron Θ(logp) lépéssel számítja ki p elem prefixeit. Bizonyítás. Az algoritmus az első szakasza O(logp) ideig, a második szakasza O(log(p/log))=O(logp) lépésig tart. Végül a harmadik szakasz ugyancsak O(logp) lépést igényel. A tételből következik, hogy az OPTIMÁLIS-PREFIX algoritmus munkaoptimális. 2.3. példa.16 elem összeadása. Legyen 16 elemünk: 5, 12, 8, 6, 3, 9, 11, 12, 1, 5, 6, 7, 10, 4, 3, 5. Az asszociatív művelet az összeadás. Ekkor logn=4. Ekkor az első párhuzamos lépésben a processzorok 4-4 elem prefixeit számolják. A második lépésben a helyi összegekből globális összegeket számolunk, majd azokkal a harmadik lépésben frissítjük a helyi eredményeket. A számítás menetét mutatja a 2.1. ábra. 2.1. ábra. 16 elem prefixeinek számítása az OPTIMÁLIS-PREFIX algoritmussal. 2.1.2. Tömb elemeinek rangsorolása A tömbrangsorolási feladat bemenő adata egy p elemű tömbben ábrázolt lista: minden elem tartalmazza jobb oldali szomszédjának az indexét (és esetleges további adatokat). A feladat az elemek rangjának (jobb oldali szomszédai számának) meghatározása. Mivel az adatokra nincs szükség a megoldáshoz, feltesszük, hogy az elemek csak a szomszéd indexét tartalmazzák. A jobb szélső elem index mezője nulla. Az indexet a továbbiakban mutatónak hívjuk. 2.4. példa.Tömbrangsorolás bemenő adatai. Legyen A[1:6] a 2.2. ábra felső sorában bemutatott tömb. Ekkor az A[1] elem jobboldali szomszédja A[5] , A[2] jobboldali szomszédja A[4] . A[4] az utolsó elem, ezért rangja 0. A[2] rangja 1, mivel csak A[4] van tőle jobbra. A[5] rangja 3, mivel az A[3],A[2] és A[4] elemek vannak tőle jobbra. Az elemek sorrendjét (balról jobbra haladva) mutatja az ábra alsó része. 2.2. ábra. Tömbrangsorolási probléma bemenő adatai és a megfelelő tömb. A tömbrangsorolás sorosan elvégezhető lineáris lépésszámmal. Először meghatározzuk a tömb fejét – az egyetlen olyan i értéket (1ip) , melyre A[j]i teljesül minden 1jn értékre. Legyen A[i] a tömb feje. A fejtől kiindulva pásztázzuk a tömböt és az elemekhez rendre hozzárendeljük a p,p1,...,1,0 rangokat. Ebben a részben két párhuzamos algoritmust ismertetünk. Az egyik a DETRANGSOROL, amely egy p processzoros EREW PRAM O¯(logp) lépésszámmal, a másik a VÉL-RANGSOROL, amely egy (p/logp) processzoros véletlenített EREW PRAM algoritmus O¯(logp) lépésszámmal. Mindkettő gyorsítása Θ(p/logn) . Az első algoritmus hatékonysága Θ(p)/(Θ(plogp))=Θ(1/logp) , míg a másodiké Θ(1) . Ezért az első algoritmus csak munkahatékony, a második algoritmus viszont munkaoptimális is. Determinisztikus tömbrangsorolás Ezekben az algoritmusokban az egyik alapvető ötlet a mutatóugrás. DET-RANGSOROL szerint először mindegyik elem a jobb oldali szomszédjának indexét tartalmazza, és ennek megfelelően a rangja – a jobb oldali szomszédjához viszonyítva – 1 (kivétel a lista utolsó eleme, melynek rangja 0. Ezt a kezdeti állapotot mutatja a 2.3. ábra első sora. 2.3. ábra. A DET-RANGSOROL algoritmus működése a 2.4. . példa adataival. Ezután módosítjuk a csúcsokat úgy, hogy mindegyik a jobb oldali szomszédjának a jobb oldali szomszédjára mutasson (ha nincs, akkor a lista végére). Ezt tükrözi a 2.3. ábra második sora. Ha p processzorunk van, akkor ez O(1) lépéssel elvégezhető. Most minden csúcs (kivéve az utolsót) olyan csúcsra mutat, amelyik eredetileg 2 távolságra volt. A mutatóugrás következő lépésében a csúcsok olyan csúcsra mutatnak, amelyek eredetileg 4 távolságra voltak tőlük (ha ilyen csúcs nincs, akkor a lista végére) – amint azt az ábra harmadik sora mutatja. A következő lépésben a csúcsok (pontosabban a mutató részük) a 8 távolságú szomszédra mutatnak (ha van ilyen – ha nincs, akkor a lista végére), az 2.3. ábra utolsó sora szerint. Minden csúcs minden lépésben információt gyűjt arról, hány csúcs van közte és azon csúcs között, amelyre most mutat. Ehhez kezdetben legyen a csúcsok rang mezőjében 1 – kivéve a jobboldali csúcsot, melyre ez az érték legyen 0. Legyen rang[i] és szomsz[i] az i csúcs rang, illetve szomszéd mezője. A mutatóugrás során rang[i] -t általában rang[i] + rang [ szomsz[i] ]-re módosítjuk – kivéve azokat a csúcsokat, melyekre szomsz[i]=0 . Ezután szomsz[i] -t úgy módosítjuk, hogy szomsz [ szomsz[i] ]-re mutasson. A teljes DET-RANGSOROL algoritmus a következő. A 2.3. ábra mutatja, hogyan működik DET-RANGSOROL a 2.6. példa adataival. Kezdetben minden csúcs rangja 1, kivéve a 4. csúcsot. Amikor q=1 , akkor például az 1. csúcs rang mezőjét kettőre változtatjuk, mert jobboldali szomszédjának (ez az 5. csúcs) rangja 1. Az 1. csúcs szomsz mezőjét az 5. csúcs szomszédjának indexére, azaz 3-ra változtatjuk. 2.4. tétel. A DET-RANGSOROL algoritmus egy EREW PRAM modellen p processzoron Θ(logp) lépésben határozza meg egy p elemű tömb elemeinek rangját. Mivel a DET-RANGSOROL algoritmus Θ(plogp) munkát végez, ezért nem munkaoptimális. A listarangsorolási probléma megfelel a lista prefix összege számításának, ahol minden csúcs súlya 1, kivéve a jobboldalit, melynek súlya 0. A DETRANGSOROL algoritmus könnyen módosítható úgy, hogy kiszámítsa egy lista prefixeit – a processzorszámra és a lépésszámra vonatkozó hasonló korlátokkal. Véletlenített listarangsorolás (*) Most egy munkahatékony véletlen listarendező algoritmus következik. Minden processzor logp csúcs rangját számolja. A Pi processzort az A[(i1)logp+1],A[(i1)logp+2],...,A[ilogp] csúcsokhoz rendeljük. Az algoritmus meneteket hajt végre. Minden menetben kiválasztja és kiemeli a csúcsok egy részét. Amikor egy csúcsot kiemelünk, akkor a rá vonatkozó információt tároljuk úgy, hogy később a rangját meg tudjuk határozni. Ha már csak 2 csúcs marad, a listarendezési probléma egyszerűen megoldható. A következő menetben a kiemelt csúcsokat beemeljük. Amikor egy csúcsot beemelünk, akkor a helyes rangját is meghatározzuk. A beemelés sorrendje a kiemelési sorrend fordítottja. A KIEMEL algoritmus a következő. A kettős láncolás p processzorral O(1) lépéssel elvégezhető. A Pi processzorhoz az A[i](1ip) csúcsot rendeljük. Egy lépésben Pi a szomsz[i] memóriarekeszbe ír úgy, hogy a következő lépésben az A [ szomsz[i] ] csúccsal összekapcsolt processzor ismerni fogja bal oldali szomszédját. A lassulási lemma segítségével belátható, hogy n/logn processzoron p elem kettős láncolása logp lépésben elvégezhető. A csúcsok beemelése (lásd . ábra) ugyancsak menetekben történik. Amikor az x csúcsot beemeljük, helyes rangját így határozzuk meg: ha kiemelésekor a bal-szomsz[x] mutatót tároltuk, akkor x rangját úgy kapjuk, hogy bal-szomsz[x] aktuális rangjából levonjuk azt a rangot, amit x kiemelésekor tároltunk. A mutatókat ugyancsak aktualizáljuk, figyelembe véve azt a tényt, hogy x -et már beemeltük. Ezt mutatja a 2.4. ábra, amelyen a csúcsoknak csak a jobb oldali mutatója szerepel. 2.4. ábra. A DET-RANGSOROL algoritmus működése a 2.4. példa adataival. Most megmutatjuk, hogy a kiemelések s összes száma O¯(logp). Ha egy csúcsot a i -edik menetben kiemelünk, akkor a (2si+1) . menetben fogjuk beemelni. Így az algoritmus szerkezete a következő. Az 1,2,...,s menetekben egymás után kiemeljük a csúcsokat. Az s menetekben az addigra megmaradt 2 csúcs egyikét kiemeljük. Az (s+1) -edik menetekben beemeljük az s -edik menetben kiemelt csúcsot. Az (s+2) -edik menetben az s=1 menetben kiemelt csúcsot emeljük be és így tovább. Az utolsó menet után az eredeti lista minden csúcsának rangját tudjuk. Mivel Pi minden menetben csak egy csúcsot vizsgál, ezért a hozzá tartozó csúcsok közül legfeljebb egyet emelünk ki. Az is minden esetben fennáll, hogy a lista szomszédos csúcsait egyszerre nem emeljük ki: ugyanis a fej után egy processzor csak akkor próbálja kiemelni a választott csúcsot, ha a jobb oldali szomszéd processzor nem fej -et dobott. Ezért a processzorok menetenként csak O(1) lépést igényelnek. Az algoritmus lépésszámához csak s -et kell meghatározni. Ehhez megbecsüljük a menetenként kiemelt csúcsok számát. Minden Pi processzorra igaz, hogy a kiválasztott x csúcsot legalább 1/4 valószínűséggel kiemeli: ugyanis Pi 1/2 valószínűséggel dob fej -et, és legalább 1/2 annak a valószínűsége, hogy x jobb oldali szomszédját (legyen ez a csúcs y ) nem választjuk ki, vagy kiválasztjuk ugyan, de y processzora írást dob. Minden processzor logp csúccsal kezdi az algoritmust és minden menetben legalább 1/4 annak valószínűsége, hogy kiemelünk egy csúcsot. Ezért s várható értéke legfeljebb 4logp. Most alkalmazzuk az (1.51) Csernov-egyenlőtlenséget, amely p darab q -paraméterű Bernoulli-kísérlet esetében minden 0<ε<1 számra igaz. A 12αlogp és 1/2 paraméterekkel az ε=2/3 esetben azt kapjuk, hogy P(s12αlogp)>1pα(2.6) minden α1 értékre. Tehát beláttuk a következő tételt. 2.5. tétel (lista rendezése O¯(logp) lépéssel). A KIEMEL algoritmus egy p hosszúságú lista rangsorolását O(p/logp) EREW PRAM processzoron O¯(logp) lépéssel elvégezi. 2.2. Kiválasztás Adott n2 kulcs és egy i(1in) egész szám. A feladat az i -edik legkisebb kulcs kiválasztása. Mivel a kiválasztáshoz minden elemet meg kell vizsgálni, ezért N(n)=Ω(n) . Erre a feladatra ismert olyan A soros algoritmus, amelyikre W(n,A)=O(n) , tehát A aszimptotikusan optimális. Ehhez hasonló a keresési feladat, amelyben azt kell eldönteni, hogy adott elem előfordul-e a vizsgált sorozatban – és ha igen, milyen indexszel. Ennél a feladatnál tagadó válasz is lehetséges és egy elemről tulajdonságai alapján eldönthető, megfelel-e a keresési feladatnak. Először 3 speciális esetet vizsgálunk, majd egy munkahatékony véletlenített algoritmust ismertetünk. 2.2.1. Kiválasztás négyzetes számú processzoron Legyen i=n, azaz a legnagyobb kulcsot keressük. Ez a feladat a következő NÉGYZETES-KIVÁLASZT algoritmussal n2 CRCW processzoron O(1) lépéssel elvégezhető. Legyenek a bemenő adatok k1,...,kn. Az összehasonlításokat párhuzamosan végezzük a Pij(1i,jn) processzorokon úgy, hogy Pij az xij=(ki<kj) logikai értéket számítja ki. Feltehetjük, hogy a kulcsok különbözőek. Ha mégse, ki helyett a (ki,i) párt alkalmazva különbözővé tehetők: ehhez minden kulcshoz egy (logn) -bites számot kell hozzáadni. Ekkor egyetlen olyan kulcs van, amelyikre minden összehasonlítás eredménye HAMIS. Ez a kulcs egy logikai VAGY művelettel azonosítható. 2.6. tétel (kiválasztás O(1) lépéssel). n kulcs közül a maximális O(1) lépéssel meghatározható n2 közös CRCW PRAM processzoron. Bizonyítás. Az első és a harmadik szakasz egységnyi ideig tart. A második szakasz O(1) lépéssel elvégezhető. Ennek az algoritmusnak a relatív sebessége Θ(n). Az elvégzett munka Θ(n2). Ezért a hatékonyság Θ(n)/n2=Θ(1/n). Tehát az algoritmus nem munkahatékony. 2.2.2. Kiválasztás p processzoron Most megmutatjuk, hogy a maximális elem p közös CRCW processzoron O(loglogp) lépéssel meghatározható. A technika az oszd-meg-és-uralkodj. Az egyszerűség kedvéért feltesszük, hogy p négyzetszám. Legyenek a bemenő adatok X=k1,k2,...,kp. Legyen az algoritmusunk lépésszáma T(p). A bemenő adatokat 2p=a csoportra osztjuk úgy, hogy minden csoportban a elem legyen. Minden csoporthoz rendeljünk a processzort – ekkor a csoportok maximális eleme párhuzamosan számítható. Mivel csoportonként a elem és ugyanannyi processzor van, a csoport maximális eleme T(a) lépéssel meghatározható. Legyenek M1,M2,...,Ma a csoportok maximális elemei. Ezek maximuma lesz az algoritmus kimenete. Mivel most csak a elemünk van, az összes processzort alkalmazhatjuk. 2.7. tétel (kiválasztás O(loglogp) lépéssel). A GYÖKÖS-KIVÁLASZT algoritmus p közös CRCW PRAM processzoron O(loglogp) lépéssel meghatározza p kulcs közül a legnagyobbat. Bizonyítás. Ennek az algoritmusnak az első lépése T(2p) , második lépése O(1) ideig tart. Ezért T(p) kielégíti a T(p)=T(2p)+O(1)(2.7) rekurzív egyenletet, melynek megoldása O(loglogp). A GYÖKÖS-KERES algoritmus összes munkája Θ(ploglogp), ezért hatékonysága Θ(p)/Θ(ploglogp)=Θ(1/loglogp), így ez az algoritmus sem munkahatékony. 2.2.3. Kiválasztás egész számok között Legyen a feladat ismét n kulcs maximumának meghatározása. Ha a kulcsok egyetlen bitből állnak, akkor a maximum keresése visszavezethető a logikai VAGY műveletre és ezért O(1) lépéssel meghatározható. Ebből adódik a kérdés: mekkora intervallumban lehetnek a kulcsok ahhoz, hogy p processzoron konstans lépéssel meg tudjuk határozni a maximális elemet? Legyen c adott konstans, a kulcsok pedig legyenek a [0,nc] intervallumban. Ekkor a kulcsok legfeljebb clogn bites bináris számok. Az egyszerűség kedvéért feltesszük, hogy pontosan ennyi bitesek (a számok elejére szükség esetén nullákat írunk). A következő CRCW algoritmus O(1) lépést tesz. Az alapötlet az, hogy a számok b1,b2,...,b2c bitjeit logn2 hosszúságú részekre bontjuk. Az i -edik rész a b(i1)+1,b(i1)+2,...,b(i1)+b(i1)+(logn)/2 biteket tartalmazza, a részek száma 2c. Ezt a helyzetet mutatja a 2.5. ábra: először az ábra első oszlopában lévő bitek alapján keressük a maximális kulcsot. 2.5. ábra. Maximális egész szám kiválasztása. 2.8. tétel (kiválasztás egész számok közül). Ha a kulcsok a [0,nc] intervallumból vett egész számok, akkor p kulcs közül a maximális O(1) lépéssel meghatározható p CRCW PRAM processzoron tetszőleges c konstans esetében. Bizonyítás. Tegyük fel, hogy a kulcsok maximumát a logn2 legfontosabb bit alapján határozzuk meg. Legyen az első részben a maximum M . Ekkor azok a kulcsok, melyek legfontosabb bitjei nem M -et adnak, biztosan nem maximálisak. Ezt az alaplépést megismételjük 2c -szer, azaz minden (logp)/2 bitre pontosan egyszer. Legalább egy kulcs megmarad az utolsó lépés után is – az lesz az eredmény. Az utolsó rész lehet rövidebb, mint (logp)/2 bit. Ha egy kulcs legfeljebb (logn)/2 bites, akkor az értéke legfeljebb 2n1. Ezért az Egészet-kiválaszt első lépésében a [0,2n1] intervallumba eső egész kulcsok maximumát kell meghatározni. Rendeljünk minden kulcshoz egy processzort és használjunk 2n közös memóriarekeszt (M1,M2,...,M2n1) , melyek tartalma kezdetben . Egy párhuzamos lépésben a Pi processzor ki -t ír az Mki memóriarekeszbe. Ezután az n kulcs maximuma a 2n memóriarekesz tartalmából n processzorral a 2.9. tétel alapján konstans idő alatt meghatározható. 2.2.4. Az általános kiválasztási feladat megoldása n2/logn processzoron Tegyük fel, hogy az X=k1,k2,...,kn sorozat különböző kulcsokat tartalmaz és az i -edik legkisebb kulcsot akarjuk kiválasztani. Legyen most az xi kulcs rangja eggyel nagyobb, mint a nála kisebb kulcsok száma (ez a definíció eggyel nagyobb értéket ad, mint a korábban használt). Ezt a rangot a 2-5. gyakorlat szerint nlogn CREW PRAM processzoron bármely kulcsra O(logn) lépésben meg tudjuk határozni. Ha n2/logn processzorunk van, akkor azokat C1,C2,...,Cn csoportokba oszthatjuk úgy, hogy minden csoportban n/logn processzor legyen. A Cj(1jn) csoport O(logn) lépésben meghatározza a kj kulcs rangját X -ben. Annak a csoportnak egyik processzora, amelyik az i rangot határozta meg, adja a kimenetet. Az így kapott algoritmus neve legyen ÁLT-KIVÁLASZT. 2.9. tétel (általános kiválasztás). Az ÁLT-KIVÁLASZT algoritmus n2/logn processzoron n különböző kulcs közül Θ(logn) lépésben meghatározza az i -edik legkisebbet. Nem nehéz belátni, hogy az ÁLT-KIVÁLASZT algoritmus munkája Θ(n2), tehát ez az algoritmus sem munkahatékony. 2.2.5. Munkaoptimális véletlenített algoritmus (*) Ebben a pontban n/logn közös CRCW processzort alkalmazunk arra, hogy O¯(logn) lépésben megoldjuk az i -edik legkisebb elem kiválasztását. A VÉL-KIVÁLASZT algoritmus a bemenő kulcsok X=k1,k2,...,kn sorozatából kiválaszt egy n1ε méretű S mintát és S két elemét elválasztó elemként. Például ε=0.6 megfelelő érték. Legyen e1 és e2 a két elválasztó elem. Az elválasztó elemek olyanok lesznek, hogy a kiválasztandó elem nagy valószínűséggel a két elválasztó elem közé fog esni. Továbbá X -nek az elválasztó elemek közé kevés eleme esik: O¯(n(1+ε)/22n). Ha már kiválasztottuk a két elválasztó elemet, X -et az X1={xX|x<e1} , X2={xX|e1xe2} és X3={xX|x>e2} diszjunkt részekre bontjuk. A felbontás során meghatározzuk az egyes részek elemszámát. Ha |X1|<i|X1|+|X2| , akkor a kiválasztandó elem X2 eleme. Ebben az esetben tovább megyünk, míg ellenkező esetben újra kezdjük. A mintavételezési és kiküszöbölési műveleteket addig ismételjük, amíg el nem érjük, hogy a megmaradó kulcsok száma legfeljebb n0.4 legyen. Ezután a megmaradó kulcsok közül az Ált-kiválaszt algoritmus segítségével végezzük el a kiválasztást. Az algoritmus pszeudokódja a következő. A pszeudokódban a N munkaváltozó az élő kulcsok számát adja meg. Kezdetben legyen N=n és minden kulcs legyen élő. Minden processzorra logn kulcs jut. A 3. és 6. lépésekben a koncentráció azt jelenti, hogy a megfelelő kulcsokat összegyűjtjük és a közös memória egymást követő rekeszeiben helyezzük el őket. Nevezzük menetnek a while ciklus egyszeri lefutását. A minták száma minden menetben N és Nε paraméterekkel rendelkező binomiális eloszlású. Ezért a mintákban lévő kulcsok számának várható értéke Nε . A Csernov-egyenlőtlenség segítségével belátható, hogy |M|=O¯(N1ε).(2.8) Legyen M egy m elemű minta, amelyet egy n elemű X halmazból állítottunk elő. Legyen kiválaszt(j,M) az M minta j -edik legkisebb eleme és rj=rang [ kiválaszt[j,M] ,X]. Bizonyítás nélkül említjük a következő lemmát. 2.10. lemma. Minden α számra P(|rjjnm|>23αn2m2logn)<nα.(2.9) Ennek a lemmának a segítségével bizonyítható a következő állítás. 2.11. tétel. A VÉL-KIVÁLASZT algoritmus n/logn processzoron O¯(logn) lépésben kiválasztja n különböző kulcs közül az i -edik legkisebbet. Ebből a tételből és a kiválasztás lineáris lépésigényéből következik, hogy a VÉL-KIVÁLASZT algoritmus nagy valószínűséggel munkahatékony. 2.3. Összefésülés Adott 2 csökkenőleg (vagy növekvőleg) rendezett sorozat, melyek együtt p elemet tartalmaznak. A feladat ennek a sorozatnak egy csökkenő (vagy növekvő) sorozattá való rendezése. Ez a feladat egy soros processzoron O(p) lépéssel megoldható. Mivel legrosszabb esetben minden elemet meg kell vizsgálni és a helyére kell tenni, ezért a feladat megoldásának lépésszámigénye Ω(p). 2.3.1. Logaritmikus idejű algoritmus Legyen X1=k1,k2,...,km és X2=km+1,km+2,...,k2m a két bemenő sorozat. Az egyszerűség kedvéért legyen m 2 hatványa és a kulcsok különbözzenek. Az összefésüléshez elég az összes kulcs rangjának kiszámítása. Ha a rangokat ismerjük, akkor p=2m processzoron egy lépésben beírhatjuk az i rangú kulcsot az i -edik memóriarekeszbe. 2.12. tétel. A LOG-ÖSSZEFÉSÜL algoritmus két m hosszúságú kulcssorozatot Θ(logm) idő alatt fésül össze 2m CREW PRAM processzoron. Bizonyítás. A k kulcs rangja legyen rk1(rk2)X1 -ben ( X2 -ben). Ha k=kjX1 , akkor legyen rk1=j . Ha egy külön π processzort rendelünk k hoz, akkor az bináris kiválasztással Θ(logm) lépéssel meghatározza azon X2 -beli elemek q számát, amelyek kisebbek, mint k. Ha q ismert, akkor π kiszámíthatja k(X1X2) -beli rangját: ez j+q lesz. Ha kX2 -höz tartozik, hasonlóképpen járhatunk el. Összegezve: ha elemenként egy, azaz összesen 2m processzorunk van, akkor két m hosszúságú rendezett sorozat O(logm) lépéssel összefésülhető. Az ezt megoldó algoritmus neve LOGÖSSZEFÉSÜL. Ez az algoritmus nem munkaoptimális, de munkahatékony. 2.3.2. Páratlan-páros összefésülő algoritmus Ez az algoritmus a klasszikus oszd meg és uralkodj elvet alkalmazza. Legyen X1=k1,k2,...,km és X2=km+1,km+2,...,k2m a két bemenő sorozat. Az egyszerűség kedvéért legyen m kettő hatványa és a kulcsok legyenek különbözőek. 2.5. példa.Kétszer nyolc szám összefésülése. Legyen X1=2, 5, 8, 11, 13, 16, 21, 25 és X2 = 4, 9, 12, 18, 23, 27, 31, 34. A 16 szám rendezését mutatja a következő 2.6. ábra. 2.6. ábra. 16 szám rendezése a PÁRATLANPÁROSÖSSZEFÉSÜL algoritmussal. 2.13. tétel (összefésülés O(logm) lépéssel). A PÁRATLAN-PÁROS-ÖSSZEFÉSÜL algoritmus két m hosszúságú kulcssorozatot O(logm) lépéssel összefésül 2m EREW PRAM processzoron. Bizonyítás. Legyen az algoritmus lépésszáma M(n). Az 1. lépés O(1) ideig tart. A 2. lépés m2 ideig tart. Innen az M(m)=M(m2)+O(1)(2.10) rekurzív egyenlőséget kapjuk, melynek megoldása M(m)=O(logm). Az összefésülő algoritmusok helyessége a nulla-egy elv segítségével bizonyítható. Egy összehasonlítás alapú rendező algoritmus egyszerű, ha az összehasonlítandó elemek sorozata előre meg van határozva (ekkor a következő összehasonlítás elemei nem függnek a mostani eredménytől). Formálisan ez azt jelenti, hogy adott az összehasonlítandó elempárok indexeinek (i1,j1),(i2,j2),...,(im,jm) sorozata. 2.14. tétel (nulla-egy elv). Ha egy egyszerű összehasonlításos rendező algoritmus helyesen rendez egy n hosszúságú nulla-egy sorozatot, akkor tetszőleges kulcsokból álló n hosszúságú sorozatot is helyesen rendez. Bizonyítás. Legyen A egy egyszerű összehasonlításos (növekvőleg) rendező algoritmus és legyen S egy olyan kulcssorozat, melyet az adott algoritmus rosszul rendez. Ekkor a rosszul rendezett S sorozatban van olyan kulcs, amely az i -edik (1in1) helyen van annak ellenére, hogy S -ben legalább i nála kisebb elem van. Legyen kS legelső (legkisebb indexű) ilyen kulcsa. A bemenő sorozatban írjunk a k -nál kisebb elemek helyére nullát, a többi elem helyére egyest. Ezt a módosított 0-1 sorozatot A helyesen rendezi, ezért a k helyére írt egyest a rendezett sorozatban legalább i darab nulla megelőzi. Most kihasználjuk, hogy A egyszerű. A bemenő sorozatban színezzük pirosra a k -nál kisebb (nulla) elemeket, és kékre a többit (egyeseket). Indukcióval megmutatjuk, hogy az eredeti és a 0-1 sorozatnak megfelelő színes sorozatok minden összehasonlítás után azonosak. A színek szerint háromféle összehasonlítás van: kék, piros vagy különböző színű elemek összehasonlítása. Ha azonos színű elemeket hasonlítunk össze, akkor a színek sorozata egyik esetben sem változik. Ha viszont különböző színű elemeket hasonlítunk össze, akkor mindkét esetben a piros elem kerül a kisebb, és a kék elem a nagyobb indexű helyre. Eszerint k -t legalább i nála kisebb elem megelőzi a rendezett sorozatban. Az ellentmondás az állítás helyességét mutatja. 2.6. példa.Egy nem összehasonlításos rendező algoritmus. Legyen k1,k2,...,kn egy bitsorozat. Rendezhetjük úgy, hogy megszámoljuk a nullák z számát, majd leírunk előbb z nullát, majd nz egyest. Erre az elv nem alkalmazható, mert ez nem összehasonlításos rendezés. Az összefésülés viszont rendezés, és a páros-páratlan összefésülés egyszerű. 2.15. tétel. A Páratlan-páros-összefésül algoritmus helyesen rendez tetszőleges számokból álló sorozatokat. Bizonyítás. Legyenek X1 és X2 rendezett 0-1 sorozatok, melyek közös hossza m . Legyen q1(q2) az X1(X2) elején álló nullák száma. Az X1ptn ban lévő nullák száma q1/2, és az X1prs -ban lévő nullák száma q1/2. Így az L1 -beli nullák száma z1=q1/2+q2/2 és az L2 -beli nullák száma z2=q1/2+q2/2.z1 és z2 különbsége legfeljebb 2. Ez a különbség pontosan akkor kettő, ha q1 és q2 is páratlan. Egyébként a különbség legfeljebb 1. Tegyük fel, hogy |z1z2|=2 (a többi eset hasonló). Most L1 -ben kettővel több nulla van. Amikor ezeket a harmadik lépésben összekeverjük, akkor L elején nullák vannak, azután 1,0, majd egyesek. A rendezetlen ( piszkos ) rész csak az 1,0. Amikor a harmadik lépésben az utolsó összehasonlítás és csere megtörténik, az egész sorozat rendezetté válik. 2.3.3. Munkaoptimális algoritmus Most 2m/logm processzoron O(logm) lépéssel végezzük az összefésülést. Ez az OPTIMÁLISANÖSSZEFÉSÜL algoritmus az eredeti problémát O(m/logm) részre osztja úgy, hogy mindegyikben O(logm) hosszúságú OPTIMÁLISANÖSSZEFÉSÜL rendezett sorozatokat kell összefésülni. Ezek a részproblémák soros algoritmussal O(logm) lépéssel megoldhatók. Legyen X1=x1,x2,...,xm és X2=xm+1,xm+2,...,xm+m a két bemenő sorozat. Osszuk X1 -et mlogm részre: ekkor mindegyikben legfeljebb logm kulcs lesz. A részek legyenek A1,A2,...,AM, ahol M=mlogm. Az Ai -beli legnagyobb kulcs legyen li(i=1,2,...,M) . Rendeljünk egy-egy processzort ezekhez az li elemekhez. Ezek a processzorok bináris kiválasztással meghatározzák liX2 -beli (rendezés szerinti) helyét. Ezek a helyek felbontják X2 -t M részre (ezek között üres részek is lehetnek – lásd a következő 2.7. ábrát). Jelöljük ezeket a részeket B1,B2,...,BM -mel. Bi -t az Ai -nek X2 -ben megfelelő részhalmaznak nevezzük. Ekkor X1 és X2 összefésülését megkaphatjuk úgy, hogy rendre összefésüljük A1 -et B1 -gyel, A2 -t B2 -vel és így tovább, majd ezeket a sorozatokat egyesítjük. 2.16. tétel. Az OPTIMÁLISAN-ÖSSZEFÉSÜL két m hosszúságú rendezett kulcssorozatot O(logm) lépésben összefésül 2mlogmCREW PRAM processzoron. Bizonyítás. Az előző algoritmust alkalmazzuk. Az Ai részek hossza logm , a Bi részek hossza azonban nagy is lehet. Ezért még egyszer alkalmazzuk a felbontást. Legyen Ai,Bi tetszőleges pár. Ha |Bi|=O(logm), akkor Ai és Bi egy processzoron O(logm) lépésben alatt összefésülhető. Ha viszont |Bi|=ω(logm) , akkor osszuk Bi -t |Bi|logm részre – ekkor minden rész legfeljebb logm egymást követő kulcsot tartalmaz. Mindegyik részhez rendeljünk egy processzort, és az keresse meg az ennek a sorozatnak megfelelő részhalmazt Ai -ben: ehhez O(loglogm) lépés elegendő. Így Ai és Bi összefésülése |Bi|logm részproblémára redukálható, ahol minden részprobléma két O(logm) hosszúságú sorozat összefésülése. 2.7. ábra. Munkahatékony összefésülő algoritmus. A felhasznált processzorok száma i=1M|Bi|/logm, ami legfeljebb m/logm+M , és ez legfeljebb 2M. 2.3.4. Egy még gyorsabb algoritmus Ha az előző algoritmust kiegészítjük az oszd-meg-és-uralkodj elvvel, akkor még gyorsabb algoritmust kapunk. Legyen Ai és Bi tetszőleges pár. Ha |Bi|=O(b) , akkor a két sorozat O(1) lépésben összefésülhető mε -áris kereséssel (ahol εtetszőleges pozitív szám ) . Ha viszont |Bi|=ω(b) , akkor Bi -t |Bi|b részre osztjuk, ahol Bi -nek minden részben legfeljebb b egymást követő eleme van. Rendeljünk minden részhez b processzort, hogy megtalálják az ehhez a halmazhoz tartozó részhalmazt Ai ben: ehhez O(1) lépés elég. Így Ai és Bi összefésülésének problémája |Bi|b részproblémára redukálható, ahol minden részprobléma két O(b) hosszúságú sorozat összefésülése. A felhasznált processzorok száma i=1bb|Bi|/b, ami legfeljebb 2m. 2.17. tétel (összefésülés O(loglogm) lépésben). Két m hosszúságú rendezett kulcssorozat O(loglogm) lépésben összefésülhető 2mCREW PRAM processzoron. Bizonyítás. Legyen X1 és X2 a két adott sorozat. Legyenek a kulcsok különbözők és legyen 2m=b . Az algoritmus a feladatot N2b részfeladatra redukálja, melyek mindegyike két O(b) hosszúságú rendezett sorozat összefésülése. A redukció m processzoron O(1) lépésben elvégezhető. Ha az algoritmus lépésszáma 2m processzoron T(m), akkor T(m) kielégíti a T(m)=T(O(b))+O(1) rekurzív egyenletet, melynek megoldása O(loglogm). Ez az algoritmus nem munkaoptimális, bár Θ(m)/Θ(loglogm)=Θ(m/loglogm) gyorsítása nagyon közel van m -hez. Hatékonysága csak Θ(1/loglogm). 2.4. Rendezés Adott n2 kulcs. A feladat ezek csökkenő vagy növekvő sorrendbe való rendezése. Ismert, hogy ha a megengedett művelet a szokásos összehasonlítás, akkor minden A soros algoritmusnak N(n,A)=Ω(nlogn) lépésre van szüksége, másrészt vannak O(nlogn) lépésszámú összehasonlítás alapú algoritmusok, amelyek tehát aszimptotikusan optimálisak. Más műveletek vagy a rendezendő kulcsok speciális tulajdonságai esetében a rendezés O(n) lépéssel is megoldható. Ha legrosszabb esetben minden kulcsot meg kell vizsgálni, akkor természetesen a lépésszám N(n)=Ω(n). Tehát mind az összehasonlítás alapú, mind pedig a speciális esetben ismert aszimptotikusan optimális soros algoritmus. Vizsgáljuk meg a következő kérdéseket. Hány rendező algoritmus van? Ezek közül hány egyszerű, hány optimális (aszimptotikusan, szigorúan)? Ezekre a kérdésekre nem könnyű válaszolni – például először pontosan definiálnunk kell, mi is az a rendező algoritmus. Szűkítsük a kérdést: hány összehasonlításra van szükség n elem rendezéséhez? jelöljük ezt a számot c(n) -nel. Ismert, hogy i=1nlogic(n)i=1nlogi(2.11) és hogy c(n)nlogn(n1).(2.12) Az alsó becslés döntési fákkal vagy információelméleti eszközökkel igazolható (lásd az alsó korlátokról szóló 1.7. alfejezetet), a felső becslések pedig a bináris beszúró, illetve az összefésüléses rendező jellemző adatai. 4 elemre az alsó és a felső becslések egyaránt ötöt adnak. 5 elemre 5! = 120 miatt az alsó becslés 7, viszont az előbbi algoritmusoknak 8 összehasonlításra van szüksége. n2 processzoron a kulcsok rangja O(logn) lépéssel meghatározható. Ha a rangokat ismerjük, akkor a rendezés egy párhuzamos írással megoldható. Tehát igaz a következő tétel. 2.18. tétel (rendezés O(logn) lépésben). n kulcs n2CRCW PRAM processzoron rendezhető O(logn) lépéssel. Mivel a kulcsok meghatározása Ω(logn) ideig tart, ez a módszer Θ(n2logn) munkát igényel, azaz nem munkahatékony. 2.4.1. Páratlan-páros algoritmus Ez az algoritmus a klasszikus oszd meg és uralkodj elvet alkalmazza. Az egyszerűség kedvéért legyen n kettő hatványa és a kulcsok legyenek különbözők. A következő EREW PRAM algoritmus O(log2n) lépést tesz. Ez az algoritmus hasonlít a soros összefésüléses algoritmusra. Ott azonban a sorozatok legkisebb elemeit hasonlítjuk össze és a kisebb elem az összehasonlítás eredménye. 2.19. tétel (rendezés O(log2n) lépéssel). n kulcs nEREW PRAM processzoron rendezhető O(log2n) lépéssel. Bizonyítás. Legyen T(n) az algoritmus lépésszáma. Az 1. lépés O(1) ideig tart, a 2. lépés T(n2) ideig, a 3. lépés pedig O(logn) ideig. Ezért T(n) kielégíti a T(n)=O(1)+T(n2)+O(logn)(2.13) rekurzív egyenlőséget, melynek megoldása T(n)=O(log2n). 2.7. példa.Rendezés 16 processzorral. Rendezzük 16 processzoron a következő számokat: 25, 21, 8, 5, 2, 13, 11, 16, 23, 31, 9, 4, 18, 12, 27, 34. Az első lépésben a páros és páratlan részeket kapjuk meg, majd a másodikban az első 8 processzor a páratlan részből kapja az X1=2,5,8,11,13,16,21,25 -öt, a második 8 processzor pedig az X2=4,9,12,18,23,27,31,34 -et. A harmadik lépésben kapjuk az eredményt. Ez az algoritmus Θ(nlog2n) munkát végez. Hatékonysága Θ(1logn) , gyorsítása Θ(nlogn). 2.4.2. Egy véletlenített algoritmus (*) Az O(log2n) lépésszám véletlenített algoritmussal is elérhető. 2.20. tétel (rendezés O¯(log2n) lépéssel). n kulcs nCREW PRAM processzoron rendezhető O¯(log2n) lépéssel. Bizonyítás. Ismert, hogy n elem közül n/logn processzoron a kiválasztás O¯(logn) lépéssel megoldható. Legyen n processzorunk. Ekkor n adott kulcs k mediánja O¯(logn) lépéssel megtalálható. Osszuk X -et 2 részre: X1 tartalmazza a k -nál nem nagyobb kulcsokat, X2 pedig a többi kulcsot. Az X1 és X2 részeket rekurzívan rendezzük n/2 processzoron, majd az eredményeket láncoljuk össze. Ha a rendezés ideje T(n), akkor T(n)=T(n2)+O¯(logn),(2.14) melynek megoldása T(n)=O¯(log2n). 2.4.3. Preparata algoritmusa Több processzorral a lépésszám csökkenthető: Preparata algoritmusa nlogn CREW PRAM processzoron logn párhuzamos lépést végez. Ez az algoritmus oszd meg és uralkodj elvű. A kulcssorozatot logn részre osztjuk, majd a részeket páronként összefésülve minden kulcsnak minden részre nézve meghatározzuk a rangját. Ezután a kulcsok tényleges rangja az előbbi rangok összege. Ha a harmadik lépésben minden (i,j) párhoz n/logn processzort rendelünk, akkor az összefésülés O(loglogn) lépéssel elvégezhető. A negyedik lépésben a rang számítása párhuzamosan végezhető a harmadik lépésben kapott logn rang összeadásával: ez a prefixet számító algoritmussal O(loglogn) lépéssel megoldható. 2.21. tétel (rendezés O(logn) lépéssel). A Preparata algoritmus n elemet nlogn CREW PRAM processzoron O(logn) lépéssel rendez. Bizonyítás. Legyen a Preparata-algoritmus futási ideje T(n). Az első lépés időigénye T(n/logn), a második és harmadik lépésé együtt O(loglogn). Ezért T(n)=T(nlogn)+O(loglogn).(2.15) melynek megoldása (helyettesítéses módszerrel) T(n)=O(logn). A lassulásra vonatkozó tétel segítségével kapjuk a következő állítást. 2.22. következmény (rendezés nlognt processzoron). Tetszőleges t1 egész számra n tetszőleges kulcs rendezhető O(tlogn) lépésben nlognt CREW PRAM processzoron. A Preparata-algoritmus munkája ugyanannyi, mint a páros-páratlan rendező algoritmusé, viszont a gyorsítása jobb: Θ(n) . Mindkét algoritmus hatékonysága Θ(1/logn). 2.4.4. Reischuk véletlenített algoritmusa (*) Reischuk algoritmusa n processzoron O¯(logn) párhuzamos lépést tesz, azaz nagy valószínűséggel munkahatékony. Alapja Preparata algoritmusa és a következő tétel. 2.23. tétel (korlátos egészek rendezése). Ha n kulcs mindegyike [0,n(logn)c] intervallumból vett egész szám (ahol c tetszőleges konstans), akkor ezek a kulcsok nlogn CREW PRAM processzoron rendezhetők O¯(logn) lépésben. Az algoritmus a következő. 2.24. tétel (tetszőleges kulcsok gyors rendezése). A Reischuk algoritmus n tetszőleges kulcsot n CREW PRAM processzoron O¯(logn) lépésben rendez. Bizonyítás. Reischuk algoritmusa szerint véletlenül kiválasztunk N=n/log4n kulcsot és ezeket Preparata algoritmusával rendezzük. Ez a rendezett minta az eredeti sorozatot N+1 – közel azonos hosszúságú – részsorozatra bontja, melyeket Preparata algoritmusával rendezünk: ezek a rendezett részsorozatok a megfelelő sorrendben véve megadják az eredményt. A Reischuk algoritmus második lépése NlogNNlogn processzoron O(logN)=O(logn) idő alatt elvégezhető. A harmadik lépésben X felbontását bináris kereséssel és az egészeket rendező algoritmussal végezzük: minden kulcshoz tartozik egy processzor, amely az l1,l2,...,lN sorozatban végzett bináris kereséssel megadja, hogy az adott kulcs a Ki részhalmazok melyikéhez tartozik. Mivel a részek sorszámai a [0,N+1] intervallumból vett egészek, az előző tétel alapján legfeljebb n processzoron O¯(logn) lépéssel rendezhetők. A Ki(1iN) részekben nagy valószínűséggel nem lesz több elem, mint O(log5n) . Ugyanennyi processzoron és lépéssel a |Ki| elemszámokat is meg tudjuk határozni minden részre. A negyedik lépésben minden Ki rész rendezhető |Ki|log|Ki| processzoron log|Ki| lépéssel. Ezért a negyedik lépés n processzoron (maxilog|Ki|)2(2.16) lépéssel elvégezhető. Ha maxi|Ki|=O(log5n) , akkor a negyedik lépés O((loglogn)2) lépéssel elvégezhető. 2.5. Gráfalgoritmusok Legyen M egy n×n méretű mátrix, amelynek az elemei nemnegatív egész számok. Az M mátrixot M minmátrixának nevezzük és a következőképpen definiáljuk: M(i,i)=0(1in)(2.17) és M(i,j)=min{Mi0i1+Mi1i2+...+Mik1ik}(ij),(2.18) ahol a minimumot az olyan – az {1,2,...,n} halmaz elemeiből képezett – i0,i1,...,ik permutációkra nézve képezzük, amelyekre i0=i és ik=j . Legyen G egy irányítatlan gráf, amelynek n csúcsa van. Ennek reflexív tranzitív lezártját A*-gal jelöljük és úgy definiáljuk, hogy ha i=j vagy Vi és VjG -nek ugyanahhoz az összefüggő komponenséhez tartoznak, akkor A*(i,j)=1, egyébként A*(i,j)=0 2.8. példa. Irányított gráf és minmátrixa. Legyen G(V,E) egy irányított gráf, melynek csúcsait az 1,2,...,n számokkal címkézzük. Legyen M[i,j]=0 , ha i=j vagy a gráf tartalmaz i -ből j -be vezető élet. Egyébként M[i,j] legyen 1. Ekkor M(i,j) pontosan akkor nulla, amikor van az i csúcsból a j csúcsba vezető út. A 2.8. ábra egy 6-csúcsú irányított gráfot, valamint a hozzá tartozó M mátrixot és annak minmátrixát ábrázolja. 2.8. ábra. Egy gráf és annak M -je és M -je. 2.5.1. Minmátrix Több – gráfokkal kapcsolatos – feladat megoldását megkönnyíti a minmátrixok felhasználása. A MINMÁTRIX algoritmus meghatározza adott M mátrix minmátrixát. Ezzel kapcsolatos a következő állítás. 2.25. tétel (minmátrix számítása). Ha ε tetszőleges pozitív szám, akkor a MIN-MÁTRIX algoritmus n3+ε CRCW PRAM processzoron O(logn) lépésben meghatározza egy n×n méretű mátrix minmátrixát. 2.5.2. Tranzitív lezárt A 2.25. tétel segítségével belátható a következő állítás. 2.26. tétel (tranzitív lezárt számítása). Ha ε tetszőleges pozitív szám, akkor n3+ε CRCW PRAM processzoron O(logn) lépésben meghatározható egy n -csúcsú irányított gráf tranzitív lezártja. Bizonyítás. Ha M -et a 2.8. példa szerint definiáljuk, akkor egy G gráf tranzitív lezártja a minmátrix segítségével könnyen meghatározható. 2.5.3. Összefüggő komponensek Ugyancsak a 2.25. tétel segítségével bizonyíthatjuk a következő állítást. 2.27. tétel (összefüggő komponensek számítása). Ha ε tetszőleges pozitív szám, akkor n3+ε CRCW PRAM processzoron O(logn) lépésben meghatározhatók egy n -csúcsú gráf összefüggő komponensei. Bizonyítás. Legyen M[i,j]=0 , ha i=j vagy i és j össze vannak kötve egy éllel. Egyébként M[i,j] legyen 1. Az i és j csúcsok pontosan akkor vannak ugyanabban az összefüggő komponensben, ha M[i,j]=0. 2.5.4. Minimális feszítőfa A soros Kruskal-algoritmus párhuzamosításával belátható a következő állítás. 2.28. tétel (minimális feszítőfa). . Ha ε tetszőleges pozitív szám, akkor n5+εCRCW PRAM processzoron O(logn) lépésben meghatározható egy n -csúcsú élsúlyozott gráf minimális feszítőfája. 2.5.5. Konvex burok Gyakorlatok 2.5–1. A globális memória M1 rekeszében van bizonyos adat. Másoljuk át ezt az adatot az M2,M3,...,Mn rekeszekbe. Mutassuk meg, hogyan lehet ezt megvalósítani O(logn) lépéssel n EREW PRAM processzor felhasználásával. 2.5–2. Adjunk meg egy olyan algoritmust, amely n/logn EREW PRAM processzor felhasználásával O(logn) lépéssel megoldja az előző gyakorlatot. 2.5–3. Legyen f(x)=anxn+an1xn1++a1x+a0. Adjunk O(1) idejű CREW PRAM algoritmust a polinom értékének adott x helyen való kiszámítására. Mennyi processzort igényel a javasolt algoritmus? 2.5– 4. Adjunk meg egy O(loglogn) idejű algoritmust, amely n/loglogn közös CRCW PRAM processzoron O(loglogn) lépésben megadja n tetszőleges szám maximumát. 2.5–5. Legyen A egy n kulcsot tartalmazó tömb. Mutassuk meg, hogy n/logn CREW PRAM processzoron O(logn) lépésben meghatározható tetszőleges kA kulcs rangja. 2.5–6. Tervezzünk egy O(1) lépésszámú algoritmust, amely n közös CRCW PRAM processzoron eldönti, hogy adott A[1..n] tömb elemei között előfordul-e az 5, és ha igen, megadja a legnagyobb olyan i indexet, amelyre A[i]=5. 2.5–7. Tervezzünk algoritmust, amely n2 CREW PRAM processzoron O(1) lépésben összefésül két n hosszúságú rendezett sorozatot. 2.5–8. Határozzuk meg a fejezetben tárgyalt algoritmusok relatív sebességét, összes lépésszámát és hatékonyságát. Feladatok 2-1. Közös elem Tervezzünk algoritmust annak eldöntésére, hogy adott A[1..n] és B[1..n] tömböknek van-e közös eleme: a. ha n2 CRCW PRAM processzorunk van, akkor O(1) lépésszámút; b. ha n CRCW PRAM processzorunk van, akkor O¯(1) lépésszámút. 2-2. Minimális feszítőfa Párhuzamosítsuk a minimális feszítőfák meghatározására szolgáló Kruskal-algoritmust és Primalgoritmust. Tervezzünk algoritmust arra a speciális esetre, amikor az élek súlya csak 0 vagy 1 lehet. 2-3. Összes csúcspár távolsága Párhuzamosítsuk a gráfok összes csúcspárjának távolságát meghatározó Bellman– Ford-algoritmust. 2-4. Körmentesség Tervezzünk párhuzamos algoritmust annak eldöntésére, hogy adott irányítatlan gráf tartalmaz-e kört. Elemezzük a különböző nagyságrendű processzorszám esetében elérhető W(n,p, P ) futási időket. 3. Rácsok Ebben a fejezetben rácsokat (láncot, négyzetet és kockát) alkalmazunk számítási modellként. 3.1. Számítási modellek A k dimenziós (k1) dimenziós rács egy olyan m1×m2××mk (m1,m2,...,mk2) méretű háló, amelynek minden egyes metszéspontjában van egy processzor. Az élek a kommunikációs vonalak, melyek kétirányúak. A rács egy processzorát megcímkézzük egy (i1,i2,...,ik)k-assal, – erre a processzorra a Pi1,...,ik jelöléssel hivatkozunk. Minden processzor egy RAM, amely rendelkezik saját (helyi) memóriával. A Pi1,...,ik processzor saját memóriája az M[i1,...,ik,1],M[i1,...,ik,2],...,M[i1,...,ik,m] rekeszekből áll. Minden processzor végre tud hajtani egyetlen lépésben olyan alapvető műveleteket, mint az összeadás, kivonás, szorzás, összehasonlítás, saját memória elérése és így tovább. A processzorok működése szinkron módon történik, azaz minden processzor egy globális óra ütemére egyszerre hajtja végre az aktuális feladatát. A legegyszerűbb rács a k=1 értékhez tartozó lánc alakú rács (röviden lánc ). Egy 6 processzoros lánc látható a 3.1. ábrán. 3.1. ábra. 6 processzoros lánc. Egy lánc processzorai P1,P2,...,Pp . Ezek a következőképpen vannak összekötve. P1 és Pp kivételével mindegyik processzor össze van kötve a nála eggyel nagyobb (jobb szomszéd), illetve eggyel kisebb (bal szomszéd) indexűvel, míg a két szélső processzornak csak egy szomszédja van, P2 , illetve Pp1 . Az összeköttetés kétirányú. Ha k=2, akkor téglalap alakú rácsot kapunk. Ha most m1=m2=2p=a, akkor a×a méretű négyzetet kapunk. Egy 4×4 méretű négyzet látható a 3.2. ábrán. 3.2. ábra.4×4 méretű négyzet. Egy a×a méretű négyzet tartalmaz részgráfként számos a processzoros láncot. A rács algoritmus egyes lépései gyakran tekinthetők láncokon végzett műveleteknek. A processzorok közötti kommunikáció bármely rögzített összekötöttségű gépben kommunikációs láncok segítségével történik. Ha két olyan processzor akar kommunikálni egymással, amik egy éllel össze vannak kötve, akkor azt egyetlen lépésben elvégezhetik. Ha nincs közöttük él, akkor az őket összekötő utak valamelyikén történhet meg a kommunikáció, tehát a szükséges lépésszám (legalábbis rövid üzenetek esetén) függ az út hosszától. Feltesszük, hogy egy processzor egyetlen lépésben képes végrehajtani egy számítást és/vagy kommunikálni akár mind a négy szomszédjával. Egy rácsban azok a processzorok, amelyeknek első (második) koordinátája megegyezik, egy sort (oszlopot) alkotnak. Például egy a×a méretű négyzetben az i -edik sor a Pi,1,Pi,2,...,Pi,a processzorokból áll. Mindegyik sor vagy oszlop egy a processzoros lánc. Egy rács algoritmus gyakran áll olyan lépésekből, melyeket csak bizonyos sorokban vagy oszlopokban lévő processzorok végeznek el. Ha k=3 , akkor tégla alakú rácsot kapunk. Az m1=m2=m3=32p speciális esetben kockáról és a kocka méretére az n×n×n jelölést alkalmazzuk. A 3.3. ábra egy 2×2×2 méretű kockát ábrázol. 3.3. ábra.2×2×2 méretű kocka. 3.2. Csomagirányítás A processzorok közötti kommunikáció egyetlen lépése egy rögzített szerkezetű hálózatban a következő – csomagirányítási problémának nevezett – feladatként fogható fel. A hálózatban minden processzornak van egy adatcsomagja, amit egy másik processzornak akar elküldeni. A feladat a csomagok eljuttatása a céljukhoz a lehető leggyorsabban úgy, hogy egy lépésben egy kommunikációs csatornán egy irányban egyszerre csak egy csomag utazhat. Az utóbbi feltételre a csatorna sávszélességének korlátozottsága miatt van szükség. Könnyen előfordulhat, hogy egy adott lépésben kettő vagy több csomag érkezik egy processzorhoz, és mindegyik ugyanazon a csatornán szeretne továbbhaladni. Ilyen esetben természetesen csak egy csomag utazhat a következő lépésben, a többiek pedig a processzornál egy várakozási sorba kerülnek a későbbi továbbküldés miatt. Egy elsőbbségi szabály alapján döntjük el, hogy melyik csomagot küldjük el ilyen esetekben. Ilyen elsőbbségi szabályok például az FDF ( Farthest Destination First) FOF ( Farthest Origin), First) , FIFO , RAN (véletlenül választunk). A csomagirányítási feladat egy speciális esete a parciális permutációs csomagirányítás ( Partial Permutation Routing). A PPR-ben minden processzornak legfeljebb egy elküldendő csomagja van, és egy adott processzorhoz legfeljebb egy csomagot kell küldenünk. A PPR-t egy ERCW PRAM gépen egy párhuzamos írással megoldhatjuk. De egy általános rögzített összekötöttségű hálózatban a probléma gyakran igen bonyolult. Tipikusan a bemenet egy bizonyos sorrendben kerül a processzorokhoz, és a kimenetnek úgyszintén egy előre megadott sorrendben kell megjelennie. Csupán egy ilyen sorrend átrendezés néha több PPR-t igényelhet. Ezért bármely nem triviális rögzített összekötöttségű hálózati algoritmus tervezéséhez szükség van PPRekre. Ez az egyik lényeges különbség a hálózati és a PRAM algoritmusok között. Egy csomagirányítási algoritmus legfontosabb jellemzői a futási ideje amíg az utolsó csomag is eléri a célját, és a várakozási sor hossza ami az egy processzornál maximálisan várakozó csomagok száma. A sor lehetséges hosszát alulról korlátozza az egy processzortól induló, valamint az egy processzorhoz érkező csomagok maximális száma. Feltételezzük, hogy a csomag nemcsak a küldendő információt tartalmazza, hanem a küldő és a célprocesszor azonosítóját is. Egy csomagirányítási algoritmus bemenő adatai a csomagok indulási helye és célja, valamint a használni kívánt elsőbbségi szabály. Egy csomag utazásának lépésszáma az indulás és a cél között megtett út és a sorokban eltöltött várakozás hosszától függ. 3.1. példa.4 csomag irányítása. Tekintsük az a,b,c,d csomagokat a 3.4. ábra (a) részén. A rendeltetési helyüket az ábra (g) része mutatja. Használjuk a FIFO elsőbbségi szabályt úgy, hogy holtverseny esetén önkényesen döntsünk valamelyik csomag a javára. A csomagok a lehető legrövidebb úton közlekedjenek. A t=1 sorszámú lépésben minden csomag eggyel közelebb kerül a céljához. Ennek eredményeként az a és a b ugyanazon a ponton vannak, tehát a t=2 sorszámú lépésben valamelyiket várakoztatni kell. Mivel mindketten egyszerre érkeztek, ezért ez egy holtverseny. Önkényesen döntünk, ezért nyerjen mondjuk a. Ugyanebben a lépésben még c és d is csatlakozik b -hez. A következő lépésben b fog továbbmenni, mivel ő előbb érkezett, és ezért elsőbbsége van a többihez képest. A negyedik lépésben c és d holtversenyben küzd a továbbhaladásért. Legyen d a győztes, aki tovább haladhat. További két lépésben c is eljut a céljába. Ekkorra minden csomag megérkezett. Az a csomagnak öt élen kellett áthaladnia, és közben sehol sem várt – ezért öt időegység alatt ért célba. A c csomagnak négy élen kellett átutaznia, és két alkalommal várt, ezért hat időegység alatt ért célba – ez adja az algoritmus futási idejét. Vajon más elsőbbségi szabályt használva csökkenhet a lépésszám? Játsszuk végig az előző példát az FDF szabállyal. Ekkor a futási idő öt időegység lesz. 3.4. ábra. Példa csomagirányításra. 3.2.1. Csomagirányítás láncon Egy láncon, mivel az összekötöttség kétirányú, a processzor egyszerre küldhet és fogadhat a szomszédjaitól üzeneteket. Ennek következtében két ellentétes irányú csomaglánc nem zavarja egymást. Ebben a részben megmutatjuk, hogy a PPR láncon megoldható legfeljebb p1 lépésben. Vegyük észre, hogy a legrosszabb esetben legalább p1 lépés kell, hiszen ez a lehető legnagyobb távolság két processzor között. Láncon PPR-en kívül vizsgálunk még néhány általánosabb csomagirányítási feladatot is. 3.2. példa.Független csomagáramok. A 3.5. ábrán a balról jobbra haladó csomagokat körökkel, a jobbról balra haladó csomagokat pedig pipával jelöltük. feltesszük, hogy a balra haladó csomagok célja P1, a jobbra haladó csomagoké pedig Pp. Például az a és b csomagoknak egyidejűleg van szüksége ugyanarra az élre, amikor az első lépést megteszik (ellenkező irányban). Mivel az élek kétirányúak, nincs verseny, a csomagok használhatják egyszerre az élet. Mivel a P1 processzortól induló csomagnak p1 élen kell keresztül haladnia, ezért a célba éréshez legalább p1 lépésre van szüksége. 3.5. ábra. A jobbra és balra haladó csomagáramok függetlenek. Tegyük fel, hogy egy p processzorból álló láncban minden processzor legfeljebb egy üzenetet küld, az üzenetek célja tetszőleges lehet. Továbbítsuk a csomagokat a célprocesszorokhoz. Ezt a feladatot egy kezdőcsomagos feladatnak nevezzük. 3.1. lemma(egy kezdőcsomagos feladat). Az egy kezdőcsomagos feladat egy p processzoros láncon megoldható legfeljebb p1 lépésben. Bizonyítás. Minden q üzenetet küldhetünk a kezdő és a végpont közötti legrövidebb úton. Tekintsük csak azokat az üzeneteket, amelyek balról jobbra utaznak, hiszen a jobbról balra utazókat teljesen hasonlóan függetlenül vizsgálhatjuk. Ha q a Pi processzortól indul és Pj felé tart, akkor ji lépésben éri azt el, hiszen sosem kell várakoznia egy másik üzenetre. A leghosszabb ilyen út 1-től p-ig vezet, ezért p1 felső korlát a lépésszámra. Az egy csúcsba küldött csomagok maximális száma jellemzi az algoritmus várakozási sorának hosszát. Adott egy p processzorból álló lánc. A Pi processzor ki(0kip) üzenetet akar küldeni és i=1pki=p.(3.1) Nincs két olyan üzenet, amelyeket azonos processzorhoz kellene küldeni. Továbbítsuk a csomagokat a célprocesszorokhoz. Ezt a feladatot egy célcsomagos feladatnak nevezzük. 3.2. lemma(egy célcsomagos feladat). Ha az FDF elsőbbségi szabályt használjuk, akkor az egy célcsomagos feladat egy p processzoros láncon megoldható legfeljebb p1 lépés alatt. Bizonyítás. Tegyük fel, hogy q üzenet Pi-ből Pj-be megy. Az általánosság megszorítása nélkül feltehetjük, hogy a csomag balról jobbra halad. A jobbról balra haladó csomagoktól eltekinthetünk hasonló okok miatt, mint az előző lemmánál. Minden csomag a lehető legrövidebb úton halad, ami a mi esetünkben ji lépést jelent. Ne feledkezzünk meg azonban azokról a csomagokról, amelyek j-nél nagyobb indexű processzorokhoz utaznak, mivel ezek (és csak ezek) megvárakoztathatják q-t. Ezen csomagok száma legfeljebb pj. Jelölje k1,k2,...,kj1 a kezdeti állapotban rendre a P1,P2,...,Pj1 processzortól induló ilyen csomagok számát. Jelölje m minden lépés után azt az indexet, melyre km1>1, és ha msj, akkor ks1. Nevezzük a km,km+1,...,kj1 sorozatot szabad sorozatnak. Vegyük észre, hogy az elkövetkezőkben a szabad sorozatban egyik csomag sem fog várakozni. Ezenfelül minden egyes lépésben legalább egy csomag csatlakozik a szabad sorozathoz. A 3.6. ábra egy szabad sorozatot mutat. Az ábrán a számok a megfelelő processzoroknál (melyeknek csak az indexe szerepel az ábrán) lévő csomagok számát mutatják. Például a nulladik lépésben (t=0) lépésben Pi-nél 3 csomag van és 1, 0, 1, 1 a szabad sorozat. A következő lépésben (t=1) egy, majd az azt követő lépésben (t=2) 4 új csomag csatlakozik a szabad sorozatban lévő csomagokhoz. 3.6. ábra. Szabad sorozat. Így legfeljebb pj lépés után minden olyan csomag csatlakozott a szabad sorozathoz, amely miatt q várakozásra kényszerülhet. Ezt a helyzetet mutatja a 3.7. ábra: a q csomagnak a legfeljebb pj lépésnyi várakozáson felül ji lépést kell tennie, ezért legfeljebb pi lépés után célba ér. 3.7. ábra. A 3.1. lemma bizonyításának szemléltetése A jobbról balra haladó csomagok esetében hasonlóan belátható, hogy legfeljebb i1 lépésben megérkeznek a rendeltetési helyükre. Most definiáljuk az általános csomagirányítási feladatot. Tételezzük fel, hogy egy p processzoros láncon több csomag származhat egy processzortól és több csomagot küldhetünk egy processzorhoz. Továbbá a P1,P2,...,Pj(j=1,2,...,p) processzoroktól összesen induló csomagok száma nem több, mint j+f(p),p valamely rögzített f(p) függvényére. Továbbítsuk a csomagokat a célprocesszorokhoz. 3.3. lemma(Általános csomagirányítási feladat). Ha a FOF elsőbbségi szabályt használjuk, akkor az általános csomagirányítási probléma megoldható p+f(p) lépésben. Bizonyítás. Legyen q egy Pi-ből Pj-be utazó üzenet, ahol i<j (a j>i eset hasonlóan kezelhető). A q csomag legfeljebb i+f(p) csomag miatt várakozhat, hiszen csak ennyi csomag érkezhet távolabbról és lehet ezért nagyobb prioritása. Ha q minden egyes ilyen csomag miatt legfeljebb egyszer kényszerül várakozni, akkor az összes várakozási lépésszáma legfeljebb i+f(p). Ha azonban valamely r csomag mondjuk kétszer várakoztatja meg q-t, ez azt jelenti, hogy r várakozásra kényszerült egy másik, nagyobb prioritású csomag miatt, ami sosem fogja q-t megvárakoztatni. Emiatt q várakozása legfeljebb i+f(p) lehet. Mivel q-nak már csak ji lépést kell megtennie, ezért legfeljebb j+f(p) lépés kell q helyre szállításához. Az összes csomagra ez a lépésszám legfeljebb p+f(p) . 3.3. példa.A 3.3lemma bizonyításának szemléltetése. A 3.8. ábra mutatja a 3.3. lemma bizonyításának menetét (a processzoroknak itt is csak az indexe szerepel). A példában 8 csomag van: a,b,c,d,e,f,g,h . Vizsgáljuk a g csomagot. Ezt a csomagot a többi 7 csomag késleltetheti. A g csomag a t=9 sorszámú lépésben éri el célját. Megtett útjának hossza 2, késleltetése 7. Az ábra nem mutatja azokat a csomagokat, amelyek a Pj csúcsban keresztezték egymást. 3.8. ábra. A 3.3. lemma bizonyítását illusztráló példa. 3.2.2. Egy mohó algoritmus a PPR megoldására rácson A PPR probléma megoldásához egy 2p×2p=a×a méretű rácson egy üzenetnek az (1,1) csúcsból az (a,a) csúcsba szállításához legalább N(n,a2,P)2(a1) lépésre van szükség. Ezért 2(a1) egy alsó korlát bármely csomagirányító algoritmus lépésszámának legrosszabb esetét vizsgálva: W(n,a2,A)2(a1). Egy egyszerű PPR algoritmus, amely felhasználja a láncoknál ismertetett csomagirányítási algoritmusokat, a következő. Legyen q egy tetszőleges csomag, amelyet a Pi,j processzortól a Pk,l indexűnek kell elküldeni. Az csomag az első fázisban a j -edik oszlop mentén a k -adik sorig halad a legrövidebb úton. A második fázisban a k -adik sor mentén a legrövidebb úton az l -edik oszlophoz elérve a csomag megérkezett a rendeltetési helyére. Egy csomag azonnal megkezdheti a második fázist az első befejezése után, nem kell semmi másra várnia. Az első fázis legfeljebb a1 lépésben elvégezhető, mivel a 3.1. lemma alkalmazható. A második fázis a 3.4. lemmából következően nem tart a1 lépésnél tovább. Így az algoritmus lépésszáma legfeljebb 2(a1), ami az elméleti alsó korlát, azaz az algoritmus abszolút optimális. De van egy komoly hátránya ennek az algoritmusnak, mégpedig az, hogy a várakozási sor hossza a/2. Nézzünk erre egy példát. Legyen a csomagirányítási feladat olyan, hogy az első oszlop minden csomagját a a/2 -edik sorba kelljen szállítani. Egy ilyen PPR esetén a (a/2,1) indexű processzor minden lépésben két csomagot kap. Mivel mindkettő ugyanazt a kommunikációs vonalat szeretné használni, ezért az egyik a várakozási sorba kerül. Ez megismétlődik egészen az a/2 -edik lépésig, mikor is a/2 csomag lesz az (a/2,1) processzor várakozási sorában. Ezt a helyzetet mutatja a 3.9. ábra. 3.9. ábra. A mohó algoritmusnak hosszú sorra van szüksége. Az ideális olyan algoritmus lenne, amelynek O(1) méretű várakozási sorra van szüksége (vagy legalább olyan algoritmus, melyre az f(p) függvény lassan nő, mint például a logp). 3.2.3. Egy kis várakozási sort használó véletlenített algoritmus (*) A kétfázisú mohó algoritmus módosítható a véletlenítés segítségével úgy, hogy csak O¯(logp) méretű várakozási sort használjon. Az új HÁROM-FÁZISÚ algoritmus három fázisú és a lépésszáma 3a+o¯(a). Ebben az algoritmusban a három fázis teljesen elkülönül, azaz egy fázis csak akkor kezdődhet el, ha az előző fázist már minden csomag befejezte. Ez a megszorítás egyszerűbbé teszi az elemzést Legyen q egy tetszőleges csomag, amelyet Pi,j-től Pk,l-hez kell továbbítani. 1. fázis . A q csomag választ egy véletlen Pi,j processzort starthelyének oszlopában és a legrövidebb úton eljut oda. 2. fázis . A q csomag az i-edik sor mentén továbbítódik a Pi,l processzorhoz. 3. fázis . Végül q – az l-edik oszlop mentén haladva – eléri rendeltetési helyét. 3.4. tétel. A HÁROM-FÁZISÚ algoritmus befejeződik 32p+O¯(p1/4logp) lépés alatt. Bizonyítás. A 3.1. lemma alkalmazásából adódik, hogy az első fázis legfeljebb a lépésben befejeződik, mivel egyetlen csomag sem kényszerül várakozásra. Tegyük fel, hogy egy csomag a második fázist a Pi,j processzornál kezdi. Az általánosság megszorítása nélkül feltehetjük, hogy a csomag jobbra mozog. A Pi,j processzortól induló csomagok száma ennél a lépésnél egy binomiális eloszlású valószínűségi változó B(a,1a)(3.2) paraméterekkel. Azért ennyi, mert a csomag van a j -edik oszlopban és mindegyik 1a valószínűséggel kerül Pi,j -hez az első fázis végén. Ezenfelül a második fázis kezdetén a Pi,1,Pi,2,...,Pi,j processzoroktól induló csomagok száma szintén binomiális eloszlású B(ja,1a)(3.3) paraméterekkel. (Felhasználtuk azt a tényt, hogy B(n1,x)+B(n2,x)=B(n1+n2,x).) Ennek a változónak a várható értéke j. A Csernov-egyenlőtlenséget felhasználva ez a szám 1pα1 valószínűséggel legfeljebb j+3αp1/4lnp minden α1 számra. Így ez az érték j+O¯(p1/4logp). A 3.5. lemmát alkalmazva most azt kapjuk, hogy a második fázis a+O¯(p1/4logp) lépésben befejeződik. A harmadik fázis elején bármely oszlopban akármelyik processzortól legfeljebb a csomag indul és legfeljebb egy csomag érkezik. Ezért a 3.4. lemmának megfelelően a harmadik fázis legfeljebb a lépést igényel. 3.3. Alapfeladatok Ebben az alfejezetben négy alapfeladat megoldását mutatjuk be: üzenetszórás, prefixszámítás, adatkoncentráció és ritka rendezés. Egy a×a méretű rácson mind a négy feladat megoldható O(a) lépésben. Mivel egy üzenet a négyzetrács egyik sarkából csak d=2(a1) lépésben juthat el az átellenes sarokba, ez a szám a lépésszám alsó korlátja az előbbi feladatokra, és legrosszabb esetben szükség van az átellenes sarokban lévő processzorok közti kommunikációra. A d szám a négyzetrács átmérője. A k-k irányítási feladat a következő. A hálózat bármely processzorától bármely másikhoz legfeljebb k csomagot kell elküldeni. 3.3.1. Üzenetszórás Az üzenetszórási feladat szerint a hálózat megadott processzorától üzenetet kell eljuttatni megadott célprocesszorokhoz (rendszerint az összes többi processzorhoz). Legyen L egy p processzoros lánc és legyen M egy üzenet, amelyet a P1 processzornak kell elküldenie a többi processzorhoz. A feladat megoldható olyan egyszerűen, hogy P1 elküldi az üzenetet P2-nek, az tovább küldi P3-nak és így tovább. Ekkor az üzenet p1 lépésben eljut a legtávolabbi processzorhoz, Pp-hez. Mivel a lánc átmérője p1, ez a lehető legkisebb lépésszám. Egy a×a méretű négyzetrácsban az üzenetküldést két fázisban valósíthatjuk meg. Az első fázisban az üzenetet küldő Pi,j processzor eljuttatja üzenetét az iedik sor minden processzorához. Ezután a második fázisban az i-edik sor minden processzora eljuttatja az üzenetet a vele azonos oszlopban lévő processzorokhoz. Ez összesen legfeljebb 2(a1) lépést vesz igénybe. Formalizáljuk állításunkat. 3.5. tétel. Egy p processzoros láncon az üzenetszórás p1=O(p) lépés alatt elvégezhető. Egy a×a méretű rácson az üzenetszórás 2(a1)=O(a) lépésben elvégezhető. 3.4. példa.Üzenetszórás rácson. A 3.10. ábra egy 4×4 méretű négyzeten való üzenetszórás két fázisát mutatja. Az üzenetek a P2,3 processzortól indulnak és az első fázisban eljutnak a P2,1,P2,2 és P2,4 processzorokhoz. A második fázisban a második sor processzorai mind felfelé, mind lefelé elküldik az M üzenetet. Az üzenetszórás a legrosszabb esetre jellemző 6 lépés helyett már 4 lépés alatt befejeződik. 3.10. ábra. Üzenetszórás négyzeten. 3.3.2. Prefixszámítás A második fejezetben több algoritmust ismertettünk, amelyek különböző párhuzamos gépeken megoldják a prefixszámítási feladatot. Most láncon és négyzeten alkalmazható algoritmusok következnek. Prefixszámítás láncon Tegyük fel, hogy az L=P1,P2,...,Pp lánc Pi(i=1,2,...,p) processzorának saját memóriájában van az xi elem, és a számítás végén a Pi processzor memóriájában lesz az yi prefix. Először nézzünk egy naiv algoritmust. Közvetlenül adódik ennek az algoritmusnak a futási ideje. 3.6. tétel. A LÁNC-PREFIX algoritmus egy láncon Θ(p) idő alatt határozza meg p elem prefixeit. Mivel egy soros processzorral p elem prefixei O(p) lépésben meghatározhatók, ugyanakkor m(p,p, LÁNC-PREFIX )=p2, ezért LÁNC-PREFIX nem munkahatékony. Hasonló algoritmus alkalmazható négyzeten is. Tekintsünk egy a×a méretű négyzetet. Szükségünk van a processzorok egy indexelésére. Ilyenek a sorfolytonos, az oszlopfolytonos, kígyószerű sorfolytonos és a blokkonként kígyószerű sorfolytonos indexelés. A blokkonként kígyószerűen sorfolytonos indexelésnél a rácsot megfelelő méretű kisebb blokkokra bontjuk, és a blokkokon belül alkalmazzuk valamelyik indexelést. A négyzeten való prefixszámítás 3 fázisra osztható, melyekben a számításokat minden fázisban vagy csak soronként, vagy oszloponként végezzük. Az alábbi NÉGYZETEN-PREFIX algoritmus sorfolytonos indexelést alkalmaz. A futási idő a következő. 3.7. tétel. A NÉGYZETEN-PREFIX algoritmus a×a méretű négyzeten sorfolytonos indexeléssel 3a+2=O(a) lépésben elvégzi a prefixszámítást. 3.5. példa.Prefixszámítás 4×4 méretű négyzeten. A 3.11. ábra (a) részén 16 rendezendő szám látható. Az első fázisban minden sorban kiszámítjuk a prefixeket – az eredményt a (b) rész mutatja. A második fázisban csak a negyedik oszlopban számolunk – az eredmény a (c) részen látható. Végül a harmadik fázisban aktualizáljuk a prefixeket – az eredményt a (d) rész mutatja. 3.11. ábra. Prefixszámítás négyzeten. 3.3.3. Adatkoncentráció Tegyük fel, hogy egy p processzoros hálózatban d adat van (d<p) – processzoronként legfeljebb egy. Adatkoncentráció az a feladat, hogy az adatokat egyesével helyezzük el az első d processzornál. Lánc esetében az adatokat a P1,P2,...,Pd processzorokhoz kell mozgatni. Rács esetében tetszés szerinti indexelés alkalmazható. 3.8. tétel. Az adatkoncentráció p processzoros láncon legfeljebb 2p lépésben, a×a méretű négyzeten 6a+O¯(p1/4) lépésben megoldható. Bizonyítás. 3.3.4. Ritka rendezés Ha a rendezendő kulcsok száma lényegesen kisebb, mint a rendező hálózat mérete, akkor ritka leszámláló rendezésről beszélünk. 3.9. tétel (rendezés négyzeten). Ha a rendezendő kulcsok száma legfeljebb a, akkor a RITKA-RENDEZ algoritmus rendezés egy négyzeten O(a) lépés alatt befejeződik. 3.6. példa.4 kulcs rendezése egy 4×4 méretű négyzeten. A 3.12. ábra mutatja a (8,5,3,7) kulcssorozat rendezését egy 4×4 méretű négyzeten. Az ábra (a) részében a bemenő adatok láthatók (a processzorok első soránál). Az első lépésben az algoritmus az oszlopokban szórja az üzenetet (a j -edik oszlopban kj-t): az eredményt a (b) részen látjuk. A második lépésben soronként szórjuk az üzeneteket (az i-edik sorban ki-t) – az eredmény a (c) részben látható. A 3. és 4. lépés utáni helyzetet – amikor a kulcsok és rangjaik az első sorban vannak – tükrözi a (d) ábrarész. Az (e) részben a kulcsok már rendezve vannak a processzorok első sorában. 3.12. ábra. Ritka leszámláló rendezés négyzeten. 3.4. Kiválasztás A második fejezetben már foglalkoztunk a speciális és általános kiválasztási feladat megoldására alkalmas PRAM algoritmusokkal. Négyzeten két változatot vizsgálunk. Az egyikben feltételezzük, hogy a kulcsok és a processzorok száma megegyezik. A második változat szerint a processzorok száma kisebb, mint a kulcsok száma. Ha a számítási modellünk PRAM, akkor az első feladatot megoldó algoritmus és a lassulási tétel segítségével olyan algoritmust kaphatunk, amely hasznosítja az elvégzett munkát. Rácsokra azonban nem ismert ilyen általános, a lassulásra vonatkozó állítás. Ezért a második esetet külön kell kezelni. 3.4.1. Véletlenített algoritmus az p=n esetre (*) A párhuzamos gépre javasolt VÉLETLEN-HATÉKONYAN-KIVÁLASZT algoritmus módosítható úgy, hogy négyzeten is munkaoptimális legyen – így kapjuk a NÉGYZETEN-HATÉKONYAN-KIVÁLASZT algoritmust. Erre az algoritmusra érvényes a következő állítás. 3.10. tétel. A NÉGYZETEN-HATÉKONYAN-KIVÁLASZT algoritmus p kulcs esetében egy négyzeten O(a) lépésben megoldja a kiválasztási feladatot. Bizonyítás. A fokozat a while ciklus magjának egyszeri végrehajtása. Korábban megmutattuk, hogy az algoritmus O¯(1) fokozat alatt véget ér. A HATÉKONY-KIVÁLASZT algoritmus első szakasza rácson O(1) lépést igényel. A 2–5. lépésekből álló szakaszban leírt prefixszámítás O(a) lépés alatt befejeződik. A 2–6.lépésekben végzett adatkoncentrációhoz a 3.11. tétel szerint elég O(2p) lépés. A 3. és 6. szakaszban végzett ritka rendezéshez szintén elég O(2p) lépés. A 4. és 6. szakaszban végzett kiválasztás konstans lépésben elvégezhető, mivel rendezett sorozatból kell választani. 3.4.2. Véletlenített algoritmus, ha a processzorsám kicsi (*) Tegyük fel, hogy kevesebb processzorunk van, mint kulcsunk. Ha feltesszük, hogy alkalmas c>1 konstanssal teljesül n=pc, akkor a HATÉKONY-KIVÁLASZT algoritmus ennek a feladatnak a megoldására is átalakítható. Minden processzor np kulccsal kezd. A while utasítás feltétele N>D lesz (ahol D egy állandó). A második lépésben a processzorok minden hozzájuk tartozó kulcsot 1N1(1/3c) valószínűséggel veszik a mintához. Ezért ez a lépés np időt vesz igénybe. A mintában lévő kulcsok száma O¯N1/3c=o¯(2p). A harmadik lépés változatlan és O(2p) időt vesz igénybe. Mivel a mintában csak O¯(N1/3c) kulcs van, a negyedik lépésben O(2p) idő alatt koncentrálhatók és rendezhetők. Az ötödik lépés O(2p) ideig tart, a hatodik és hetedik ugyancsak. Így minden fokozat O(np+2p) ideig tart. Ennek az algoritmusnak a lépésszámára vonatkozik a következő tétel. 3.11. tétel. Ha c>1 állandó és n=pc, akkor az n kulcs közül történő kiválasztás egy négyzeten O¯((np+2p)loglogp) lépésben elvégezhető. Bizonyítás. A 2.3. lemmából következik, hogy az egyes fokozatokat túlélő kulcsok száma legfeljebb 22αN1(1/6c)2logN=O¯(N1(1/6c)2logN),(3.4) ahol N az élő kulcsok száma az adott fokozat kezdetekor. Ebből adódik, hogy az algoritmusnak csak O¯(loglogp) fokozata van. 3.4.3. Determinisztikus algoritmus kis processzorszámra Az algoritmus alapja, hogy az elemeket például ötös csoportokra bontja, minden csoportnak meghatározza a mediánját, majd kiszámítja ezen mediánok M mediánját. Ezután meghatározzuk M rangját (rM), majd az irM összehasonlítás eredményétől függően elhagyjuk az M-nél nagyobb, illetve nem nagyobb elemeket. Végül a megmaradó kulcsok közül rekurzívan kiválasztjuk a megfelelőt. Amikor ezt az algoritmust hálózatban hajtjuk végre, akkor célszerű arra törekedni, hogy a kulcsok egyenletesen legyenek a processzorok között elosztva. Ennek érdekében a mediánok M mediánját súlyozással számoljuk: minden csoportot az elemszámának megfelelő súllyal veszünk figyelembe. Legyen X=k1,k2,...,kn egy kulcssorozat, és legyen wi a ki kulcs súlya, továbbá legyen a súlyok összege W : W=i=1nwi.(3.5) Ekkor az X sorozat súlyozott mediánja az a kjX kulcs, amelyre kmX,kmkjwklW2(3.6) és kmX,kmkjwklW2.(3.7) 3.7. példa. Súlyozott médián meghatározása. A súlyozott médián meghatározásának egyik módja, hogy rendezzük a kulcsokat, és az így kapott X=k1,k2,...,kn kulcssorozathoz tartozó W=w1,w2,...,wn rendezett súlysorozatnak meghatározzuk a legkisebb olyan prefixét (az összeadás a művelet), amely már legalább W2. Legyen X = 1, 3, 5, 6, 4, 2 és a megfelelő súlyok legyenek 1, 2, 3, 4, 5, 6. Ekkor W=21,W= 1, 6, 2, 5, 3, 4 és a prefixek 1, 7, 9, 14, 17, 21. Mivel 14 a legelső megfelelő prefix, ezért XW-vel súlyozott – mediánja 4 (és ennek súlya 5). 3.8. példa. Kiválasztás3×3méretű rácson. A 3.13. ábra determinisztikus kiválasztást mutat be. 3.13. ábra. Determinisztikus kiválasztás 3×3 méretű négyzeten. A futási idő a következő. 3.12. tétel (kiválasztás négyzeten). A DET-NÉGYZETEN-KIVÁLASZT algoritmus n kulcs közül a×a méretű négyzeten O(nploglogp+alogn) lépésben megoldja a kiválasztást. 3.5. Összefésülés A második fejezetben több algoritmust is elemeztünk, amelyek PRAM segítségével oldották meg az összefésülési feladatot. 3.5.1. Rangon alapuló összefésülés láncon A RANGSOROL rangsorolási algoritmus átalakítható úgy LÁNCONÖSSZEFÉSÜL algoritmussá, hogy a futási ideje lineáris legyen. Legyen L egy p processzoros lánc. A bemenő sorozatok legyenek X1=k1,k2,...,km és X2=km+1,km+2,...,k2m. Kezdetben a Pi processzornál két kulcs van: ki és ki+m. A 3.14. ábra mutatja, hogyan utaznak a ci számlálót tartalmazó csomagok, amelyek végül visszatérnek a Pi processzorhoz. 3.14. ábra. Kulcsok rangjának számítása. kulcsok rangja 3.13. tétel (rangsorolásos összefésülés láncon). Két p hosszúságú rendezett sorozat egy p processzoros láncon O(p) lépésben összefésülhető. 3.5.2. Páratlan-páros összefésülés láncon 3.14. tétel (páros-páratlan összefésülés láncon). Két m hosszúságú sorozat egy 2m processzoros láncon O(m) lépésben összefésülhető. 3.9. példa. Két 4 hosszúságú sorozat összefésülése 8 processzoron. A 3.15. ábra mutatja, hogyan fésüli össze az algoritmus a rendezett (3,5,6,8) és (1,4,2,7) sorozatokat egy 8 processzoros láncon. Az ábra (a) része a bemenő adatokat mutatja. A (b) rész a bemenő sorozatok páros és páratlan indexű elemeket tartalmazó részsorozatokra való felbontását mutatja. A (c) rész az P2 és Q1 sorozatok felcserélésével kapott állapotot tükrözi. A (d) ábrarész a P1 és P2, valamint a Q1 és Q2 sorozatok (rekurzív) összefésülésével kapott sorozatokat tartalmazza. A következő két ábrarész az összekeveréssel kapott sorozatot, illetve a cserélő-összehasonlítással kapott végeredményt ábrázolja. 3.15. ábra. Páratlan-páros összefésülés láncon 3.5.3. Páratlan-páros összefésülés négyzeten Ebben a szakaszban négyzet a számítási modell. Feltesszük, hogy a 2 hatványa és a bemenő adatok két részre osztva, a 3.16. ábra (a) részének megfelelően kígyószerűen helyezkednek el az 1,2,...,a/2, illetve az a/2+1,a/2+2,...,a oszlopindexű processzorok helyi memóriájában. Mindkét rész a oszlopból és a/2 sorból álló adatkígyó. 3.16. ábra. Páratlan-páros összefésülés négyzeten Ennek a két rendezett sorozatnak az összefésülésére alkalmas a következő algoritmus. Most megmutatjuk, hogy ez az algoritmus O(a) lépésben befejeződik. 3.15. tétel (kígyók rendezése rácson). . A RÁCSON-PP-FÉSÜL algoritmus két a×a2 hosszúságú rendezett adatkígyót O(a) lépésben összefésül egy a×a méretű négyzeten. Bizonyítás. Az algoritmus lépésszámára az M(l)M(l2)+2l(3.8) adódik, amelynek a megoldása M(l)=O(2p). 3.6. Rendezés A 2. fejezetben foglalkoztunk PRAM modellen rendező algoritmusokkal. Most lánc és rács lesznek a felhasznált számítási modellek. 3.6.1. Rendezés láncon A LÁNCON-RANG-RENDEZ algoritmus először meghatározza a rendezendő kulcsok rangját, majd eljuttatja a kulcsokat a megfelelő helyre. A LÁNCONBUBORÉK-RENDEZ algoritmus a soros buborékrendezéshez hasonlít. Rangsoroló rendezés láncon Ez az algoritmus O(p) lépést tesz. 3.16. tétel. A LÁNCON-RANG-RENDEZ algoritmus p kulcsot egy p processzoros láncon O(p) lépésben rendez. Páratlan-páros felcserélő rendezés láncon A LÁNCON-PP-RENDEZ algoritmus alapötlete ugyanaz, mint a soros buborékrendezésé: a szomszédos kulcsokat összehasonlítjuk és szükség esetén felcseréljük. Ez az algoritmus is O(p) lépést tesz. 3.17. tétel. A LÁNCON-PP-RENDEZ algoritmus egy p processzoros láncon p kulcsot O(p) lépésben rendez. 3.17. ábra. Páros-páratlan felcserélő rendezés láncon Páratlan-páros összefésülő rendezés láncon A LÁNCON-FÉSÜL-RENDEZ algoritmus alapötlete ugyanaz, mint a soros buborékrendezésé: a szomszédos kulcsokat összehasonlítjuk és szükség esetén felcseréljük. Ez az algoritmus is O(p) lépést tesz. 3.18. tétel. A LÁNCON-FÉSÜL-RENDEZ algoritmus egy p processzoros láncon p kulcsot O(p) lépésben rendez. 3.6.2. Rendezés négyzeten Két algoritmust vizsgálunk ebben az alfejezetben. A SHEARSON-RENDEZ Θ(aloga) lépést tesz, a másik viszont O(a) lépésszámának köszönhetően munkahatékony. Schearson rendező algoritmusa Ebben a pontban Schearson algoritmusát mutatjuk be. 3.10. példa.Schearson-rendezés. A 3.18. ábra (a) része egy 4×4 méretű négyzeten elrendezett kulcsokat ábrázol. Az első fázisban a sorokat rendezzük – az egymást követő sorokat ellenkező módon (az első sort növekvőleg, a másodikat csökkenőleg stb.) Az első fázis eredményét mutatja az ábra (b) része. Az ábra következő részei rendre a második, ..., ötödik fázis utáni helyzetet mutatják. Az ötödik fázis végén a négyzet rendezve van. 3.18. ábra. Példa Schearson-rendezésre Páratlan-páros összefésülő rendezés Most a páratlan-páros rendezési algoritmust négyzeten valósítjuk meg. Egy példát mutat a 3.19. ábra. 3.19. ábra. Páratlan-páros összefésülés négyzeten Az algoritmus futási ideje a következő. 3.19. tétel (páratlan-páros összefésülő rendezés). p elem 2p×2p méretű négyzeten O(2p) lépésben rendezhető. 3.11. példa. 16 elem rendezése páratlan-páros összefésüléssel A 3.19. ábra mutatja 16 szám rendezését négyzeten kígyószerű sorfolytonos sorrendbe. 3.7. Gráfalgoritmusok Ebben az alfejezetben először néhány kockán futó gráfalgoritmust mutatunk be, majd négyzeten oldunk meg gráfokkal kapcsolatos feladatokat. 3.7.1. Kocka Ebben a szakaszban kocka lesz a számítási modell. A minmátrix, tranzitív lezárt, és az összefüggő komponensek számítását mutatjuk be. Újra alkalmazzuk a második fejezetben a tranzitív lezárt, összefüggő komponensek és legrövidebb utak meghatározására kidolgozott formalizmust. Először a minmátrix számítására mutatunk egy algoritmust, amely n×n×n méretű kockán O(nlogn) lépést tesz. Ezután a tranzitív lezárt, a legrövidebb utak és a konvex burok meghatározására mutatunk be négyzeten működő algoritmusokat. Minmátrix számítása Az M mátrixból az M¯ mátrixot egy kockán O(nlogn) lépésben meg tudjuk határozni. Egy n×n×n méretű kocka elemeit úgy definiáljuk, hogy (i,*,*) azokat a processzorokat jelöli, amelyeknek az első koordinátája i. 3.20. tétel (minmátrix számítása kockán). Egy n×n méretű mátrix minmátrixa egy n×n×n méretű kockán O(nlogn) lépésben kiszámítható. Irányított gráf tranzitív lezártja Az előzőek alapján adódik a KOCKA-LEZÁR algoritmus, melynek lépésszáma a következő. 3.21. tétel (tranzitív lezárt számítása kockán). Egy n csúcsú irányított gráf tranzitív lezárt mátrixa egy n×n×n méretű kockán O(nlogn) lépésben kiszámítható. Összefüggő komponensek meghatározása 3.22. tétel (összefüggő komponensek számítása rácson). Egy n csúcsú irányított gráf összefüggő komponensei egy n×n×n méretű kockán O(nlogn) lépésben kiszámíthatók. Bizonyítás. A minmátrixra vonatkozó tétel segítségével. 3.7.2. Négyzet Ebben az alfejezetben a tranzitív lezárt és a legrövidebb utak számítására determinisztikus, a teljes párosítás keresésére (páros gráfban és általános gráfban) pedig véletlenített algoritmust mutatunk be. Tranzitív lezárt Egy n -csúcsú gráf tranzitív lezártja meghatározható úgy, hogy n×n méretű mátrixokkal logn szorzást végzünk. A következő tétel ezen szorzások négyzeten való gyors elvégezhetőségét mondja ki. 3.23. tétel (mátrixok szorzása négyzeten). Az n×n méretű A=a[i,j] és B[i,j] mátrixok egy n×n méretű négyzeten O(n) idő alatt összeszorozhatók. Ennek a tételnek a segítségével belátható a következő állítás. 3.24. tétel (tranzitív lezárt rácson). Adott irányítatlan gráf tranzitív lezárt mátrixa egy n×n méretű négyzeten O(nlogn) lépésben meghatározható. Bizonyítás. A tétel bizonyítását a 3.20. ábra és a 3.21. ábra segítségével szemléltetjük. 3.20. ábra. Két mátrix szorzása. 3.21. ábra. Az adatáram szimulálása. Legrövidebb utak A legrövidebb utak minden csúcspárra való meghatározására vonatkozik a következő tétel. 3.25. tétel (legrövidebb utak meghatározása négyzeten). A legrövidebb utak egy gráf minden csúcspárjára egy négyzeten O(nlogn) lépésben meghatározhatók. Konvex burok n síkbeli pont konvex burka egy n -processzoros láncon O(n) idő alatt meghatározható (ld. 3.10. gyakorlat). Ez az idő nagy valószínűséggel lényegesen csökkenthető. Legyen H1 és H2 a síkbeli pontok két felső burka. 3.26. lemma(érintő számítása). Legyen H1 és H2 két olyan felső burok, amelynek legfeljebb n pontja van. Ha P pontja H1 -nek, akkor a H2 -vel bezárt szöge O(2n) lépésben meghatározható. 3.27. lemma(két felső burok közös érintője). Ha H1 és H2 két felső burok legfeljebb n ponttal, akkor közös érintőjük O(2nlogn) lépésben meghatározható. A két lemmából adódik a következő tétel. 3.28. tétel (konvex burok számítása). n síkbeli pont közös konvex burka egy 2n×2n méretű négyzeten O(2nlog2n) lépésben meghatározható. 3.12. példa.16 pont konvex burka. A 3.22. ábra (a) része 16 pont adatait mutatja. Ezek az adatok egy 4×4 méretű négyzetnek megfelelően vannak elrendezve. A 4 részre tagolt adatok minden negyedrészben az x -koordináták szerint rendezve tartalmazzák az adatokat (azonban nem sorfolytonosan, hanem kígyószerű sorrendben). A felső burok (rekurzív) kiszámításának eredményét mutatja az ábra (b) része. A két felső, és a két alsó negyedrész összefésülésének eredményét mutatja az ábra (c) része. Végül az ábra felső részén, illetve alsó részén ábrázolt burok összefésülésével kapjuk az ábra (d) részén bemutatott végeredményt. 3.22. ábra. Felső burok számítása. Az összefésülés gyorsabb megoldásával csökkenthetjük az algoritmus lépésszámát. A Felső-burkot-fésül algoritmus összesen legfeljebb a2 pontot tartalmazó felső burkokat O(a) lépésben összefésül. 3.23. ábra. Két felső burok összefésülése. 3.29. lemma. A FELSŐ-BURKOT-FÉSÜL algoritmus egy a×a méretű rácson O¯(a) lépésben összefésül két konvex burkot. Innen adódik, hogy a konvex burkot nagy valószínűséggel az előbbinél gyorsabban is meg tudjuk határozni. 3.30. tétel (konvex burok négyzeten). A KONVEX-BUROK-NÉGYZETEN algoritmus egy a×a méretű négyzeten O¯(a) lépésben meghatározza a2 pont konvex burkát. Gyakorlatok 3.7–1. Mennyi a FOF és a LIFO elsőbbségi algoritmusok lépésszáma a 3.1. példa adatai esetében? 3.7–2. Egy p processzoros lánc minden processzoránál két csomag van. Feltesszük, hogy p páros. A Pi processzornál lévő csomagok rendeltetési helye a Pp/2+i(i=1,2,...,p2+i) . Minden csomag a számára legrövidebb úton jut el a célba. Határozzuk meg a csomagok utazási idejét a FOF, FDF, FIFO és LIFO elsőbbségi módszerek esetében. 3.7–3. Egy a×a méretű rácsban minden processzortól legfeljebb k1 csomag indul és minden processzorhoz legfeljebb k csomag érkezik. Tervezzünk algoritmust, amely legfeljebb (k+1)p2 lépésben megoldja a csomagirányítási feladatot. 3.7–4. Mutassuk meg, hogy egy p processzoros gyűrűben a PPR probléma p2 lépésben megoldható. 3.7–5. Hogyan oldható meg a szuffixszámítási feladat egy 2p×2p méretű rácson O(2p) lépésben? 3.7–6. p elem közül kell a maximálisat megkeresni egy 2p×2p méretű rács segítségével. Az A algoritmus T(2p) lépésben meghatározza p elem súlyozott mediánját. Hogyan használható fel A a keresésre és milyen lépésszámot kapunk? 3.7–7. Legyen f(x)=anxn+an1xn1++a1x+a0.(3.9) Tervezzünk algoritmust, amely láncon és rácson meghatározza az f(x) polinom értékét egy x=x0 helyen. Mennyi lesz a tervezett algoritmus lépésszáma? 3.7–8. Tekintsünk egy 2p×2p méretű négyzetet, melynek minden processzorának memóriájában van egy, a [0,pε] intervallumból vett egész szám, ahol ε a (0,1) intervallumból vett állandó. Tervezzünk algoritmust a legnagyobb kulcs kiválasztására. Mennyi lesz e tervezett algoritmus lépésszáma? 3.7–9. Valósítsuk meg a rangsorolási algoritmust egy 2p×2p méretű rácson. 3.7–10. Mutassuk meg, hogy p pont konvex burka O(p) lépésben meghatározható egy p processzoros láncon. 3.7– 11. Tervezzünk algoritmust, amely láncon és rácson meghatározza, hogy adott n pont között van-e 3 olyan pont, amelyek egy egyenesre esnek. Mit mondhatunk algoritmusaink lépésszámáról és a felhasznált processzorok számáról? Feladatok 3-1. Csomagok irányítása közeli célokhoz Egy a×a méretű rácsban minden processzor legfeljebb egy üzenetet küld és legfeljebb d távolságra. Tervezzünk csomagirányítási algoritmust, amely O¯(d) lépést tesz. 3-2. Csomagirányítás tóruszon Módosítsuk úgy a HÁROMFÁZISÚ algoritmust, hogy tóruszon 1.52p+o¯(p) lépést tegyen. 3-3. Palindrómák ellenőrzése Egy adott Σ ábécé feletti w=x1x2...xp szót akkor nevezünk palindrómának, ha w=xpxp1...x1 teljesül. Tervezzünk párhuzamos algoritmust, amely egy p processzoros láncon O(p) lépésben eldönti, hogy egy p hosszúságú szó palindróma-e. 3-4. Gyors Fourier-transzformált kiszámítása Tervezzünk algoritmust, amely egy p processzoros láncon O(p) lépésben kiszámítja egy p hosszúságú vektor FFT-jét (gyors Fourier-transzformáltját). Tervezzünk rácsot használó algoritmust az FFT kiszámítására. Milyen lépésszám érhető el? 3-5. Egycsomagos csomagirányítás Tegyük fel, hogy egy 2p×2p méretű rácsban minden processzor pontosan egy csomagot küld és pontosan egy csomagot fogad. Tervezzünk olyan csomagirányító algoritmust, melynek lépésszáma O(2p), az igényelt sorhosszúsága pedig O(1).3-6. Csoportokba rendezés láncon Tegyük fel, hogy egy logn processzoros lánc minden processzorának memóriájában n/logn kulcs van. Tervezzünk algoritmust, amely biztosítja, hogy P1 memóriájába kerüljön a legkisebb n/logn kulcs, P2 memóriájába a következő n/logn legkisebb kulcs, és így tovább, a legnagyobb indexű processzor memóriájába kerüljön a n/logn legnagyobb kulcs. Mutassuk meg, hogy ez a rendezés megoldható O(n) lépésben. 3-7. Soronkénti és oszloponkénti rendezés Mutassuk meg, hogy ha egy 2p×2p méretű rácsban minden processzor memóriájában van egy kulcs és ezeket a kulcsokat először soronként, azután oszloponként rendezzük, akkor a sorok és oszlopok is rendezettek lesznek. 3-8. Prefix számítása bináris fávalProcesszorok bináris fája (röviden: bináris fa) olyan teljes bináris fa, melynek minden csúcsában van egy processzor és az élek adatátviteli vonalak. A 4.8. ábra egy 4 levelű bináris fát mutat. A bemenő adatok rendszerint a fa levelein jelennek meg. A n levelű bináris fában 2n1 processzor van és a fa magassága logn. Ha minden levélen van egy szám, ezen számok összegét kiszámíthatjuk a következőképpen. Először minden levél elküldi a nála lévő számot a szülőjének. Ha egy belső processzor kap két számot alulról, akkor összeadja őket és az összeget elküldi a szülőjének. Ilymódon logn lépés után a gyökérben megjelenik az összeg. Oldjuk meg a prefixszámítási problémát egy n levelű bináris fával. Kezdetben minden levélnél van egy elem. A prefixek értékét a levelekről lehet kivinni. Hogyan oldható meg a feladat O(n) lépésben? 3-9. Topologikus rendezés rácson Tervezzünk algoritmust, amely rács segítségével topologikusan rendez. 3-10. Körmentesség ellenőrzése Tervezzünk algoritmust, amely rácson ellenőrzi, hogy adott irányítatlan gráf tartalmaz-e kört? 3-11. Minimális feszítőfa 0-1 súlyok esetében Tegyük fel, hogy az irányított gráfok éleinek súlya nulla vagy egy lehet. Tervezzünk rácsalgoritmust, amely meghatározza a minimális feszítőfát. 3-12. Háromszög mátrix invertálása négyzeten Mutassuk meg, hogyan lehet egy a×a méretű háromszög mátrixot O(a) lépésben invertálni egy a×a méretű négyzeten. 3-13. Háromátlós mátrix invertálása négyzeten Mutassuk meg, hogyan lehet egy a×a méretű háromátlós mátrixot O(a) lépésben invertálni egy a×a méretű négyzeten. 3-14. Konvex burok területe Tervezzünk olyan algoritmust, amely egy a×a méretű négyzeten O¯(a) lépésben meghatározza a2 pont konvex burkának területét. 4. Hiperkocka Ebben a fejezetben először a felhasznált számítási modelleket mutatjuk be, azután speciális hálózatos (mint a csomagirányítás, üzenetszórás, adatkoncentráló), végül tipikus,,soros” (mint a kiválasztás, összefésülés, rendezés, gráfokkal kapcsolatos problémák) feladatokat megoldó algoritmusokat elemzünk. 4.1. Számítási modellek Ebben az alfejezetben egyrészt a hiperkocka és pillangó számítási modelleket, másrészt hálózatok egymásba ágyazását tárgyaljuk. 4.1.1. Hiperkocka Az első fejezetben szereplő definíció szerint egy d dimenziós hiperkocka, amelyet Hd -vel jelölünk, 2d processzorból áll. Hd minden processzora megcímkézhető egy d bites bináris számmal. A harmadik fejezetben lévő 3.3. ábra egy 3 dimenziós, a 4.1. ábra pedig egy 4 dimenziós hiperkockát ábrázol. 4.1. ábra. 4 dimenziós hiperkocka. A processzort és címkéjét ugyanazon szimbólummal jelöljük. Ha v egy d bites bináris szám, akkor v első bitjét tekintjük legmagasabb helyiértékűnek. Jelölje v(i) azt a d bites bináris számot, amely v -től csak az i -edik bitjében tér el. Hd minden Pv processzorára igaz, hogy az pontosan a Pv(i)(i=1,2,...,d) processzorokkal van összekapcsolva. A (v,v(i)) kapcsolatot i-edik szintű kapcsolatnak nevezzük. Mivel Hd minden processzora pontosan d másikkal van összekötve, így Hdd -reguláris és a fokszáma d. Az u és v bináris számok Hamming-távolsága azon bitpozíciók száma, amelyeken a két bináris szám eltér. Jele H(u,v). A Hd hiperkocka bármely Pu és Pv processzora között van H(u,v) hosszúságú út. Ha ugyanis u és v két processzor Hd -ben, akkor egy közöttük vezető út megadható a következő módon. Legyenek i1,i2,...,ik azon bitpozíciók (növekvő sorrendben) amelyeken Pu és Pv eltérnek. Ekkor létezik a következő útvonal: u=w0,w1,w2,...,wk=v, ahol wj=wj1(i,j)(1jk). Ebből következik, hogy egy d dimenziós hiperkocka átmérője pontosan d. A hiperkocka minden processzora egy helyi memóriával rendelkező RAM, amely minden alapvető műveletet (összeadás, kivonás, szorzás, osztás, összehasonlítás vagy a hozzáférés a helyi memóriához stb.) egységnyi idő alatt végez el. A processzorok közötti kommunikáció a processzorokat összekötő kapcsolatok mentén történik. Ha két processzor között nincs közvetlen kapcsolat, akkor a kommunikáció az egyik processzortól a másikig vezető út mentén lehetséges, ám az adatátvitel időigénye egyenesen arányos az út hosszával. A kommunikáció egyidejűsége szempontjából kétféle hiperkockát különböztethetünk meg. Az első típus a soros vagy egyportos hiperkocka, amelynél egy processzor egységnyi idő alatt egyetlen szomszédjával képes kommunikálni. Ezzel szemben a párhuzamos vagy többportos hiperkocka egy processzora egységnyi idő alatt mind a d szomszédjával képes adatot cserélni. A továbbiakban mindig jelölni fogjuk, hogy melyik kommunikációs modellt használjuk. Mindkét megoldás szinkron processzorműködést tételez fel, azaz minden időegységben a processzorok mindegyike pontosan egy utasítást hajt végre. A hiperkockáknak több – számunkra kedvező – tulajdonsága is van. Az egyik a kicsi átmérő. Egy p processzoros hiperkockának az átmérője logp, míg az azonos számú processzort tartalmazó rács átmérője legalább 2(2p1). Egy másik kedvező tulajdonság, hogy Hd+1 felépíthető rekurzívan. Vegyük ugyanis Hd két példányát, H -t és H -t. Egészítsük ki H processzorainak címkéjét a 0 prefixszel, H-ét pedig az 1 prefixszel. Ezután H minden Pv processzorát kössünk össze HPv(1) processzorával. Ez a tulajdonság megfordítva azt is jelenti, hogy Hd+1Hdnek két példányát tartalmazza. Például azon processzorok, amelyek címkéjének első bitje 0, ha csak a közöttük futó kapcsolatokat vesszük figyelembe, pontosan kiadják Hd-t. Sőt, tetszőleges 1qd-re, azon processzorok, amelyek címkéjének q -adik bitje azonos, kiadják Hd -t. Még általánosabban, ha rögzítjük i(1id+1) bit értékét, a megadott feltételt kielégítő processzorok H(d+1)it alkotnak. 4.1.2. Pillangó hálózat A pillangóhálózat közeli kapcsolatban áll a hiperkockákkal. A pillangóhálózatokra tervezett algoritmusok könnyedén átültethetők hiperkockákra és fordítva. Valójában gyakran könnyebb az adott probléma megoldását pillangóhálózaton elkészíteni, majd onnan átültetni hiperkockára. Egy d dimenziós pillangóhálózat, amelyet Bd -vel fogunk jelölni, p=(d+1)2d processzorból és d2d+1 élből áll. Bd minden processzora egy r,l párral jellemezhető, ahol 0r2d1 és 0ld. Az r változót a processzor sorindexének nevezzük, míg l a processzor szintje. Egy Pu=r,l processzor (0l<d)Bd-ben két, az (l+1) -edik szinten levő processzorral van összekötve, a Pv=r,l+1 és w=r(l+1),l+1 processzorokkal. Az (u,v) kapcsolatot közvetlen kapcsolatnak,(u,w) -t pedig kereszt kapcsolatnak nevezzük. Mindkét típust (l+1)-edik szintű kapcsolatnak mondjuk. Mivel minden processzor pontosan négy másikkal van összekötve, így Bd csúcsainak fokszáma ( d -től, illetve p -től függetlenül) négy, ezért a d dimenziós pillangó hálózat 4-reguláris és a fokszáma 4. Ha Pu egy 0-adik szintű processzor és Pv egy d-edik szintű, akkor létezik (és egyértelműen meg van határozva) egy d hosszúságú út Pu és Pv között. Legyen Pu=r,0 és Pv=r,d. Ekkor az út r,0,r1,1,r2,2,...,r,d, ahol rinek az első i bitje megegyezik r-vel, a többi pedig r-rel (1id1). Vegyük észre, hogy ez az út létezik a pillangókapcsolatok definíciója miatt. Ezt az utat mohó útnak nevezzük. A 4.2. ábrán B3 látható. A vastagított vonal a Pu=100,0 és Pv=010,3 közötti mohó utat jelöli. 4.2. ábra. 4 sorban 32 processzort tartalmazó pillangó hálózat. A fentiekből következik, hogy Bd -ben bármely két processzor távolsága legfeljebb 2d. A korlát éles, hiszen például a Pu=0,d és Pv=2d1,d processzorok távolsága pontosan ennyi, így Bd átmérője 2d. A pillangóhálózat is rendelkezik a hiperkockához hasonló rekurzív tulajdonsággal. Ha Bd-ből eltávolítjuk a nulladik szinten lévő processzorokat a hozzájuk csatlakozó élekkel együtt, akkor a hálózat két d1 dimenziós pillangóhálózatra esik szét. Hd és Bd között szoros kapcsolat van. Ha Bd minden sorát egyetlen processzorba fogjuk össze, megtartva a kimenő éleket, akkor az eredményül kapott gráf Hd (a keletkező többszörös éleket egyetlen példánnyal helyettesítve). Ennek következményeként kapjuk a következő lemmát. 4.1. lemma(pillangó hálózat szimulálása). Bd minden végrehajtási lépése szimulálható egy párhuzamos Hd egyetlen lépésével vagy egy soros Hdd lépésével. Egy Bd algoritmust normálisnak nevezünk, ha minden időpillanatban legfeljebb egy szint processzorai vesznek részt a kiszámításban. 4.2. lemma(normális algoritmus szimulálása). Egy normális Bd egy lépése szimulálható egy soros Hd egyetlen lépésével. 4.1.3. Hálózatok beágyazása Egy hálózatnak egy másikra történő leképezését beágyazásnak nevezzük. Formálisan, a G(V1,E1) hálózat beágyazása a H(V2,E2) hálózatba, egy leképezés V1-ről V2-re. G-nek H-ra való leképezését felhasználva a G hálózatra tervezett algoritmusok lefuttathatók a H hálózaton. A 4.3. ábra bal oldalán látható G hálózat egy lehetséges beágyazása H -ba a következő leképezés: 1b,2c,3a. 4.3. ábra. Példa beágyazásra. A beágyazás felfúvódásának a |V2|/|V1| hányadost nevezzük. A beágyazás késleltetése a leghosszabb út hossza, amelyre G-nek egy éle leképződött. A H hálózat egy éle torlódásának nevezzük az adott élt használó olyan utak számát, amelyekre G valamely élét leképeztük. A beágyazás torlódása a H élei torlódásának maximuma. A 4.3. ábrán látható példában a felfúvódás mértéke 4/3, a késleltetés 2, mivel minden él egy-egy kettő hosszúságú útra képződött le. Hasonlóan a H összes élének torlódása 2, így az egész leképezés torlódása is 2. Gyűrű beágyazása A p processzoros gyűrű egy síkhálózat, amelyben a Pi(1ip) processzor a Pi+1 és a Pi1 processzorokkal van összekötve – ahol az indexeket (mod p ) vesszük. A 4.4. ábra egy 6 processzoros gyűrűt ábrázol. 4.4. ábra. 6 processzoros gyűrű. Megmutatjuk, hogyan lehet egy 2d processzoros gyűrűt beágyazni Hd-be. Hd processzorait d bites bináris számokkal címkézzük. Ha a gyűrű processzorait 0-tól (2d1)-ig indexeljük a gyűrű mentén, akkor a 0-s processzor Hd000...00 jelű processzorára fog leképződni, a többi processzor megfelelőjét a Gray-kód segítségével határozhatjuk meg. A k-ad rendű Gray-kód – jele Gk – a k bites bináris számok egy adott permutációját definiálja. Az elsőrendű Gray-kód (G1) a következő: 0, 1. Gk -t (k>1) -re rekurzívan definiáljuk a következőképpen: 0[Gk1],1[Gk1]R , ahol 0[Gk1] a (k1) -edrendű Gray-kód elemeit jelenti úgy, hogy mindegyikükhöz hozzáragasztunk egy 0 prefixet. Hasonlóképpen 1[Gk1]R is a (k1) -edrendű Gray-kód elemeit jelenti, ám fordított sorrendben és 1-es prefixszel. A 4.5. ábra azt mutatja, hogyan származtatható G2 a G1 kódból. G0 elemei a nullás prefixszel a 00, 01 sorozatok adják, G1 elemeinek megfordítása az egyes prefixszel pedig az 11, 10 sorozatot eredményezi. Tehát 0[G2]=00,11,11,10. 4.5. ábra. Gray-kód létrehozása. A Gki -edik elemét (0i2k1)g(i,k) -val jelöljük. A Gray-kód egyik tulajdonsága, hogy a szomszédos elemek pontosan egy bitben térnek el egymástól. Ebből az következik, hogy Gd a Hd processzorainak egy olyan permutációja, hogy a sorban egymást követő processzorok össze vannak kötve éllel a hiperkockában, azaz a gyűrű i -edik processzorát (0i2d1) a hiperkocka g(i,d) processzorára képezzük le. 4.3. tétel (gyűrű beágyazása hiperkockába). Egy 2d processzorból álló gyűrű beágyazható Hd -be úgy, hogy a felfúvódás, a késleltetés és a torlódás mindegyike 1 . Tórusz beágyazása Egy m×n tórusz származtatható egy m×n méretű rácsból úgy, hogy a rács minden sorának első és utolsó processzorát, valamint minden oszlopának első és utolsó processzorát is összekötjük: tehát a rácsot kiegészítjük a Pi,1Pi,m(1im) és P1,jP1,n(1jn) élekkel. Már a 3×3 méretű tórusz ábrázolásához is 3 dimenzióra van szükségünk. A 4.6. ábra egy 5×5 méretű tóruszt ábrázol. 4.6. ábra.5×5 méretű tórusz. Legyen M egy 2r×2c méretű tórusz. Megmutatjuk, hogy M beágyazható úgy egy hiperkockába, hogy a felfúvódás, a késleltetés és a torlódás mindegyike 1 legyen. Ez az állítás egyszerűen adódik az előző fejezet végén kimondott lemmából. Van 2r sor és 2c oszlop M ben. Korábban már láttuk, hogy ha egy d -dimenziós hiperkockában a d bitből valamely q -t rögzítjük (1qd1), akkor a feltételnek megfelelő processzorok egy Hdq alkockát alkotnak Hd -ben. Ha egy (r+c) -bites bináris számnak rögzítjük az r legnagyobb helyi értékű bitjét ( Most Significant Bits = MSB) és a maradék c bitet tetszőlegesen variáljuk, a kapott 2c szám egy alkockát határoz meg Hr+c -ben. A fenti lemma értelmében ebbe az alkockába beágyazható egy c processzorból álló gyűrű. Az r MSB minden lehetséges megválasztásához megvan a megfelelő Hc, így M minden sorát leképezhetjük egyre. Egészen pontosan az i-edik sort azon Hc-re képezzük, amelyet úgy kapunk, hogy az r MSB értékét pontosan g(i,r) -re állítjuk. Ebből következik, hogy általában a tórusz Pi,j processzora a Hr+cPg(i,r),g(j,c) processzorára képződik. Így minden sor szomszédos processzorai a hiperkocka szomszédos processzoraira képződnek. A fentihez hasonló gondolatmenettel belátható, hogy a megadott leképezés az oszlopok szomszédos elemeit is szomszédos processzorokra képezi. Ebből következik, hogy mind a felfúvódás a késleltetés és a torlódás 1. A 4.7. ábra egy 2×4 méretű tórusznak a H3 pillangó hálózatba való beágyazását mutatja (a processzoroknak csak az indexe szerepel). Az ábra (a) részén ábrázolt tórusznak 2 sora (a nulladik és az első), valamint négy oszlopa (nulladik, első, második és harmadik) van. Például a tórusz P1,2 csúcsát a hiperkocka Pg(1,1)g(2,2)=P1,1,1, csúcsára képezzük le. Az ábrán mind a két csúcsot g betűvel jelöltük. 4.7. ábra. Tórusz beágyazása hiperkockába. Bináris fa beágyazása Egy d szintes (teljes) bináris fában p=2d1 processzor van: P1,P2,...,Pp. Az adatszerkezetekkel kapcsolatos terminológia szerint a P1 processzort gyökérnek, a P(p+1)/2,P(p+1)/2+1,...,Pp processzorokat levélnek a többi processzort belső processzornak nevezzük. Ha Pi nem levél, akkor össze van kötve a gyerekeinek nevezett P2i és P2i+1 processzorokkal. Ha Pj nem a gyökér, akkor össze van kötve a szülőjének nevezett Pj/2 processzorral. A 4.8. ábra egy 3 szintes bináris fa hálózatot ábrázol. 4.8. ábra. 3 szintes bináris fa hálózat. Bináris fák sokféle módon beágyazhatók hiperkockába. A következőkben megmutatjuk, hogy egy Fp levelű (teljes, bináris) fa (ahol p=2d ) beágyazható Hd-be. Mivel a p levelű fának 2p1 processzora van, így a leképezés nem lehet kölcsönösen egyértelmű. Ha a leveleket 0,1,...,p1 jelöli, akkor képezzük az i -edik levelet Hdi-edik processzorára. F belső processzorait pedig képezzük arra a processzorra, amelyre az adott processzor legbaloldalibb leszármazottját képeztük. A 4.9. ábrán egy 8 levelű bináris fa csúcsainak leképezését láthatjuk. 4.9. ábra. Bináris fa beágyazása hiperkockába. A fa csúcsai melletti bitsorozat a H3 hiperkocka megfelelő csúcsának címkéje. Például a hiperkocka 0,0,0 csúcsára a fa 4 csúcsát képeztük le, míg az 1,1,1 csúcsra csak a fa egyetlen csúcsát. A megadott beágyazás segítségével fa algoritmusokat hatékonyan szimulálhatunk soros hiperkockákkal. Ha a fa algoritmusban a számítás egy lépésében a fának legfeljebb egy szintjén lévő processzorok vesznek részt, akkor az a lépés a hiperkocka egyetlen lépésével szimulálható. 4.2. Csomagirányítás A probléma: minden processzor legfeljebb egy csomagot küld és minden processzor legfeljebb egy csomag címzettje. Juttassuk el a csomagokat a feladótól a címzettekhez. 4.2.1. Mohó algoritmus Tekintsük a csomagirányítási problémát először egy pillangóhálózaton, ahol kezdetben minden csomag a nulladik szinten helyezkedik el, a címzett processzorok pedig a d-ediken, azaz a címzett sorok a küldő sorok egy parciális permutációját alkotják. A mohó megoldás a csomagirányítási problémára ekkor az, hogy minden csomagot a mohó úton küldünk címzettjéhez. Ekkor minden csomag pontosan d hosszúságú utat tesz meg, így a továbbiakban az algoritmus vizsgálatához csak azt kell megvizsgálnunk, hogy mennyi késleltetést szenvedhet el egy csomag útja során. Legyen u=r,l egy tetszőleges processzor Bd-ben. Ekkor legfeljebb 2l csomag mehet keresztül u -n, hiszen a hálózat minden processzorának (a nulladik szintet kivéve) pontosan két szomszédja van a felette levő szinten. Hasonlóan a processzoron átmenő minden csomag címzettje az u-ból elérhető 2dld-edik szinten levő processzor valamelyike. Ebből az következik, hogy az u processzorba befutó bármelyik l edik szintű élen legfeljebb min(2l1,2dl) csomag osztozik. Legyen most p egy tetszőleges csomag. p egy l -edik szintű élen áthaladva legfeljebb min(2l1,2dl) késleltetést szenved el (l=1,2,...,d). Így a maximális késleltetés, ami összesen egy csomagot érhet: D=l=1dmin{2l1,2dl}.(4.1) Az általánosság megszorítása nélkül feltehetjük, hogy d páros. Ekkor D felírható a következőképpen: D=l=1d/22l1+l=d/2+1d2dl(4.2)=2*2d/22(4.3)=Θ(2d/2).(4.4) Az O(2d/2) érték felső korlát a maximális sorhosszúságra, ugyanis – mint láttuk – egy l -edik szintű processzoron legfeljebb min(2l1,2dl) csomag haladhat át. Ezen érték maximuma (l=1,2,...,d)-re pedig 2d/2. 4.4. tétel (mohó algoritmus lépésszáma). A mohó algoritmus Bd -n O(2d/2) időben fut, a maximális sorhosszúság szintén O(2d/2). 4.2.2. Véletlenített algoritmus A véletlenítés, mint oly sokszor korábban, itt is számottevően javíthatja az előbb említett mohó algoritmus tulajdonságait. Már a rácsokon értelmezett csomagirányítási feladatoknál is alkalmaztuk azt a megoldást, hogy a csomagot először egy véletlenszerűen választott közbülső állomásra küldjük, majd onnan továbbítjuk eredeti céljához. Ezzel a megoldással elérhetjük, hogy a csomagok nagy valószínűséggel nem találkoznak egyetlen másik csomaggal sem útjuk során, aminek következtében az egyes élek menti torlódás kialakulásának valószínűsége jelentősen csökken. Ezt a stratégiát követjük a pillangóhálózatok esetében is. A probléma tehát az eredeti, a javasolt megoldás pedig a következő HÁROMFÁZISÚ algoritmus: 1. fázis . A csomagot egy véletlenszerűen választott közbülső címre irányítjuk a d-edik szinten. 2. fázis . A csomagot az eredeti céljának megfelelő sorba irányítjuk, ám a nulladik szinten. 3. fázis . A csomagok elérik tényleges céljukat a d-edik szinten. A 4.10. ábra szemlélteti az algoritmus 3 fázisát. 4.10. ábra. Véletlenített csomagirányítás 3 fázisa. Az ábrán r a d-edik szint egy véletlenül választott csúcsa. u és v a vizsgált csomag kezdeti, illetve végső helye. A vastagított élek mutatják, hogy r az első fázisban eljut a d-edik szintre, onnan a második fázisban a nulladik szintre, végül a harmadik fázisban a csomag célba ér. A harmadik fázisban a csomagok végig a közvetlen éleken közlekednek, így akkor torlódás nem léphet fel, ezért a harmadik fázis végrehajtása pontosan d lépést igényel. A második fázis az első fázis inverze, tulajdonságai megegyeznek az első fáziséval, így a továbbiakban elegendő azt vizsgálni, hogy megkapjuk a teljes algoritmus lépésszámát. Ehhez felhasználjuk majd a következő definíciókat és lemmát. Legyen P utak egy halmaza egy hálózatban. Azt mondjuk, hogy P nem ismétlődő úthalmaz, ha bármely két útra a P halmazból igaz, hogy a metszetük üres vagy összefüggő, azaz ha találkoznak, akkor egy darabig együtt mennek, majd szétválás után nem találkoznak többé. Két csomagot átfedőnek mondunk egy hálózatban, ha az általuk megtett utak legalább egy közös élt tartalmaznak. 4.5. lemma(sorban állási lemma). Legyen P utak halmaza egy hálózatban, amelyeken csomagok haladnak. Ha P nem ismétlődő úthalmaz, akkor tetszőleges p csomag késleltetése legfeljebb akkora, mint a p -vel átfedő csomagok száma. Bizonyítás. Legyen p egy tetszőleges csomag. Ha egyetlen pvel átfedő csomag sem késlelteti p-t egynél több alkalommal, akkor az állítás teljesül. Tegyük fel, hogy valamely qp-vel átfedő csomag kétszer is késlelteti p-t. Ekkor q maga is késleltetve volt egy p-vel átfedő másik csomag által, amely így már nem fogja késleltetni p-t. 4.2.3. Az első fázis elemzése Legyen π egy tetszőleges csomag, jelölje továbbá ei az az élt amelyen π az iedik szinten áthalad (1id). A sorbaállási lemma alapján π késleltetésének meghatározásához elegendő meghatározni a π-vel átfedő csomagok számát. Jelöljük ni-vel azon csomagok számát, amelyek útvonalában szerepel ei. Ekkor D=i=1dni(4.5) felső korlát a π-vel átfedő csomagok számára. Tekintsük most az ei élet. Ezen az élen legfeljebb 2i1 csomag halad keresztül, mivel ennyi processzor van a nulladik szinten amelyek mohó útvonalában szerepelhet ei. Minden ilyen csomag 12i valószínűséggel halad át az ei élen mivel minden, a nulladik szintről induló, csomag 1/2 valószínűséggel választja vagy a közvetlenvagy a keresztélt minden szinten, egymástól függetlenül, i szinten keresztül, míg áthalad ei-n. Így az ni értéke B(2i1,12i) binomiális eloszlású, melynek várható értéke 1/2. Ebből következik, hogy D várható értéke a várható értékek összege, azaz d2. Most megmutatjuk, hogy a teljes késleltetés nagy valószínűséggel O(d). A D változónak B(d,1/2) egy felső korlátja. A Csernov-egyenlőtlenséget felhasználva az alábbi egyenlőtlenségeket kapjuk: P[D>eαd](d/2eαd)eαdeeαdd/2(4.6)<(12eα)eαdeeαd(4.7)(12eα)eαd(4.8)<2eαd(4.9)<pα1,(4.10) ahol α1 és kihasználtuk azt a tényt, hogy d=Θ(logp). Mivel a csomagok száma p -nél kisebb, így annak a valószínűsége, hogy legalább egyikük 2eαd-nél nagyobb késleltetést szenved, kisebb, mint pα1p=pα. Ezzel bebizonyítottuk a következő tételt. 4.6. tétel (VÉLETLEN-CSOMAG-IRÁNYÍT futási ideje). A VELETLEN-CSOMAG-IRANYIT algoritmus Bd -n O¯(d) lépést tesz. Mivel bármely hálózatban a hálózat átmérője alsó korlát a csomagirányítási probléma maximális lépésszámára, így a fenti algoritmus nagy valószínűséggel aszimptotikusan optimális. A sorméret elemzése Az algoritmus várakozási sorok mérete szintén O¯(d). Legyen vi egy i -edik szintű processzor. A vi -n potenciálisan átmenő csomagok száma 2i . Minden ilyen csomag 1/2i valószínűséggel halad át vi-n, így az áthaladó csomagok várható értéke 1. A Csernov-egyenlőtlenség felhasználásával megmutatható, hogy az áthaladó csomagok száma O¯(d). 4.3. Alapvető algoritmusok Ebben a fejezetben alapvető problémák – üzenetszórás, prefixszámítás, adat koncentráció – megoldására mutatunk hiperkocka algoritmusokat. Mindezen algoritmusok lépésszáma O(d). Mivel a hálózat átmérője minden nem triviális probléma megoldásánál alsó korlát a lépésszámra, így ezek aszimptotikusan optimális algoritmusok. 4.3.1. Üzenetszórás fában Az üzenetszórás problémája egy hálózatban azt a feladatot jelenti, amikor egy üzenetet valamely processzortól el kell juttatni a hálózathoz tartozó összes többi processzorhoz (vagy esetleg azok egy részhalmazához). Az üzenetszórást sokszor más algoritmusokba beépítve használjuk. A feladatot a FÁT-KOCKÁBA algoritmus segítségével oldjuk meg, amely a bináris fa architektúrának hiperkockába való beágyazásán alapul. Feltesszük, hogy az elküldendő üzenet a fa gyökerében található. Ez a processzor két másolatot készít a csomagról és elküldi a két leszármazottjának. Ha a fa egy belső processzora kap egy csomagot, akkor arról egy-egy másolatot továbbküld gyerekeinek. Ez folytatódik mindaddig, amíg minden levélen megjelenik az üzenet egy példánya. 4.7. tétel (üzenetszórás fában). A fában való üzenetszórást a FAT-KOCKABA algoritmus egy soros Hd hiperkockán Θ(d) lépésben oldja meg. Bizonyítás. A beágyazott bináris fa magassága d, így O(d) lépés után minden levél processzor ismerni fogja az üzenetet. Az algoritmus végrehajtásakor minden időegységben a fának pontosan egy szintjén elhelyezkedő processzorok dolgoznak, más szóval az algoritmus normális, így egy lépése – amint azt a bináris fáknak a hiperkockába ágyazásakor megmutattuk – Hd -nek pontosan egy lépésével szimulálható. Másrészt legrosszabb esetben legalább egy levélhez el kell juttatni az üzenetet, ezért a fenti beágyazásra W(d, FAT-KOCKABA )=Ω(d). 4.1. példa.Üzenetszórás 4 levelű fában. A 4.11. ábra egy 3 szintes fát mutat, melyben a gyökérben lévő üzenetet juttatjuk el a többi csúcshoz. Az ábra első része azt mutatja, hogy az első lépésben az üzeneteket a gyökércsúcs gyerekei kapják meg. A középső részen az üzenetek a gyerekek gyerekeihez, azaz a levélcsúcsokhoz jutnak el. Végül az ábra harmadik része a végső állapotot mutatja, amelyben már minden csúcs megkapta az üzenetet. Mivel a fát úgy ágyaztuk be a hiperkockába, hogy a fa különböző szintjein lévő processzorok a hiperkocka különböző processzorára képződjenek le, H2 két lépésben megoldja a feladatot. 4.11. ábra. Üzenetszórás 4 levelű fában. 4.3.2. Prefixszámítás fán Ezen feladat megoldásához ismét a bináris fa beágyazását fogjuk felhasználni. Legyen xi a bemenet a 2d levelű bináris fa i-edik levelén. Az alább bemutatott PREFIX-FÁBAN algoritmus két fázisban számítja ki az eredményt. Az első (felfelé haladó) fázisban az adatok felfelé áramlanak a bináris fában, a gyökér felé. A második fázisban (lefelé haladó) az adatok a gyökér felől haladnak a levelekhez. Mindkét fázis minden lépésében a bináris fának pontosan egy szintje vesz részt a számításban, azaz az algoritmus normális. Felfelé haladó fázis . A levelek elküldik az xi-ket a szülő csúcsoknak. A fa egy tetszőleges belső csúcsa, amennyiben két elemet kap ( y-t a bal és z-t a jobb oldali leszármazottjától), akkor kiszámítja a w=y+z értéket, tárolja w-t és y-t, majd elküldi w -t a szülőjének. Az első fázis végére minden processzor kiszámítja és tárolja a hozzá tartozó részfában levő bemeneti elemek összegét. Így a gyökér az összes elem összegét tartalmazza. Lefelé haladó fázis . A gyökérben levő processzor elküld egy nullát a bal oldali gyerekének és y-t a jobb oldalinak. Egy tetszőleges belső processzor ha q értéket kapja a szülőjétől, akkor elküldi q-t a bal oldali és qy értéket a jobb oldali gyerekének. Az i-edik levél processzor, ha a szülőjétől a q értéket kapja, akkor kiszámolja és végeredményként tárolja az xi+q értéket. Az algoritmus felfelé haladó fázisában minden processzor a hozzá tartozó részfa leveleiben tárolt számok összegét számolja ki. Legyen Pv egy processzor és jelöljük Pv-vel Pv részfájának legbaloldalibb levele. Ekkor a lefelé haladó fázis során a Pv által kapott q értéke, azaz q a Pv-től balra eső elemek összege. Az észrevétel felhasználásával az algoritmus helyessége egyszerűen bizonyítható. Az algoritmus mindkét fázisa d1 lépést igényel. Mivel minden időpillanatban a fának pontosan egy szintje aktív, így az algoritmus minden lépése szimulálható Hd egy lépésével. 4.2. példa.Prefixszámítás fán. A 4.12. ábrán egy 4 levelű fa leveleiben vannak az 5, 8,1 és 4 számok. A feladat a megfelelő prefixek számolása, ha az elvégzendő művelet az összeadás. Az ábra (a) része szerint minden levél elküldi a tárolt számot a szülőjének. A (b) ábrarész szerint a szülők tárolták a bal oldali gyereküktől kapott értéket (a kiszámított összeget is, de ezt az ábra nem mutatja), és szülőjüknek elküldték a kapott 2 szám összegét. 4.12. ábra. Prefixszámítás bináris fán. 4.8. tétel (prefixszámítás fán és pillangón). A PREFIX-FAN algoritmus a prefixszámítást 2d levelű bináris fán, valamint Hd-n is Θ(d) lépésben oldja meg. Összegzési feladatnak nevezzük az x1x2xn kifejezés értékének kiszámítását adott xi-khez. A fenti algoritmus felfelé haladó fázisának végére kiszámítja ezt az összeget, így az összegzési feladat megoldásához szükséges idő a fele az összes prefix kiszámításához szükséges időnek. 4.3.3. Adatkoncentráció Legyen egy Hd hiperkocka k(k<p) processzorán egy-egy elem elhelyezve. A feladat, hogy mozgassuk ezen elemeket a hiperkocka P0,P1,...,Pk1 processzoraira (processzoronként egy elemet elhelyezve). Ha meg tudjuk határozni, hogy melyik elemet melyik processzorra kell juttatnunk, akkor a 4.2.2. pontban vizsgált véletlenített HÁROM-FÁZISÚ csomagirányítási algoritmus segítségével O(d) lépésben megtehetjük ezt. Ez az algoritmus párhuzamos (többportos) hiperkockát feltételez. Van azonban egy jóval egyszerűbb, determinisztikus algoritmus is a feladat megoldására. Pontosabban a feladatra adunk egy normális megoldást pillangóhálózaton, majd felhasználjuk az ide vonatkozó beágyazási lemmát. Előtte azonban vizsgáljuk meg a pillangóhálózatok két tulajdonságát, amelyekre az algoritmus elemzésekor hivatkozni fogunk. 1. tulajdonság. Ha egy pillangóhálózatból eltávolítjuk a d-edik szint összes processzorát és a hozzájuk kapcsolódó éleket (lásd 4.13. ábra), két d1 szintes pillangóhálózatot kapunk eredményül. Az egyik hálózat az eredetinek a páros sorait tartalmazza, így ezt páros alhálózatnak nevezzük, a másik a páratlanokat, így az a páratlan alhálózat. 4.13. ábra. A d-edik szinten lévő processzorok és élek eltávolítása.2. tulajdonság. A nulladik szint bármely processzora a leszármazottaival együtt egy 2d levelű bináris fát alkot, amelynek levelei pontosan a d-edik szintű processzorok. Ezek után felvázolhatjuk az adatkoncentráció problémájának megoldó algoritmusát. 4.3.4. Kisszámú elem rendezése hiperkockán A ritka leszámláló rendezés problémája már szerepelt a harmadik fejezetben. Legyen X=k0,k1,...k2p1, ahol p=2d. Az általánosság megszorítása nélkül feltehető, hogy d páros. Tegyük fel, hogy a bemenő adatok a hiperkocka azon processzorain vannak (processzoronként egy kulcs), melyek címkéjét úgy kapjuk, hogy a címkék d bitje közül az első d2 -t nullának választjuk. A rendezett sorozatot ugyanezen processzorokon állítjuk elő kimenetként. Legyen Pv a Hd hiperkocka egy processzora. Pv címkéje i,j párként is felfogható, ahol i az első d2 bit, j pedig a második j2 bit. Azok a processzorok, melyek címkéjének első fele i(0i2d/21), egy Hd hiperkockát alkotnak. Ezt a hiperkockát Hdi-edik sorának fogjuk nevezni. Hasonlóképpen határozzuk meg a hiperkocka j-edik oszlopát. A rendezendő kulcsok kezdetben a nulladik sor processzorain vannak. Az egyértelműség kedvéért tegyük fel, hogy az r rangú kulcs kimenetként a 0,r1(0r2d/2) processzoron fog megjelenni. A KEVESET-KOCKÁN algoritmus a következőképpen működik. A lépészám a következő. 4.9. tétel (ritka leszámláló rendezés kockán). A KEVESET-KOCKAN algoritmus legfeljebb 2p kulcs ritka leszámláló rendezését egy Hd hiperkockán Θ(d) lépésben végzi el. Bizonyítás. Az algoritmus csak olyan műveleteket végez, amelyben egy sor vagy oszlop processzorai vesznek részt. Az elvégzett műveletek mindegyike – prefixszámítás, üzenetszórás, összehasonlítás – O(d) lépésben elvégezhető, és legrosszabb esetben Ω(d) lépést igényel. 4.4. Kiválasztás Az egyszerű kiválasztás célja, hogy adott n kulcs közül az i-edik (1in) legkisebbet meghatározzuk. A korábbiakhoz hasonlóan két esetet vizsgálunk: az egyikben a processzorok p száma megegyezik a kulcsok n számával, a másikban pedig a processzorok száma kisebb, mint a kulcsoké. Három algoritmust mutatunk be, mindegyik pillangó hálózaton fut. Az elsőnél p=n, a másik kettőnél p<n. Az első nagy valószínűséggel munkahatékony, a másik kettő viszont nem az. 4.4.1. Véletlenített algoritmus, ha p és n megegyezik (*) A PRAM-on futó munkahatékony véletlenített algoritmus alkalmazható hiperkockán is. A KOCKÁN-KIVÁLASZT fokozatainak száma O¯(1). A PRAM-KIVÁLASZT első lépése hiperkockán O(1) lépést vesz igénybe. A 2. és 5. lépésekben szükséges prefixszámítás összesen O(d) lépésben elvégezhető. A 3. és 6. lépésekben a koncentrálás ugyancsak megoldható O(d) lépésben. A 3. és 6. lépésekben szükséges ritka rendezés ugyanennyi lépést vesz igénybe. Mivel a 4. és 6. lépésben rendezett sorozatból kell kiválasztani, ezért az O(1) lépésben megoldható. A 2., 4. és 5. lépésben lévő üzenetszórás lépésigénye O(d). Innen adódik a következő tétel. 4.10. tétel (kiválasztás hiperkockán). Ha p=n, akkor a KOCKAN-KIVALASZT algoritmus a kiválasztási feladatot a Hd hiperkockán O¯(d) idő alatt megoldja. 4.4.2. Véletlenített algoritmus kis processzorszámhoz (*) Tegyük fel, hogy ε>1 és n=pε. A PRAM modellen futó VÉLETLENKIVÁLASZT algoritmus módosított változata a rácsokhoz hasonlóan most is alkalmazható. A KOCKÁN-VÉL-KIVÁLASZT algoritmus esetén minden processzor n/p kulccsal kezd. A while utasítás feltételét (N>D)-re változtatjuk (ahol D állandó). Az első lépésben minden processzor minden kulcsa 1/(N1(1/3c)) valószínűséggel lesz a mintában.Ezért ez a lépés ebben az esetben n/p lépésig tart. A második lépés változatlan és O(d) lépést vesz igénybe. A 3. lépésben a koncentrálás és a ritka leszámláló rendezés is végrehajtható O(d) lépésben. A 4., 5. és 6. lépések szintén végrehajthatók O(d) lépésben. Így minden fokozat O(n/p+d) lépést vesz igénybe. Az algoritmusnak O¯(loglogn) fokozatra van szüksége. A 6 lépésre külön kapott becslések összegét a fokozatszámra kapott becsléssel összeszorozva kapjuk a következő tételt. 4.11. tétel (kiválasztás hiperkockán). Ha c>1 és n=pc, akkor a kiválasztási feladat a Hd hiperkockán O¯(((n/d)+d)loglogp) idő alatt megoldható. 4.4.3. Determinisztikus algoritmus kis processzorszámhoz A négyzeten futó kiválasztó algoritmus adaptálható hiperkockára. Az így kapott KOCKÁN-DET-KIVÁLASZT algoritmus lépésszámának elemzése hosszú, csak az eredményét adjuk meg. 4.12. tétel (kiválasztás hiperkockán). Ha p<n, akkor a KOCKAN-DET-KIVALASZT algoritmus a kiválasztási feladat a Hd hiperkockán O(nploglogp+d2logn) lépésben megoldja. 4.3. példa. Legnagyobb elem kiválasztása hiperkockán Tegyük fel, hogy a H3 hiperkocka minden processzorának memóriájában 5–5 kulcsot helyezünk el – ahogyan azt a 4.14. ábra mutatja. A feladat a harminckettedik legkisebb elem kiválasztása. 4.14. ábra. Kiválasztás 8 elem közül. Először minden processzor meghatározza saját kulcsainak mediánját – ezeket az ábra felső részén bekarikáztuk. Ezen mediánok rendezett sorozata 6, 16, 18, 22, 25, 26, 45, 55. Mivel most minden processzornál 5-5 kulcs van, a súlyozott médián megegyezik a mediánnal, ami 22. Ezután meghatározzuk M=22 rangját, ami 21. Mivel i=32>21, a 22-nél kisebb vagy vele egyenlő kulcsokat elhagyjuk. i frissített értéke 3221=11 lesz. Ezzel a while ciklus egy menetét befejeztük. A while ciklus következő menetében 19 elemmel kezdünk. Az ábra középső részén bekarikáztuk a helyi mediánokat. A mediánok rendezett sorozata 23, 24, 27, 28, 35, 36, 45, 63, a megfelelő súlysorozat pedig 1, 2, 1, 3, 2, 3, 4, 3, így a súlyozott médián 36. Elhagyjuk a kis kulcsokat és i=1110=1 lesz az új i érték. Ezzel vége a while ciklus következő menetének. Így folytatva megkapjuk, hogy a kiválasztás eredménye a megmaradt 9 szám közül a legkisebb, a 42. 4.5. Összefésülés Amint már láttuk az előző két fejezetben, az összefésülés célja, hogy két rendezett sorozatból a két sorozat minden elemét tartalmazó, rendezett sorozatot állítsunk elő. Beláttuk, hogy ez a feladat hiperkockán – m hosszúságú bemenő sorozatokra – m2 processzoron O(logm) idő alatt megoldható. A számítási modell most is a hiperkocka lesz, de csak 2m processzort használunk (feltéve, hogy m 2 hatványa). 4.5.1. Páratlan-páros összefésülés Legyen X1=k0,k1,...,km1 a két összefésülendő rendezett sorozat, ahol 2m=2d. Először szétválasztjuk X1 és X2 páros és páratlan részét. Legyenek ezek O1,E1,O2 és E2. Ekkor E1 -et rekurzívan összefésüljük O2 -vel, az eredmény A=a0,a1,...,am1. Ugyanígy kapjuk B=b0,b1,...,bm1 -et O1-ből és E2ből. Ezután A és B összekeverésével kapjuk a C=a0,b0,a1,b1,...,am1,bm1 sorozatot, majd rendre összehasonlítjuk (és szükség esetén felcseréljük ai -t és bi -t (0im1). Az algoritmus helyessége belátható a 0-1-elv segítségével. 4.4. példa. 2×4elem összefésülése. Legyen X1=7,11,24,30 és X2=2,4,27,45. Ebben az esetben O1=11,30 és E1=7,24,O2=4,45 és E2=2,27.E1 és O2 összefésülésével A=4,7,24,45 adódik. Hasonlóképpen B=2,11,27,30.A és B összekeverésének eredménye C=4,2,7,11,24,27,45,30. Ha a 4-et és 2-t, valamint a 45-öt és 30-at felcseréljük, akkor az eredmény 2, 4, 7, 24, 27, 30, 45. A módosított algoritmust könnyű a könnyű a Bd pillangón megvalósítani. Például X1 és X2 páros és páratlan részre való felbontása a pillangó hálózaton egy lépésben elvégezhető. A keverési művelet szintén könnyen elvégezhető. tegyük fel, hogy X1 és X2 is a Bd pillangó hálózat d-edik szintjének bemenő adatai. Legyen X1 a bemenet az első m sorban és X2 a második m sorban. Az algoritmus első lépése X1 és X2 szétválasztása páratlan és páros részre. Ezután rekurzívan összefésüljük E1-et O2-vel és O1-et E2-vel. Ennek érdekében az első m sorban lévő kulcsokat a közvetlen éleken, a többi kulcsot a keresztéleken mozgatjuk (lásd 4.15. ábra). 4.15. ábra. Páratlan-páros összefésülés pillangón. 4.13. tétel. Ha m=2d, akkor két m hosszúságú lista mind a Bd pillangó hálózaton, mind pedig a Hd hiperkocka hálózaton összefésülhető O(d) idő alatt. 4.5.2. Biton összefésülés A K=k0,k1,...,kn1 sorozatot biton sorozatnak nevezzük, ha rendelkezik a következő két tulajdonság valamelyikével: a) van olyan j(0jn1) index, amelyre k0k1...kj és kjkj+1...kn1 ; b) van olyan j(1jn1) index, amelyre a K sorozat K=kj+1,kj+2,...,kn1,k1,k2,...,kj1 ciklikus eltoltja rendelkezik az előző tulajdonsággal. Megmutatjuk, hogyan lehet rendezni egy biton sorozatot pillangó hálózaton. Az első lépésben – ahogyan ezt a 4.16. ábra mutatja – a nulladik szint processzorai mind a közvetlen, mind a kereszt éleken elküldik a kulcsukat. Az első szint processzorai felülről 2-2 kulcsot kapnak. 4.16. ábra. Bitonikus összefésülés pillangó hálózaton. 4.14. tétel. Egy 2d hosszúságú biton sorozat mind a Bd pillangó hálózaton, mind pedig a Hd hiperkocka hálózaton rendezhető O(d) idő alatt. 4.6. Rendezés Ebben az alfejezetben hiperkocka és pillangó hálózat lesz a számítási modell. 4.6.1. Páratlan-páros összefésülő rendezés Első algoritmusunk a PÁROS-PÁRATLAN-FÉSÜL-RENDEZ egy megvalósítása. Jelöljük R(d)-vel algoritmusunk lépésszámát Bd-n. Ekkor R(d)=R(d1)+O(d).(4.11)Ennek a rekurzív egyenletnek a megoldása S(d)=O(d2). 4.15. tétel. Ha p=2d, akkor p elem mind a Bd pillangó hálózaton, mind pedig a Hd soros hiperkockán rendezhető O(d2) idő alatt. 4.6.2. Biton rendezés Az összefésülő rendezés alapötlete a biton összefésülő algoritmussal kapcsolatban is alkalmazható – az eredmény a PILLANGÓN-BITON-RENDEZ algoritmus. Most ismét felírhatjuk a 4.11rekurzív egyenletet, ahonnan a következő lépésszámot kapjuk. 4.16. tétel (biton sorozat rendezése pillangón és hiperkockán). A PILLANGON-BITON-RENDEZ algoritmus p=2d elemet O(d2) lépésben rendez a Bd pillangó hálózaton, és ugyancsak O(d2) lépésben hiperkockán. 4.7. Gráfalgoritmusok Ebben az alfejezetben minmátrix, tranzitív lezárt, összefüggő komponensek és minimális feszítőfa meghatározására szolgáló algoritmusokat mutatunk be. 4.7.1. Minmátrix meghatározása Újra alkalmazzuk a második fejezetben bevezetett formalizmust. Legyen q egy pozitív egész szám, n=2q és legyen M[0:n1,0:n1] egy n×n méretű mátrix. Az M mátrix minmátrixának számítására a H3q hiperkockát fogjuk használni, amelyben 23q processzor van, melyek címkéi 3q bit hosszúak. Ezek a címkék i,j,k alakban is felírhatók, ahol i a címke első q bitjét, j a címke második q bitjét és k a címke harmadik q bitjét jelentik. Jelölje (i,,*)(0i2q1) a H3q hiperkocka azon processzorait, melyek címkéjében az első q bit bináris számként i . Ezek a processzorok együtt egy H2q hiperkockát alkotnak. Hasonlóképpen definiáljuk a (*,j,*),(*,*,k) , (i,j,*),(i,*,k) és (*,j,k) jelöléseket is. Ekkor a KOCKÁN-MINMÁTRIX algoritmus a következőképpen működik. A lépészám a következő. 4.17. tétel. Ha M egy n×n méretű mátrix, akkor a KOCKÁN-MINMÁTRIX algoritmus M minmátrixát egy H3l hiperkockán O(log2n) lépésben meghatározza. Bizonyítás. Az algoritmus első szakaszában az üzenetszórás és a mátrixtranszponálás O(logn) lépésben végrehajtható. A második szakaszban az m[i,j] értékek frissítése prefixszámítással megoldható O(lgn) lépésben. A négyzeten futó algoritmusban szereplő két üzenetszórás helyett itt a hiperkockában üzenetszórást végző algoritmust alkalmazzuk, ugyancsak O(logn) lépésszámmal. Tehát a for ciklus magjának minden végrehajtása O(logn) lépést vesz igénybe. Mivel a ciklusmagot logn -szer kell végrehajtani, ebből a lépésszám felső korlátja már adódik. Mivel például a második szakaszban végzett prefixszámítás lépésszáma Ω(n), ezért az elemzett algoritmus lépészámának nagyságrendje valóban log2n. 4.7.2. Tranzitív lezárt Irányított gráf tranzitív lezártját a második fejezetben definiáltuk. 4.18. tétel. Egy n csúcsú irányított gráf tranzitív lezártja O(log2n) lépésben meghatározható egy n3 processzort tartalmazó hiperkockán. Bizonyítás. Állításunk a 4.17. tétel következménye. 4.7.3. Összefüggő komponensek Gráfok összefüggő komponenseit a második fejezetben definiáltuk. 4.19. tétel. Egy n csúcsú irányított gráf összefüggő komponensei egy n3 processzort tartalmazó hiperkockán O(log2n) lépésben meghatározhatók. Bizonyítás. Állításunk a 4.17. tétel következménye. 4.7.4. Legrövidebb utak A HIPERKOCKÁN-UTAK algoritmus lépésszámára vonatkozik a következő tétel. 4.20. tétel. A HIPERKOCKAN-UTAK algoritmus egy n csúcsú irányított gráf összes csúcspárjának távolságát meghatározza O(log2n) lépésben egy n3logn processzort tartalmazó hiperkockán. Bizonyítás. A PRAM modellek elemzése során megmutattuk, hogy egy gráf csúcsai közötti távolságokat logn mátrixszorzás segítségével meghatározhatók. Két n×n méretű mátrix egy n3logn processzoros hiperkockán O(logn) lépésben összeszorozható. 4.7.5. Konvex burok A konvex burok számítására – hasonlóan a PRAM és négyzet modellek esetéhez – oszd meg és uralkodj elvű algoritmust javaslunk. Ha a rekurzív algoritmusunk lépésszámát a d -dimenziós hiperkockán K(d) vel jelöljük, akkor K(d)=K(d1)+O(d2),(4.12) ahonnan K(d)=O(l3). 4.21. tétel. Ha n=2d , akkor egy sík n pontjának konvex burka O(log3n) lépésben meghatározható a Hd hiperkockán. Gyakorlatok 4.7–1. Állapítsuk meg, van-e Euler-kör és/vagy Hamilton-kör a vizsgált hálózatokban? 4.7–2. Mennyi idő alatt lehet egy üzenetet eljuttatni a fejezetben vizsgált hálózatok adott processzorától az összes többihez? Tervezzünk bejárási algoritmusokat és elemezzük lépésszámukat. 4.7–3. Mutassuk meg, hogy egy pillangó hálózat első szintjén lévő processzorból pontosan egy út vezet a d-edik szint bármelyik processzorához. 4.7–4. Foglaljuk táblázatba a vizsgált hálózatok jellemző tulajdonságait. 4.7–5. Hányféleképpen lehet beágyazni a 4.3. ábra bal oldalán látható G hálózatot az ábra jobb oldalán látható H hálózatba? 4.7–6. Adjuk meg a G3 , G4 és G5 Gray-kódokat. 4.7–7. Tervezzünk O(kd) lépésszámú algoritmust, amely 2dk bites kulcsnak a Bd pillangó hálózaton való rendezésére. Feladatok 4-1. Gray-kód elemzése Adjuk meg, összesen hány nullát és hány egyest tartalmaz Gk (k1). Hány olyan elrendezése van a k -jegyű bináris számoknak, melyekre jellemző, hogy az i-edik (2i2k) szám pontosan egy helyen tér el az (i1)ediktől? Hány ilyen ciklikus elrendezés van? 4-2. Rács beágyazása hiperkockába Tekintsük egy 4×8 méretű rácsnak H5-be ágyazását. Az első két bitet használjuk a rács sorainak, a további három bitet pedig a rács oszlopainak azonosítására: G2 feleljen meg a nulladik, első, második, illetve harmadik sornak. Ugyanígy G3 elemei rendre megfelelnek a 0.,1.,...,(n1)-edik oszlopnak. Adjuk meg a beágyazás jellemző adatait (felfúvódás, késleltetés, torlódás). 4-3. Teljes bináris fa beágyazása de Bruijn-hálózatba Mutassuk meg, hogy egy d szintes teljes bináris fa beágyazható egy d -dimenziós de Bruijn-hálózatba úgy, hogy a beágyazás késleltetése 1. 4-4. Mohó algoritmus korlátjának élessége Lássuk be, hogy a mohó algoritmus lépésszámára és sorhosszúságára bizonyított felső korlát aszimptotikusan éles, azaz van csomagirányítási feladatoknak olyan sorozata amelyre a 4.4egyenletben megadott nagyságrend a jellemző. Útmutatás. Vizsgáljuk meg azt az úgynevezett bitfordításos feladatot, ahol a b1...bd sorbeli csomag címzettje a bd...b1 sorbeli processzor. Vizsgáljuk meg ebben az esetben egy (d/2) -edik szintű él forgalmát. 4-5. Polinomok szorzása Tervezzünk algoritmust, amely két 2d -edfokú polinomot O(d) idő alatt összeszoroz a Bd pillangó hálózaton. 4-6. Gyors Fourier-transzformáció Tervezzünk algoritmust, amely a Bd pillangó hálózaton kiszámítja egy 2d hosszúságú vektor gyors Fourier-transzformáltját. 5. Szinkronizált hálózat Ebben a fejezetben döntési feladatokat oldunk meg – speciális és általános hálózatokban. 5.1. Számítási modell A H hálózatot a korábbiakhoz hasonlóan H=(V,E) formában adjuk meg, ahol V={P1,P2,...,Pp} a processzorok halmaza. Két processzor között vagy kétirányú adatátvitel lehetséges, vagy csak egyirányú adatátvitel van, vagy nincs kapcsolat. Ennek megfelelően az élek E halmaza két részből áll: E=(S,D), ahol S az egyirányú adatátviteli vonalakat leíró irányított élek halmaza, míg D a kétirányú adatátvitelt leíró irányítatlan élek halmaza. A keverő-cserélő hálózatokban kétféle él van: kétirányú cserélő és egyirányú keverő él. A d dimenziós teljes keverő-cserélő hálózatban p=2d processzor van. A cserélő élek a P2i processzorból a P2i+1(i=0,1,...,2d11) processzorhoz vezetnek. Minden processzorból egy keverő él indul: a Pi(i=0,1,...2p1) processzorból induló keverő él a P2i processzornál végződik, ahol az indexeket (mod 2p1 ) vesszük. Az 5.1. ábra egy 8-processzoros teljes keverő-cserélő hálózatot ábrázol. 5.1. ábra. 8 processzoros keverő-cserélő hálózat. A gyakorlatban használt hálózatok többségében csak kétirányú adatátviteli vonalak vannak. A de Bruijn-hálózat csak egyirányú adatátvitelt enged meg. A Pi processzor szomszédaitszomszéd[i]vel jelöljük és a következőképpen definiáljuk: szomszéd [i]={Pj|(i,j)S(i,j)D(i,j)D}.(5.1) A processzorokat automataként írjuk le, amelyek a szinkronizált lépésekben üzeneteket küldhetnek és kaphatnak, és adott kezdőállapotból kiindulva minden lépésben – a beérkező üzenetek és a korábbi állapot által meghatározott – új állapotba mennek át. A Pi processzor a KÜLD i(üzenet ) és a FOGAD i(üzenet ) függvénnyel küldenek, illetve fogadnak üzenetet. Az üzenet az Üε halmaz eleme, ahol Ü a lehetséges üzenetek halmaza, ε pedig az üres üzenet. Egy üzenet lehet például a küldő folyamat azonosítója, és állhat több részből is. Ebben a fejezetben a futási idő mellett az elküldött és fogadott üzenetek száma is gyakran használt hatékonysági jellemző. 5.2. Vezető választása Ennek az alfejezetnek a témája az egyik legfontosabb döntési feladat, a vezetőválasztás. Tegyük fel, hogy kezdetben minden processzor azonos állapotban van. A cél olyan állapot elérése, amelyben pontosan egy processzor a vezető a többi processzor pedig a nem-vezető állapotban van. A későbbiekben (főleg az algoritmusok leírásában) használjuk a rövidebb vez , illetve nem-vez jelölést is. Számos feladat megoldásához szükség van a processzorok szimmetriájának megtörésére, és egy vezető processzor megválasztására. Ezt a feladatot LeLann fogalmazta meg 1977-ben. Először megmutatjuk, hogy a vezetőválasztás bizonyos körülmények között megoldhatatlan feladat. Azután algoritmusokat mutatunk be és elemzünk, amelyek gyűrűben, fában és általános hálózatban megoldják a vezetőválasztást. 5.2.1. Vezetőválasztás megoldhatatlansága gyűrűben Legyen H egy p processzoros gyűrű. Ha H -ban minden processzor azonos kezdeti állapotban van, akkor nincs mód ennek a kezdeti szimmetriának a megszüntetésére. Ezt az állítást formalizálja a következő tétel. 5.1. tétel (vezetőválasztás gyűrűben). Ha G egy egyirányú vagy kétirányú gyűrű, melyben a processzorok kezdeti állapota, állapotátmeneti függvénye és üzenet-előállító függvénye is azonos, akkor ebben a gyűrűben a vezetőválasztás nem oldható meg. Bizonyítás. Az állítást indirekt módon bizonyítjuk. Tegyük fel, hogy a P algoritmus megoldja a feladatot. Feltehetjük, hogy a gyűrű minden processzorának csak egy kezdőállapota van (ha több van, közülük tetszőlegesen választva elérhetjük, hogy minden processzornak csak egy kezdőállapota legyen). Az első lépésben minden processzor ugyanazt az üzenetet küldi szomszédjának (kétirányú gyűrűben mindkét szomszédjának), ezért a második lépésben a processzorok azonos új állapotba mennek át és azonos üzenet küldenek szomszédjuknak. A lépések száma szerinti indukcióval adódik, hogy ha bármely processzor állapota vezető, akkor a többi processzor állapota is vezető lesz, ami nem biztosítja a vezetőválasztás egyértelműségét. A gyakorlatban rendszerint nem azonos a processzorok kezdőállapota. A továbbiakban feltesszük, hogy minden processzornak egyedi azonosítója van, amely a többi processzortól megkülönbözteti. 5.2.2. Vezetőválasztás gyűrűben Az első gyűrűs vezetőválasztó algoritmus LeLann nevéhez fűződik. A LELANN algoritmusra jellemző, hogy a szükséges üzenetek száma négyzetesen nő a processzorok számával. Chang és Roberts 1979-ben olyan javítást dolgoztak ki, amely legrosszabb esetben továbbra is négyzetes volt, de átlagos esetben már O(nlogn) lépésben megoldotta a vezetőválasztást. 1980-ban Hirschberg és Sinclair olyan megoldást talált, melyre a legrosszabb esetben is bizonyítani tudták az O(nlogn) felső korlátot. Igaz, míg a korábbi módszerek egyirányú gyűrűben is működtek, a HIRSCHBERG-SINCLAIRS algoritmusnak kétirányú adatátviteli vonalakra van szüksége. Az alsó korlátokkal kapcsolatos eredmények szerint a vezetőválasztást aszimptotikusan optimálisan is meg tudjuk oldani. LeLann algoritmusa A LELANN algoritmus megengedi, hogy a vezető az úgynevezett kezdő processzorok közül kerüljön ki. A kezdő processzorok halmazát K -val jelöljük. A processzoroknak nincs szüksége arra, hogy ismerjék a hálózat méretét. Az algoritmus pszeudokódja a következő. Az algoritmus szerint először az 1–6. sorokban beállítjuk a processzorok állapotát: jelölt lesz a kezdő processzorok állapota és nem-jelölt lesz a többi processzor kezdőállapota. A kezdő processzorok a jelöltek Ji halmazába beteszik saját azonosítójukat. A 7–13. sorokban a kezdő processzorok addig fogadják és küldik az üzeneteket, amíg saját azonosítójukat – amely körbeért a gyűrűn – vissza nem kapják. A 14–16. sorokban a legkisebb azonosítójú processzor vez-re, a többi kezdő processzor n-vez-re állítja a saját állapotát. A nem kezdő processzorok szerepe az üzenetek továbbítása (17–21. sorok). 5.2. tétel. A LELANN algoritmus egy egyirányú gyűrűn minden esetben Θ(p) lépésben és legrosszabb esetben O(p2) üzenetet küldve oldja meg a vezetőválasztást. Bizonyítás. Az 1–6. sorokban két lépésben beállítjuk áll[i] és Ji értékét. A kezdő processzorok a p-edik lépésben visszakapják saját azonosítójukat (a többi kezdő processzor azonosítóját már korábban megkapták). Ekkor a legkisebb azonosítójú processzor állapota a 14–15. sor szerint vezető lesz, a többi kezdő processzor állapota pedig a 16. sorban nem-vez lesz. Mivel legfeljebb p különböző azonosító van és mindegyik p lépést tesz, ezért az elküldött és fogadott üzenetek száma O(p2). Mivel legrosszabb esetben minden processzor kezdő, ezért az üzenetek száma W(p, LELANN )=Θ(p2). Mivel a kezdő folyamatok azonosítója p lépés alatt ér körbe a gyűrűn, ezért az algoritmus lépésszáma minden esetben p=Θ(p). A LELANN algoritmus biztosítja, hogy a processzorok a megfelelő állapotba kerüljenek, de nem biztosítja azt, hogy a nem kezdő processzorok megálljanak. Ezt a megállást például úgy biztosíthatjuk, hogy a vezetőnek választott processzor körbeküld egy értesítő üzenetet. Az így kiegészített algoritmusra is érvényes a W(p, ERTESIT-LELANN )=O(p) és Wu(p, ERTESIT-LELANN )=O(p2). Chang és Roberts algoritmusa Chang és Roberts azzal javították az előző algoritmust, hogy csökkentették a feleslegesen továbbküldött azonosítók számát: a kezdő processzorok csak a saját azonosítójuknál kisebb azonosítókat küldik tovább. 5.3. tétel. A CHANG-ROBERTS algoritmus Θ(p) lépéssel és legrosszabb esetben Θ(p2) üzenettel oldja meg egyirányú gyűrűben a vezetőválasztást. Az algoritmus átlagos üzenetszáma O(plogp). Bizonyítás. A legrosszabb esetre vonatkozó bizonyítás hasonló a LELANN algoritmusra vonatkozó bizonyításhoz. Az átlagos üzenetszámmal kapcsolatban legyen s a legkisebb a p azonosító közül. p különböző azonosítónak (p1)! különböző ciklikus permutációja van. Adott ciklikus permutációban legyen ai az az azonosító, amely i lépéssel halad s előtt. Mivel az s azonosító minden permutációban p lépést tett meg, ezért a (p1)! ciklikus permutációban összesen p(p1)! lépést tett meg. Az ai azonosítót legfeljebb i -szer kellett továbbítani, mivel eldobjuk, amikor eléri az s azonosítójú processzort. Legyen Ai,k azoknak a ciklikus permutációknak a száma, amelyekben az ai azonosítót pontosan k -szor kellett továbbítani. Ekkor az ai azonosítót összesen k=1ikAi,k(5.2) alkalommal kell továbbítani. Ha ai a legkisebb az a1,a2,...,ai azonosítók között – ami (p1)!/i permutációban fordul elő – akkor az ai azonosítót pontosan i -szer kell továbbítani, ezért Ai,i=(p1)!i.(5.3) Ha az ai azonosítót k1 olyan azonosító követi, amelyek nagyobbak, mint ai , akkor ai -t legalább k-szor kell továbbítani (itt ki ). Azoknak a ciklikus permutációknak a száma, amelyekben ai a legkisebb az aik+1,aik+2,...,ai azonosítók között, (p1)!/k. Ezért ha k<i , akkor az ai azonosítót (p1)!k(p1)!k+1(5.4) permutációban kell pontosan k -szor továbbítani, és így Ai,k=(p1)!k(k+1)(ha k<i).(5.5) Ezért az ai azonosítót az összes ciklikus permutációban összesen k=1i1k((p1)!k(k+1))+i1i(p1)!=(p1)!k=1i1k(5.6) alkalommal kell továbbítani. Ismert, hogy az egyenlőség jobboldalán lévő szumma a Hiharmonikus szám, amelyre i=1mHi=(m+1)Hmm.(5.7) Most összegezzük az s -től különböző i azonosítók által megtett lépések számát: i=1p1(p1)!Hi=(pHp1(p1))(p1)!.(5.8) Mivel ez a lépésszám az összes ciklikus permutációhoz tartozik, ezért az átlag pHp. Mivel Hp=lnp+O(1) , azt kaptuk, hogy az átlag valóban O(plogp). Ha az azonosítók kezdeti permutációja kedvező – például a1>a2>...>ap – akkor az aj(1jp1) azonosító csak egy lépést tesz meg, ezért Bu(p, CHANG-ROBERTS )=O(p). Hirschberg és Sinclair algoritmusa Az eddig tárgyalt vezetőválasztó algoritmusok kevés lépést tesznek, de sok üzenetre van szükségük. Most egy olyan algoritmust mutatunk be, amelynek a korábbinál lényegesen kevesebb üzenetet igényel. Hirschberg és Sinclair algoritmusa is a legnagyobb azonosítóval rendelkező folyamatot választja vezetőnek. Itt azonban az azonosítók nem körbejárják a gyűrűt, hanem bizonyos (egyre nagyobb) lépés megtétele után visszafordulnak. Ezt szemlélteti a . ábra. 5.2. ábra. A HIRSCHBERG–SINCLAIR algoritmus szemléltetése. 5.4. tétel. A HIRSCHBERG–SINCLAIR algoritmus üzenetszáma kétirányú gyűrűben W(p, HIRSCHBERG-SINCLAIR )=O(plogp). IDŐSZELET algoritmus Az eddigi vezetőválasztó algoritmusok az azonosítók összehasonlításával jutottak információhoz. A következő IDŐ-SZELET algoritmus nagyon kevés üzenetet használ. Az algoritmus szakaszokban működik, és minden szakasz p lépésből áll. A j -edik szakaszban csak j azonosítót lehet üzenetként elküldeni. Ha a Pi processzor azonosítója ai, akkor ez a processzor az 1.,2.,...,(ai1). szakaszban nem küld üzenetet. Ha a Pi processzor az első ai1 szakaszban nem kap üzenetet, akkor az ai-edik szakasz első lépésében elküldi szomszédjának a saját azonosítóját, és ez az azonosító körbemegy az egyirányú gyűrűn. 5.5. tétel. Az IDŐ-SZELET algoritmus egy p processzoros egyirányú gyűrűben p üzenettel Θ(pamin) lépésben oldja meg a vezetőválasztást. Ennek a tételnek közvetlen következménye, hogy az IDŐ-SZELET algoritmus üzenetszámát tekintve aszimptotikusan optimális. Alsó korlát az üzenetszámra Az összehasonlítás alapú vezetőválasztó algoritmusok üzenetszámára érvényes a következő alsó korlát. 5.6. tétel. Ha a P algoritmus bármely p processzoros gyűrűben vezetőt tud választani, akkor megadható p darab különböző azonosító olyan permutációja, amelyre az A algoritmus Nu(p,P)=Ω(plogp) üzenetet küld. 5.2.3. Vezetőválasztás fában Az alábbi algoritmus fában megoldja a vezetőválasztást. Az algoritmus menetét illusztrálja az 5.3. ábra. Az ábra felső része a T fának a Tpq és Tqp részfákra bontását mutatja. Az ábra bal alsó része a Tpq fa felbontását mutatja. 5.3. ábra.Tpq részfái. 5.7. tétel. A FÁBAN-VEZETŐ algoritmus egy p processzoros fában (p) üzenettel megoldja a vezetőválasztást. Tpq részfái. 5.2.4. Vezetőválasztás általános hálózatban Általános hálózatban először egy egyszerű üzenetterjesztő algoritmust, majd annak javított változatát mutatjuk be. MAX-TERJED algoritmus A MAX-TERJED algoritmus alapötlete, hogy a processzorok minden menetben elküldik szomszédaiknak az addig hozzájuk eljutott legnagyobb azonosítót. 5.8. tétel. Ha egy tetszőleges H hálózat átmérője átm (H), akkor a MAX-TERJED algoritmus ebben a hálózatban legfeljebb átm (H) menetben a legnagyobb azonosítójú folyamatot vezetővé választja. Az elküldött üzenetek száma pedig O(|E|átm ). OPT-MAX-TERJED algoritmus Általános hálózatban is alkalmazható az a javítás, amit már a gyűrű esetében láttunk: a processzorok csak akkor küldenek tovább azonosítót, ha az új információt tartalmaz. Ezzel ugyan a legrosszabb esetben szükséges üzenetek számának nagyságrendje változatlan marad, az üzenetek átlagos száma azonban lényegesen csökken. 5.9. tétel. Ha egy tetszőleges H hálózat átmérője átm (H), akkor az OPT-MAX-TERJED algoritmus ebben a hálózatban legfeljebb átm (H) menetben vezetővé választja a legnagyobb azonosítójú folyamatot. 5.2.5. Alsó korlát az üzenetek számára Az általános hálózatokban szükséges üzenetek számára vonatkozik a következő tétel. 5.10. tétel. Ha H egy p processzort tartalmazó hálózat, akkor a vezetőválasztás ebben a hálózatban N(p)pHp(5.9) üzenetet igényel. Ebből a tételből adódik a következő állítás. 5.11. következmény. A CHANG-ROBERTS algoritmus üzenetszáma aszimptotikusan optimális. Bizonyítás. A 5.3. tétel szerint az algoritmus üzenetszámára W(p)=O(plogp).(5.10) Mivel Hp=Θ(logp) , így Θ(W(p))=N(p). 5.3. Megegyezés A következő döntési feladat a megegyezés. Tegyük fel, hogy kezdetben minden Pi processzor rendelkezik egy bi bemeneti értékkel, és az a cél, hogy a processzorok azonos k kimenő értékre jussanak. Ezt a problémát mind az üzenetek egy részének elvesztését, mind a processzorok hibáját megengedve is szokták vizsgálni. A k-megegyezés problémája az egyszerű megegyezési probléma természetes általánosítása: a processzorok feladata az, hogy a bemenő értékek egy k -elemű részhalmazából válasszanak közösen elfogadott értéket. 5.3.1. Megegyezés vonalhibák esetében A probléma lényegét jól tükrözi az összehangolt támadási feladat Eszerint tábornokok összehangolt támadást terveznek közös célpont ellen. A tábornokok hírnökök segítségével válthatnak üzenetet. Feltesszük, hogy a tábornokok egy G irányítatlan (nem teljes) gráf csúcsaiban vannak, és az élek mentén küldhetnek üzenetet. Megbízható élekkel G átm lépésben minden tábornok teljes információval rendelkezik a többiek véleményéről, és a katonai akadémián tanultak alapján ugyanarra a döntésre juthatnak. Ha azonban az élek meghibásodhatnak, ez az egyszerű gondolatmenet nem alkalmazható, a probléma nem oldható meg (ennek belátását meghagyjuk gyakorlatnak). Hibás élek esetén csak az a reális célkitűzés, hogy megadott valószínűséggel jussanak a tábornokok közös véleményre. A problémának ez a változata már determinisztikus és véletlenített algoritmussal is kezelhető. 5.3.2. Megegyezés processzorhibák esetében A processzorok működése során különböző hibák fordulhatnak elő. Az egyik a megállási hiba, melyben a processzor bármely lépésben beszüntetheti működését. A másik a bizánci hiba, melyben a processzorok a számukra megadott korlátokon (elvégezhető műveletek, felhasználható üzenetábécé) belül tetszőlegesen működhetnek. Ennek a problémának egy egyszerű megoldását biztosítja a HALMAZ-TERJED algoritmus. Ennek lényege, hogy a processzorok türelmesen terjesztik a tudomásukra jutott összes információt – és ha bizonyos ideig nem kapnak új információt, akkor az addig kapott üzenetek alapján döntenek. Ha a processzorok értékelik is a beérkezett információt és csak a lényeges részt adják tovább, akkor az elküldendő üzenetek száma csökkenthető. Így jutunk az OPT-HALMAZ-TERJED algoritmushoz. 5.3.3. k -megegyezés A k -megegyezési feladatnál a processzoroknak a bemeneti értékek k -elemű részhalmazából kell közösen elfogadott értéket választaniuk. Ezt a feladatot például a MIN-TERJED algoritmussal lehet megoldani. Ennek lényege, hogy a processzorok karbantartják és terjesztik az addig kapott legkisebb értéket. Erről az algoritmusról belátható, hogy ha legfeljebb h processzor hibásodhat meg, akkor h/k+1 lépésben megoldja a feladatot. A következő alsó korlát ismert. 5.12. tétel. Ha ph+k+1, akkor minden algoritmusnak legalább h/k+1 lépésre van szüksége, hogy h hibás processzor esetén megoldja a k -megegyezési feladatot. 5.3.4. Közelítő megegyezés A közelítő megegyezési feladatban minden processzornak van egy valós kezdeti értéke és a processzorok valós értékeket küldenek egymásnak és egymástól kevéssé eltérő értékekben kell megegyezniük. Megengedjük, hogy a processzorok bizáci hibákat kövessenek el. 3 feltételnek kell teljesednie. A befejeződési feltétel szerint minden hibátlanul működő processzornak végül döntést kell hoznia. Az érvényességi feltétel szerint a hibátlanul működő processzoroknak a hibátlan processzorok kezdeti értékeit tartalmazó (lehető legrövidebb) intervallumból vett értékkel kell megállniuk. A megegyezési feltétel szerint akármely két hibátlanul működő processzor kimenő értéke legfeljebb egy előre adott ε értékkel térhet el egymástól. Ismertek olyan algoritmusok, amelyek teljes hálózatban biztosítják a közelítő megegyezést, ha a hibás processzorok száma kisebb, mint az összes processzorok számának egy harmada. Gyakorlatok 5.3–1. Elemezzük a LELANN és a CHANG-ROBERTS algoritmusokat. a. Adjuk meg az azonosítók olyan permutációját, amelyre az elküldött üzenetek száma Ω(n2).b. Adjuk meg az azonosítók olyan permutációját, amelyre az elküldött üzenetek száma O(n). 5.3–2. Módosítsuk a CHANG-ROBERTS algoritmust úgy, hogy az összes nem-vezető folyamat a nem-vezető kimenetet eredményezze, vagyis az összes folyamat végül is álljon meg. Adjuk meg a módosított algoritmus pszeudokódját. 5.3–3. Mutassuk meg, hogy a CHANG-ROBERTS algoritmus különböző induló időpontok mellett is helyesen működik. (Ehhez módosítsuk a kódot.) 5.3–4. Bizonyítsuk be a LELANN és a CHANG-ROBERTS algoritmusok helyességét. 5.3–5. Mutassuk meg, hogy a HIRSCHBERG–SINCLAIR algoritmus különböző induló időpontok mellett is helyesen működik. (Ehhez egy kicsit módosítsuk a pszeudokódot.) 5.3–6. Tegyük fel, hogy a HIRSCHBERG–SINCLAIR algoritmust úgy módosítjuk, hogy kettő-hatványok helyett egymás utáni k -hatványokat használunk az utak hosszára (k>2). Elemezzük a módosított algoritmus lépésszámát és kommunikációs bonyolultságát úgy, mint az eredeti HIRSCHBERG–SINCLAIR algoritmusnál. Hasonlítsuk össze az eredményeket. 5.3–7. Tekintsük a HIRSCHBERG–SINCLAIR algoritmus olyan módosított változatát, ahol a processzorok mindkét irány helyett csak az egyik irányba küldhetnek üzeneteket. a. Mutassuk meg, hogy a könyvben megadott algoritmus legkézenfekvőbb módosítása nem eredményez O(nlogn) üzenetszámot. Adjunk felső korlátot az üzenetszámra. b. Módosítsuk úgy az algoritmust, hogy az üzenetszáma O(nlogn) legyen. 5.3–8. Tervezzünk egyirányú gyűrűben olyan vezetőválasztó algoritmust, amely nem ismeri a gyűrű méretét és legrosszabb esetben is csak O(nlogn) számú üzenetet használ. Az algoritmus az azonosítókra kizárólag az összehasonlítás műveletet használhatja. 5.3–9. Adjunk a menetek számára vonatkozó minél jobb alsó korlátot valamely n méretű gyűrű vezető folyamat kiválasztásos algoritmusának legrosszabb esetére. A feltevéseket körültekintően fogalmazzuk meg. 5.3–10. Adjuk meg az n=16 csúcsú bitfordító gyűrű pontos leírását. 5.3–11. Bizonyítsuk be, hogy az n=2k méretű bitfordító gyűrű minden kN esetén 1/2 -szimmetrikus. 5.3–12. Tervezzünk c -szimmetrikus gyűrűt nem kettő-hatvány számú csúcs esetén valamilyen c>0 értékre. 5.3–13. Valamely szinkron gyűrű esetén tekintsük a vezető folyamat kiválasztásának problémáját, ahol minden folyamat ismeri a gyűrű n méretét és a processzoroknak nincs azonosítójuk. Adjunk a probléma megoldására véletlenített algoritmust, vagyis olyat, ahol a processzorok kódjuk determinisztikus végrehajtásán kívül véletlen választással is élhetnek. A helyes működést kielégítő tulajdonságokat óvatosan fogalmazzuk meg. Például az egyedi vezető folyamat kiválasztása biztosan garantált-e vagy valamilyen kis valószínűséggel elképzelhető, hogy ez nem történik meg? Mennyi lesz az algoritmus lépésszáma és üzenetszáma? 5.3–14. Tekintsünk valamilyen ismeretlen n méretű kétirányú gyűrűt, ahol a processzoroknak van egyedi azonosítójuk. Adjunk az üzenetek számára vonatkozó alsó és felső korlátot olyan összehasonlítás alapú algoritmus esetén, ahol minden processzor mod 2 számolja ki n -et. 5.3–15. A MAX-TERJED algoritmusban használt üzenetek átm|E| száma O(n3). Adjunk meg olyan irányított gráfokat, amelyekre az átm|E| szorzat Ω(n3) , vagy mutassuk meg, hogy nincs ilyen irányított gráf. 5.3–16. Az OPT-MAX-TERJED algoritmus által elküldött üzenetek számára adjunk a O(n3) -nál kisebb felső korlátot vagy mutassuk meg, hogy a korlát aszimptotikusan éles. 5.3–17. Elemezzük a vezetőválasztás lépésszámát és üzenetszámát, feltéve, hogy néhány szomszédos csúcs között kétirányú kommunikációt is megengedünk. 5.3–18. Tervezzünk egy vezetőválasztó algoritmust egy olyan erősen összefüggő irányított hálózatban, amelyben a processzoroknak van egyedi azonosítójuk. a. Tegyük fel, hogy a kommunikáció a szomszédos csúcsok között kétirányú. b. Ne alkalmazzuk az előző feltevést. 5.3–19. Adjunk algoritmust a csúcsok számának megállapítására egy olyan erősen összefüggő irányított hálózatban, amelyben a processzoroknak van egyedi azonosítójuk. a. Tegyük fel, hogy a kommunikáció a szomszédos csúcsok között kétirányú. b. Ne alkalmazzuk az előző feltevést. 5.3–20. Adjunk algoritmust az élek számának megállapítására egy olyan erősen összefüggő irányított hálózatban, amelyben a processzoroknak van egyedi azonosítójuk. a. Tegyük fel, hogy a kommunikáció a szomszédos csúcs közt kétirányú. b. Ne alkalmazzuk az előző feltevést. 5.3–21. Tegyük fel, hogy egy láncban minden Pi processzor meg tudja különböztetni a bal oldalát a jobb oldalától, és ismeri azt is, hogy ő maga végpont-e vagy sem. Tegyük fel, hogy minden processzor kezdetben egy nagyon nagy ai egész értékkel rendelkezik, és azt, hogy az ilyen értékekből egy adott időpillanatban csak adott számút tarthatunk nyilván a memóriában. Tervezzük meg azt az ezen értékeket sorba rendező algoritmust, amelyben az egyes Pi processzorok által előállított oi kimeneti értékek összeszorzott halmaza megegyezik az ai bemeneti értékek összeszorzott halmazával, és o1...on . Próbáljuk meg előállítani mind az üzenetek, mind a menetek száma tekintetében a leghatékonyabb algoritmust. 5.3–22. Mutassuk meg, hogy az összehangolt támadási probléma (determinisztikus változatának) megoldása bármely nem triviális, összefüggő gráf esetében magában foglalja a probléma megoldását arra az egyszerű, két pontból álló gráfra, mely egy éllel van összekötve. (Ebből következik, hogy a probléma megoldhatatlan tetszőleges, nem triviális gráf esetében.) 5.3–23. Tekintsük a (determinisztikus) összehangolt támadási probléma következő változatát. Tegyük fel, hogy a hálózat n>2 résztvevőből álló teljes gráf. A befejezési és érvényességi feltételek az 5.3. alfejezetben leírtakkal azonosak. A megegyezési feltételt azonban gyengítjük:,,Ha van olyan a folyamatok között, amelyik döntése 1, akkor legalább kettőnek 1-est kell döntenie.” (Azaz szeretnénk kizárni azt az esetet, amikor egy tábornok magányosan támad, de megengedjük azt, hogy két vagy több tábornok együtt támadjon.) Vajon ez a probléma megoldható, vagy nem? 5.3–24. Tekintsük az összehangolt támadási problémát vonalhibák esetében arra az egyszerű esetre, amikor két folyamat egy éllel van összekötve. Tegyük fel, hogy a processzorok működése determinisztikus, de az üzenetrendszer véletlenített abban az értelemben, hogy mindegyik üzenetnek van egy független q valószínűségi értéke (0<q<1) , ami annak a valószínűségét adja meg, hogy az üzenet sikeresen megérkezik. (Ahogy általában, most is megengedjük, hogy a folyamatok menetenként csak egy üzenetet küldjenek.) Tervezzünk ezekkel a beállításokkal olyan algoritmust, mely rögzített r számú meneten belül befejeződik, a megegyezés hiányának valószínűsége legfeljebb ε, és ehhez hasonlóan az érvényességi feltétel megsértésének valószínűsége is legfeljebb ε. A lehető legkisebb ε érték elérésére törekedjünk. 5.3–25. Az előző gyakorlat kikötései szerinti modellben adjunk alsó korlátot az ε értékére, bizonyítsuk be, hogy ez az elérhető legalacsonyabb érték. 5.3–26. Általánosítsuk az összehangolt támadási probléma véletlenített változatát úgy, hogy megengedjük ε valószínűséggel mind az érvényességi, mind a megegyezési szabályok megsértését. Írjuk át a VÉLETLENÍTETT-TÁMADÁS algoritmust úgy, hogy a módosított feltételek mellett elérje a lehető legkisebb ε értéket. Végezzünk elemzést. 5.3–27. Általánosítsuk a VÉLETLENÍTETT-TÁMADÁS algoritmust és az elemzését az általános irányítatlan gráfokra. 5.3–28. Mi történne a fejezetben tárgyalt, véletlenített környezettel kapcsolatos eredményekkel, ha az ellenfél kommunikációs mintája nem lenne előre rögzítve, mint ahogy eddig feltettük, hanem az ellenfél közvetlen irányítással határozhatná meg azt. Pontosabban szólva, tegyük fel, hogy az ellenfél képes arra, hogy megvizsgálja a végrehajtási sorozatot bármely k -adik menettől visszafelé a kezdetig, mielőtt döntene, hogy a k -adik menetbeli üzenetek közül melyek legyenek kézbesítve. a. Milyen ε korlát garantálható a VÉLETLENÍTETT-TÁMADÁS algoritmus esetében a megegyezés hiányára, ilyen közvetlen irányításra képes ellenfelek esetében? b. Adhatunk-e valamilyen érdekes alsó korlátot az elérhető ε értékekre? 5.3–29. Bizonyítsuk be, hogy tetszőleges olyan algoritmus, mely megoldja a bizánci megegyezés problémát, megoldja a megegyezési problémát megállási hibák esetében is, ha a megállási hiba modellben úgy módosítjuk az érvényességi feltételt, hogy csak a hibamentes folyamatok megegyezését követeljük meg. 5.3–30. Bizonyítsuk be, hogy tetszőleges olyan algoritmus, mely megoldja a bizánci megegyezés problémát és amelyben a hibátlan folyamatok mindig egyszerre, ugyanazon menetben hoznak döntést, megoldja a megegyezési problémát megállási hiba modellben is. 5.3–31. Kövessük nyomon a HALMAZ-TERJED algoritmus végrehajtását négy folyamattal és két hibával, melyben a folyamatok kezdőértékei rendre az 1, 0, 0, 0 értékek. Tegyük fel, hogy P1 és P2 folyamatok hibásak, P1 az első menetben lesz hibás, miután egyedül a P2 folyamatnak elküldte az üzenetet, P2 pedig a második menetben lesz hibás, P1 -nek és P3 -nak küld üzenetet, viszont P4 -nek nem. 5.3–32. Tekintsük a HALMAZ-TERJED algoritmust f hibára. Tegyük fel, hogy az algoritmus f+1 menet helyett csak f menetben fut, ugyanazzal a döntési értékkel. Találjunk egy olyan végrehajtási sorozatot, mely megsérti a helyességi feltételeket. 5.3–33. Legfeljebb mennyi lehet a hibamentes folyamatok által hozott, egymástól különböző döntési értékek darabszáma, ha a HALMAZ-TERJED algoritmus f+1 menet helyett csak f menetben fut. 5.3–34. a. Találjunk egy másik lehetséges, helyesen működő döntési szabályt a HALMAZ-TERJED algoritmusban, amelyik eltér szövegben megadottól. b. Adjunk pontos jellemzést azon döntési szabályok halmazáról, amelyek helyesen működnek. 5.3–35. Terjesszük ki a HALMAZ-TERJED algoritmust, a helyesség bizonyítását, és az elemzést, tetszőleges összefüggő gráfokra. 5.3–36. Készítsük el az OPT-HALMAZ-TERJED algoritmus kódját. 5.3–37. Tekintsük a következő egyszerű algoritmust a megállási hibák mellett történő megegyezésre, egy adott V értékhalmaz esetében. Legyen mindegyik processzornak egy min-érték változója, melyet induláskor a saját kezdeti értékére állít be. Az f+1 menet mindegyikében a processzorok közreadják min-érték változójuk értékét, majd újra beállítják úgy, hogy a minimuma legyen a min-érték változó eredeti értékének, valamint az üzenetekben kapott értékeknek. Végül a processzor döntési értéke min-érték lesz. Készítsük el ennek az algoritmusnak a kódját és bizonyítsuk be (vagy direkt módon, vagy szimulációval), hogy helyesen működik. Feladatok 5-1. Vezetőválasztás négyzeten Bizonyítsuk be, hogy négyzeten O(nlogn) idő alatt megoldható a vezető választása. 5-2. Vezetőválasztás tóruszon Bizonyítsuk be, hogy tóruszban O(nlogn) idő alatt megoldható a vezetőválasztás. 5-3. Vezetőválasztás hiperkockán Bizonyítsuk be, hogy hiperkockán O(nlogn) idő alatt megoldható a vezetőválasztás. 5-4. Nem összehasonlítás alapú vezetőválasztás Az anyagban csak összehasonlítás alapú vezetőválasztó algoritmusokat tárgyaltunk. Vizsgáljunk meg néhány más típusú algoritmust is. a. Írjuk meg az IDŐ-SZELET algoritmus pszeudokódját. b. Módosítsuk úgy az IDŐ-SZELET algoritmust, hogy hozzávett üzenetek árán fázisonként egyetlen azonosító helyett k darab azonosító továbbküldésének engedélyezésével csökkenjen a lépésszám. Bizonyítsuk be az algoritmus helyességét és elemezzük bonyolultságát. c. Adjuk meg a VÁLTOZÓ-SEBESSÉGEK algoritmus pszeudokódját. d. Mutassuk meg, hogy ha a processzorok különböző időpontokban ébredhetnek fel, a VÁLTOZÓ-SEBESSÉGEK algoritmus üzenetszáma nem szükségszerűen O(n).5-5. Harmonikus szám Bizonyítsuk be a harmonikus számok alábbi tulajdonságait: i=1nHi=(n+1)Hnn(han1)(5.11) és ln(n+1)<Hn<1+ln(n+1)(han1).(5.12)5-6. CHANG-ROBERTS algoritmus a. Ha minden processzor kezdő processzor, legjobb esetben hány üzenetet továbbít a CHANG-ROBERTS algoritmus? b. Ha pontosan s kezdő processzor van, amelyek egyforma valószínűséggel lesznek vezetők, akkor mennyi lesz az algoritmus átlagos kommunikációs bonyolultsága (üzeneteinek száma)? 6. Hagyományos és elektronikus irodalom Ebben a fejezetben összefoglaljuk az előző öt fejezet anyagához kapcsolódó szakirodalmat. 6.1. Megjegyzések az 1. fejezethez A párhuzamos algoritmusok alapját képező soros algoritmusok magyar nyelvű szakirodalma jelentős. Gazdag anyagot tartalmaz Knuth monográfiája [210] [211] [212] [215], Cormen, Leiserson és Rivest [53] könyve, valamint annak javított és bővített változata [54] – melyeket több mint tíz nyelvre lefordítottak. 31 témakör algoritmusait foglalja össze a nemzetközi összefogással született kétkötetes Informatikai algoritmusok [158] [160], melynek első kötete elektronikus formában is megjelent [159]. Több témában hasznos anyagot tartalmaznak – ugyancsak magyarul – Aho, Hopcroft és Ullman [3] [4], Artiaga és Davis [17], Kása Zoltán [192], Lawler [242], Lovász és Gács [253], Marton és Fehérvári [260], Papadimitriou [291], Rónyai, Ivanyos és Szabó [320], Trahtenbrot [371], valamint Wirth [395] könyvei. Az angol és német nyelvű könyvek közül elsősorban Berman és Paul [34], Cormen, Leiserson, Rivest és Stein ( [54], ami [53] bővített kiadása), Mehlhorn [262] [263] [264] műveit, továbbá az Atallah [18], Gonnet és Baeza-Yates [122], Gruska [126], Ralston, Reilly és Hemmendinger [314], valamint a van Leewen [374] által szerkesztett enciklopédiákat ajánljuk. Kiegészítésképpen érdemes elolvasni Baase [22], Baase és Van Gelder [23], Brassard és Bratley [38], Gibbons és Rytter [120], Greenflaw, Hoover, Ruzzo [124], Jájá [180], Miller és Boxer [265], Selim [337], Skiena [346], Valiente [373], valamint Wilf [392] könyveit. Elektronikus formában több algoritmusgyűjtemény elérhető, például a CALGO [42], LEDA [7], NetLib [275] és XTANGO [396].A párhuzamos algoritmusok témakörében az első lényeges gondolatok Neumann Jánosnak a negyvenes évek végén és az ötvenes évek elején elhangzott előadásaiban és azóta megjelent dolgozataiban [276] [277] [278] [280] találhatók. Ezekben a sokprocesszoros rendszereken belül való munkamegosztás problémáira is felhívta a figyelmet. Azt is igazolta, hogy kellő többszörözéssel védekezhetünk a sokkomponensű rendszerek elemeinek bizonyos mértékű meghibásodásával szemben. Ezen gondolatok egy része magyarul is hozzáférhető Drommerné Takács Viola [73] és Neumann János [278] könyvében, valamint Gács Péter friss munkájában [117]. A párhuzamos algoritmusok magyar nyelvű irodalma még kicsi. Figyelemre méltó anyag Lovász László és Gács Péter 1978-ban megjelent, az algoritmusokat népszerűsítő könyvében [253] a párhuzamos számítások lehetőségeiről szóló fejezet. N. A. Lynch [257] könyve részletesen tárgyalja az osztott rendszerekkel (elsősorban az aszinkron hálózatokkal) kapcsolatos problémák egy részét. 2003-ban jelent meg a Párhuzamos algoritmusok [174], amely ennek az elektronikus tankönyvnek az alapját képezi. A legegyszerűbb párhuzamos algoritmusok és párhuzamos programozási eszközök összefoglalását megtalálható a 2004-ben megjelent [158] hatodik fejezetében, ami a hálózaton [159] is elérhető. Az algoritmusokkal kapcsolatos szakkifejezések egy része is megtalálható a Frey Tamás és Szelezsán János által a hőskorban szerkesztett könyvekben [115] [116], valamint a Horváth László és Pirkó József által szerkesztett lexikonokban [143] [144] [145]. Ezeket egészítjük ki a könyvünk Angol kifejezések és Magyar kifejezések című részeiben lévő szótárakkal. A miénknél bővebb szótár a nyomtatott [?] és a hálózaton található [?]. A könyv anyagának elmélyítéséhez elsősorban a következő műveket ajánljuk. A függvények növekedésével kapcsolatos alapfogalmakat Knuth klasszikus cikkéből [208] [214], Almasi és Gottlieb hangulatos leírásából [8], valamint Schöning könyvéből [334] vettük át. A Hanoi tornyaira vonatkozó feladat Lucastól [256] származik. A feladat leírása magyarul is hozzáférhető, például Knuth, Graham és Patashnik [216] könyvében. A Föld életkorára vonatkozó becslés az Officina Nova kiadó világatlaszából származik [287]. A matematikai alapok ismétléséhez Andrásfai Béla [14], Demetrovics János, Denev és Pavlov [65], Dringó László és Kátai Imre [72], Láng Csabáné és Gonda János [121] [238] [239], valamint Járai Antal [182] tankönyveit ajánljuk. Amdahl törvénye a [9], Gustafson törvénye pedig a [127] konferenciakötetben jelent meg. Az alkalmazott pszeudokódot Cormen, Leiserson, Rivest és Stein [54], valamint Berman és Paul [34] Pascal-alapú pszeudokódja és a Stroustrup által kifejlesztett C++ nyelv [364] ötvözésével állítottuk össze. A hatékonysági mértékeket többek között Horowitz, Sahni és Rajasekaran [142], Lynch [257], valamint Roosta [321] és Tel [370]alapján definiáltuk. A lépésszámfüggvények polinomiális és exponenciális osztályokra való bontásával a bonyolultságelmélet bibliáját, Garey és Johnson könyvét [118] követtük. A számítási modelleket illetően főleg Cormen, Leiserson, Rivest és Stein [54], valamint Berman és Paul [34] műveire támaszkodtunk. Sima, Fountain és Kacsuk könyve [342] részletesen tárgyalja a hagyományos és a modern rendszerek felépítését. A könyvhöz jó kiegészítés a számítási modellekkel foglalkozó első fejezet kézirata [341], amely lényegesen bővebb a nyomtatásban megjelent változatnál. A párhuzamos rendszerek hardver- és szoftverproblémáival kapcsolatban gazdag anyag van például Almasi és Gottlieb [8], Amestoy [10], Kacsuk Péter és Kotsis Gabrielle [190], Kacsuk Péter, Kranzlmüller, Németh Zsolt és Volkert [191], valamint Leighton [245] [246] műveiben. Flynn [88]1966-ban publikálta osztályozási rendszerét. Az ILLIAC IV számítógéppel foglalkozik Barnes [28] cikke. A párhuzamos számítógépek előfutárának tekinthető D. H. Lehmernek [243] [244]a harmincas években épített mechanikus szerkezete, amely párhuzamos műveletek elvégzésére is képes volt. Lehmer például a 293+1 tényezőkre bontására használta fel a szerkezetet. A rekurzív algoritmusokkal és rekurzív egyenletekkel kapcsolatban hasznos magyarul Cormen, Leiserson és Rivest [53], Knuth, Graham és Patashnik [216], angolul pedig Berman és Paul [34], Greene és Knuth [123], Purdom és Brown [308], Sedgewick és Flajolet [336], valamint Wilf [391] műve. A rekurziótétel megtalálható például Halmos [128] könyvében. A véletlenített algoritmusokról szóló alfejezethez Bollobás [36], Erdős és Spencer [77], Hofri [139], Motwani és Raghavan [271], Mayr, Prömel és Steiger [261], Pardalos és Rajasekaran [292], valamint Spencer [348]könyveit ajánljuk. A Csernov-egyenlőtlenségeket Csernov [47]1952-ben publikálta. A valószínűségszámítás magyar nyelvű szakirodalmához tartoznak Feller [81], Prékopa [306]és Rényi [318]könyvei. Az anomáliára példák szerepelnek Coffman [50], Iványi és Szmeljánszkij [178], valamint Roosta [321]könyvében, továbbá Fornai Péter és Iványi Antal [90], valamint Lai és Sahni [237]. Alsó korlátra vonatkozó eredmények találhatók például Berman és Paul [34], valamint Lynch [257] könyvében. A párhuzamos és osztott rendszerek számos részkérdéséről tartalmaznak hasznos anyagot Akl [5], Gibbons és Rytter [120], Heath, Renade és Schreiber [132], Jájá [180], Leopold [248]és Zomaya [397] [398]könyvei. A gyakorlatok és feladatok részben a már említett szakkönyvekből származnak, részben oktatóés kutatómunkánk során gyűltek össze. Érdemes meglátogatni Járai Antal [183]és Katona Gyula [195]magyar nyelvű – soros algoritmusokkal kapcsolatos – elektronikus feladatgyűjteményét. Nagyon hasznos Sussman oktatói kézikönyve [365], amely [53]-hez készült, továbbá Hecker [135]és Winkler [394] feladatsorozatai. Értékes oktatási segédeszköz Cormen, Lee és Lin oktatói segédkönyve [55], amely Cormen, Leiserson, Rivest és Stein könyvéhez [54] készült. Párhuzamos programokat tartalmaznak Rajasekaran [311] és Horváth Zoltán [152] honlapjai. A további megjegyzések a gyakorlatokra és feladatokra vonatkoznak. Az első feladat alapja Cormen, Leiserson és Rivest [54], a második feladaté Roosta könyve [321], a harmadik Iványi Annától [161] származik. A negyedik feladat megoldásához hoz Coffman könyvének [50], Fornai Péter és Iványi Antal [90], valamint Lai és Sahni cikkének [237], az ötödikhez Berman és Paul könyvének [34], végül a hatodikhoz Iványi Antal cikkeinek [169] [172], valamint Kovács Gábor Zsolt és Pataki Norbert diákköri dolgozatának [222]elolvasása nyújthat segítséget.A kétdimenziós tökéletes mátrixokkal kapcsolatban nagy anyag található D. E. Knuth monográfiájának negyedik kötetében, a már nyomtatva is megjelent második füzetben [215]. További algoritmusok találhatók a Belényesi Viktor és Németh Cs. Dávid diákköri dolgozatában [30], Ferenczi és Kása Zoltán [82], valamint Iványi Antal és Tóth Zoltán cikkeiben [163] [166] [167] [168]. Háromdimenziós tökéletes mátrixok előállítási algoritmusait tartalmazzák Horváth Márk és Iványi Antal cikkei [146] [168].A bináris sorozatok feldolgozásával kapcsolatos algoritmusok Iványi Antal és Kátai Imre [175] [176], valamint Iványi Antal és Pergel József [177]dolgozataiból származnak. A foksorozatokkal kapcsolatosak Iványi Antal [169], Kemnitz és Dulff [198], Kovács Gábor Zsolt és Pataki Norbert [222], Moon [269], Narayana és Bent [273], Pécsy Gábor és Szűcs László [298], Siklósi Bence [339], valamint Szadovszkij és Szadovszkij [327]művei. A ládapakolással kapcsolatban Coffman, Csirik János és Woeginger összefoglalóját [51], Coffman, Galambos Gábor, Martello és Vigo [52], Csirik János, Galambos Gábor, Frenk és Rinnoy Kan [58], Csirik János és Imreh Balázs [59], Csirik János és Johnson [60]cikkét, valamint Iványi Antal dolgozatait [162] [164] említjük. 6.2. Megjegyzések a 2. fejezethez A prefixszámítás aszinkron megoldására például Horváth Zoltán cikkében [147] és elektronikus kéziratában [149], valamint Kozsik Tamás technikai riportjában [236] található algoritmus. Nehéz lenne a gráfelmélet elméleti és gyakorlati jelentőségét túlbecsülni, ezért nem meglepő, hogy számos magyar nyelvű könyv szól a gráfokról: Andrásfai Béla [11] [12] [13], Busacker és Saaty [41], Cseke Vilmos [56], Kaufman [197], Katona, Recski és Szabó [196], Ore [289], Recski András [316] művei. Megemlítjük Kása Zoltán elektronikus feladatgyűjteményét [193], valamint Lovász László [251] angolul, magyarul és elektronikusan is elérhető példatárát is. Az idegen nyelvű könyvek közül Berge [32], Bollobás Béla [36], Diestel [68], Jungnickel [189] műveit említjük A munkaoptimális véletlenített kereső algoritmust Floyd és Rivest [87] publikálta 1975-ben. Preparata algoritmusa 1978-ban vált ismertté [307]. Reischuk munkaoptimális rendező algoritmusa 1985 óta ismert [317]. A feladatok forrása Horowitz, Sahni és Rajasekaran [142], Berman és Paul [34], valamint Tel [370] könyve. 6.3. Megjegyzések a 3. fejezethez Leighton könyve [245] a rácsalgoritmusokról szóló monográfia. Véletlenített csomagirányítási algoritmust javasolt Rajasekaran és Tsantilas 1992-ben [312]. Aszimptotikusan optimális csomagirányítási algoritmust ismertet Nassimi és Sahni 1982-ben [274]. A konvex burok számításáról összefoglalás található Sack és Urrutia [326] kézikönyvében. A feladatok megoldásához Berman és Paul [34], valamint Horowitz, Sahni és Rajasekaran könyve [142] a leghasznosabb. 6.4. Megjegyzések a 4. fejezethez Leighton két könyve [245] [246], valamint Ranka és Sahni műve [315] jelentős anyagot tartalmaznak a hiperkockákkal kapcsolatban. A feladatok többségének forrása Cormen, Leiserson, Rivest és Stein [53], valamint Horowitz, Sahni és Rajasekaran [142] könyve. 6.5. Megjegyzések az 5. fejezethez Ehhez a fejezethez elsősorban N. A. Lynch magyarul is megjelent könyvét [257], valamint Englert, Kowalski, Malewicz és Shvartsman [?]összefoglalóját ajánljuk. Számos gyakorlati példát tartalmaz Tanenbaum és van Steen [369] könyve, további algoritmusokat tárgyal Tel [370] friss monográfiája. A magyarul is hozzáférhető anyagot csak röviden ismertetjük és kiegészítjük más algoritmusok elemzésével. LeLann 1977-ben egy konferencián [247] fogalmazta meg és oldotta meg a vezetőválasztási problémát. Chang és Roberts két év múlva a [46] cikkben javasoltak átlagosan kevesebb üzenetet igénylő módszert. Peterson [299] cikke újabb 3 év múlva jelent meg. Hirschberg és Sinclair [133] 1980-ban javasolt O(plogp) üzenetszámú algoritmust kétirányú gyűrűk vezetőjének megválasztására. Később Peterson [300] és Dolev, Klawe, Rodeh [69] egymástól függetlenül egyirányú gyűrűben is megoldották O(plogp) üzenettel a vezetőválasztást. Pachl, Korach és Rotem [290] 1984-ben mutatták meg, hogy minden gyűrűben átlagosan Ω(plogp) üzenetre van szükség a vezetőválasztáshoz. 1988-ban Bodlaender [35] bebizonyította, hogy kétirányú gyűrűben legrosszabb esetben legalább 0.34plogp üzenetre van szükség. A fejezet feladatai részben Lynch [257]és Tel könyvéből származnak [370]. A terjedelem szabta korlátok miatt a témakör több lényeges területével nem foglalkoztunk. Ezeket az ACM (Association for Computing Machinery) és az IEEE (Institute of Electrical and Electronics Engineers) által 2001-ben összeállított Informatikai Tanterv, a Steelman Report [155] alapján csoportosítjuk. Ez a tanterv az informatikai ismeretek 14 különböző területét különbözteti meg (zárójelben megadjuk az ajánlott minimális előadási óraszámot, valamint a rövid és teljes angol nevet): diszkrét matematika (43 óra, DS = Discrete Structures), programozás alapjai (38 óra, PF = Programming Fundamentals), algoritmusok és bonyolultság (31 óra, AL = Algorithms and Complexity), programozási nyelvek (21 óra, PL = Programming Languages), számítógépek felépítése(18 óra, AR = Architecture and Organization), operációs rendszerek (18 óra, OS = Operating Systems), hálózatok (15 óra, NC = Net-Centric Computing), ember-gép kapcsolat (8 óra, HC = Human-Computer Interaction), grafika (3 óra, GV = Graphics and Visual Computing), mesterséges intelligencia (10 óra, IS = Intelligent Systems), információkezelés (10 óra, IM = Information Management), szoftvertechnológia (31 óra, SE = Software Engineering), számítógép és társadalom (16 óra, SP = Social and Professional Issues), kiszámításelmélet (0 óra, CN = Computational Science).Az ismereteknek ebben a rendszerezésében könyvünk témája elsősorban az algoritmusok témakör 11 altémája közül kettő: a párhuzamos algoritmusok és az osztott algoritmusok.1. Diszkrét matematika (DS). A Steelman Report a függvények, relációk és halmazok egyszerű tulajdonságait, logika elemeit, alapvető bizonyítási és leszámlálási módszereket, valamint a valószínűségszámítás alapfogalmait sorolja. Ajánlott irodalom magyarul Andrásfai Béla [14], Bagyinszki János és György Anna [25], Demetrovics János, Denev és Pavlov [65], Dringó László és Kátai Imre [72], Gavrilov és Szapozsenko [119], Gonda János és Láng Zsuzsa [238] [239] [121], valamint Járai Antal [183] elektronikus jegyzete. A legfontosabb matematikai képleteket és definíciókat tartalmazza Bronstein, Szemengyajev et al. [39] és Obádovics J. Gyula [286]könyve. A matematika tanításának pszichológiájába ad betekintést Klein Sándor [205] műve. Jó angol nyelvű főiskolai könyvek Dossey, Otto, Spence és Eynden [71], valamint Prather [305] művei, szórakoztató Vilenkin könyve [380] a kombinatorikáról. Komolyabb matematikai alapokat nyújtanak a logika területéről magyarul Flach [85], Pásztorné Varga Katalin és Várterész Magdolna [294], valamit Ruzsa Imre [324], lineáris algebráról Freud Róbert [113], számelméletről Freud Róbert és Gyarmati Edit [114], kombinatorikáról pedig Lovász László [251]. Angolul vagy németül algebrai algoritmusokról Pethő Attila [301]és Winkler [393], kombinatorikáról pedig Erdős Pál [76], valamint Lovász László [251]adnak részletes ismereteket. Nagy anyagot tartalmaz a leszámlálás módszereiről Stanley [349]kétkötetes monográfiája. Konkrét kombinatorikai algoritmusokat (és programokat) tartalmaz Nijenhuis és Wilf [281]könyve, valamint Knuth elektronikus kézirata [215]és elektronikus formában is elérhető könyve [209]. Az informatika matematikai alapjait foglalja össze Ferenczi Miklós és Rónyai Lajos megjelenőben lévő, angol nyelvű könyve [83]. 2. Programozás alapjai (PF). Ide a legfontosabb programkonstrukciók, feladatok specifikációja, egyszerű adatszerkezetek, rekurzió tartozik. Ajánlott irodalom: magyarul Fóthi Ákos [91], angolul Baase és van Gelden [22] [23], oroszul pedig Iványi Antal és Szmeljánszkij [178]könyvei. A szakirodalom értékes részét képezi azoknak a szoftver eszközöknek (Mathematica, Matlab, Maple) a leírása, melyek segítségével kényelmesen programozhatók oktatási és kutatási feladatok: Klincsik Mihály és Maróti György [206], Molnárka Győző, Gergó Lajos, Wettl Ferenc, Horváth Gábor, Kallós Gábor [268], Szili László és Tóth János [361], valamint Stoyan [350]könyvei. Absztrakt adattípusok megvalósításával foglalkozik Horváth Zoltán, Kozsik Tamás és Venczel Tibor cikke [150]. 3. Algoritmusok (AL). Algoritmikai alap fogalmak, alapvető algoritmusok, osztott és párhuzamos algoritmusok, kriptográfiai algoritmusok, automataelmélet, geometriai algoritmusok, kiszámíthatóság, algoritmusok önálló elemzése). A problémák bonyolultság szerinti osztályozásával kapcsolatban magyarul is hozzáférhető Ausiello [19] és Papadimitriou [291]könyve. Angolul Garey és Johnson klasszikus műve [118] mellett figyelmet érdemelnek Ausiello és társszerzői [20], Jones [185], Li és Vitanyi [249], Lovász [252], Sipser [345], Vogel és Wagner [384], valamint Wagner és Wechsung [385] eredményei. A szóbonyolultság számos kutatójának adatai megtalálhatók Iványi Antal honlapján [172]. A közelítő algoritmusokkal kapcsolatban gazdag anyagot tartalmaznak Hochbaum [138]és Vazirani [378]könyvei. A genetikus algoritmusokkal foglalkozik magyarul Álmos Attila, Győri Sándor, Horváth Gábor és Várkonyiné Kóczy Annamária [6], angolul pedig Goldberg [106], Langdon és Poli [240], valamint Mitchell [267].A kriptográfiával kapcsolatban Dénes József és Keedwell [66], valamint Salomaa, Rozenberg és Brauer [331]könyvét említjük. A szimulációval foglalkozik Kátai Imre [194], valamint Aven, Coffman és Kogan [21]. Csirik János és Woeginger [61] összefoglalta a közvetlen pakolási és lefedési algoritmusok témakörét. Mintegy harminc informatikai téma algoritmusait foglalja össze az Iványi Antal szerkesztésében megjelent kétkötetes Informatikai algoritmusok [158] [160], melynek első kötete az ELTE IKelektronikus könyvtárában is megtalálható. 4. Programozási nyelvek (PL). Konkrét programozási nyelvek és rendszerezésük, absztrakt adattípusok, objektumelvű programozás, funkcionális programozás, fordítóprogramok. A programozási nyelvek magyar nyelvű irodalma gazdag. A korai művek közül Farkas Zsuzsa, Futó Iván, Langer Tamás, és Szeredi Péter [79], Iványi Antalné és Kovács Zoltán [173], Jakobi Gyula [179], Horowitz [141], Kőhegyi János [230] [231] [232] [233], Kozics Sándor [227], Lőcs Gyula és Vigassy József [254] [255], Pirkó József [303] [302], Pongor György [304], Pyle [309], Sipos Annamária [344], Szlávi Péter és és Zsakó László [363] [399] [400]könyveit, az újak közül pedig Fóthi és Steingart [93], Stroustrup [364]művét, továbbá a Nyékyné Gaizler Judit szerkesztésében megjelent könyveket [283] [284] [285], valamint FóthiÁkos és Horváth Zoltán elektronikus tankönyvét említjük. Automatákkal és formális nyelvekkel foglalkozik magyarul Bach Iván [24]és Fülöp Zoltán [97] tankönyve, Csörnyei Zoltán [64], valamint Hunyadvári László és Manherz Tamás elektronikus jegyzete [153], Trahtenbrot [371] könyve, angolul pedig Hopcroft, Motwani és Ullman friss monográfiája [140]. 5. Számítógépek felépítése (AR). Az alapok, számábrázolás, funkcionális szervezés, multiprogramozás, hálózatok és osztott rendszerek felépítése. Számítógépek felépítésével kapcsolatos Kovács Győző [223], Cserny László [57], Knuth [213], valamint Tanenbaum [366]könyve. Az elektronikus áramkörök tervezésének algoritmusait foglalja össze Arató Péter, Jankovits István és Visegrády Tamás könyve [15]. Párhuzamos rendszerek hardverének és szoftverének kérdéseivel foglalkozik Amestoy [10], Hennessy és Patterson [136], Hwang [154], Kacsuk és Kotsis [190], Kacsuk, Kranzlmüller, Németh és Volkert [191]. 6. Operációs rendszerek (OS). Konkrét rendszerek, elvek, párhuzamos folyamatok, ütemezés, memóriaszervezés, fájlszervezés, biztonság és védelem, hatékonyság. Ajánlott irodalom: a rendszerprogramozási algoritmusok összefoglalása magyar nyelven megtalálható Csörnyei Zoltán [63], Donovan [70], Galambos Gábor [99], Tanenbaum és Woodhull [368], valamint Varga László [375] [376]könyveiben, idegen nyelven pedig Silberschatz, Galvin és Gagne [340], valamint Tanenbaum és Tanenbaum [?]műveiben. Chow és Johnson [48], Malyshkin [258], valamint Tanenbaum és van Steen [369]könyvei az osztott rendszerek működésével foglalkoznak. Norton és Stockman könyve [282]a biztonsági kérdések jó összefoglalója. Az ütemezési algoritmusok idegen nyelvű irodalmából P. Brucker [40], French [112], valamint Iványi Antal és Szmeljánszkij [178]könyvét említjük. Magyar nyelven Vizvári Béla [382]jegyzete, Iványi Antal elektronikus jegyzete [?], Jordán Tibor, Recski András és Szeszlér Dávid könyve [188], valamint Imreh Csanád [157]és Vizvári Béla [383]könyvfejeze is hozzáférhető. Az utóbbi anyag elektronikusan is elérhető. Petri-hálókról szól Kotov klasszikus [220], valamint Girault és Valk [104]most megjelent könyve. 7. Hálózatok (NC). Kommunikáció, biztonság, adattömörítés, konkrét webalkalmazások készítése, vezetékmentes számítások. A sejtautomatákkal kapcsolatos cikkeket tartalmaz a Drommerné Takács Viola [73]által zerkezstett könyv. A neurális hálókkal kapcsolatos angol nyelvű irodalomból Chua és Roska Tamás [49], valamint Roska Tamás és Rodríguez-Vázquez [322]könyvét, továbbá Marczell Zsolt, Szepesváry Csaba, Kalmár Zsolt és Lőrincz András cikkét [259]emeljük ki. Hálózatokkal foglalkozik magyarul Jutasi István [187], angolul Tanenbaum [?]. Idegen nyelven a neurális hálókkal kapcsolatban Chua és Roska Tamás [49]valamint Roska Tamás és Rodríguez-Vázquez [322]könyvét, továbbá Marczell Zsolt, Szepesváry Csaba, Kalmár Zsolt és Lőrincz András cikkét [259]emeljük ki. 8. Ember-számítógép kapcsolatok (HC). Ebben a témakörben a Mehdi Khoshrow-Pour által szerkesztett információtechnológiai enciklopédiát [207]ajánljuk.9. Grafika (GV). Alapvető módszerek, grafikus kommunikáció, geometriai modellezés, animáció, láthatóság, virtuális valóság. Ajánlott irodalom számítógépi grafikáról magyarul Füsi János [98]és SzirmayKalos László [362]könyve, valamint Vida János honlapja [379]. Geometriai modellezéssel foglalkozik de Berg, van Kreveld, Overmas és Schwarzkoff monográfiája [31]és Farin [78]könyve. Az animációval kapcsolatban magyarul hozzáférhető Nagy Tibor [272]és Salamon Gábor [328]elektronikus gyűjteménye. Idegen nyelven nagy értéket képvisel Gloor, Dynes és Lee [105]CD-je, amelyen Cormen, Leiserson és Rivest [53]könyvének hiperszövege és animált algoritmusai is megtalálhatók. Parent friss könyve [?], Stasko honlapja [?], valamint Jürgen Winkler [?]elektronikus gyűjteménye is említésre méltó. 10. Intelligens rendszerek (IS). Tudás ábrázolása, következtetés, fejlett keresés, ágensek, természetes nyelv feldolgozása, gépi tanulás, robotika. A mesterséges intelligencia számos algoritmusa megtalálható magyarul Fekete István, Gregorics Tibor és Nagy Sára [80], Futó Iván, Fekete István, Gregorics Tibor, Gyimóthy Tibor, Nagy Sára, Tatai Gábor és Sántáné Tóth Edit [96], Kelemen József és Nagy Sára [204], valamint Russel és Norvig [323]könyvében. 11. Információs rendszerek (IM). Adatmodellezés, lekérdező nyelvek, relációs adatbázisok, osztott adatbázisok, adatbányászás, digitális könyvtárak, hiperszöveg, multimédia. Ajánlott irodalom magyarul adatbázisokkal kapcsolatban Békéssy és Demetrovics [29], Garcia-Molina, Ullman és Widom [372] [102], valamint Rolland [319]könyvei. Az adatbányászat alapjait tartalmazza Adriaans és Zantinge műve [2]. A szakértői rendszereket elemzi Sántáné Tóth Edit jegyzete [332]. Nagy adathalmazok kezelésével foglalkozik Abello, Pardalos és Resende monográfiája [1]. 12. Szoftvertechnológia (SE). Tervezés, eszközök és környezetek, folyamatok, követelmények és specifikáció, helyességbizonyítás, fejlesztés, csoportmunka irányítása, megbízhatóság. A feladatok specifikációjával is foglalkozó magyar nyelvű anyagok közül ajánljuk például Sike Sándor és Varga László [377], valamint Sommerville [347]tankönyveit. Párhuzamos programozásról szól Horváth Zoltán [149]és Szeberényi Imre [357]elektronikus kézirata, Kozma László és Varga László [228], valamint Chandy és Misra [45] [266]könyvei. 13. Társadalomtudományi alkalmazások (SP). Informatika története, társadalmi környezet, elemzés eszközei és módszerei, szakmai és erkölcsi felelősség, kockázatok, számítógépi jog, filozófia. Ajánlott irodalom: magyarul Boros László [37]és Kurtán Lajos [234] [235]könyvei. 14. Kiszámíthatóság (CN). A fő témák numerikus módszerek, operációkutatás, nagy méretű számítások. Numerikus módszereket ismertet magyarul Galántai Aurél és Jeney András [101], Gergó Lajos [103], Kiss Ottó és Kovács Margit [203], Henrici [137], Obádovics J. Gyula [286], Ralston [313], Simon Péter [343], Stoyan Gisbert és Takó Galina [351] [352] [353]és Szidarovszky Ferenc [358]könyve. Az angol nyelvű szakirodalomból Argyros, Bahill, Okuguchi, Szidarovszky Ferenc és Yakowitz [16] [359] [360], az orosz nyelvűből pedig N. N. Bahvalov, E. P. Zsidkov és G. M. Kobelkov [26] könyveit emeljük ki. A numerikus módszerek alapját képező klasszikus analízis bizonyos részeit tárgyalja Járai Antal [181]könyve. Az optimalizálás módszereivel kapcsolatos magyar nyelvű irodalomból Bajalinov Erik és Imreh Balázs [27], Imreh Balázs [156], Komlósi Sándor [217]könyvét, valamint Frank András [111]és Szántai Tamás elektronikus jegyzetét [356]említjük. Angol nyelvű Censor és Stavros [44]könyve, a Floudas és Pardalos által szerkesztett hét kötetes enciklopédia [86], valamint Pardalos és Resende [293]kézikönyve. Operációkutatással foglalkozik Kovács Margit nyomtatott [224]és elektronikus [225], valamint Vizvári Béla [381]hagyományos jegyzete és Szántai Tamás [356]könyve. A játékelmélettel kapcsolatban Morgenstern és Neumann János klasszikus műve [270]mellett Forgó Ferenc, Szép Jenő és Szidarovszky Ferenc [89], Kiss Béla és Krebsz Anna [202], valamint Okuguchi és Szidarovszky Ferenc könyvét [288]ajánljuk. A fuzzy rendszerek elméletével kapcsolatos friss könyvek közül Carlsson és Fullér Róbert [43] [95]műveit említjük meg. Fourier-analízissel foglalkoznak Weisz Ferenc [388] [389]könyvei. Schipp Ferenc, Wade, Simon Péter és Pál Jenő [333]monográfiájának témája a harmonikus analízis . A valószínűségszámítás eszközeinek különböző alkalmazásairól szólnak Györfi Lászlónak és társszerzőinek a művei [67] [107] [108] [109] Jelölések A könyvben a következő jelöléseket alkalmazzuk. A,B : soros algoritmusok b(n,k)=(nk) : n alatt a k binomiális együttható B(n,π,p,P) : a P párhuzamos algoritmus legjobb lépésszáma B(n,π,A) : az A soros algoritmus legjobb lépésszáma p processzoron C(n,π,p,P) : a P párhuzamos algoritmus legrosszabb üzenetszáma g(n,π,A,P) : aP párhuzamos algoritmus gyorsítása h(n,π,p,P) : a P : párhuzamos algoritmus hatékonysága logn=log2n : kettes alapú logaritmus lnn=logen : természetes alapú logaritmus logkn=(logn)k : logaritmus függvény hatványa logn=log10n : tízes alapú logaritmus logn = iterált logaritmus függvény n : probléma mérete N(n,π,p,P) : a P párhuzamos algoritmus szükséges lépésszáma p processzoron N(n,π,A) : az A soros algoritmus szükséges lépésszáma o : kis ordó O : abszolút nagy ordó O~ : gyenge nagy ordó O : nagy ordó O¯ : nagy valószínűségű nagy ordó O : végtelen nagy ordó p : processzorok száma P,Q : párhuzamos algoritmusok W(n,π,p,P) : a P párhuzamos algoritmus legrosszabb lépésszáma W(n,π,A) : az A soros algoritmus legrosszabb lépésszáma ω : kis omega Ω : nagy omega Ω¯ : nagy valószínűségű nagy-omega Ω : végtelen nagy omega π : probléma Σ : véges ábécé Θ : nagy teta Θ¯ : nagy valószínűségű nagy teta : alsó egész rész : bináris asszociatív operátor × : Descartes-szorzat :=: értékadás jele és and: logikai és! : faktoriális : felső egész rész || : halmaz elemszáma : fekete kocka (bizonyítás végének a jele) : megjegyzés szimbólum : : olyan, mint és or: logikai vagy Angol kifejezések Ebben a részben megadjuk a témakör angol nyelvű irodalmából átvett szakkifejezések magyar megfelelőjét. anomaly = anomáliabig oh = nagy ordóbig omega = nagy omegabig theta = nagy tetabinary tree network = bináris fa hálózatbutterfly = pillangóconcurrent read, concurrent write (CRCW) = párhuzamos olvasás, párhuzamos írásconcurrent read, exclusive write (CREW) = párhuzamos olvasás, kizárólagos íráscross link = kereszt kapcsolatde Bruijn network = de Bruijn-hálózatdirect link = közvetlen kapcsolatefficiency = hatékonyságexclusive read, exclusive write (EREW) = kizárólagos olvasás, kizárólagos írásexclusive read, concurrent write (ERCW) = kizárólagos olvasás, párhuzamos írásfarthest destination first (FDF) = legtávolabbra utazó csomag előszörfarthest origin first (FOF) = legtávolabbról jött csomag előszörfirst in first out (FIFO) = előbb be, előbb kiHamming distance = Hamming-távolsághipercube = hiperkockaLCCB (least cost branch-and-bound) = legkisebb költségű korlátozás és szétválasztáslinear speedup = lineáris gyorsításlinear running time = lineáris futási időmesh = rácsmost significant bits (MSB) = legnagyobb helyi értékű bitekonline algorithm = közvetlen algoritmuspacket routing (PR) = csomagirányításpartial permutation routing (PPR) = parciális permutáció irányításparallel hypercube = párhuzamos hiperkockaparallel random access machine (PRAM) = párhuzamos közvetlen hozzáférésű géppyramid network = piramis hálózatrandom access machine (RAM) = közvetlen hozzáférésű gépsequential hypercube = soros hiperkockaspeedup = relatív sebességstar network = csillag hálózatsublinear speedup = szublineáris gyorsítássublogarithmic running time = szublogaritmikus futási idősuperlinear speedup = szuperlineáris gyorsítástotal work = összes munkawork-optimal parallel algorithm = munkahatékony párhuzamos algoritmus Magyar szakkifejezések Ebben a részben összefoglaljuk a könyvben használt magyar szakkifejezések angol megfelelőit. anomália = anomalybináris fa hálózat = binary tree network csillag hálózat = star networkcsomagirányítás = packet routing (PR)de Bruijn-hálózat = de Bruijn networkelőbb be, előbb ki = first in first out (FIFO)Hamming-távolság = Hamming distancehatékonyság = efficiencyhiperkocka = hipercubekereszt kapcsolat = cross linkkizárólagos olvasás, kizárólagos írás = exclusive read, exclusive write (EREW) kizárólagos olvasás, párhuzamos írás = exclusive read, concurrent write (ERCW)közvetlen algoritmus = online algorithmközvetlen hozzáférésű gép = random access machine (RAM)közvetlen kapcsolat = direct linklegkisebb költségű korlátozás és szétválasztás = LCCB (least cost branchand-bound) legnagyobb helyi értékű bitek = most significant bits (MSB)legtávolabbra utazó csomag először = farthest destination first (FDF)legtávolabbról jött csomag először = farthest origin first (FOF)lineáris futási idő = linear running time lineáris gyorsítás = linear speedupmunkahatékony párhuzamos algoritmus = workefficient parallel algorithm munkaoptimális párhuzamos algoritmus = work-optimal parallel algorithm nagy o = big oh nagy omega = big omeganagy teta = big thetaösszes munka = total workparciális permutáció irányítás = partial permutation routing (PPR) párhuzamos hiperkocka = parallel hypercubepárhuzamos közvetlen hozzáférésű gép = parallel random access machine (PRAM)párhuzamos olvasás, kizárólagos írás = concurrent read, exclusive write (CREW)párhuzamos olvasás, párhuzamos írás = concurrent read, concurrent write (CRCW)pillangó = butterfly piramis hálózat = pyramid networkrács = meshrelatív sebesség = speedupsoros hiperkocka = sequential hypercubeszublineáris gyorsítás = sublinear speedupszublogaritmikus futási idő = sublogarithmic running timeszuperlineáris gyorsítás = superlinear speedup Folyóiratok a hazai könyvtárakban Ebben a részben összefoglaljuk a legfontosabb informatikai folyóiratok nyomtatott és elektronikus változatainak adatait. A több részből álló első táblázatban – teljes nevük ábécé szerinti sorrendjében – felsoroljuk a legfontosabb informatikai folyóiratok nevét és ISSN azonosítóját. Ennek a listának az alapja a Fachinformationszentrum (Karlsruhe) által karbantartott Compuscience informatikai adatbázis, amely 2005-ben 264 folyóirat cikkeit referálja. A listából kihagytuk a magyar olvasó számára nehezen elérhető folyóiratokat. Ugyanakkor a listát kiegészítettük a hazai és az olyan külföldi informatikai és matematikai folyóiratokkal, amelyek gyakran szerepelnek az általunk idézett szerzők műveiben. A folyóirat neve előtt lévő ++ jel azt mutatja, hogy a folyóirat nem szerepel a Compuscience listájában. L.1.a táblázat. Folyóiratok nevei és ISSN számai Sorszám és cím ISSN 001 ACM Computing Surveys 0360-0300 +++ ACM SIGACT News 0163-5700 +++ ACM Sigplan Notices 0362-1340 +++ ACM Transactions on Computer Systems 0734-2071 002 ACM Transactions on Database Systems 0362-5915 003 ACM Transactions on Graphics 0730-0301 004 ACM Transactions on Mathematical Software 0098-3500 005 ACM Transactions on Programming Lang. 0164-0925 +++ ACM Transactions on Software Engineering Meth. 1049-331X 006 Acta Cybernetica 0324-721X 007 Acta Informatica 0001-5903 +++ Acta Mathematica Academiae Nyíregyháziensis 0866-0182 +++ Acta Mathematica Hungarica 0236-5295 +++ Acta Scinetiarum Mathematicarum 0001-6969 011 Algorithmica 0178-4617 +++ Alkalmazott Matematikai Lapok 0133-3399 +++ The American Mathematical Monthly 0002-9890 +++ Analysis Mathematica 0133-3852 L.1.b. táblázat. Folyóiratok nevei és ISSN számai Sorszám és cím ISBN +++ Annales Universitatis Eötvös, Sectio Computatorica 0138-9491 +++ Annales Universitatis Eötvös, Sectio Mathematica 0524-9007 +++ Applied and Computational Harmonic Analysis 1063-5203 +++ Applied Mathematics and Computation 0096-3003 +++ Applied Numerical Mathematics 0168-9274 ++ Ars Combinatoria 0381-7032 016 Artificial Intelligence 0004-3702 +++ Australasian Journal of Combinatorics 1034-4942 022 Automated Software Engineering 0928-8910 +++ Avtomatika i Telemehanika 0005-2310 +++ BIT. Numerical Mathematics 0006-3835 +++ C/C++ User’s Journal 1075-2828 +++ Calculateurs Parallélels 1260-3198 +++ Combinatorica 0209-9683 034 Communications of the ACM 0001-0782 035 Complexity 1076-2787 040 Computational Complexity 1016-3328 043 Computer Graphics 1067-7055 +++ The Computer Journal 0010-4620 L.1.c. táblázat. Folyóiratok nevei és ISSN számai 045 Computer Languages 0096-0551 047 Computer Networks and ISDN Systems 0169-7552 +++ Computers and Education 0360-1315 048 Computers and Operation Research 0305-0548 +++ Computing. Archiv Inf. Numerik 0010-485X +++ Computing Reviews 0010-4884 +++ Congressus Numerantium 0384-9684 +++ Current Mathematical Publications 0361-4794 +++ CWI Quarterly 0922-5366 063 Data Knowledge Engineering 0169-023X +++ Discrete Applied Mathematics 0166-218X +++ Discrete Mathematics 0012-365X 065 Distributed Computing 0178-2770 +++ The Electronic Journal Qualitative Th. Diff. Eq. 1417-3875 +++ Dr. Dobb’s Journal 1044-789X+++ European Journal of Combinatorics 0195-6698 074 European Journal of Operation Research 0377-2217 080 Formal Aspects of Computing 0934-5043 +++ Foundations of Computing and Decision Systems 0324-8747 L.1.d. táblázat. Folyóiratok nevei és ISSN számai Sorszám és cím ISSN 081 Future Generation Computer Systems 0167-739X +++ Fuzzy Sets and Systems 0165-0114 086 Graphical Models 1524-0703 087 Higher-Order and Symbolic Computation 1388-3690 +++ IBM Journal of Research and Development 0018-8646 090 IBM Systems Journal 0018-8670 094 IEEE Transactions on Communications 0090-6778 095 IEEE Transactions on Computers 0018-9340 +++ IEEE Transactions on Information Theory 0018-9448 097 IEEE Transactions on Parallel and Distr. Syst. 1045-9219 +++ IEEE Transactions on Signal Processing 1053-587X 100 IEEE Transactions on Software Engineering 0098-5589 +++ IEEE Transactions on Visualization Comp. G. 1077-2626 +++ IMA Journal on Numerical Analysis 0272-4979 102 Information and Computation 0890-5401 +++ Information and Control 0019-9958 103 Information Processing Letters 0020-0190 L.1.e. táblázat. Folyóiratok nevei és ISSN számai Sorszám és cím ISSN +++ Java Developer’s Jounal 1087-6944 138 Journal of (the) ACM 0004-5411 139 Journal of Algorithms 0196-6774 141 Journal of Automated Reasoning 0168-7433 +++ Journal of Combinatorial Theory, Series A 0097-3165 +++ Journal of Combinatorial Theory, Series B 0097-3165 +++ Journal of Computational and Appl. Math. 0377-0427 148 Journal of Computer and Systems Sci. 0022-0000 +++ (The) Journal of Fourier Analysis and Applications 1069-5869 157 Journal of Functional Programming 0956-7968 +++ Journal of Grid Computing 1570-7873 +++ Journal of Graph Algorithms and Applications 1526-1719 +++ Journal of Graph Theory 0364-9024 +++ Journal of Integer Sequences 1530-7638 +++ Journal of Logic, Language and Information 0925-8531 +++ Journal of Logic Programming 0743-1066 170 Journal of Parallel and Distributed Computing 0743-7316 +++ Journal of Systems and Software 0164-1212 L.1.f. táblázat. Folyóiratok nevei és ISSN számai Sorszám és cím ISSN +++ Lecture Notes in Computer Science 0302-9743 191 Management Sciences 0025-1909 +++ Mathematica Pannonica 0865-2090 +++ Mathematical Methods in Applied Sciences 0170-4214 +++ Mathematics of Computation 0025-5718 +++ Neural Networks 0893-6080 +++ Nieuw Arakief voor Wiskunde 0028-9825 209 Nordic Journal of Computing 1236-6064 +++ Numerische Mathematik 0029-599X 211 (L’)Objet 1262-1137 +++ Operating Systems Review 0163-5980 +++ Operations Research 0030-364X 212 Operation Research Letters 0167-6377 +++ Parallel Computing 0167-8091 221 Performance Evaluation 0166-5316 +++ Periodica Mathematica Hungarica 0031-5303 +++ Proceedings of IEEE 0018-9219 226 Programmirovanie 032-3474 +++ Publicationes Mathematicae 0033-3883 L.1.g. táblázat. Folyóiratok nevei és ISSN számai Sorszám és cím ISSN +++ Pure Mathematics and Applications 1218-4586 +++ Quarterly of Applied Mathematics 0033-569X 228 RAIRO. Informatique Theoretique et Applications 0988-3754 +++ Random Structures and Algorithms 1042-9832 238 Science of Computer Programming 0167-6423 +++ SIAM Journal on Applied Mathematics 0036-1399 239 SIAM Journal on Computing 0097-5397 +++ SIAM Journal on Control and Optimization 0363-0129 +++ SIAM Journal on Discrete Mathematics 0895-4801 +++ SIAM Journal on Numerical Analysis 0036-1429 +++ SIAM Journal on Optimization 1052-6234 +++ SIAM Journal on Scientific Computing 1064-8275 +++ SIAM Review 0036-1445 L.1.h. táblázat. Folyóiratok nevei és ISSN számai Sorszám és cím ISSN 242 Simulation 0037-5497 +++ Sysadmin and Perl Journal 1061-2688 246 Software Practice and Experience 0038-0644 +++ Studia Scientiarum Mathematicarum 0081-6906 +++ Studia Universitatis Babes-Bolyai, Informatica 1224-869x 253 Theoretical Computer Science 0304-3975 261 VLDB Journal 1066-8888 ++ Zentralblatt für Mathematik 1436-3356 A második táblázatban megadjuk a folyóiratok nyomtatott és elektronikus változatainak a 6 legnagyobb hazai informatikai könyvtárban (BME, Debreceni Egyetem, ELTE, Rényi Alfréd Intézet, Szegedi Tudományegyetem, SZTAKI) való elérhetőségét (az adatok a 2004-es évre vonatkoznak). A nyomtatott változatok adatai a Nemzeti Periódika Adatbázis (NPA) honlapjáról és az NPA által évente kiadott CD-ről származnak. Az elektronikus változatok adataihoz felhasználtuk az említett könyvtárak honlapját. A folyóiratok nevét az NPA szerint rövidítettük. A nemzetközi rövidítések listája letölthető a referáló folyóiratok honlapjáról. A táblázatban N a nyomtatott, E az elektronikus változat, K az elektronikus kivonat, T az elektronikus tartalomjegyzék elérhetőségét jelzi. L.2.a. táblázat. Informatikai folyóiratok a magyar könyvtárakban Sorszám és címBM DE EL RA SE SZ 001 ACM Surveys E E NE NE NE +++ ACM SIGACT News E E E E E +++ ACM Sigplan Notices E E E E E +++ ACM Trans. Comput. Syst. NE E NE E E E 002 ACM Trans. Database Syst. NE E NE E E E 003 ACM Trans. Graph. E E E E E 004 ACM Trans. Math. Softw. E E E E E NE 005 ACM Trans. Program. Lang. NE E NE NE NE +++ ACM Transactions on Software Engineering Methods NE E E E E E 006 Acta Cybernetica K K NK K NK NK 007 Acta Informatica E E NE E E NE +++ Acta Mathematica Academiae Nyíregyháziensis E E E E E E +++ Acta Mathematica Hungarica N N N +++ Acta Scientiarum Math. N N N 011 Algorithmica E E NE E E NE +++ Alkalmazott Matematikai Lapok NK NK NK NK NK NK +++ The American Math. Monthly E E NE E E E +++ Analysis Mathematica T T NT T T +++ Ann. Univ. Eötvös, Sectio Computatorica NT NT NT NT NT NT +++ Ann. Univ. Eötvös, Math. N N N N L.2.b. táblázat. Informatikai folyóiratok a magyar könyvtárakban Sorszám és címBM DE EL RA SE SZ +++ Applied Comp. Harmonic Analysis E E NE E E E +++ Applied Math. Comput. N+++ Applied Numerical Math. +++ Ars Combinatoria K K K K N016 Artificial Intelligence E E NE E E NE +++ Australasien Journal Comb. K K K K K 022 Automated Software Eng. N +++ Avtomatika i Telemehanika N +++ BIT. Numerical Mathematics NE +++ C/C ++ User’s Journal N+++ Calculateurs Paralléls N+++ Combinatorica NE NE NE NE NE NE 034 Communications of ACM NE E NE NE E NE 035 Complexity E EEEE040 Computational Complexity E E E E E NE +++ (The) Computer Journal NE NE 045 Computer Languages 047 Computer Networks ISDN Syst. E E EN E E E L.2.c. táblázat. Informatikai folyóiratok a magyar könyvtárakban Sorszám és címBM DE EL RA SE SZ +++ Computers and Education N048 Computers and Op. Research E E NE E E E +++ Computing. Archiv für Inf. E E N E E +++ Computing Reviews E E NE NE E +++ Congressus Numerantium N+++ Current Mathematical Publ. N +++ CWI Quarterly E E EN E E 063 Data Knowledge Engineering N+++ Discrete Applied Mathematics EENENEEE +++ Discrete Mathematics E E NE NE E E 065 Distributed Computing NE E NE E E +++ Dr. Dobb’s Journal E E NE E E E +++ (The) Electronic Journal of Combinatorics E E E E E E +++ (The) Electronic Num. Anal. E E E E E E +++ European Journal of Combinatorics E E E E E E +++ European Journal Op. Research E E NE E E E 080 Formal Aspects of Compurting E E NE E E E +++ Foundations of Computing Dec. N L.2.d. táblázat. Informatikai folyóiratok a magyar könyvtárakban CímBM DE EL RA SE SZ +++ Fundamenta Mathematicae T N 081 Future Generation Comp. Syst. T N +++ Fuzzy Sets and Systems E E E E E 086 Graphical Models E E NE E E 087 Higher-Order and Symb. Comp. E E NE E E +++ IBM Journal of Research Dev. E E NE E E 090 IBM Systems Journal E E NE E E 094 IEEE Transactions Comm. NK NE 095 IEEE Trans. Comput. NE NK NK K K K +++ IEEE Transactions Inf. Th. NK K NK K K NK +++ IEEE Transactions Signal Processing NK K NK K K NK 100 IEEE Transactions on Software EN EN +++ IEEE Transactions Visualization E E NE E E NE +++ IMA Journal Num. Analysis E E NE E E 102 Information and Computation KN EN +++ Information and Control TK N 103 Information Processing Letters E E NE E NE NE +++ Java Developer’s Journal E E E E E E 139 Journal of (the) ACM EN E EN E E E 139 Journal of Algorithms KT KT KTN KTN KT KT L.2.d. táblázat. Informatikai folyóiratok a magyar könyvtárakban CímBM DE EL RA SE SZ +++ Journal of Comb. Theory, A TK TK NK TK TK TK +++ Journal of Comb. Theory, B TK TK NK TK TK TK 148 Journal of Computer Syst. EN EN +++ Journal of Graph Alg. E E E E E E ++ Journal of Grid Computing T T T T T T +++ Journal of Integer Sequences E E E E E E +++ Lecture Notes in CS E E EN E E +++ Math. Syst. N +++ Nieuw Arakief N 209 Nordic J. Com. KT 211 (L’)Objet KT KT KTN KT KT +++ Proc. IEEE NK K NK K K NK +++ Publ. Math. NT NT NT NT NT NT +++ Quarterly of Appl. Math. N N E 238 Science of Computer Programming N N E 239 SIAM J. Comp. NE NE E +++ SIAM Discret. K KN EN EN +++ SIAM Rev. NE K NE K K NE 253 Theoretical Computer Science E E EN E E E 261 VLDB Journal E E EN E E E +++ Zentralbl. Did. der Math. E E E E E E Végül a digitális és elektronikus adatbázisok és könyvtárak adatait foglaljuk össze. Az internet terjedésével erősödött és gyorsult fel az a törekvés, hogy a nyomtatott dokumentumok tartalma szabadon letölthető formában is rendelkezésre álljon. Az informatika területén elsősorban a BME, DE, ELTE és a SZTE oktatónak honlapjain lehet már a kilencvenes évek óta letölthető tananyagokat találni. Ma már a rangos folyóiratok nagy része elektronikus formában is elérhető (a feltételek sokszínűek: egy részük szabadon elérhető, másutt például csak a tartalomjegyzék és a cikkek kivonata – míg a teljes tartalomhoz csak jelentős előfizetési díj kifizetése árán lehet hozzáférni). A felsőoktatás területén várhatóan jelentős mennyiségi és minőségi fejlődést eredményez, hogy 2004-től kezdve az Oktatási Minisztérium pályázati úton támogatja a digitalizálást. 2004-ben például négy informatikai és hat matematikai tankönyv kapott támogatást (listájuk elérhető az OMAI honlapján: http://www.omai.hu/main.php?folderID=484 ). Digitális adatbázisok Ebben a részben a könyvek, folyóiratok ás más dokumentumok beszerzésével és tartalmával kapcsolatos adatbázisokat ajánlunk Olvasóink figyelmébe. Ezek egy része szabadon felhasználható, mások tartalmához a hozzáférés korlátozott (például csak meghatározott IP-című géperkről tudunk a tartalomhoz hozzáférni, vagy csak a tartalom egy részéhez tudunk hozzáférni – a személyesen vagy munkahelyünk által kifizetett előfizetési díj függvényében). Amazon: nagy könyvkereskedő cég – honlapján a kapható könyvekkel kapcsolatban értékes információt tartalmaz – http://www.amazon.com/. ASP (Academic Search Premier): az EBSCO adatbázis része, például kulcsszó szerinti keresést és teljes folyóiratcikkek letöltését teszi lehetővé (az OM támogatásával az oktatási intézmények használhatják) – például a könyvtárak számítógépei segítségével. Barneandnoble: nagy könyvkereskedő cég – honlapján a kapható könyvekkel kapcsolatban értékes információt tartalmaz – http://www.barnesandnoble.com/. Citeseer: tudományos eredmények ingyenes közzétételét és a közzétett dokumentumokban való keresést lehetővé tevő adatbázis, amely a NASA, az NSF és a Microsoft segítségével működik – http://citeseer.ist.psu.edu/. Computing Reviews: informatikai folyóiratok tartalmáról közöl (nyomtatott és elektronikus formában) referátumokat – www.reviews.com/. Compuscience: informatikai referáló adatbázis, amylyet a Karlsruheban működő Fachinformationszentrum kezel – http://www.zblmath.fiz-karlsruhe.de/cs/index.htmlEFTAN : Egyetemi és Főiskolai Tankönyvek adatbázisa ELTE: a Horizon rendszeren keresztül hozzáférés az ELTE, SOTE és a ME könyvtárainak katalógusaihoz – http://www.konyvtar.elte.hu/. Kiskapu Kiadó és Könyvesbolt: könyvesboltoknak a magyar nyelvű informatikai szakirodalom teljes választékát kínáló hálózata (rendszeresen közread magyar nyelvű katalógusokat) – http://www.kiskapu.hu/main.php Könyvkereső: magyar nyelvű könyveket interneten árusító cég, honlapja bibliográfiai és kereskedelmi adatokat is tartalmaz – http://www.konyvkereso.hu/. Mathematical Reviews: valószínűleg a legrégibb és legnagyobb referáló adatbázis, amely a matematikai (és részben az informatikai) folyóiratok, könyvek tartalmáról közöl a tartalmat ismertető (és rendszerint kritikai értékelést is tartalmazó) referátumokat: www.ams.org/mathscinet NPA: Nemzeti Periodika Adatbázis (az Országos Széchenyi Könyvtár által karbantartott adatbázis a hazai könyvtárakban lévő külföldi és hazai folyóiratokról; 2000-ben abbamaradt az adatok frissítése – viszont az OSZK által évente kiadott NPA-CD vagy az OSZK fizetős honlapja friss adatokat tartalamaz). A régi adatok a http://www.iif.hu/db/npac/ címen érhetők el. Software Station: idegen nyelvű könyveket hagyományos módon és interneten is árusító cég, honlapja az árusított könyvek adatait tartalmazza – www.swsbooks.hu/ SWETS: a legnagyobb folyóiratkereskedő cég adatbázisa kb. 16000 folyóirat tartalomjegyzékét tartalmazza, emellett a cégen keresztül megrendelt folyóiratok jelentős részének teljes szövegéhez is hozzáférést biztosít DLBP: a trieri egyetem adatbázisa, amely számítástudományi cikkek adatait tartalmazza – http://www.informatik.uni-trier.de/ ley/db/index.html Typotex: elsősorban matematikai könyvek kiadója, honlapján a kiadó könyveinek adatai mellett az informatikai és matematikai publikációkhoz nélkülözhetetlen LA T E X kiadványszerkesztővel kapcsolatos anyagok is találhatók – http://www.typotex.hu/. Universitas: a legjelentősebb magyar cég, amelyen keresztül külföldi kiadású könyvek megrendelhetők. Honlapján sok könyv adatai (például az ára) megtalálhatók. Zentralblatt für Mathematik: matematikai referáló folyóirat – http://www.emis.de/ZMATH/ Digitális könyvtárak Academic Press: a kiadó folyóiratainak és könyveinek adatai (ingyenesen a folyóiratok tartalomjegyzéke és a cikkek kivonata tölthető le) – http://idealibrary.com ACM Digital Library: az ACM folyóiratait és egyéb kiadványait tartalmazza. Ingyenesen a tartalomjegyzékek és kivonatok érhetők el, a magyar konzorcium tagjainak IP-tartományából a teljes szöveg is letölthető – http://www.acm.org/dl BME-OMIKK: folyóiratok és 500 digitális könyv érhető el (könyvtári tagok a BME gépeiről, látogató jegyet váltók a könyvtár gépeiről) – http://www.omikk.bme.hu/ Cambridge University Press: a legrégebbi és legnagyobb egyetemi kiadó könyveinek és folyóiratainak adatai, és részleges tartalma: http://www.cambridge.org/ DML (Digital Mathematics Library): a Cornell University Library által 2002-ben kezdeményezett és az NSF (U.S. National Science Foundation) által támogatott terv, melynek célja a matematikai szakkönyvek digitalizálása – http://www.library.cornell.edu/dmlib/index.html. EISZ: Elektronikus Információ Szolgálat (ingyenes hozzáférés minden egyetemi hallgató és oktató számára az Elsevier folyóiratainak teljes tartalmához): http://www.eisz.hu/ ELEK (ELTE IK Elektronikus könyvtára): magyar és angol nyelvű könyvek teljes szövege, a kar folyóiratának és technikai riportjainak teljes szövege – http://elek.inf.elte.hu IEEE (Institute of Electrical and Electronic Engineering): a kiadó könyveiről és folyóiratairól tartalmaz információt http://computer.org. EMIS (European Mathematical Information Service): ingyenes hozzáférés 35 matematikai folyóirat teljes tartalmához, ugrópontok referáló folyóiratokhoz – http://www.emis.de/ Kempelen Farkas Felsőoktatási Digitális Tankönyvtár: közel száz digitalizált tankönyvet tartalmaz, közülük körülbelül tíz könyv informatikai vagy matematikai témájú – http://www.hik.hu/index.asp?r=90,261 MEK (Magyar Elektronikus Könyvtár): digitalizált könyveket és tanulmányokat tartalmaz – http://www.mek.iif.hu/ SIAM (Society of Industrial and Applied Mathematics): a kiadó könyveiről és folyóiratairól tartalmaz adatokat – az egyes intézmények az előfizetett nyomtatott folyóiratok tartalmát elektronikusan is elérhetik – http://epubs.siam.org/ Springer Verlag: az egyik legnagyobb európai kiadó könyveinek és folyóiratainak adatai és a folyóiratok teljes tartalma – http://www.springeronline.com/ Elektronikus könyvtár Ebben a részben két elektronikus könyvtárat ajánlunk Olvasóink figyelmébe. ELEK (az ELTE Informatikai Karának elektronikus könyvtára): magyar és angol nyelvű könyveket, a kar folyóiratának tartalomjegyzékét és technikai riportjait tartalmazza – http://elek.inf.elte.hu.. Living Reviews: a Max Planck Gesellschaft által kiadott fizikai folyóiratok (egyik a gravitáció, a másik pedig a napfizika aktuális témáiról közöl rendszeresen frissített áttekintő cikkeket) neve. A folyóiratok az intézetben kifejlesztett – HeRMeS nevű, szabadon felhasználható LA T E X2HTML fordítóprogram segítségével készülnek és élő (az idézett dokumentum letöltését biztosító) irodalomjegyzéket tartalmaznak – http://www.livingreviews.org/. Konferenciák anyagai Ebbenm a részben a legismertebb informatikai konferenciák kiadványainak adatait összegezzük. L.5. táblázat. Informatikai konferenciák anyagai Cím BMEDEELTERAISzTESZTAKI 1 ACM Dist. E E E E 2 ACM Theory E E E E 3 ECOOP E E E E 4 ESA E E E E 5 FCT E E E E 6 MFCS E E E E 7 STACS E E E E Ezeknek a kiadványoknak a hálózati címe a következő: 1. ACM Dist.: http://www.acm.org/pubs/citations/podc/62546/2. ACM Theory http://www.acm.org/pubs/citations/podc/62546/3. ECOOP: http://www.link.springer.de/4. ESA: http://www.link.springer.de5. FCT: http://www.link.springer.de/6. MFCS: http://www.link.springer.de/7. STACS: http://www.link.springer.de/Ebben a táblázatban a Proceedings of Annual ACM Symposium on Principles of Distributed Computing, a Proceedings of Annual ACM Symposium on Theory of Computation, a European Conference on Object-Oriented programming, az European Sympozium on Algorithms, a Foundation of Computing Theory, a Mathematical Foundations of Computer Science és az Annual Symposium on Theoretical Aspects of Computer Science nevű konferenciák adatai szerepelnek. Irodalomjegyzék [1] J. Abello, P. M. Pardalos, M. G. C. Resende: Handbook of Massive Data Sets. Kluwer Academic Publishers, Dordrecht, 2002. 1236 oldal. ISBN 1-4020-0489-3. [2] P. Adriaans, D. Zantinge: Data Mining. Addison -Wesley Longman, 1996. Magyarul: Adatbányászat. Panem, Budapest, 2002. 157 oldal, 39 hivatkozás. ISBN 963 545 367 1. [3] A. V. Aho, J. E. Hopcroft, J. D. Ullman: The Design and Analysis of Computer Algorithms. Addison-Wesley, Reading, 1974. 240 oldal, 235 hivatkozás, ISBN 0-201000-296. Magyarul: Számítógép-algoritmusok tervezése és analízise. Műszaki Könyvkiadó, Budapest, 1982. 487 oldal, 235 hivatkozás, ISBN 963 104 323 1. [4] A. V. Aho, J. E. Hopcroft, J. D. Ullman: Data Structures and Algorithms. Addison-Wesley, Reading, 1983. 427 oldal, 158 hivatkozás, ISBN 0-201-00023-7. [5] S. G. Akl: The Design and Analysis of Parallel Algorithms. Prentice-Hall, Englewood Cliffs, 1989. 400 oldal, ISBN 0132000563. [6] Álmos Attila, Győri Sándor, Horváth Gábor, Várkonyiné Kóczy Annamária: Genetikus algoritmusok. Typotex, Budapest, 2002. 255 oldal, 137 hivatkozás. [7] Algorithmic Solutions Software GmbH: LEDA (Library of Efficient Data Types and Algorithms). 2003 (karbantartva, fizetős). [8] George S. Almasi, A. Gottlieb: Highly Parallel Computing. The Benjamin/Cummings Publ. Comp., Redwood City, 1994. 669 oldal, 472 hivatkozás, ISBN 0-8053-0443-6. [9] G. M. Amdahl: Validity of the single-processor approach to achieving large-scale computer capabilities. In: AFIPS Conference Proceedings 30 1967, 483–485. [10] P. Amestoy (szerkesztő): Euro-Par’99 . LNCS 1685.Springer -Verlag, Berlin, 1999, 1503 oldal. ISBN 3540 664432 [11] Andrásfai Béla: Ismerkedés a gráfelmélettel. Második kiadás. Tankönyvkiadó, Budapest, 1973. 237 oldal, 48 hivatkozás, ISBN 363 178 663 3. [12] Andrásfai Béla: Gráfok. Mátrixok és folyamok. Akadémiai Kiadó, Budapest, 1983. 263 oldal, 74 hivatkozás, ISBN 963 05 31461. [13] Andrásfai Béla: Gráfelmélet. Polygon Kiadó, Szeged, 1994. 174 oldal, 10 hivatkozás, ISBN 1417-0590. [14] Andrásfai Béla: Infor-matek. Polygon Kiadó, Szeged, 1997. 282 oldal, 13 hivatkozás, ISBN 1218-4071. [15] Arató Péter, Jankovits István, Visegrády Tamás: High-Level Synthesis of Pipelined Datapaths.Panem /John Wiley & Sons, Budapest, 1999. 251 oldal, ISBN 0471495824. [16] I. K. Argyros, F. Szidarovszky: The Theory and Applications of Iteration Methods.CRC Press Inc., Boca Raton, 1993. 335 oldal, 110 hivatkozás, ISBN 0-8493-8014-6. [17] L. Artiaga, L. Davis: Algoritmusok és FORTRAN programjaik. Műszaki Könyvkiadó, Budapest, 1977. [18] M. J. Atallah: Algorithms and Theory of Computation Handbook.CRC Press, Boca Raton, 1999. 1218 oldal, 4118 hivatkozás, ISBN 0-8493-2649-4. [19] G. Ausiello: Complessitá di calcolo delle functioni. Bodoglierie Societá, Torino, 1975. Magyarul: Algoritmusok és rekurzív függvények bonyolultságelmélete. Műszaki Könyvkiadó, Budapest, 1984. 67 oldal, 109 hivatkozás, ISBN 963 10 5159 5. [20] G. Ausiello, P. Crescenzi, G. Gambosi, V. Kann, A. Marchetti-Spaccamela, M. Protasi: Complexity and Approximation. Springer -Verlag, Berlin, 1999. 524 oldal, 602 hivatkozás, ISBN 3504-65431-3. [21] O. I. Aven, E. G. Coffman jr., Y. A. Kogan: Stochastic Analysis of Computer Storage. D. Reidel Publ. Company, Dordrecht, 1987. 254 oldal, 157 hivatkozás, ISBN 90-277-2515-2. [22] S. Baase: Computer Algorithms: Introduction to Design and Analysis. Második kiadás. Addison-Wesley, l988. 435 oldal, 131 hivatkozás. ISBN 0-201-06035-3. [23] S. Baase, A. Van Gelder: Computer Algorithms: Introduction to Design and Analysis. Harmadik kiadás. Addison -Wesley, Reading, 2000. 688 oldal, ISBN 0-201-61244-5. [24] Bach Iván: Formális nyelvek. Typotex, Budapest, 2001. [25] Bagyinszki János, György Anna: Diszkrét matematika főiskolásoknak. Typotex, Budapest, 2001. 152 oldal, ISBN 9639132969. [26] N. N. Bahvalov, E. P. Zhidkov, G. M. Kobelkov: Numerical Methods. Fizmatlit, Moscow, 2000. 624 oldal. [27] Bajalinov Erik, Imreh Balázs: Operációkutatás. POLYGON Kiadó, Szeged, 2001. [28] G. H. Barnes: The ILLIAC-IV computer. IEEE Transactions on Computers C-17 1968, 746–757. [29] Békéssy András, Demetrovics János: Adatbázis szerkezetek.Akadémiai Kiadó, Budapest, 2005 (megjelenőben). [30] Belényesi Viktor, Németh Cs. Dávid: d-bonyolultság számítása. TDK-dolgozat. ELTE, Informatikai Tanszékcsoport, Budapest, 2002. 17 oldal. [31] M. de Berg, M. van Kreveld, M. Overmas, O. Schwarzkoff: Computational Geometry. Második kiadás. Springer -Verlag, Berlin, 2000. 367 oldal, 348 hivatkozás, ISBN 3-540-65620-0. [32] C. Berge: Graphs and Hypergraphs. North Holland Publishing Company, Amsterdam, 1976. 528 oldal, 542 hivatkozás, ISBN 0 7204 2453 4. [33] Berke Barnabásné: ISBN útmutató . Második kiadás. Országos Széchenyi Könyvtár, Budapest, 1991. 22 oldal, ISBN 963 200 305 5. [34] K. A. Berman, J. L. Paul: Fundamentals of Sequential and Parallel Algorithms. PWS Publishing Company, Boston, 1997. XXIII+744 oldal, 80 hivatkozás, 0-534-94674-7. [35] H. L. Bodlaender: A better lower bound for distributed leader finding in bidirectional asynchronous rings of processors. Information Processing Letters qhhspace 27 1988, 287–290. [36] B. Bollobás: Random Graphs. Academic Press, London, 1985. XII+441 oldal, 757 hivatkozás. ISBN 0-12-11756-1. [37] Boros, László: Jogi alapismeretek.Vince Kiadó, Budapest, 1998. 154 oldal. [38] G. Brassard, P. Bratley: Fundamentals of Algorithms. Prentice Hall, Englewood Cliffs, 1996. 524 oldal, 355 hivatkozás, ISBN 0-13-335068-1. [39] I. N. Bronstejn, I. N. Szemengyajev et al.: Matematikai kézikönyv. 8., átdolgozott kiadás. Typotex, Budapest, 2002. 1209 oldal, ISBN, 9639132594. [40] P. Brucker: Scheduling Algorithms . Springer -Verlag, Berlin, 1998. 342 oldal, 216 hivatkozás, ISBN 3-540-64105-X. [41] R. G. Busacker, T. L. Saaty: Finite Graphs and Networks. Mc-Graw Hill and Company, New York, 1965. XIV+294 oldal, hivatkozás. Magyarul: Véges gráfok és alkalmazásaik. Műszaki Könyvkiadó, Budapest, 1969. 347 oldal. [42] Association for Computing Machinery: CALGO (Collected Algorithms of ACM). 2003. [43] C. Carlsson, R. Fullér: Fuzzy Reasoning inDecisionMaking and Optimization.Studies in Fuzziness and Soft Computing Series82 . Springer -Verlag, Berlin/Heildelberg, 2002. 338 oldal, ISBN 3-7908-1428-8. [44] Y. Censor, A. Z. Stavros: Parallel Optimization: Theory, Algorithms, and Applications.Oxford University Press, New York, 1997, XVII+539 oldal, 566 hivatkozás. ISBN 0-19-510062–X. [45] K. M. Chandy, J. Misra: Parallel Program Design: A Foundation . Addison -Wesley, 1988. [46] E. J.-H. Chang, R. Roberts: An improved algorithm for decentralized extrema finding in circular arrangement of processes. Communication of ACM 22 1979, 281–283. [47] H. Chernoff: A measure of asymptotic efficiency for tests of a hypothesis based on the sum of observations. Annals of Mathematical Statistics, 23 1952, 493–507. [48] R. Chow, T. Johnson: Distributed Operating Systems and Algorithms.Addison -Wesley, Reading, 1997. 569 oldal, 512 hivatkozás, 0-201-49838-3. [49] L. Chua, T. Roska: Cellular Neural Networks and Visual Computing – Foundations and Applications. Cambridge University Press, Cambridge, 2001. 380 oldal, ISBN 0521652472. [50] E. G. Coffman, Jr.: Computer and Job Shop Scheduling. John Wiley & Sons, New York, 1976. 299 oldal, 158 hivatkozás, ISBN 0-471-16319-8. [51] E. G. Coffman jr., J. Csirik, G. J. Woeginger: Approximate solutions to bin packing problems. In: [293]. [52] E. G. Coffman, G. Galambos, S. Martello, D. Vigo: Bin packing approximation algorithms: combinatorial analysis. In [74], 151–208. [53] T. H. Cormen, C. E. Leiserson, R. L. Rivest: Introduction to Algorithms. The MIT Press/McGraw-Hill, Cambridge/New York, 1990, 1028 oldal, 205 hivatkozás. ISBN 0-262-03141-8. Magyarul: Algoritmusok. Harmadik kiadás. Műszaki Könyvkiadó, Budapest, 2001. XVI+884 oldal, 205+65 hivatkozás, ISBN 963 163029 3. [54] T. H. Cormen, C. E. Leiserson, R. L. Rivest, C. Stein: Introduction to Algorithms. The MIT Press/McGraw -Hill, Cambridge/New York, 2001. XI+1180 oldal, 320 hivatkozás. ISBN 0-262-03293-7. Magyarul: Új algoritmusok. Scolar, Budapest, 2003 szeptember. 1020 oldal, ISBN 963 9193 90 9. [55] T. H. Cormen, C. Lee, E. Lin: Instructor’s Manual. The MIT Press, Cambridge, 2002. 402 oldal. [56] Cseke Vilmos: A gráfelmélet és alkalmazásai. Tudományos Könyvkiadó, Bukarest, 1972. 165 oldal, 8 hivatkozás. [57] Cserny László: RISC processzorok.LSI, Budapest, 1996. 403 oldal, 34 hivatkozás, ISBN 963 577 155 X. [58] J. Csirik, G. Galambos, J. B. G. Frenk, A. H. G. Rinnooy Kan: A probabilistic analysis of a dual bin packing problem. Journal ofAlgorithms 12 (1987), 189-203. [59] J. Csirik, B. Imreh: On the worst case behaviour of the Next-k Fit bin packing algorithm. Acta Cybernetica9 (2) (1989), 89–95. [60] J. Csirik, D. S. Johnson: Best is better than first. Algoritmica . 31 2001, 115–138. 31 hivatkozás. [61] J. Csirik, G. J. Woeginger: On-line packing and covering problems. In: [84], 147–177. [62] Csizmazia Balázs: Hálózati alkalmazások készítése (második, javított kiadás).Kalibán Bt., Budapest, 1999. 362 oldal, 16 hivatkozás, ISBN 963 04 9630 5. Elektronikus könyvként: Magyar Elektronikus Könyvtár[63] Csörnyei Zoltán: Fordítási algoritmusok. Erdélyi Tankönyvtanács, Kolozsvár, 2000. VII+195 oldal, 13 hivatkozás, ISBN 973 99814 8 8. [64] Csörnyei Zoltán: Típuselmélet (Kombinátor logika. λ-kalkulus. Típusos λ -kalkulus . Elektronikus jegyzet. ELTE Informatikai Kar, Budapest, 2005. [65] Demetrovics János, Denev J., Pavlov R.: Bevezetés a számítástudományba. Tankönyvkiadó, Budapest, 1982. 374 oldal, 26 hivatkozás, ISBN 963 118463 8 [66] J. Dénes, A. D. Keedwell: Latin Squares. North Holland, Amsterdam, 1991. XIV+453 oldal, ISBN 0-444-88899-3. [67] L. Devroye, L. Györfi, G. Lugosi: A Probabilistic Theory of Pattern Recognition.Springer -Verlag, New York, 1996. [68] R. Diestel: Graph Theory. Springer-Verlag, Berlin, 1997. 312 oldal, ISBN 0-387-95014-1. [69] D. Dolev, M. Klawe, M. Rodeh: An O(NlogN) unidirectional distributed algorithm for extrema-finding in circle. Journal of Algorithms 3 1982, 245-260. [70] J. J. Donovan: Systems Programming. McGraw-Hill, 1972. Magyarul: Rendszerprogramozás.Műszaki Könyvkiadó, Budapest, 1976. [71] J. A. Dossey, A. D. Otto, L. E. Spence, C. W. Eynden: Discrete Mathematics. Scott, Foresman and Company, Glenview, 1972. 482 oldal, 45 hivatkozás, ISBN 0-673-18191-X. [72] Dringó László, Kátai Imre: Bevezetés a matematikába. Tankönyvkiadó, Budapest, 1977. 288 oldal. [73] Drommerné Takács Viola (szerkesztő): Sejtautomaták. Gondolat, Budapest, 1978. 288 oldal, 176 hivatkozás, ISBN 963 280 665 4. [74] D.-Z. Du, P. M. Pardalos:Handbook of Combinatorial Optimization. Supplement Volume.Kluwer Academic Publishers, 1999. 656 oldal, ISBN 0-7923-5924-0. [75] F. Ercal, S. Olariu, A. Y. Zomaya (szerkesztők): Solutions to Parallel and Distributed Computing Problems: Lessons from Biological Sciences . John Wiley, 2001. ISBN 0-471-35352-3. [76] P. Erdős: The Art of Counting (szerkesztő J. Spencer ). The MIT Press, Cambridge, 1973. 742 oldal, 596 hivatkozás, ISBN 0-262-19116-4. [77] P. Erdős, J. Spencer: Probabilistic Methods in Combinatorics.Akadémiai Kiadó/ Academic Press, Budapest/New York, 1974. 106 oldal, 119 hivatkozás. [78] G. E. Farin: Curves and Surfaces for Computer Aided Geometric Design. A Practical Guide. Negyedik kiadás. Academic Press, 1998. [79] Farkas Zsuzsa, Futó Iván, Langer Tamás, Szeredi Péter: MPROLOG programozási nyelv.Műszaki Könyvkiadó, Budapest, 1986. 280 oldal, 8 hivatkozás. [80] Fekete István, Gregorics Tibor, Nagy Sára: Bevezetés a mesterséges intelligenciába.LSI Kiadó, Budapest, 1990. 289 oldal, 28 hivatkozás. Gábor Dénes Főiskola, Budapest. 1999. 292 oldal, 33 hivatkozás. [81] W. Feller: An Introduction to Probability Theory and its Applications. Harmadik kiadás. John Wiley & Sons, New York, 1968. Magyarul: Bevezetés a valószínűségszámításba. Műszaki Könyvkiadó, Budapest, 1978. 478 oldal, hivatkozás, ISBN 963 102 070 3. [82] S. Ferenczi, Z. Kása: Complexity of finite and infinite words. Theoretical Computer Science 218 1999, 177–195. MR2000d:68121, ZB916.68112 [83] M. Ferenczi, L. Rónyai: Mathematical Foundations of Computer Science.Akadémiai Kiadó, Budapest, 2005 (megjelenőben). [84] A. Fiat, G. J. Woeginger: Online Algorithms. The State of Art.LNCS1442.Springer -Verlag, Berlin, 1998. 436 oldal, 1285 hivatkozás, ISBN 3-540-64917-4. [85] P. Flach: Simply Logical. Intelligent Reasoning by Example . John Wiley & Sons. 1989., London. 236 oldal, 45 hivatkozás. Magyarul: Logikai programozás.Panem, Budapest, 2001. 288 oldal, 45 hivatkozás, ISBN 963 545 297 7. [86] C. A. Floudas, P. M. Pardalos: Encyclopedia of Optimization (7 kötet). Kluwer Academic Publishers, 2001, 3200 oldal, ISBN 0-7923-6932-7. [87] R. W. Floyd, R. L. Rivest: Expected time bounds for selection Communication of ACM 18 (3) 1975, 165–172. [88] M. J. Flynn: Very high-speed computer systems. Proceedings of theIEEE5 (6) 1966, 1901–1909. [89] F. Forgó, J. Szép, F. Szidarovszky: Introduction to Games: Concepts, Methods and Applications.Kluwer Academic Press, Boston, 1999. 352 oldal, 152 hivatkozás, ISBN 0-7923-5775-2. [90] Fornai Péter, Iványi, Antal: Bélády’s anomaly is unbounded. In: [221], 65–72. 13 hivatkozás. [91] Fóthi Ákos: Bevezetés a programozásba.Tankönyvkiadó, Budapest, 1983. 101 oldal. [92] Fóthi Ákos, Steingart Ferenc: Bevezetésa programozáshoz. Elektronikus kézirat. Budapest, ELTE Informatikai Kar, 2003. 130 oldal. [93] Fóthi Ákos, Horváth Zoltán: Bevezetésa programozáshoz. Elektronikus tankönyv. Budapest, ELTE Informatikai Kar, 2003. 130 oldal. [94] Á. Fóthi, Z. Horváth, T. Kozsik: Parallel elementwise processing a Novel version. Annales Univ. Sci. Budapest de R. Eötvös Nom., SectioComputatorica17 1998, 105–124. MR 2000c:68150, ZB 0981.68177. [95] R. Fullér: Introduction toNeuro-FuzzySystems.Advances in Soft Computing Series.Springer -Verlag, Berlin/Heidelberg, 2000. 289 oldal, 46 hivatkozás, ISBN 3-7908-1256-0. [96] Futó Iván, Fekete István, Gregorics Tibor, Gyimóthy Tibor, Nagy Sára, Sántáné Tóth Edit, Tatai Gábor. Mesterséges intelligencia. Aula Kiadó, Budapest, 1999. XIX+986 oldal, ISBN 963 907 899 9. [97] Fülöp Zoltán: Formális nyelvek és szintaktikus elemzésük.Polygon, Szeged, 1999. [98] Füsi János: 3D grafikai animáció.LSI Kiadó, Budapest, 1993. 227 oldal, 7 hivatkozás, ISBN 963 618 111 X. [99] Galambos Gábor: Operációs rendszerek.Műszaki Könyvkiadó, Budapest, 2003. ISBN 963 162284 3. [100] Galántai Aurél, Hujter Mihály: Optimalizálási módszerek . Miskolci Egyetemi Kiadó, Miskolc, 1997. [101] Galántai Aurél, Jenei András: Numerikus módszerek . Miskolci Egyetem Kiadó, Miskolc, 1998. 171 oldal, ISBN 963 661 3117. [102] H. Garcia-Molina, J. D. Ullman, J. Widom: Database System Implementation. Prentice Hall, 2000. 654 oldal, 109 hivatkozás. Magyarul: Adatbázisrendszerek megvalósítása (szerkesztette Benczúr András). Panem, Budapest, 2001. 684 oldal, 109 hivatkozás, ISBN 9635452 80 2. [103] Gergó Lajos: Numerikus módszerek. Példák és feladatok. ELTE Eötvös Kiadó, Budapest, 2000. 204 oldal, 16 hivatkozás. [104] C. Girault, R. Valk (szerkesztők): Petri Nets for System Engineering. A Guide to Modelling, Verification, and Applications.Springer -Verlag, Berlin, 2003. 597 oldal, ISBN 3-540-41217-4. [105] P. Gloor, C. Dynes, L. Lee: Animated Algorithms. A Hypermedia Learning Environment for Introduction to Algorithms. CD ROM. The MIT Press, 1993. [106] D. E. Goldberg: Genetic Algorithms in Search, Optimization and Machine Learning.Addison -Wesley Publ. Comp. 1989. 412 oldal, ISBN 0201157675. [107] L. Györfi, M. Kohler, A. Krzyzak, H. Walk: A Distribution-Free Theory of Nonparametric Regression.Springer -Verlag, New York, 2002. [108] Györfi László, Győri Sándor, Vajda István: Információés kódelmélet.Typotex Kiadó, Budapest, 2000. 371 oldal, 42 hivatkozás, ISBN 963 9132 845. [109] L. Györfi (szerkesztő) Principles of Nonparametric Learning.Springer -Verlag, Wien/New York, 2002. [110] Á. Fóthi, Z. Horváth, T. Kozsik: Parallel elementwise processing a Novel version. Annales Univ. Sci. Budapest de R. Eötvös Nom., SectioComputatorica17 1998, 105–124. MR 2000c:68150, ZB 0981.68177. [111] Frank András: Kombinatorikusalgoritmusok. Elektronikus jegyzet. ELTE, Operációkutatási Tanszék, Budapest, 2003. 57 oldal. [112] S. French: Sequencing and Scheduling. Ellis Horwood Limited, New York, 1982. 245 oldal, 234 hivatkozás, ISBN 0-85312-364-0. [113] Freud Róbert: Lineáris algebra. ELTE Eötvös Kiadó, Budapest, 1996. 518 oldal, ISBN 963 463 080 4. [114] Freud Róbert, Gyarmati Edit: Számelmélet. Nemzeti Tankönyvkiadó, Budapest, 2000. 740 oldal, ISBN 9631907848. [115] Frey Tamás, Szelezsán János: Matematikai kibernetika. Akadémiai Kiadó, Budapest, 1973. 120 oldal. [116] Frey Tamás, Szelezsán János: Számítástechnika. Akadémiai Kiadó, Budapest, 1973. 168 oldal. [117] Gács Péter: Megbízható számítások. In: [160], 234–273. oldal. [118] M. R. Garey, D. S. Johnson: Computers and Intractability: A Guide to the Theory of NP-Completeness. W. H. Freeman, San Francisco, 1979. 338 oldal, 763 hivatkozás. ISBN 0-7167-1044-7. [119] G. P. Gavrilov, A. A. Szapozsenko: Diszkrét matematikai feladatgyűjtemény (oroszul). Moszkva, Nauka, 1977, 367 oldal. Magyarul: Diszkrét matematikai feladatgyűjtemény (fordította Bagyinszki János). Műszaki Könyvkiadó, Budapest, 1981. 357 oldal, 36 hivatkozás, ISBN 963 103 779 9. [120] A. Gibbons, W. Rytter: Efficient Parallel Algorithms.Cambridge University Press, 1988, 259 oldal, 154 hivatkozás. ISBN 0 52134585 4. [121] Gonda János: Bevezetés a matematikába. III. . ELTE TTK, Budapest, 1998. 295 oldal, 17 hivatkozás. [122] G. H. Gonnet, R. Baeza-Yates: Handbook of Algorithms and Data Structures. In Pascal and C. Addison -Wesley, Wokingham, 1991. 424 oldal, 1350 hivatkozás, ISBN 0-201-41607-7. [123] D. H. Greene, D. E. Knuth: Mathematics for the Analysis of Algorithms.Birkh¨auser, Boston, 1990. 132 oldal, 44 hivatkozás, ISBN 0-8176-3515-7. [124] R. Greenflaw, J. Hoover, J. W. Ruzzo: Limits to Parallel Computation: P-completeness Theory.Oxford University Press, New York, 1995. ISBN 0 19 508591 4. [125] B. Gilchrist (szerkesztő): Proceedings of Information Processing’77. North Holland, 1977. [126] J. Gruska: Foundations of Computing. International Thomson Computer Press, London, 1997. 716 oldal, 427 hivatkozás, ISBN 1-85032-243-0. [127] J. Gustafson: Reevaluating Amdahl’s law. Communications of ACM28 (1) 1988, 532–535. [128] P. R. Halmos: Naive Set Theory.Springer -Verlag, New York, 1987. 104 oldal, 19 hivatkozás, ISBN 0387900926. Magyarul: Elemi halmazelmélet (fordította Kósa András). Műszaki Könyvkiadó, Budapest, 1981. 100 oldal, 19 hivatkozás, ISBN 963 10 3857 2. [129] T. J. Harris: A survey of PRAM simulation techniques. ACMComputing Surveys26 1964, 164–206. [130] Hatvani László, Imreh Balázs: Kombinatorikus optimalizálás. Novadat Bt., Győr, 1999. [131] R. L. Haupt, S. E. Haupt: Practical Genetic Algorithms.Wiley, John & Sons, 1997. 192 oldaL, ISBN 0471188735. [132] M. T. Heath, A. Ranade, R. S. Schreiber (szerkesztők): Algorithms für Parallel Processors. IMA105.Springer -Verlag, Berlin, 1999, 366 oldal. ISBN 0387-98680-4. [133] D. S. Hirschberg, J. B. Sinclair: Decentralized extrema-finding in circular configurations of processes. Communications of ACM 23 1980, 627–628. [134] M. Hofri: Probabilistic Analysis of Algorithms. Springer -Verlag, New York, 1987. 240 oldal, 102 hivatkozás, ISBN 0-387-96578-5. [135] H.-D. Hecker: Übungsserie für Algorithmen und Datenstrukturen . Friedrich Schiller Universit¨at, Jena, 2003. [136] J. L. Hennessy, D. A. Patterson: Computer Architecture. A Quantitative Approach . Morgan Kaufmann Publishers, San Mateo, 2002. 1136 oldal, ISBN 55860 596 7. [137] R. Henrici: Numerikus módszerek. Műszaki Könyvkiadó, Budapest, 1985. 370 oldal, 56 hivatkozás, ISBN 963 10 6419 0. [138] D. S. Hochbaum: Approximation Algorithms for NP-hard Problems. PWS Publishing Company, Boston, 1995. 596 oldal, 683 hivatkozás, ISBN 0-534-94968-1. [139<