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 n≥n0,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 n≥n0, 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 n≥n0, 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 n≥n0, 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 n≥n0, akkor f(n)≥cg(n).(1.5) Ha f(n)=o(g(n)) , akkor limn→∞f(n)g(n)=0,(1.6) és ha f(n)=ω(g(n)) , akkor limn→∞f(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 n≥1 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 v≥0 pozitív egész számra teljesül, hogy 1. f(v)=g(v); 2. (f(v−1)−g(v−1))(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 (u≥1) 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 i1←1 to m1,...,ik←1 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 t⌈p/q⌉, és így H munkája legfeljebb qt⌈pq⌉≤pt+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+1−sp.(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(1−s)s+(1−s)=s+p(1−s).(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=2d−1 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,...,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 P⌊j/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 (k≥1) rács egy olyan m1×m2×⋯×mk(m1,m2,...,mk≥2) 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,j−1,Pi,j+1Pi+1,j,Pi−1,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 (1≤i≤d) szintjén 4d−i−1 processzor van, amelyek az 1.6. ábra szerint vannak összekötve. Eszerint a piramis i -edik szintje egy 2d−i×2d−i 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,...,d−1} á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,...,d−1} á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 (2≤j≤d) 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 d−1=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 ppp−1p−1Gyűrű ppp⌈p2⌉Csillag ppp−12 Fa d2d−12d−22d−2Négyzet a=2pa22d(d−1)2d−2Kocka a=32pa33(a−1)a23a−3Piramis d4d+1−132d2d−2Permutációs dd22dd(d−1)!2De Bruijn d2d2d+1dHiperkocka d2dd2d−1dTeljes ppp(p−1)/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ő n−1 korongot áthelyezzük egy másik rúdra, ezután a legalsó korongot áthelyezzük, és végül az n−1 kisebb korongot ráhelyezzük a legnagyobb korongra. Eszerint minden K algoritmusra fK(n)≥2fK(n−1)+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(n−1).(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 n≥2, akkor f(n)=2f(n−1)+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)=2n−1(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)=2n−1s(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ő n−1 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 1−n−α. 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)]≥1−1nα.(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[X≥x]≤μx.(1.51) A Bernoulli-kísérletnek 2 lehetséges eredménye van: p valószínűséggel sikeres, 1−p 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[X≥m]≤(npm)mem−np.(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(n2−1)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*10−10né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 c≥1log54, akkor (45)cαlogn<n−α.(1.58) Tehát az algoritmus legalább 1−n−α 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[X≥600]≤e−(0,2)2(500/3)(1.60)=e−20/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)≥n−1(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 n−1 ö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 n−1. 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(n−1)4.(1.67) Bizonyítás. Ha n=1, akkor igaz az állítás. Ha n≥2, 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 (1≤i,j≤n) 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(n−1)/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 (1≤m≤M≤n<∞),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, q0∈QP 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)=liminfk→∞fP(Rk,m)k(1.74) módon definiálunk, ahol Rk=(r1,r2,...,rk). Legyen 1≤m<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<2m−1. Az anomália mértékével kapcsolatban pedig a következőt bizonyították. 1.14. tétel. Ha m<M<2m−1 , 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>m≥1 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 p′≥p 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+m−1m′.(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=liminft→∞M(∑i=1thi(f)t)(1.79) határértékkel definiáljuk. Könnyen belátható, hogy ha 1≤f≤g , akkor a gombócevési sebességekre fennáll f≤Sf≤fn,g≤Sg≤gn,(1.80) a két óriás relatív gombócevési sebességére pedig fgn≤SfSg≤fng.(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 r≥1,n≥3,g>f≥1, 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 1f−132f1f(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=1naixi≤b,(1.88)a1x12−a2x1x2+a3x34=6.(1.89) Az explicit korlátozások az xi értékekre adnak korlátokat, például xi∈{0,1},xi≥0.(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 n≥n0, akkor 0≤f(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(k≥1) 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 k≥1 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(1≤a≤k≤b) 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 (x⊕y)⊕z=x⊕(y⊕z).(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,x1⊕x2,...,x1⊕x2⊕x3⊕⋯⊕xp 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(i−1)logp+k=∑j=(i−1)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 (1≤i≤p) , melyre A[j]≠i teljesül minden 1≤j≤n é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,p−1,...,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[(i−1)logp+1],A[(i−1)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](1≤i≤p) 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 (2s−i+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(s≤12αlogp)>1−p−α(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 n≥2 kulcs és egy i(1≤i≤n) 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(1≤i,j≤n) 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(i−1)+1,b(i−1)+2,...,b(i−1)+b(i−1)+(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 2n−1. Ezért az Egészet-kiválaszt első lépésében a [0,2n−1] 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,...,M2n−1) , 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(1≤j≤n) 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={x∈X|x<e1} , X2={x∈X|e1≤x≤e2} és X3={x∈X|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(|rj−jnm|>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=kj∈X1 , 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(X1∪X2) -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 (1≤i≤n−1) 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 n−z 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 |z1−z2|=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 ⌈2mlogm⌉CREW 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 N≤2b 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 n≥2 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=1nlogi⌉≤c(n)≤∑i=1n⌈logi⌉(2.11) és hogy c(n)≤nlogn−(n−1).(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 t≥1 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 NlogN≤Nlogn 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(1≤i≤N) 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(1≤i≤n)(2.17) és M∼(i,j)=min{Mi0i1+Mi1i2+...+Mik−1ik}(i≠j),(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+an−1xn−1+⋯+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 k∈A 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 (k≥1) dimenziós rács egy olyan m1×m2×⋯×mk (m1,m2,...,mk≥2) 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 Pp−1 . 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 p−1 lépésben. Vegyük észre, hogy a legrosszabb esetben legalább p−1 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 p−1 élen kell keresztül haladnia, ezért a célba éréshez legalább p−1 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 p−1 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 j−i 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 p−1 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(0≤ki≤p) ü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 p−1 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 j−i 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 p−j. Jelölje k1,k2,...,kj−1 a kezdeti állapotban rendre a P1,P2,...,Pj−1 processzortól induló ilyen csomagok számát. Jelölje m minden lépés után azt az indexet, melyre km−1>1, és ha m≤s≤j, akkor ks≤1. Nevezzük a km,km+1,...,kj−1 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 p−j 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 p−j lépésnyi várakozáson felül j−i lépést kell tennie, ezért legfeljebb p−i 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 i−1 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.