External Sorting

(1)

Katedra informatiky

Tˇr´ıd ˇen´ı na extern´ım ´

uloˇzi ˇsti

External sorting

(2)

(3)

V Ostravˇe 23. ˇcervence 2010 . . . .

Prohlaˇsuji, ˇze jsem tuto diplomovou práci vypracoval samostatnˇe. Uvedl jsem vˇsechny literárn´ı prameny a publikace, ze kter ých jsem ˇcerpal.

(4)

(5)

(6)

(7)

velikost operaˇcn´ı pamˇeti poˇc´ıtaˇce. Seznámit se znám ými algoritmy, jejich nedostatky a následn ými optimalizacemi, dále navrhnout komponentu pro tˇr´ıdˇen´ı dat s pouˇzit´ım tˇechto algoritm ˚u. Tuto komponentu implementovat v jazyce C++ nad jiˇz implementova-nou strukturou perzistentn´ıho pole a následnˇe ji otestovat, popˇr. dále optimalizovat.

Kl´ıˇcov ´a slova: Tˇr´ıdˇen´ı dat, extern´ı tˇr´ıdˇen´ı, tˇr´ıd´ıc´ı algoritmus, sloˇzitost algoritmu, C++

Abstract

The aim of this thesis is to describe the problem of data sorting whose size is larger than the main memory. Familiarize with known algorithms, their shortcomings and subse-quent optimization, design component for sorting the data using these algorithms. This component implemented in C++ over the structure of the implemented persistent array and consequently they are tested, respectively. further optimize.

(8)

(9)

Obsah

1 Uvod´ 11

1.1 C´ıl diplomov´e pr´ace . . . 11

2 Uvod do tˇr´ıd´ıc´ıch algoritm ˚u´ 13 2.1 Algoritmus . . . 13

2.2 Tˇr´ıd´ıc´ı algoritmy . . . 13

2.3 Z´akladn´ı typy tˇr´ıd´ıc´ıch algoritm ˚u . . . 14

3 Algoritmy pro tˇr´ıdˇen´ı na extern´ım ´uloˇziˇsti 15 3.1 Uvaˇzovan ´y model . . . 15

3.2 Popis extern´ıho mergesortu . . . 15

3.3 Spojovac´ı algoritmy . . . 19

4 Komponenta perzistentn´ıho pole 23 4.1 Popis komponenty . . . 23

4.2 Pˇr´ıklad pr´ace s perzistentn´ım polem . . . 23

5 Anal ´yza a n´avrh komponenty pro extern´ı tˇr´ıdˇen´ı prvk ˚u 29 5.1 Specifikace poˇzadavk ˚u . . . 29

5.2 Specifikace pomoc´ı pˇr´ıpadu uˇzit´ı . . . 29

5.3 Tˇr´ıdn´ı diagram . . . 30

6 Implementace 33 6.1 Tˇr´ıda ArrayTest . . . 33

6.2 ˇSablona RunInfo . . . 34

6.3 ˇSablona SortArray . . . 34

6.4 Pouˇzit´e technologie a programov´e vybaven´ı . . . 39

7 Testy 41 7.1 Data pouˇzit´a pro testov´an´ı . . . 41

7.2 Grafy . . . 43 7.3 Shrnut´ı testován´ı . . . 45 8 Závˇer 49 9 Reference 51 Pˇr´ılohy 51 A Uˇzivatelská pˇr´ıruˇcka 53 B Obsah pˇriloˇzeného CD 55

(10)

(11)

Seznam tabulek

1 Seznam vstupn´ıch soubor ˚u k testov´an´ı a jejich parametry . . . 42 2 Mˇeˇren´ı ˇcasu tˇr´ıdˇen´ı vstupn´ıch soubor ˚u pro r ˚uzn´e velikosti hlavn´ı pamˇeti . 42

(12)

(13)

Seznam obr ´azk ˚

u

1 Prvn´ı f´aze extern´ıho mergesortu . . . 16

2 Druh´a f´aze extern´ıho mergesortu vyuˇz´ıvaj´ıc´ı dva pr ˚uchody . . . 16

3 Diagram pˇr´ıpadu uˇzit´ı syst´emu . . . 30

4 Tˇr´ıdn´ı diagram komponenty pro tˇr´ıdˇen´ı prvk ˚u . . . 32

5 Graf tˇr´ıdˇen´ı souboru test setrideny.txt . . . 43

6 Graf tˇr´ıdˇen´ı souboru test1.txt . . . 44

(14)

(15)

Seznam algoritm ˇ

u

1 Uk´azka pseudok ´odu extern´ıho mergesortu . . . 17

2 Uk´azka pseudok ´odu algoritmu posloupnosti spotˇreby . . . 21

3 Ukázka pseudok ódu algoritmu seskupován´ı blok ˚u . . . 22

4 Pseudok ´od algoritmu naˇcti-setˇr´ıd’-uloˇz . . . 36

5 Pseudok ód k-cestného sléván´ı bez rekurze . . . 37

6 Pseudok ód metody Slévej() potˇrebné k algoritmu k-cestného sléván´ı bez rekurze . . . 38

(16)

(17)

Seznam v ´ypis ˚

u zdrojov ´eho k ´

odu

1 Uk´azka v ´ypisu vektor ˚u ze souboru perzistentn´ıho pole . . . 24

2 V ´ystup z metody v ´ypisu vektor ˚u ze souboru perzistentn´ıho pole . . . 25

3 Uk´azka z´apisu vektor ˚u do souboru perzistentn´ıho pole . . . 26

(18)

(19)

1 Uvod

´

V dneˇsn´ı uspˇechané dobˇe si ˇclovˇek snaˇz´ı vˇsemoˇzn ými zp ˚usoby ulehˇcit svou práci. S ob-rovsk ým boomem poˇc´ıtaˇcové techniky v devadesát ých letech minulého stolet´ı postupnˇe nar ˚ustalo nasazován´ı poˇc´ıtaˇc ˚u i do dˇr´ıve tˇeˇzko pˇredstaviteln ých pozic. S poˇc´ıtaˇcem um´ı pracovat dˇeti, poˇc´ıtaˇce dnes dokonce ˇr´ıd´ı letouny. K denn´ı rutinˇe patˇr´ı komunikovat pˇres email, m´ıt pˇr´ıstup k bankovn´ımu kontu prostˇrednictv´ım internetu, vést videokonference, pˇrenáˇset multimédia. Um´ıte si bez poˇc´ıtaˇce pˇredstavit ˇzivot? Poˇcitaˇce zkrátka pronikly do ˇzivot ˚u nˇekolika miliard lid´ı na této planetˇe.

Z hlediska informatiky je to jistˇe pozitivn´ı informace. A nyn´ı si zkuste pˇredstavit, kolik dat vytvoˇr´ı dennˇe, t ýdnˇe, mˇes´ıˇcnˇe kaˇzd ý uˇzivatel pracuj´ıc´ı s poˇcitaˇcem. Kaˇzd ým nákupem v internetovém obchodˇe, kaˇzd ým odeslan ý emailem. Pokud tyto data chceme dále vyuˇz´ıvat, je potˇreba je dˇr´ıve nebo pozdˇeji setˇr´ıd´ıt. Pokud se mnoˇzina dat k setˇr´ıdˇen´ı nevejde do hlavn´ı pamˇeti poˇc´ıtaˇce, kter ý má daná data setˇr´ıdit, je nutno pouˇzit extern´ı tˇr´ıdˇen´ı. To zajist´ı správné setˇr´ıdˇen´ı dat ˇrádovˇe vˇetˇs´ıch neˇz samotná nám dostupná ˇcást hlavn´ı pamˇeti.

1.1 C´ıl diplomov ´e pr ´ace

C´ılem mé diplomové práce je popsat souˇcasn ý stav znám ých algoritm ˚u pro tˇr´ıdˇen´ı dat na extern´ım úloˇziˇsti a jejich optimalizace. Dále se seznámit s jiˇz implementovan ými tˇr´ıdami perzistentn´ıho pole, popsat jejich strukturu, chován´ı a pˇredvést na nich nˇekolik základn´ıch operac´ı.

Pro tyto tˇr´ıdy navrhnout obecnou komponentu pro tˇr´ıdˇen´ı vyuˇz´ıvaj´ıc´ı pro tento pˇr´ıpad co nejvhodnˇejˇs´ı tˇr´ıd´ıc´ı algoritmus. Dále navrhnout a popsat vhodnou optimalizaci, která bude posléze také implementována. Poté popsat v ýslednou implementaci a v závˇeru provést nˇekolik srovnávac´ıch test ˚u a ukázku práce s v ýslednou aplikac´ı.

(20)

(21)

2 Uvod do tˇr´ıd´ıc´ıch algoritm ˚

´

u

2.1 Algoritmus

Algoritmus je pˇredpis, kter ý se skládá z koneˇcného poˇctu krok ˚u a kter ý zajist´ı, ˇze na základˇe vstupn´ıch dat budou poskytnuta data v ýstupn´ı. Kaˇzd ý algoritmus má následuj´ıc´ı vlastnosti:

• Koneˇcnost - poˇzadovan ý v ýsledek mus´ı b ýt poskytnut v rozumném ˇcase. Za ro-zumn ý lze povaˇzovat ˇcas, po kterém bude v ýsledek v ýpoˇctu relevantn´ı vzhledem ke vstupn´ım dat ˚um.

• Hromadnost – Vstupn´ı data nejsou v popisu algoritmu reprezentována konkrétn´ımi hodnotami, ale sp´ıˇse mnoˇzinami, ze kter ých lze data vybrat.

• Jednoznaˇcnost – Kaˇzd ý pˇredpis je sloˇzen z krok ˚u, které na sebe navazuj´ı. Kaˇzd ý krok m ˚uˇzeme charakterizovat jako pˇrechod z jednoho stavu algoritmu do jiného, pˇriˇcemˇz kaˇzd ý stav je urˇcen zpracovávan ými daty. Vˇzdy mus´ı b ýt urˇceno, kter ý krok následuje.

• Opakovatelnost – Pˇri pouˇzit´ı stejn ých vstupn´ıch dat mus´ıme dostat stejná data v ýstupn´ı.

• Resultativnost – Algoritmus vede ke správnému v ýsledku [2]. 2.2 Tˇr´ıd´ıc´ı algoritmy

Tˇr´ıd´ıc´ı algoritmus je úloha, jej´ımˇz c´ılem je zajistit seˇrazen´ı daného souboru dat podle pˇredem urˇceného kl´ıˇce (numericky, abecednˇe, atd.) v co nejkratˇs´ım ˇcase. Problém tˇr´ıdˇen´ı patˇr´ı mezi nejv´ıce studované problémy v poˇc´ıtaˇcové vˇedˇe, s nar ˚ustaj´ıc´ım trendem za-znamenáván´ı a shromaˇzd’ován´ı digitáln´ıch údaj ˚u rostou i poˇzadavky na tˇr´ıdˇen´ı velkého mnoˇzstv´ı dat [1].

2.2.1 D ˇelen´ı tˇr´ıd´ıc´ıch algoritm ˚u

Pokud se vˇsechna data k seˇrazen´ı nevejdou do hlavn´ı pamˇeti poˇc´ıtaˇce, prob´ıhá extern´ı tˇr´ıdˇen´ı, kdy je k mezioperac´ım pouˇzito ˇrádovˇe pomalejˇs´ı pamˇeti, dnes pˇreváˇznˇe pevné disky. Tyto algoritmy narozd´ıl od klasick ých tˇr´ıd´ıc´ıch algoritm ˚u mus´ı brát v úvahu mno-hem vˇetˇs´ı náklady pˇri ˇcten´ı nebo zápisu na extern´ı médium. Algoritmy pro tˇr´ıdˇen´ı se tedy podle pamˇeti, ve které prob´ıhaj´ı, dˇel´ı na:

• Vnitˇrn´ı – cel ý soubor dat k setˇr´ıdˇen´ı se vejde do hlavn´ı pamˇeti poˇc´ıtaˇce, k poloˇzkám lze pˇristupovat náhodnˇe se zanedbateln ými náklady.

• Vnˇejˇs´ı – do hlavn´ı pamˇeti poˇc´ıtaˇce se vejde jen ˇcást dat k setˇr´ıdˇen´ı, algoritmy pro vnˇejˇs´ı tˇr´ıdˇen´ı minimalizuj´ı poˇcet pˇr´ıstup ˚u na disk, pˇr´ıpadnˇe ˇreˇs´ı dalˇs´ı optimalizace pro co moˇzno nejlepˇs´ı pˇrekr ýván´ı procesorového a vstupnˇe/v ýstupn´ıho ˇcasu [1].

(22)

14

Podle dalˇs´ıch vlastnost´ı pak na:

• Pˇrirozené - pˇrirozen ý algoritmus pracuje rychleji na jiˇz ˇcásteˇcnˇe setˇr´ıdˇené mnoˇzinˇe dat.

• Stabiln´ı - stabiln´ı tˇr´ıd´ıc´ı algoritmy zachovávaj´ı relativn´ı poˇrad´ı záznam ˚u se stejnou hodnotou kl´ıˇce. Pokud tedy v souboru dat existuj´ı dva záznamy se stejnou hodno-tou kl´ıˇce, mus´ı algoritmus zachovat jejich vzájemné poˇrad´ı.

2.2.2 Sloˇzitost tˇr´ıd´ıc´ıch algoritm ˚u

• ˇCasová - ˇcasovou sloˇzitost´ı rozum´ıme funkci, která kaˇzdé mnoˇzinˇe vstupn´ıch dat pˇriˇrazuje poˇcet operac´ı vykonan ých pˇri v ýpoˇctu podle daného algoritmu.

• Pamˇet’ová - pamˇet’ovou sloˇzitost definujeme jako závislost pamˇet’ov ých nárok ˚u al-goritmu na vstupn´ıch datech.

ˇ

Casová sloˇzitost v ýpoˇcetn´ıch metod zpravidla vzbuzuje menˇs´ı respekt neˇz sloˇzitost pamˇet’ová [2].

2.3 Z ´akladn´ı typy tˇr´ıd´ıc´ıch algoritm ˚u

• Bubblesort - Pˇri neustálém procházen´ı seznamu porovnáváme dva sousedn´ı prvky, pokud nejsou ve správném poˇrad´ı, vymˇen´ıme je. Procházen´ı seznamu skonˇc´ı, po-kud je cel ý setˇr´ıdˇen. Jednoduch ý na implementaci. Pˇrirozen ý, stabiln´ı. Vyˇzaduje velké mnoˇzstv´ı zápis ˚u do pamˇeti. Pr ˚umˇerná i maximáln´ı sloˇzitost: O(n2).

• Quicksort - Patˇr´ı mezi algoritmy typu rozdˇel a panuj. Nejprve na seznamu zvol´ıme pivota (nejlépe medián celého seznamu). Algoritmus pak seznam rozdˇel´ı na dva znamy, v nˇemˇz v jednom jsou prvky menˇs´ı neˇz pivot, ve druhém vˇetˇs´ı. Oba tyto se-znamy se stejn ým postupem rekurzivnˇe setˇr´ıd´ı. Sloˇzitost algoritmu závis´ı na volbˇe pivota, poˇc´ıtat medián u velkého mnoˇzstv´ı dat vˇsak nen´ı efektivn´ı, pouˇz´ıvá se tedy náhodnˇe vybran ý prvek (nepˇr´ıliˇs efektivn´ı), nebo medián náhodnˇe vybrané malé ˇcásti seznamu. Nepˇrirozen ý, nestabiln´ı. Pr ˚umˇerná sloˇzitost O(n · log n), maximáln´ı sloˇzitost: O(n2)(pˇri pouˇzit´ı vˇzdy nejhorˇs´ıho moˇzného pivota).

• Mergesort - ˇRazen´ı sléván´ım, dalˇs´ı z algoritm ˚u typu rozdˇel a panuj. Algoritmus postupnˇe dˇel´ı seznam na menˇs´ı ˇcásti, dokud nen´ı rozdˇelen ý na jednotlivé prvky (triviáln´ı problém). Pak jej postupnˇe spojuje zpátky s pˇrihlédnut´ım na hodnoty kl´ıˇc ˚u (v ýbˇer nejvhodnˇejˇs´ıho kl´ıˇce). Pˇrirozen ý, stabiln´ı.

Pr ˚umˇern´a i maxim´aln´ı sloˇzitost: O(n · log n).1

(23)

3 Algoritmy pro tˇr´ıd ˇen´ı na extern´ım ´

uloˇzi ˇsti

Jak jsme jiˇz uvedli dˇr´ıve, tˇr´ıdˇen´ı mimo hlavn´ı pamˇet sebou pˇrináˇs´ı nové nároky na efek-tivitu algoritmu, jde pˇredevˇs´ım o problémy spojené s ukládán´ım na ˇrádovˇe pomalejˇs´ı médium, pevn ý disk. Ten dnes pˇredstavuje nejpomalejˇs´ı ˇcást poˇc´ıtaˇce, jeho typické vlast-nosti vycház´ı ze staré kontrukce vyuˇz´ıvaj´ıc´ı magnetickou indukci a mechanické pˇresouván´ı záznamov ých hlav. Naˇstˇest´ı jsou dostupné plnˇe elektronické SSD disky, u kter ých odpa-daj´ı mechanické neduhy pˇri zápisu ˇci ˇctˇen´ı dat. Vyhneme se tak dosti velké pˇr´ıstupové dobˇe a závislosti na fyzickém um´ıstˇen´ı zapsan ých dat, nemluvˇe o pˇr´ıpadné fragmentaci soubor ˚u [4].

3.1 Uvaˇzovan ´y model

V celé diplomové práci i pozdˇejˇs´ım ˇreˇsen´ı uvaˇzuji následuj´ıc´ı model: Pˇredpokládám, ˇze poˇc´ıtaˇc, na kterém bude tˇr´ıdˇen´ı prob´ıhat, má jednu hlavn´ı pamˇet’, jeden procesor a je-den disk, které budu pouˇz´ıvat pro operace potˇrebné k bˇehu algoritmu. Jako jednu stranu pamˇeti uvaˇzuji takovou ˇcást hlavn´ı pamˇeti, která má stejnou velikost, jako alokaˇcn´ı jed-notka pouˇz´ıvaného souborového systému.

Pˇreváˇzná vˇetˇsina algoritm ˚u pro vnitˇrn´ı tˇr´ıdˇen´ı nem ˚uˇze b ýt upravena tak, aby efek-tivnˇe pracovala jako algoritmus pro vnˇejˇs´ı tˇr´ıdˇen´ı. Metody vyuˇz´ıvaj´ıc´ı sekvenˇcn´ıho pˇr´ıstupu jako je napˇr. insertsort a selectsort m ˚uˇzeme z dalˇs´ıch úvah rovnou vylouˇcit. V milu-losti byly algoritmy pro vnitˇrn´ı tˇr´ıdˇen´ı studovány také v souvislost´ı s virtuáln´ı pamˇet´ı, v ýsledky vˇsak nebyly tak slibné d ˚usledkem nadmˇerného poˇctu odkládac´ıch stránek. Snaha pˇrepracovat heapsort a quicksort pro vnˇejˇs´ı tˇr´ıdˇen´ı nebyla efektivn´ı, nepodaˇrilo se dosáhnout tak malého poˇctu vstupnˇe v ýstupn´ıch operac´ı jako u mergesortu, kter ý je z tohoho hlediska nejlepˇs´ım algoritmem pro vnˇejˇs´ı tˇr´ıdˇen´ı.

V posledn´ıch letech se v ýzkum zamˇeˇruje na jeho optimalizaci vedouc´ı k co nejvˇetˇs´ımu zefektivnˇen´ı a optimáln´ımu pˇrekr ýván´ı procesorového a vstupnˇe/v ýstupn´ıho ˇcasu [1]. 3.2 Popis extern´ıho mergesortu

Pˇredpokládejme, ˇze soubor, kter ý má b ýt setˇr´ıdˇen, má N stran a ˇze máme k dispozici B stran v hlavn´ı pamˇeti. Tˇr´ıd´ıc´ı algoritmus pak prob´ıhá ve dvou fáz´ıch:

• V prvn´ı fázi je soubor rozdˇelen do ˇcást´ı, které se naz ývaj´ı skupiny nebo vlákna. Celá skupina m ˚uˇze b ýt zcela uloˇzena v B stranách hlavn´ı pamˇeti a tud´ıˇz existuje N/B skupin vyprodukovan ých v této fázi. Kaˇzdá skupina je setˇr´ıdˇena nezávisle v hlavn´ı pamˇeti nˇekter ým z vnitˇrn´ıch tˇr´ıd´ıc´ıch algoritm ˚u a pak zapsána zpˇet na disk, viz Obrázek 1.

• V pr ˚ubˇehu druhé fáze jsou skupiny slévány tak, aby vyrobily menˇs´ı poˇcet sku-pin a nakonec byly spojeny do jediné v ýsledné. Spojovac´ı fáze se m ˚uˇze skládat z nˇekolika pr ˚uchod ˚u. Dostupnou pamˇet’ ve druhé fázi rozdˇel´ıme tak, aby vznikla jedna vyrovnávac´ı pamˇet’ pro v ýstupn´ı soubor a zbytek pamˇeti se rozdˇelil jako ˇctec´ı vyrovnávac´ı pamˇet jednotliv ých skupin. V kaˇzdém pr ˚uchodu se z kaˇzdé skupiny,

(24)

16

Obr´azek 1: Prvn´ı f´aze extern´ıho mergesortu

Obrázek 2: Druhá fáze extern´ıho mergesortu vyuˇz´ıvaj´ıc´ı dva pr ˚uchody

resp. jej´ıho ˇctec´ıho zásobn´ıku, vybere nejmenˇs´ı popˇr. nejvˇetˇs´ı prvek a ten se po-rovnává s dalˇs´ımi takto z´ıskan ými prvky z ostatn´ıch skupin. Na konci kaˇzdého pr ˚uchodu dostaneme vˇzdy jeden prvek, kter ý zap´ıˇseme na v ýstupn´ı zásobn´ık. Po-kud je v ýstupn´ı zásobn´ık pln ý, zap´ıˇse se do v ýsledného souboru, obdobnˇe, poPo-kud je nˇekter ý ze vstupn´ıch zásobn´ık ˚u prázdn ý, naˇcte se do nˇej dalˇs´ı ˇcást pˇr´ısluˇsné sku-piny [3], viz Obrázek 2.

V ýkonnost extern´ıho mergesortu záleˇz´ı mj. na v ýbˇeru spojovac´ıho schéma, jak ým se vyb´ıraj´ı skupiny pro spojován´ı ve druhé ˇcásti algoritmu. R ˚uzné postupy totiˇz mohou vést ke znaˇcn ým v ýkonov ým rozd´ıl ˚um [1].

3.2.1 Algoritmy pro tvorbu skupin

Pro tvorbu skupin se bˇeˇznˇe pouˇz´ıvaj´ı dva algoritmy:

Prvn´ı, naz ývaj´ıc´ı se naˇcti-setˇrid’-uloˇz, napln´ı vˇsechny dostupné stránky hlavn´ı pamˇeti záznamy ze souboru k seˇrazen´ı a spust´ı vnitˇrn´ı tˇr´ıdic´ı algoritmus heapsort nebo quicksort. V ýsledek je zapsán zpˇet na disk jako setˇr´ıdˇená skupina. Tento postup se opakuje, dokud nejsou setˇr´ıdˇeny vˇsechny záznamy. Jednotlivé skupiny tedy maj´ı velikost shodnou s ve-likost´ı dostupné hlavn´ı pamˇeti.

Druh ý algoritmus se naz ývá výmˇenný výbˇer. Vyuˇz´ıvá minimáln´ı haldu k v ýbˇeru kl´ıˇce s minimáln´ı hodnotou. Halda se nejprve napln´ı, pak je záznam s nejmenˇs´ı hodnotou kl´ıˇce (vrchol haldy) pˇresunut z haldy do v ýstupn´ıho zásobn´ıku a t´ım uvoln´ı m´ısto pro nov ý prvek. Dalˇs´ı prvek, kter ý má b ýt pˇresunut do v ýstupn´ıho zásobn´ıku, mus´ı m´ıt vˇetˇs´ı

(25)

Algoritmus 1: Ukázka pseudok ódu extern´ıho mergesortu Input: file BLOCKSIZE; RAMSIZE; N=size(file)/BLOCKSIZE; B=RAMSIZE/BLOCKSIZE; //prvn´ı ˇcást

while file != empty do for i:=1 to N/B do ram:=load(file)/RAMSIZE; sort(ram); write(filesort, i); // druh´a ˇc´ast for b:=1 to B-1 do alokuj(Bi, B/ N+1); alokuj(Bout, B/ N+1); for b:=1 to N/B do Bb:=read(filesort, b, B/ N+1);

while filesort != empty do

Bout= merge(B1... BN/B);

if Bxis empty then

dopl ˇn(filesort, x + pˇreˇcteno);

if Boutis full then

write(Bout, finallyfile);

(26)

18

kl´ıˇcovou hodnotu, neˇz posledn´ı vyjmut ý prvek. Pokud se v souboru vyskytnou záznamy s menˇs´ı kl´ıˇcovou hodnotou, neˇz posledn´ı prvek vloˇzen ý do v ýstupn´ıho zásobn´ıku, um´ıst´ı se do nové minimáln´ı haldy. T´ım se postupnˇe prvn´ı halda zmenˇsuje a druhá zvˇetˇsuje. Pˇri vyprázdnˇen´ı prvn´ı haldy je dokonˇcena tvorba prvn´ı skupiny a prvky z dalˇs´ı haldy jiˇz pln´ı dalˇs´ı skupinu. Tento proces konˇc´ı, kdyˇz v souboru nezb ývaj´ı ˇzádné dalˇs´ı záznamy k setˇr´ıdˇen´ı [3].

Jak bylo prokázáno [3], pr ˚umˇern ý poˇcet skupin vytvoˇren ých v ýmˇenn ým v ýbˇerem je poloviˇcn´ı oproti velikosti skupin, vytvoˇren ých algoritmem naˇcti-setˇrid’-uloˇz. To má vliv na v ýpoˇcetn´ı ˇcas druhé ˇcásti algoritmu, menˇs´ı poˇcet skupin totiˇz zkrát´ı ˇcas potˇrebn ý k vy-konán´ı druhé ˇcásti extern´ıho mergesortu. Algoritmus v ýmˇenn ý v ýbˇer má stálejˇs´ı pr ˚ubˇeh vstupnˇe/v ýstupn´ıch operac´ı a dosahuje lepˇs´ıch v ýsledk ˚u na jiˇz ˇcásteˇcnˇe pˇredtˇr´ıdˇen ých datech. Mezi jeho nev ýhody patˇr´ı nutnost souˇcasného ˇcten´ı záznam ˚u ze vstupn´ıho zásob-n´ıku a zápis na v ýstupn´ı zásobn´ık. Jsou-li oba soubory uloˇzeny na stejném disku, je potˇreba v´ıce ˇcasu na reˇzii pˇri ˇcten´ı a zápisu dat, vypl ývaj´ıc´ı z tˇechto poˇzadavk ˚u. Pokud ovˇsem máme k dispozici dva disky, je v ýmˇenn ý v ýbˇer lepˇs´ı volbou [1].

3.2.2 Spr áva pam ˇeti pro z áznamy r ˚uzn ých d élek

V reálném svˇetˇe potˇrebujeme pracovat se záznamy r ˚uzn ých délek. V ýˇse popsané algo-ritmy vˇsak nejsou pˇr´ımo pouˇzitelné pro záznamy s r ˚uzn ými délkami, protoˇze pamˇet’ov ý prostor pro tˇr´ıdˇen´ı je pevnˇe dán a poˇcet záznam ˚u, které mohou b ýt vyjmuty z tohoto prostoru, nen´ı pˇredem znám. Budeme pˇredpokládat, ˇze se pamˇet’ov ý prostor skládá z nˇekolika rozsah ˚u, protoˇze nen´ı moˇzné alokovat libovolnˇe velké ˇcásti soused´ıc´ı pamˇeti. Postup je následuj´ıc´ı: Pˇri spuˇstˇen´ı algoritmu pro tvorbu skupin jsou záznamy s promˇennou délkou ˇcteny ze vstupu a vkládány do pamˇet’ového prostoru. Tato metoda má naj´ıt m´ısto pro kaˇzd ý nov ý záznam uvnitˇr existuj´ıc´ıho pamˇet’ového prostoru. Pokud nen´ı nalezeno ˇzádné volné m´ısto, je záznam pˇresunut z pamˇet’ového prostoru na v ýstup a t´ım vytvoˇr´ı prostor pro nov ý vstup. Pokud záznamy neobsad´ı vˇsechna vytvoˇrená volná m´ısta, mus´ı pak systém sledovat volné segmenty a kontrolovat moˇznost slouˇcen´ı potencionáln´ıch sousedn´ıch voln ých segment ˚u. V následuj´ıc´ıch dvou heuristick ých metodách je popsáno hledán´ı voln ých segment ˚u.

Dalˇs´ı vyhovuj´ıc´ı - tato metoda sekvenˇcnˇe vyhledává vˇsechny volné segmenty pamˇeti, zaˇc´ıná od pozice, kde doˇslo k posledn´ımu vloˇzen´ı, a prob´ıhá, dokud nenalezne dostateˇcnˇe velkou ˇcást pamˇeti pro uloˇzen´ı nového záznamu. Jelikoˇz m ˚uˇze b ýt vyhledáván´ı dosti nároˇcné, zavád´ı se prahová hodnota k omezen´ı poˇctu zkouman ých voln ých segment ˚u. Pokud je tento limit dosaˇzen a nebyl nalezen ˇzádn ý voln ý segment, snaˇz´ı se algorit-mus pˇresunout záznam soused´ıc´ı s voln ým segmentem z jeho aktuáln´ı pozice k dalˇs´ımu volnému segmentu, kter ý byl zkoumán v pr ˚ubˇehu stejného vyhledáván´ı. Pokud tento pˇresun vytvoˇr´ı poˇzadované m´ısto, je záznam vloˇzen do pamˇet’ového prostoru, pokud nevytvoˇr´ı, je jeden nebo v´ıce existuj´ıc´ıch záznam ˚u odstranˇeno z pamˇet’ového prostoru a vytvoˇr´ı tak vhodné volné m´ısto.

Nejlepˇs´ı vyhovuj´ıc´ı - v této metodˇe jsou nové záznamy vkládány do nejmenˇs´ıho volného segmentu, kter ý je natolik velk ý, aby dan ý záznam pˇrijal. Pro efektivn´ı vyhledáván´ı vhodného volného segmentu sleduje algoritmus velikosti voln ých segment ˚u v binárn´ım

(27)

stromu. Pˇri vkládán´ı nového záznamu prohledá algoritmus binárn´ı strom, aby nalezl voln ý segment minimáln´ı velikosti, kter ý je vˇetˇs´ı nebo roven velikosti nového záznamu. V pˇr´ıpadˇe, ˇze neexistuje ˇzádn ý voln ý segment, jsou existuj´ıc´ı záznamy odstranˇeny, do-kud nen´ı dostatek volného m´ısta.

Podle test ˚u, které byly provedeny, dosahuje metoda nejlepˇs´ı vyhovuj´ıc´ı aˇz 95% vyuˇzit´ı pamˇeti pro velké pamˇet’ové rozsahy. Pro menˇs´ı pamˇet’ové rozsahy je vyuˇzit´ı kolem 75%. Metoda nejlepˇs´ı vyhovuj´ıc´ı je dále ˇcasovˇe úspornˇejˇs´ı - náklady na vyhledáván´ı v této metodˇe totiˇz nar ˚ustaj´ı s poˇctem voln ých segment ˚u logaritmicky (d´ıky vyuˇzit´ı binárn´ıho stromu). Pro záznamy s promˇennou velikost´ı je tedy metoda nejlepˇs´ı vyhovuj´ıc´ı s meto-dou v ýmˇenného v ýbˇeru tou nejlepˇs´ı kombinac´ı [1].

3.3 Spojovac´ı algoritmy

Vzhledem k tomu, ˇze je spojován´ı skupin pˇreváˇznˇe vstupnˇe/v ýstupn´ı operac´ı, snaˇz´ı se vˇsechny algoritmy minimalizovat poˇcet pˇr´ıstup ˚u na disk. Vyváˇzen ý k-cestný mergesort tˇr´ıd´ı data pouˇzit´ım opakovaného sluˇcován´ı. Rozdˇel´ı vstup do dvou skupin opakovan ým ˇcten´ım blok ˚u dat ze vstupu, které zapln´ı hlavn´ı pamˇet’, skupina se setˇr´ıd´ı, a pak se zap´ıˇse do dalˇs´ı skupiny. Ve druhé fázi se opakovanˇe spojuj´ı dvˇe skupiny do jedné ze dvou v ýstupn´ıch skupin, dokud nevznikne jedna setˇr´ıdˇená skupina [7].

Dˇr´ıvˇejˇs´ı studie ukázaly, u v´ıcecestného spojován´ı, obecnˇe k-cestného spojován´ı, zvo-len´ım k co nejvyˇsˇs´ıho nemus´ı vˇzdy vést ke zlepˇsen´ı v ýkonnosti. Jedno z ˇreˇsen´ı je vloˇzit nejprve tolik prázdn ých skupin, kolik je potˇreba k vytvoˇren´ı vˇsech skupin-1, dˇeliteln ých k-1. Pak algoritmus spoj´ı v kaˇzdém pr ˚uchodu k nejkratˇs´ıch skupin, dokud nez ˚ustane jen jedna. Tento postup vˇsak nedosahuje pˇrekr ýván´ı mezi vstupnˇe/v ýstupn´ım a CPU ˇcasem: procesor z ˚ustane v neˇcinnosti, zat´ımco je k zásobn´ık ˚u plnˇeno ˇcástmi odpov´ıdaj´ıc´ıch sku-pin naˇc´ıtan ých z disku. Tento problém ˇreˇs´ı prognostická metoda, metoda dvojitého vy-rovnáván´ı nebo metoda prokládaného rozvrˇzen´ı.

Prognostická metoda - tato metoda sleduje ˇctec´ı zásobn´ık, kter ý bude vyprázdnˇen jako prvn´ı a pouˇz´ıvá dalˇs´ı zvláˇstn´ı zásobn´ık ke ˇcten´ı dalˇs´ı vhodné ˇcásti z disku, dokud obsah zb ývaj´ıc´ıch zásobn´ık ˚u nepokraˇcuje ke zpracován´ı. Vylepˇsená prognostická metoda zavád´ı posloupnost spotˇreby k urˇcen´ı, kter ý ze zásobn´ık ˚u bude vyprázdnˇen jako prvn´ı a ˇcten´ı dat z disku zaˇc´ıná jiˇz ve chv´ıli, kdy je v pamˇeti voln ých m stran. Nemus´ıme tedy ˇcekat na uvolnˇen´ı celého zásobn´ıku nˇekteré skupiny [1].

Dvojité vyrovnáván´ı - v této metodˇe se pro kaˇzdou skupinu vytvoˇr´ı dva zásobn´ıky, je-den pro provádˇen´ı V/V operac´ı a druh ý pro zpracován´ı. M ˚uˇze b ýt pouˇzita bud’ pˇri ˇcten´ı z disku nebo pˇri zápisu na nˇej. Oproti prognostické metodˇe vyˇzaduje tato metoda v´ıce pamˇeti, nebo sn´ıˇzen´ı velikosti stávaj´ıc´ıho zásobn´ıku. D´ıky dvˇema zásobn´ık ˚um m ˚uˇze b ýt dosaˇzeno pˇrekr ýván´ı mezi V/V a CPU ˇcasem, ale nutno poznamenat, ˇze nemá vyuˇzit´ı u témˇeˇr setˇr´ıdˇen ých dat [5]. V rozˇs´ıˇren´ı této metody, naz ývaj´ıc´ım se rovnomˇerné vyrovnáván´ı, se pro kaˇzdou skupinu vytvoˇr´ı m zásobn´ık ˚u. Nyn´ı nastává otázka, jak brzy zahájit nové ˇcten´ı pro zaplnˇen´ı prázdn ých zásobn´ık ˚u. Pokud zaˇcneme ˇc´ıst, kdyˇz je prázdn ých m-1 zásobn´ık ˚u, minimalizujeme vyhledávac´ı ˇcas, nebot’ vˇsech m-1 blok ˚u bude ˇcteno z po sobˇe jdouc´ıch m´ıst. T´ım vˇsak nen´ı zaruˇceno úplné pˇrekryt´ı CPU a V/V ˇcasu, protoˇze pˇri ˇcten´ı m-1 blok ˚u m ˚uˇze CPU z ˚ustat neˇcinn ý. V tomto okamˇziku se vyuˇz´ıvá vlastnosti

(28)

20

modern´ıch diskov ých systém ˚u, které rozdˇel´ı ˇcten´ı velkého mnoˇzstv´ı dat na ˇcten´ı po-sloupnosi nˇekolika menˇs´ıch datov ých blok ˚u. V pr ˚ubˇehu plnˇen´ı zásobn´ık ˚u sekvenˇcn´ım ˇcten´ım z disku, jsou jiˇz nˇekteré zásobn´ıky naplnˇeny a mohou b ýt pouˇzity k dalˇs´ımu zpra-cován´ı. Nev ýhodou je, ˇze ˇcten´ı nem ˚uˇze zaˇc´ıt dˇr´ıve, dokud nen´ı prázdn ých m-1 zásobn´ık ˚u patˇr´ıc´ıch ke stejn ým skupinám, operaˇcn´ı pamˇet’ tedy nen´ı plnˇe vyuˇzita.

V pr ˚ubˇehu sluˇcovac´ı fáze jsou data ˇctena v odliˇsném poˇrad´ı, neˇz v jakém byla za-pisována ve fázi tvorby skupin. Ve fázi pro tvorbu skupin se totiˇz skupiny zapisuj´ı na po sobˇe jdouc´ı m´ısta na disku, narozd´ıl od spojovac´ı fáze, kde jsou data ˇctena v urˇcitém poˇrad´ı, které závis´ı na poˇrad´ı vstupn´ıch záznam ˚u. To má dopad na celkové pˇr´ıstupové náklady na disk, zvyˇsuje se totiˇz vyhledávac´ı doba. Metoda prokládané rozvrˇzen´ı [6] umist’uje záznamy z r ˚uzn ých skupin do souvisl ých pozic podle algoritmu robin-round. Je zaloˇzena na oˇcekáván´ı, ˇze m´ısto nového záznamu je bl´ıˇze k poˇrad´ı, v jakém budou ˇcteny záznamy z disku a takto sniˇzuje vyhledávac´ı ˇcas. Pˇredstavuje vˇsak reˇzii v pr ˚ubˇehu fáze pro tvorbu skupin.

3.3.1 Pl ´anov ´an´ı ˇcten´ı

Kaˇzdá skupina je rozdˇelena do blok ˚u o délce rovnaj´ıc´ı se velikosti vyrovnávac´ı pamˇeti. Uloˇzen´ım maximáln´ı kl´ıˇcové hodnoty z kaˇzdého bloku dat jsme schopni urˇcit poˇrad´ı, ve kterém budou bloky poˇzadovány v pr ˚ubˇehu spojovac´ı fáze. Toto poˇrad´ı se naz ývá posloupnost spotˇreby [6]. Ukládán´ı maximáln´ı kl´ıˇcové hodnoty nepˇredstavuje v ýznamnou reˇzii, protoˇze lze provést v hlavn´ı pamˇeti. Tyto kl´ıˇce by mˇely b ýt setˇr´ıdˇeny, coˇz je moˇzno provést, kdyˇz se zaˇc´ıná zapisovat posledn´ı skupina na disk (v pr ˚ubˇehu tvorby skupin) nebo bˇehem pˇredcházej´ıc´ı spojovac´ı fáze.

Pokud jsou bˇehem spojovac´ı fáze dostupné nˇejaké extra zásobn´ıky, lze je pouˇz´ıt pro ˇcten´ı datov ých blok ˚u, které nejsou aktuálnˇe potˇrebné v nˇejaké ˇcásti spojován´ı. ˇCten´ı tˇechto blok ˚u nepˇredstavuje rotaˇcn´ı nebo vyhledávaj´ıc´ı zpoˇzdˇen´ı, jelikoˇz bloky jsou v po sobˇe jdouc´ıch pozic´ıch. Posloupnost spotˇreby m ˚uˇzeme pouˇz´ıt k urˇcen´ı, které bloky bu-dou potˇrebné v následuj´ıc´ıch fáz´ıch, naˇc´ıst je za n´ızké náklady a urychlit tak spojovac´ı ˇcást.

Tento problém lze formulovat následovnˇe [6]: Bud’ n poˇcet skupin, T poˇcet datov ých blok ˚u, B poˇcet zásobn´ık ˚u. Pak C = {C1, C2, ..., CT} je blok posloupnosti spotˇreby, R =

{R₁, R2, ..., RT} je ˇctec´ı sekvence, L je mapovac´ı funkce mezi datov ´ymi bloky a

pozi-cemi disku, které jsou oznaˇceny ˇc´ısly 1, 2, ..., T. Kaˇzdá ˇctec´ı sekvence R je charakteri-zována svou cenou, která je rovna souˇctu celkového vyhledávac´ıho ˇcasu a celkového pˇrenosového ˇcasu potˇrebného ke ˇcten´ı datov ých blok ˚u v poˇrad´ı urˇceném R. Vzhledem k tomu, ˇze kaˇzdá ˇctec´ı sekvence má stejou dobu pˇrenosu, v ýbˇer nejlepˇs´ı sekvence je zaloˇzen na v ýpoˇctu hledac´ıho ˇcasu. ˇCtec´ı sekvence nav´ıc mus´ı spl ˇnovat dalˇs´ı podm´ınku - v kaˇzdé fázi mus´ı b ýt uchován nejménˇe jeden blok dat z kaˇzdé skupiny v jednom z dostupn ých zásobn´ık ˚u. Sekvence spl ˇnuj´ıc´ı tuto podm´ınku se naz ývá proveditelná. Mus´ıme tedy naj´ıt proveditelnou sekvenci, která má minimáln´ı hledac´ı ˇcas.

Lze snadno odvodit, ˇze problém nalezen´ı optimáln´ı proveditelné ˇctec´ı sekvence je ekvivalentn´ı s problémem obchodn´ıho cestuj´ıc´ıho, proto m ˚uˇze b ýt navrˇzeno jen heuris-tické ˇreˇsen´ı. Heuristika je zaloˇzená na um´ıstˇen´ı kaˇzdého Ci údaje z bloku posloupnosti

(29)

spotˇreby C uvnitˇr ˇctec´ı sekvence R v pozici, která minimalizuje vyhledávac´ı ˇcas. Ten se vypoˇcte podle L(Ri)pozice disku, kde jsou uloˇzeny údaje o ˇctec´ı sekvenci. Aby byla ˇctec´ı

sekvence proveditelná, je udrˇzována dalˇs´ı sekvence F. J-t ý údaj sekvence F pˇredstavuje poˇcet voln ých zásobn´ık ˚u pˇred pˇreˇcten´ım údaje Rjve ˇctec´ı sekvenci. Pokud je Civloˇzeno

na pozici p ˇctec´ı sekvence, dostaneme Rp, kde p < i, pak je pro jeho uloˇzen´ı potˇreba

dalˇs´ıho z´asobn´ıku. Proto je Fj zmenˇseno o 1, kdyˇz p ≤ j < i, ve smyslu, ˇze pro bloky

Rp, ..., Ri−1bude o jeden zásobn´ık ménˇe, neˇz kdyˇz zaˇcaly b ýt ˇcteny. Pokud je Fj = 0pro

dané j, pak ˇzádn ý blok za j z posloupnosti spotˇreby nem ˚uˇze b ýt um´ıstˇen pˇred j ve ˇctec´ı sekvenci. Promˇenná s zaznamenává posledn´ı hodnotu j, kde je Fj = 0.

Algoritmus 2: Uk´azka pseudok ´odu algoritmu posloupnosti spotˇreby R1:=C1; s:=1; for j:=1 to T do Fj:=B-n; for i:=2 to T do p:=i; for j:=s to i-1 do

if Rj se nach´az´ı na stejn´e stopˇe na disku jako CiAND L(Ri) > L(Ci) then

p:=j; break;

for k:=i downto p+1 do

Rk:= Rk− −;

Fk:= Fk−1− −;

if Fk=0 AND s¡=k then

s:=k+1; Rp:=Ci;

Popsan ý algoritmus má sloˇzitost O(T2)a m ˚uˇze b ýt spuˇstˇen, dokud je na disku uloˇzena posledn´ı skupina. Metoda plánován´ı ˇcten´ı s pouˇzit´ım posloupnosti spotˇreby dokázala pˇrekonat metody dvojitého vyrovnáván´ı i prognostickou metodu [6].

3.3.2 Seskupov ´an´ı blok ˚u

Tato metoda se snaˇz´ı o nalezen´ı heuristického ˇreˇsen´ı problému optimáln´ı ˇctec´ı cesty. Je zaloˇzena na seskupen´ı takového mnoˇzstv´ı sousedn´ıch blok ˚u dat ze stejné skupiny, jak je jen moˇzné. Nˇekolik sousedn´ıch blok ˚u ze stejné skupiny tvoˇr´ı celek, kter ý m ˚uˇze b ýt pˇreˇcten sekvenˇcnˇe. ˇC´ım menˇs´ı je poˇcet skupin, t´ım ménˇe vyhledávac´ıho ˇcasu bude potˇreba bˇehem spojován´ı. Tato ˇctec´ı sekvence (celek) je proveditelná, pokud je v pr ˚ubˇehu spojovac´ı ˇcásti pˇreˇcten kaˇzd ý blok právˇe jednou. Metoda pro stanoven´ı proveditelnosti ˇctec´ı sekvence je zaloˇzena na poˇctu voln ých zásobn´ık ˚u, F. Fi je rovno poˇctu voln ých

(30)

22

zásobn´ıkov ých stránek po pˇreˇcten´ı i-tého celku. Velikosti celk ˚u jsou oznaˇceny L = {L1, L2, ..., LN}

pro dan´e N [6].

Algoritmus 3: Ukázka pseudok ódu algoritmu seskupován´ı blok ˚u R:=C;

//ˇctec´ı sekvence se inicializuje podobnˇe jako posloupnost spotˇreby

for i:=1 to T do

Li:=1;

//nastaven´ı prvotn´ı velikosti celku lastC1:=n;

for i:=n+1 to T do

for j:=lastC1 downto 1 do

if Rj.runNumber=Ri.runNumber then

k:=j; break;

if lze Rizkombinovat s RK pˇri zachov´an´ı proveditelnosti then

LK++;

else

//Rise stane nov ´ym celkem lastC1++;

RlastC1++;

N:=lastC1;

Seskupován´ı blok ˚u je nejefektivnˇejˇs´ı metodou ze vˇsech variant pro zlepˇsen´ı spojo-vac´ıch algoritm ˚u. Oproti metodˇe plánován´ı ˇcten´ı, která je druhá nejlepˇs´ı, dosahuje nár ˚ust v ýkonu 30%. Nav´ıc je schopna vyuˇz´ıt jiˇz ˇcásteˇcnˇe pˇredtˇr´ıdˇená data [1].

Extern´ı mergesort je doposud nejlepˇs´ı tˇr´ıd´ıc´ı algoritmus pro vnˇejˇs´ı tˇr´ıdˇen´ı [1], zde uvedené optimalizace jeˇstˇe dále vylepˇsuj´ı jeho v ýkonnost. Obecnˇe jde o snahu minimali-zovat prodlevu pˇri ˇcten´ı a ukládán´ı na pevn ý disk (ˇci ji co nejv´ıce vyuˇz´ıt k dalˇs´ı optima-lizaci) nebo pˇrekr ýván´ı procesorového a vstupnˇe/v ýstupn´ıho ˇcasu.

(31)

4 Komponenta perzistentn´ıho pole

4.1 Popis komponenty

Pˇri úvahami nad anal ýzou tˇr´ıdˇen´ı dat na extern´ım úloˇziˇsti podle popsan ých algoritm ˚u se nám nask ýtá nˇekolik problém ˚u. Mezi jeden z nich patˇr´ı jak ým zp ˚usobem navrhnout a implementovat vyrovnávac´ı pamˇet’ pro ˇcten´ı a zápis soubor ˚u. Jelikoˇz je nutno m´ıt kon-trolu nad volbou velikost´ı jednotliv ých vyrovnávac´ıch pamˇet´ı, je vyrovnávac´ı pamˇet’ v souborovém systému operaˇcn´ıho systému nevyhovuj´ıc´ı. Rozhodl jsem se vyuˇz´ıt ˇreˇsen´ı, které je jiˇz naimplementováno a vˇsechny potˇrebné podm´ınky spl ˇnuje - perzistentn´ı pole. Perzistentn´ı pole se z hlediska programátora tváˇr´ı jako dynamické pole vektor ˚u, které vˇsechna svá data samostatnˇe ukládá do extern´ıho souboru a napodobuje sv ým chován´ım reáln ý souborov ý systém operaˇcn´ıho systému. Hlav´ı v ýhoda perzistentn´ıho pole na-rozd´ıl od bˇeˇzného datového souboru uloˇzeném v souborovém systému spoˇc´ıvá ve vlastn´ı vyrovnávac´ı pamˇet’ cache, která umoˇz ˇnuje lépe ˇr´ıdit, co bude uloˇzeno na pevném disku a co v hlavn´ı pamˇeti. Vˇsechny tˇr´ıdy implementuj´ıc´ı toto pole jsem pˇrevzal z aplikaˇcn´ıho rámce ATOM implementovan ý databázovou skupinou na Katedˇre informatiky Fakulty elektrotechniky a informatiky, Vysoké ˇskoly Bá ˇnské - Technické univerzity Ostrava.

Nyn´ı jiˇz k samotn ým tˇr´ıdám implementuj´ıc´ım perzistentn´ı pole. To v sobˇe ukládá vektory typu zdˇedˇeného ze tˇr´ıdy cBasicType, v následuj´ıc´ıch pˇr´ıkladech i v této práci budu pouˇz´ıvat prvky, jeˇz reprezentuje tˇr´ıda cNTreeTuple NoEncodeType. Nezbytnou souˇcást´ı je ˇsablona cSizeInfo, která zajiˇst’uje správn ý v ýpoˇcet velikosti poloˇzky, d ˚uleˇzit ý pˇredevˇs´ım u sloˇzitˇejˇs´ıch typ ˚u. Parametrizuje se poloˇzkami konkrétn´ıho typu zdˇedˇené z jiˇz zmi ˇnované tˇr´ıdy cBasicType. Pro vkládán´ı prvk ˚u typu cNTreeTuple je pˇripravená tˇr´ıda cNTupleSizeInfo parametrizuj´ıc´ı ˇsablonu cSizeInfo typem cNTreeTuple. Tato tˇr´ıda obsahuje informace i pro zde pouˇz´ıvan ý typ prvk ˚u cNTreeTuple NoEncodeType.

4.2 Pˇr´ıklad pr ´ace s perzistentn´ım polem

Pro práci se samotn ým perzistentn´ım pole potˇrebujeme vytvoˇrit nˇekolik pomocn ých ob-jekt ˚u a definovat parametry pˇri jejich vytváˇren´ı:

• Nejprve je tˇreba definovat typ vkládan ých prvk ˚u. V následuj´ıc´ıch pˇr´ıkladech bu-dou jednotlivé prvky typu cNTreeTuple NoEncodeType, jednotlivé vektory mohou m´ıt promˇennou délku, tedy kaˇzd ý z nich nemus´ı m´ıt délku urˇcenou dimenz´ı. Po-sledn´ı definic´ı typu tPersistentArray jen vloˇz´ıme pˇredchoz´ı typy do ˇsablony sa-motného perzistentn´ıho pole.

• Dále je tˇreba popisovaˇc m´ısta, pˇri jehoˇz vytváˇren´ı vkládáme do kontruktoru hod-noty maximáln´ı dimenze vektor ˚u a jejich datov ý typ, dˇed´ıc´ı ze tˇr´ıdy cDataType. Popisovaˇc m´ısta je nová instance tˇr´ıdy zdˇedˇené z obecného popisovaˇce cTreeSpa-ceDescriptor. V tomto pˇr´ıpadˇe tedy bude maximáln´ı dimenze vektor ˚u 10 prvk ˚u a jednotlivé prvky vektoru budou neznaménkové celoˇc´ıselné, viz ˇrádek 7 ve zdro-jovém k ódu 1.

(32)

24

• Hlaviˇcka perzistentn´ıho pole je zdˇedˇená ze tˇr´ıdy cHeader. Jak jiˇz název napov´ıdá, jde o hlaviˇcku ekvivalentn´ı ke zvolenému typu prvku i samotného perzistentn´ıho pole, tj. cPersistentArrayHeader VarLen. Jako parametry konstruktoru vkládám informace o volném m´ıstˇe, kterému dále pˇredám dˇr´ıve vytvoˇren ý popisovaˇc m´ısta. Tato infor-mace o volném m´ıstˇe dˇed´ı ze základn´ı tˇr´ıdy cSizeInfo a odpov´ıdá zvolenému typu prvku pole. Druh ý vkládan ý parametr je velikost uzlu vkládaného prvku, tˇret´ı pak urˇcuje velikost bloku, v podstatˇe jde velikost alokaˇcn´ı jednotky, zde tedy 4kB. • Nyn´ı jiˇz m ˚uˇzeme vytvoˇrit samotné perzistentn´ı pole, jako parametr konstruktoru

pˇredávám dˇr´ıve vytvoˇrenou hlaviˇcku, viz ˇrádek 15 ve zdrojovém k ódu 1.

• Pro ˇcten´ı vektor ˚u z pole pouˇz´ıvám kontext, slouˇz´ıc´ı k uloˇzen´ı informac´ı potˇrebn ých pro práci s perzistentn´ım polem s promˇennou délkou vektor ˚u. Sleduje uzel, aktuáln´ı m´ısto v uzlu a aktuáln´ı poloˇzku. Ukládá také dalˇs´ı pomocnou pamˇet’. Jde o tˇr´ıdu zdˇedˇenou ze základn´ı tˇr´ıdy cDataStructureContext. Jej´ı typ opˇet odpov´ıdá typu per-zistentn´ıho pole. Jako parametr kontruktoru vkládám hlaviˇcku, která obsahuje vˇsechny potˇrebné údaje pro jeho správnou inicializaci.

Nyn´ı chv´ıli máme vytvoˇreny a inicializovány vˇsechny potˇrebné objekty a m ˚uˇzeme zaˇc´ıt pracovat se samotn ým polem. Vstupn´ı soubor pole naˇcteme metodou Open() (ˇrádek ˇc. 21), kde jako parametry uvedeme název otev´ıraného souboru, dále logickou hodnotu, má-li b ýt dan ý soubor otevˇren jen pro ˇcten´ı a velikost vyrovnávac´ı pamˇeti v poˇctech blok ˚u. Dalˇs´ı metodou OpenContext() (ˇrádek ˇc. 23) otevˇru kontext daného pole na indexu a pozici, které mi urˇcuj´ı prvn´ı dva parametry. Zde je to logicky zaˇcátek celého pole. Dále v jednoduchém cyklu vypisuji vˇsechny vektory a jejich jednotlivé prvky ze souboru per-zistentn´ıho pole, dokud kontext nedojde na jeho konec. Metodou Advance() (ˇrádek ˇc. 29) posunu kontext z aktuáln´ıho vektoru vˇzdy o jeden dále, pokud kontext dojde na ko-nec souboru, vrac´ı metoda logickou hodnotu false. Po ukonˇcen´ı práce s kontextem staˇc´ı zavolat metodu CloseContext() (ˇrádek ˇc. 31), obdobnˇe zavoláme po skonˇcen´ı práce s per-zistentn´ım polem metodu Close() (ˇrádek ˇc. 32).

Nyn´ı se jiˇz pod´ıvejme na samotn ý zdrojov ý k ód:

1 void Ukazka::Vypis ze souboru(){

2

3 typedef cNTreeTuple NoEncodeType Type;

4 typedef cPersistentArrayNode VarLen<Type> tNode;

5 typedef cPersistentArray VarLen<Type, tNode> tPersistentArray;

6

7 cNTreeSpaceDescriptor ∗popisovac =new cNTreeSpaceDescriptor(10, new cUIntType());

8

9 cPersistentArrayHeader VarLen<Type> ∗hlavicka =

10 new cPersistentArrayHeader VarLen<Type>(

11 new cNTupleSizeInfo(popisovac),

12 tNode::GetNodeExtraSize(), 13 4096);

14

15 tPersistentArray ∗pole =new tPersistentArray(hlavicka) ;

16

(33)

18 new cPersistentArrayContext VarLen<Type>(hlavicka); 19 20 21 pole−>Open(”Output.dat”,true, 8); 22 23 pole−>OpenContext(0, 0, kontext); 24 25 do{ 26 27 kontext−>GetItem()−>Print(”\n”); 28 29 }while(pole−>Advance(kontext)); 30 31 pole−>CloseContext(kontext); 32 pole−>Close(); 33 34 delete pole; 35 delete kontext; 36 delete hlavicka; 37 delete popisovac; 38 39 }

V ýpis 1: Ukázka v ýpisu vektor ˚u ze souboru perzistentn´ıho pole V ýpis z uvedeného zdrojového k ódu bude podobn ý tomuto:

(34, 8, 28, 68, 3, 29),realSize: 6 (0, 51, 70, 19, 8, 18, 16, 14, 99, 17),realSize: 10 (1, 23, 71, 36, 61, 57, 77, 16),realSize: 8 (79, 72, 77, 34, 69, 12, 1, 70, 55, 41),realSize: 10 (1, 39, 80, 81, 24, 90, 94, 82, 94, 91),realSize: 10 (2, 35, 9, 81, 11, 92, 30),realSize: 7

V ýpis 2: V ýstup z metody v ýpisu vektor ˚u ze souboru perzistentn´ıho pole

Na druhém pˇr´ıkladu si ukáˇzeme jednoduché vkládán´ı vektor ˚u do souboru. Vyuˇzijeme typy a objekty popsány v pˇr´ıkladˇe 1, novˇe nám pˇribyde objekt prvek (ˇrádek ˇc. 20), kter ý zde pˇredstavuje vektor ukládan ý do perzistentn´ıho pole. Jako parametr kontruktoru zde pˇredávám hlaviˇcku perzistentn´ıho pole.

Nov ý soubor perzistentn´ıho pole vytvoˇr´ıme metodou Create() (ˇrádek ˇc. 18), kde jako parametry vloˇz´ıme název souboru, kter ý se má vytvoˇrit a velikost vyrovnávac´ı pamˇeti v poˇctech blok ˚u. Metodou SetValue() (ˇrádek ˇc. 24) nastavujeme jednotlivé poloˇzky vek-toru, zde neznaménková celá ˇc´ısla. Prvn´ım parametrem metody je pozice ve vekvek-toru, kterou chceme nastavit, t´ım druh ým pak samotná hodnota. Metoda AddItem() (ˇrádek ˇc. 28) pak vytvoˇren ý prvek uloˇz´ı do perzistentn´ıho pole. Tato metoda vrac´ı index a po-zici právˇe vloˇzeného prvku, tˇret´ım parametrem je prvek, kter ý chceme vloˇzit. Pro v ýpis prvku slouˇz´ı metoda Print() (ˇrádek ˇc. 29), kde vloˇzen ý parametr pln´ı funkci oddˇelovaˇce. Stejnˇe jako pˇri ˇcten´ı z pole je tˇreba jej po ukonˇcen´ı práce zavˇr´ıt metodou Close() (ˇrádek ˇc. 33).

(34)

26

Tento k ód vytvoˇr´ı perzistentn´ı pole o 10 prvc´ıch, kde na nultou pozici uloˇz´ı jeho poˇrad´ı od 0 a na dalˇs´ıch pozic´ıch postupnˇe ukládá druhé mocniny aˇz do hodnoty aktuáln´ı pozice. V ýsledek bude zapsán v souboru mojepole.dat.

1 void Ukazka::Zapis do souboru(){

2

3 typedef cNTreeTuple NoEncodeType Type;

4 typedef cPersistentArrayNode VarLen<Type> tNode;

5 typedef cPersistentArray VarLen<Type, tNode> tPersistentArray;

6

7 unsigned int index, pozice;

8 cNTreeSpaceDescriptor ∗popisovac =new cNTreeSpaceDescriptor(10, new cUIntType());

9

10 cPersistentArrayHeader VarLen<Type> ∗hlavicka =

11 new cPersistentArrayHeader VarLen<Type>(

12 new cNTupleSizeInfo(popisovac),

13 tNode::GetNodeExtraSize(), 14 4096);

15

16 tPersistentArray ∗pole =new tPersistentArray(hlavicka) ;

17

18 pole−>Create(”mojepole.dat”, 8); 19

20 cNTreeTuple ∗prvek =new cNTreeTuple(popisovac);

21

22 for(unsigned int i=0; i <10; i++){

23 for(unsigned int j=1; j<=i; j ++){

24 prvek−>SetValue(0, i); 25 prvek−>SetValue(j, j∗j); 26 }

27

28 pole−>AddItem(index, pozice, ∗prvek); 29 prvek−>Print(”\n”); 30 prvek−>Clear(); 31 } 32 33 pole−>Close(); 34 35 delete prvek; 36 delete pole; 37 delete hlavicka; 38 delete popisovac; 39 40 }

V ýpis 3: Ukázka zápisu vektor ˚u do souboru perzistentn´ıho pole V ýpis z uvedeného zdrojového k ódu bude následuj´ıc´ı:

() ,realSize: 0 (1, 1),realSize: 2 (2, 1, 4),realSize: 3 (3, 1, 4, 9),realSize: 4 (4, 1, 4, 9, 16),realSize: 5 (5, 1, 4, 9, 16, 25),realSize: 6

(35)

(6, 1, 4, 9, 16, 25, 36),realSize: 7 (7, 1, 4, 9, 16, 25, 36, 49),realSize: 8 (8, 1, 4, 9, 16, 25, 36, 49, 64),realSize: 9 (9, 1, 4, 9, 16, 25, 36, 49, 64, 81),realSize: 10

V ýpis 4: V ýstup z metody v ýpisu vektor ˚u ze souboru perzistentn´ıho pole

Jak lze vidˇet z pˇredchoz´ıch pˇripad ˚u, samotná práce s perzistentn´ım polem je intu-itivn´ı a velice podobné práci s bˇeˇzn ými soubory. Pˇri vytváˇren´ı pol´ı a potˇrebn ých typ ˚u je dobré b ýt pozorn ý a pˇr´ıpadnou alokaci prvk ˚u provádˇet mimo ˇcasto pouˇz´ıvané me-tody. Uˇsetˇr´ıme tak nemalé mnoˇzstv´ı pamˇeti, jelikoˇz C++ nemá tak propracovanou správu pamˇeti jako modernˇejˇs´ı jazyky jako C# nebo Java. Napˇr. opakovanou alokaci jednoho prvku v cyklu ˇreˇs´ı alokac´ı nového m´ısta na haldˇe a pamˇet’ potˇrebná k alokaci jednoho prvku tak m ˚uˇze v extrémn´ım pˇr´ıpadˇe nar ˚ust na souˇcin velikosti prvku a délky cyklu!

(36)

(37)

5 Anal ´yza a n ´avrh komponenty pro extern´ı tˇr´ıd ˇen´ı prvk ˚

u

5.1 Specifikace poˇzadavk ˚u

M ým úkolem bylo navrhnout a implementovat komponentu pro tˇr´ıdˇen´ı prvk ˚u ze struk-tury perzistentn´ıho pole vyuˇz´ıvaj´ıc´ı jen pˇredem definovanou velikost hlavn´ı pamˇeti. Po prostudován´ı teorie t ýkaj´ıc´ı se tˇr´ıdˇen´ı dat na extern´ım úloˇziˇsti jsem musel vz´ıt v potaz samotná data, nad kter ými bude pozdˇeji algoritmus bˇeˇzet. Jelikoˇz jde o data s relativnˇe velk ým hodnotov ým rozsahem, zvolil jsem ve své implementaci k algoritmu pro tˇr´ıdˇen´ı dat na extern´ım úloˇziˇsti, extern´ımu mergesortu, optimalizaci posloupnosti spotˇreby, viz. kapitola 3.3. Prvn´ı fáze algoritmu vyuˇz´ıvá schéma naˇcti-setˇrid’-uloˇz popsané v kapitole 3.2.1.

Celou komponentu bylo nutno navrhnout obecnˇe, jelikoˇz komponenta perzistentn´ıho pole je navrhnována pro mnoˇzstv´ı typ ˚u, kde kaˇzd ý z nich rozˇsiˇruje základn´ı tˇr´ıdu typu o metody nutné ke správnému chodu konkrétn´ıho typu. Mnou navrˇzená komponenta tedy mus´ı umˇet tˇr´ıd´ıt typy rozˇsiruj´ıci základn´ı tˇr´ıdu cDataType, jin ými slovy, tˇr´ıdˇen ý typ bude mou tˇr´ıdu parametrizovat.

Komponenta mus´ı spl ˇnovat:

• Tˇr´ıdit prvky rozˇsiˇruj´ıc´ı tˇr´ıdu cDataType, resp. jej´ıho potomka cBasicType. • Pˇri tˇr´ıdˇen´ı pouˇz´ıvat jen pˇredem zn´amou velikost hlavn´ı pamˇet’i.

• Komponentu optimalizovat pro reálná data, nad kter ými bude bˇeˇzˇet.

• Pro testován´ı implementovat metodu pro naˇc´ıtán´ı dat z textového souboru, dále vhodn ým zp ˚usobem umoˇznit zadávat jednotlivé parametry tˇr´ıdˇen´ı.

Jako omezen´ı se aˇz v pr ˚ubˇehu implementace ukázala b ýt nesprávnˇe pracuj´ıc´ı vy-rovnávac´ı pamˇet perzistentn´ıho pole, kv ˚uli které bylo nutno úplnˇe odstranit rekurzi ve druhé ˇcásti mergesortu a nahradit ji upraven ým nerekurzivn´ım algoritmem. Bylo tedy nutno upravit anal ýzu a následnou imlementaci tak, abych se tomuto problému vyva-roval. I tak jsem se ale nevyhnul omezen´ı v podobˇe nadmˇernˇe nar ˚ustaj´ıc´ıch nároc´ıch na dalˇs´ı hlavn´ı pamˇet’ pˇri bˇehu v ýsledné aplikace.

Dostupná pamˇet’ pˇredstavuje pro algoritmus v prvn´ı ˇcásti mnoˇzstv´ı hlavn´ı pamˇeti (v bloc´ıch definovan ých pˇri vytváˇren´ı hlaviˇcek pole, viz ˇrádek 9 ve zdrojovém k ódu 1) pouˇzitou ke tˇr´ıdˇen´ı jednotliv ých skupin. Velikost skupin v prvn´ı fázi algoritmu je tedy rovna velikosti dostupné hlavn´ı pamˇeti. Ve druhé fázi nám velikost hlavn´ı pamˇeti definuje maximáln´ı poˇcet skupin otevˇren ých souˇcasnˇe pˇri bˇehu slévac´ı ˇcásti algotimu. Vstupn´ı a v ýstupn´ı zásobn´ık o kter ých jsme mluvili v úvodu zde nejsou potˇreba, tuto reˇzii za nás ˇreˇs´ı samotné perzistentn´ı pole.

5.2 Specifikace pomoc´ı pˇr´ıpadu uˇzit´ı

Diagram pˇr´ıpadu uˇzit´ı, tzv. Use Case, nám popisuje, jak aktéˇri, stoj´ıc´ı vnˇe systému, pra-cuj´ı s jednotliv ými funkcemi systému.

(38)

30

Obr´azek 3: Diagram pˇr´ıpadu uˇzit´ı syst´emu

V tomto pˇr´ıpadˇe jde o velice jednoduch ý model, kdy uˇzivatel, pracuj´ıc´ı se systémem, pouˇz´ıvá jen se samotnou komponentou pro testován´ı tˇr´ıdˇen´ı, která vyuˇz´ıvá tˇr´ıdy pro tˇr´ıdˇen´ı na extern´ım úloˇziˇsti a tˇr´ıdy perzistentn´ıho pole. Komponenty pro tˇr´ıdˇen´ı samozˇrejmˇe také vyuˇz´ıvaj´ı tˇr´ıdy perzistentn´ıho pole.

5.3 Tˇr´ıdn´ı diagram

Pomoc´ı tˇr´ıdn´ıho diagramu (Obrázek 4) je zde nast´ınˇena statická struktura systému prostˇrednictv´ım jednotliv ých tˇr´ıd a vzájemn ých vztah ˚u mezi nimi:

• SortArray je ˇsablona implementuj´ıc´ı samotné tˇr´ıdˇen´ı dat za pomoc´ı omezeného mnoˇzstv´ı hlavn´ı pamˇeti. Parametrizuje se konkrétn´ı typem, pˇredstavuj´ıc´ı tˇr´ıdˇen ý prvek, dˇed´ıc´ı ze tˇr´ıdy cBasicType. Jsou zde jednotlivé metody pro tˇr´ıdˇen´ı i dále po-psaná optimalizace.

• ˇsablona RunInfo slouˇz´ı k ukládán´ı údaj ˚u o jednotliv ých setˇr´ıdˇen ých skupinách vzni-kaj´ıc´ıch v prvn´ı ˇcásti algoritmu. Zaznamenává se zde index a pozice posledn´ıho

(39)

prvku skupiny, jej´ı maximáln´ı a minimáln´ı prvek a logickou hodnotu vypov´ıdaj´ıc´ı o pouˇzit´ı dané skupiny ve druhé ˇcásti algoritmu.

• tˇr´ıda ArrayTest je tˇr´ıdou pro testován´ı v ýˇse uveden ých tˇr´ıd, jej´ı souˇcást´ı je generátor náhodn ých vektor ˚u a naˇc´ıtán´ı textov ých soubor ˚u. Uˇzivatel s touto tˇr´ıdou komuni-kuje pˇres rozhran´ı pˇr´ıkazové ˇrádky, kde zadává odpov´ıdaj´ıc´ı parametry.

• tˇr´ıda cNTreeTuple NoEncodeType zde pˇredstavuje konkrétn´ı tˇr´ıdˇen ý prvek, jediná vazba na nˇej bude ze samotné testovac´ı tˇr´ıdy.

• ˇsablona cPersistentArrayNode VarLen pˇredstavuje vektor vkládan ý do perzistentn´ıho pole, parametrizuje se konkrétn´ım tˇr´ıdˇen ým typem.

• ˇsablona cPersistentArray VarLen odpov´ıdá jiˇz zmi ˇnovanému konkrétn´ımu perzis-tentn´ımu poli. Parametrizuje se konkrétn´ım tˇr´ıdˇen ým typem a jemu odpov´ıdaj´ıc´ım uzlem.

Uˇzivatel bude s aplikac´ı kominukovat prostˇrednictv´ım pˇr´ıkazové ˇrádky, kde bude zadávat potˇrebné parametry. Samotná tˇr´ıda ArrayTest v sobˇe zahrnuje jak generován´ı náhodn ých vektor ˚u dle uˇzivatelem zadan ých parametr ˚u, tak i naˇc´ıtán´ı textov ých sou-bor ˚u a jejich následné pˇreveden´ı do perzistentn´ıho pole tak, aby danou mnoˇzinu dat bylo moˇzno dále setˇr´ıdit. Setˇr´ıdˇen´ı perzistentn´ıho pole pak probˇehne zavolán´ım metody Sort() ze tˇr´ıdy SortArray s odpov´ıdaj´ıc´ımi parametry.

(40)

32

(41)

6 Implementace

C´ılem této kapitoly je popsat samotnou implementaci vycházej´ıc´ı z pˇredchoz´ı anal ýzy a návrhu, popsat nejd ˚uleˇzitˇejˇs´ı metody komponenty pro tˇr´ıdˇen´ı prvk ˚u na extern´ım úloˇziˇsti a jejich optimalizaci. Aplikace je naprogramována jako konzolová v jazyce C++, pˇredáván´ı informac´ı a pˇrep´ınaˇc ˚u je realizováno pomoc´ı voliteln ých parametr ˚u, kter ým se podrobnˇeji vˇenuji v pˇr´ıloze A.

V dalˇs´ıch kapitolách si pˇredstav´ıme implementované tˇr´ıdy, jejich v ýznam a nejd ˚uleˇzitˇejˇs´ı metody.

6.1 Tˇr´ıda ArrayTest

Tˇr´ıda ArrayTest slouˇz´ı k otestován´ı n´ıˇze popsan ých ˇsablon pro tˇr´ıdˇen´ı prvk ˚u na extern´ım úloˇziˇsti, obsahuje metodu main, která je po spuˇstˇen´ı aplikace volána. Pro optimáln´ı tes-tován´ı má uˇzivatel k dispozici jak vygenerován´ı náhodn ých vektor ˚u pole podle pˇredem nastaven ým parametr ˚u tak moˇznost naˇcten´ı textového souboru s jednotliv ými vektory, kde kaˇzd ý ˇrádek odpov´ıdá jednomu vektoru a prvky kaˇzdého vektoru jsou oddˇeleny ˇcárkou (dalˇsi popis je uveden v pˇr´ıloze A). Po vygenerován´ı, resp. naˇcten´ı dat, jsou vektory uloˇzeny do struktury perzistentn´ıho pole pˇripraveny na samotné tˇr´ıdˇen´ı. Ty-pem tˇr´ıdˇeného prvku parametrizujeme obˇe potˇrebné ˇsablony a voláme potˇrebné me-tody. Kromˇe názvu extern´ıho souboru perzistentn´ıho pole obsahuj´ıc´ı vektory ke tˇr´ıdˇen´ı a nˇekolika zadan ých parametr ˚u, jako je poˇcet vektor ˚u, jejich dimenze, typ tˇr´ıdˇeného prvku a velikost bloku perzistentn´ıho pole, je nutno pˇredat tˇr´ıdˇe SortArray také instanci po-tomka tˇr´ıdy cSizeInfo obsahuj´ıc´ı informace potˇrebné k v ýpoˇctu m´ısta podle zadanéh ých parametr ˚u a hlaviˇcku vytvoˇreného perzistentn´ıho pole.

Nyn´ı si pop´ıˇseme nˇekteré d ˚uleˇzité metody tˇr´ıdy ArrayTest. Vˇsechny metody jsou popsány vygenerovanou programátorskou dokumentac´ı na pˇriloˇzeném CD.

6.1.1 Generov án´ı n áhodn ých dat

Metoda ArrayTest::Generate(cDataType *typ prvku, char *input file) je urˇcená ke generován´ı náhodn ých vektor ˚u, tedy vektor ˚u, které maj´ı náhodnou dimenzi od 1 do zadané ma-ximáln´ı dimenze a jejich prvky jsou náhodnˇe vygenerované od 0 do hodnoty globáln´ı konstanty MAX GEN, nastavené standardnˇe na 1000. Poˇcet vektor ˚u a jejich maximáln´ı dimenzi urˇcuj´ı globáln´ı promˇenné count a dim. V této metodˇe se také vytváˇr´ı hlaviˇcka perzistentn´ıho pole, která bude pouˇzita jako parametr tˇr´ıdy pro tˇr´ıdˇen´ı prvk ˚u.

Metoda m´a dva argumenty:

• prvn´ım je typ prvku, kter ´y bude pˇredstavovat jednotliv ´y prvek vektoru, jde o no-vou instanci potomka tˇr´ıdy cBasicType.

• t´ım druh ým je název souboru perzistentn´ıho pole, kter ý se vytvoˇr´ı touto metodou. Vkládán´ı náhodn ých dat prob´ıhá vˇzdy pro jeden prvek, ten je uloˇzen do struktury per-zistentn´ıho pole a poté vyprázdnˇen a t´ım pˇripraven pro dalˇs´ı plnˇen´ı.

(42)

34

6.1.2 Na ˇcten´ı dat z textov ´eho souboru

Metoda ArrayTest::GenerateFromTextFile(char *soubor, char *vstupni soubor) provád´ı naˇc´ıtán´ı vektor ˚u uloˇzen ých v textovém souboru do perzistentn´ıho pole. Nejprve jsou z prvn´ıho ˇrádku textového souboru naˇcteny údaje o konkrétn´ım typu tˇr´ıdˇen ých vektor ˚u, opˇet jde o jednoho z potomk ˚u tˇr´ıdy cBasicType, dále o maximáln´ı dimenzi vektor ˚u a nakonec o jejich celkovém poˇctu. Poté je podle naˇcteného typu zavolána pˇretypovaná metoda ArrayTest::LoadFromText(), která zajist´ı správné naˇcten´ı zbyl ých vektor ˚u do struktury per-zistentn´ıho pole.

Metoda vyˇzaduje dva argumenty:

• prvn´ı pˇredstavuje n´azev vstupn´ıho textov´eho souboru.

• druh ´y je vygenerovan ´y soubor struktury perzistentn´ıho pole, tedy vstupn´ı soubor pro tˇr´ıd´ıc´ı algoritmus.

6.2 Sablona RunInfoˇ

Jak jsme jiˇz popsali v kapitole Anal ýza a návrh, ˇsablona RunInfo slouˇz´ı k ukládán´ı in-formac´ı o jednotliv ých skupinách vznikaj´ıc´ıch v prvn´ı ˇcásti tˇr´ıd´ıc´ıho algoritmu. ˇSablona je parametrizována konkrétn´ım typem tˇr´ıdˇeného prvku a je poˇc´ıtáno, ˇze jedna instance bude pˇredstavovat popis jedné skupiny. Lokáln´ı promˇenné index a position zaznamenávaj´ı index a pozici posledn´ıho vloˇzeného prvku, logická hodnota used urˇcuje, zda jiˇz byla tato skupina pouˇzita ve druhé ˇcásti tˇr´ıd´ıc´ıho algoritmu a max a min pˇredstavuj´ıc´ı maximáln´ı a minimáln´ı prvek skupiny (tyto údaje se ukládaj´ı kv ˚uli pozdˇejˇs´ı optimalizaci). Pˇr´ıstup k tˇemto promˇenn ým je zapouzdˇren do metod Set a Get, maj´ıc´ıch standardn´ı konvenci, tedy napˇr. SetIndex() a GetIndex(). Pro jednoduˇsˇs´ı kop´ırován´ı cel ých ˇsablon je zde implemen-tován také operátor rovná se.

6.3 Sablona SortArrayˇ

Nyn´ı se koneˇcnˇe dostáváme k ˇsablonˇe, ˇreˇs´ıc´ı poˇzadované tˇr´ıdˇen´ı prvk ˚u na extern´ım úloˇziˇsti. Tato ˇsablona se, obdobnˇe jako ˇsablona RunInfo, parametrizuje konkrétn´ım ty-pem tˇr´ıdˇeného prvku. Z veˇrejn ých metod obsahuje kromˇe konstruktoru metodu Sort(), jej´ıˇz zavolán´ım dojde k postupnému spuˇstˇen´ı prvn´ı a druhé ˇcásti vnˇejˇs´ıho tˇr´ıd´ıc´ıho algo-ritmu.

Obˇe tyto ˇc´asti si podrobnˇe pop´ıˇseme.

6.3.1 Algoritmus pro vytvoˇren´ı setˇr´ıd ˇen ´ych skupin

Metoda pro vytvoˇren´ı setˇr´ıdˇen ých skupin implementovaná podle algoritmu naˇcti-setˇr´ıd’-uloˇz popsaného v kapitole 3.2.1 se jmenuje SortArray<TupleType>::MakeRuns( cPersisten-tArrayHeader VarLen<TupleType> *mHeader, unsigned int ram size, unsigned int count). Jej´ı argumenty jsou:

(43)

• hlaviˇcka perzistentn´ıho pole, kterou jsme dˇr´ıve vytvoˇrili, zde se pˇred´av´a hlaviˇcka z testovac´ı tˇr´ıdy ArrayTest.

• velikost dostupné hlavn´ı pamˇeti pro algoritmus, je definovaná poˇctem voln ých blok ˚u, kde jeden blok hlavn´ı pamˇeti odpov´ıdá velikosti jednomu bloku perzis-tentn´ıho pole. Je stejná pro prvn´ı i druhou fázi algoritmu. V této fázi velikost do-stupné hlavn´ı pamˇeti urˇcuje velikost jednotliv ých setˇr´ıdˇen ých skupin.

• posledn´ı poloˇzkou je poˇcet vektor ˚u, které vstupn´ı perzistentn´ı pole obsahuje. Metoda vrac´ı logickou 1, pokud algoritmus probˇehne korektnˇe a v jeho pr ˚ubˇehu ne-dojde k ˇzádné chybˇe, logickou nulu, pokud tomu tak nen´ı.

6.3.2 Algoritmus pro sl év án´ı setˇr´ıd ˇen ých skupin

Metoda zajiˇst’uj´ıc´ı sléván´ı setˇr´ıdˇen ých skupin implementovaná podle algoritmu vyuˇz´ıvaj´ıc´ıho k-cestn ý mergesort, popsan ý v kapitole 3.2, má název

SortArray<TupleType>::Merge( unsigned int ram size, char *vystupni soubor, bool use optimalization) a n´asleduj´ıc´ı argumenty:

• velikost dostupné hlavn´ı pamˇeti pro algoritmus, je definovaná poˇctem voln ých blok ˚u, kde jeden blok hlavn´ı pamˇeti odpov´ıdá velikosti jednomu bloku perzis-tentn´ıho pole. Je stejná pro prvn´ı i druhou fázi algoritmu. V této fázi velikost do-stupné hlavn´ı pamˇeti urˇcuje poˇcet najednou otevˇren ých skupin pro sléván´ı.

• dalˇs´ım parametrem je jméno v ýstupn´ıho souboru, jde o v ýsledn ý soubor obsahuj´ıc´ı setˇr´ıdˇené perzistentn´ı pole.

• posledn´ım parametrem je logická hodnota urˇcuj´ıc´ı, zdá má algoritmus vyuˇz´ıvat implementovanou optimalizaci.

Metoda vrac´ı, stejnˇe jako metoda implementuj´ıc´ı prvn´ı ˇcást tˇr´ıd´ıc´ıho algoritmu, logic-kou 1, pokud algoritmus probˇehne korektnˇe a v jeho pr ˚ubˇehu nedojde k ˇzádné chybˇe, logickou nulu, pokud tomu tak nen´ı.

Mimo algoritm ˚u pro samotné tˇr´ıdˇen´ı je zde i nˇekolik pomocn ých metod, at’ uˇz jde o metodu Quicksort(), vyuˇz´ıvanou pˇri tˇr´ıdˇen´ı ˇcásti prvk ˚u v hlavn´ı pamˇeti potˇrebnou v prvn´ı fázi tˇr´ıd´ıc´ıho algoritmu, nebo metodu Zformuj pole bin(), která novˇe vloˇzen ý prvek do pole index ˚u skupin binárnˇe zaˇrad´ı podle jeho velikosti na patˇriˇcné m´ısto v poli.

6.3.3 Optimalizace algoritmu pro sl év án´ı setˇr´ıd ˇen ých skupin

Optimalizace implementována ve druhé ˇcásti algoritmu pro tˇr´ıdˇen´ı na extern´ım úloˇziˇsti vyuˇz´ıvá prognostickou metodu, konkrétnˇe upravenou posloupnost spotˇreby, popsanou v kapitole 3.3.

Pˇri sléván´ı máme k dispozici pouze N stran volné hlavn´ı pamˇeti, znamená to, ˇze m ˚uˇzeme najednou otevˇr´ıt a slévat jen N skupin. Pokud se jedna ze vkládan ých skupin vyprázdn´ı, hledáme na jej´ı m´ısto jinou vyhovuj´ıc´ı skupinu. Nejprve z jeˇstˇe neslévan ých

(44)

36

Algoritmus 4: Pseudok ´od algoritmu naˇcti-setˇr´ıd’-uloˇz

Input: hlaviˇcka vstupn´ıho pole, velikost pamˇeti, poˇcet vektor ˚u vytvoˇr a inializuj potˇrebn´e promˇenn´e;

vstupn´ı soubor.otevˇri();

kontext.otevˇri(vstupn´ı soubor.zaˇc´atek()); v ´ystupn´ı soubor.vytvoˇr();

poˇcet prvk ˚u ve skupinˇe := (ram size * block size) / (dim * sizeof(typ)); poˇcet skupin := poˇcet vektor ˚u / poˇcet prvk ˚u ve skupinˇe;

if (poˇcet vektor ˚u % ((int)(ram size * block size) / (dim * sizeof(typ))) != 0) then

poˇcet skupin++;

vytvoˇr a inicializuj In desc[poˇcet skupin+1]; //popisovaˇc skupin

inicializuj pole[poˇcet prvk ˚u ve skupinˇe];

//pole pˇredstavuj´ıc´ı data z perzistentn´ıho pole v hlavn´ı pamˇeti i:=0;

p i:=0;

for do

pole[i++] = kontext.vrat’Prvek();

if kontext != vstupn´ı soubor.konec then if i == poˇcet prvk ˚u ve skupinˇe then

Quicksort(pole, 0, i);

for x:=0 to i do

v ´ystupn´ı soubor.pˇridej(pole[x]); Uloˇz informace o skupinˇe do In desc[p i]; i:=0; p i++; else Quicksort(pole, 0, i); for x:=0 to i do v ´ystupn´ı soubor.pˇridej(pole[x]); Uloˇz informace o skupinˇe do In desc[p i]; break;

kontext.zavˇri();

vstupn´ı soubor.zavˇri(); v ´ystupn´ı soubor.zavˇri(); smaˇz jiˇz nepotˇrebn´e objekty;

(45)

Algoritmus 5: Pseudok ód k-cestného sléván´ı bez rekurze

Input: velikost pamˇeti, v ýstupn´ı soubor vytvoˇr a inializuj potˇrebné promˇenné; Out poˇcet skupin := 0;

for do

vytvoˇr a inicializuj Out desc[poˇcet skupin]; vstup.otevˇri();

v ´ystup.vytvoˇr();

vytvoˇr a inicializuj pole kontext ˚u[poˇcet skupin+1]; i := 0;

dolni := 0; horni := 0;

Out poˇcet skupin := 0;

max = (velikost pamˇeti > poˇcet skupin)?poˇcet skupin:velikost pamˇeti;

repeat

vektor<unsigned int> pole sk;

for i:=dolni to horni do

inicializuj kontext In pole ctx[i];

In pole ctx[i].otevˇriKontext(zaˇc´atek it´e skupiny); pole sk.dejNaKonec(i);

In desc[i].NastavPouˇzit´ı(true);

if pole sk.velikost() == max then

break;

vyvtoˇr a inicializuj pole index ˚u skupin; dolni := pole sk[0];

horni := pole sk[pole sk.velikost()-1]; horni++;

setˇrid’ pole index ˚u skupin podle nejmenˇs´ıho prvku In pole ctx; Sl´evej skupiny();

uloˇz informace o v ´ysledn´e skupinˇe do Out desc[Out poˇcet skupin]; dolni := horni;

until horni != poˇcet skupin; vstup.zavˇri();

v ´ystup.zavˇri(); celk poˇcet++;

poˇcet skupin := Out poˇcet skupin; In desc = Out desc;

if Out poˇcet skupin == 1 then

break;

je-li posledn´ım v ýst. souborem soubor doˇcasn ý, naˇcti jej do souboru v ýst.; smaˇz jiˇz nepotˇrebné objekty;

(46)

38

Algoritmus 6: Pseudok ód metody Slévej() potˇrebné k algoritmu k-cestného sléván´ı bez rekurze

Input: Pole index ˚u skupin, In pole ctx, In desc, vstupn´ı a v ´ystupn´ı perz. pole mnoˇzstv´ı opakov´an´ı = 0;

poˇcet sk = pole sk.velikost();

for do

if je-li prvek ze skupiny uloˇzen´e na nult´em indexu v poli pole index ˚u skupin > neˇz

prvek ze skupiny uloˇzen´e na dalˇs´ım indexu then

bin´arnˇe zatˇrid’ prvek na nult´em indexu v poli pole index ˚u skupin pomoc´ı kontextu In pole ctx;

v ´ystup.pˇridej(prvek odpov´ıdaj´ıc´ı In pole ctx[pole index ˚u skupin[0]]);

if jde-li o prvn´ı prvek vloˇzen´y do skupiny then

uloˇz jej jako minimum;

if nen´ı-li prázdná skupina, ze které byl vloˇzen posledn´ı prvek then

posu ˇn kontext In pole ctx[pole index ˚u skupin[0]];

else

if m´a-li b´yt pouˇzita optimalizace then

Optimalizuj();

if byla nalezena optimalizace then

pokraˇcuj ve sl´ev´an´ı;

else

uloˇz posledn´ı prvek jako maximum skupiny; zavˇri kontext In pole ctx[pole index ˚u skupin[0]]; odeber ukonˇcenou skupinu z pole index ˚u skupin; poˇcet sk–;

if poˇcet sk == 0 then

break;

(47)

skupin vybereme ty, které maj´ı minimum vˇetˇs´ı nebo rovno naposledy vloˇzenému prvku, logicky nás zaj´ımaj´ı jen skupiny, které má cenu v aktuáln´ım bodˇe dále slévat. Z tˇechto skupin pak vyberemu tu, jej´ıˇz maximum má nejmenˇs´ı hodnotu.

Tento postup m ˚uˇze uˇsetˇr´ıt nˇekolik pr ˚uchod ˚u v druhé ˇcásti algoritmu, v ideáln´ım pˇr´ıpadˇe by sléván´ı probˇehlo jen v jednom pr ˚uchodu, v nejhorˇs´ım algoritmus probˇehne stejnˇe rychle, jako bez optimalizace.

Algoritmus 7: Pseudok ´od upraven´e posloupnosti spotˇreby

ve chv´ıli, kdy dojde k vyprázdnˇen´ı jedné ze vstupn´ıch skupin ve druhé ˇcásti algoritmu provádˇej:

ind dalˇs´ıho := -1;

for pp:=horni to poˇcet skupin do

if !In desc[pp].BylaPouˇzita() and In desc[pp].Minimum() >= posledn´ı vloˇzen´y prvek then

if pp == -1 then

maximum := In desc[pp].Maximum(); ind dalˇs´ıho := pp;

else if In desc[pp].Maximum() < maximum then

ind dalˇs´ıho := pp;

if ind dalˇs´ıho != -1 then

naˇcti na pozici posledn´ı vypr´azdnˇen´e skupiny skupinu s indexem ind dalˇs´ıho; vytvoˇr a otevˇri pro ni kontext;

In desc[ind dalˇs´ıho].BylaPouˇzita(true);

6.4 Pouˇzit ´e technologie a programov ´e vybaven´ı

• Pro v ývoj komponenty pouˇz´ıvám Visual Studio ve verzi 2008 od spoleˇcnosti Micro-soft. Jde o integrované v ývojové prostˇred´ı pro v ývoj aplikac´ı s podporou nˇekolika programovac´ıch jazyk ˚u, obsahuje propracovan ý editor k ódu podporuj´ıc´ı Intelli-Sense a refaktoring, v ýkonn ý debugger, grafick ý editor webov ých stránek, atd. • Pro modelován´ı systému pomoc´ı jazyka UML vyuˇz´ıvám nástroje Enterprise

Archi-tect od spoleˇcnosti Sparx Systems ve verzi 7.

• Aplikace byla vyv´ıjena a testov´ana na operaˇcn´ım syst´emu Windows XP s bal´ıkem SP3 spoleˇcnosti Microsoft.

(48)