analiza algoritmilor de sortare pe arhitecturi paralele
DESCRIPTION
Sursele: https://bitbucket.org/wooptoo/asapa/ Lucrarea completa: http://wooptoo.com/papers/Analiza_Algoritmilor_de_Sortare_pe_Arhitecturi_Paralele.pdfTRANSCRIPT
Analiza Algoritmilor de Sortare
pe Arhitecturi Paralele
Radu Potop
Scopul
● Prezentarea și analiza a unei serii de algoritmi de sortare
● Paralelizarea algoritmilor
● Obținerea de rezultate experimentale ale algoritmilor paraleli
● Construirea de algoritmi paraleli hibrizi
● Obținerea de rezultate experimentale ale algoritmilor hibrizi
Motivația
● Fascinația personală pentru algoritmi de sortare
● Dorința de a construi și rula astfel de algoritmi pe arhitecturi
paralele
● Dorința de a construi algoritmi de sortare hibrizi și de a descoperi
dacă aceștia oferă sporuri de performanță
● Metoda de cercetare - predominant experimental
Categorii de algoritmi de sortare
Dupa metoda generală de lucru:
● Inserție (insertion sort, shellsort, cyclesort)
● Selecție (selection sort, heapsort)
● Partiționare (quicksort, introsort)
● Interclasare (mergesort, timsort)
Am ales câțiva:
● Quicksort, Mergesort - divide et impera
● Selection sort, Heapsort
Quicksort, Mergesort
● Algoritmi recursivi
● Împart lista de intrare în sub-liste
● Rulează recursiv pe aceste sub-liste
● n=1 cazul de bază
● Apelurile => arbore de recurență
● Quicksort și Mergesort:
● Quicksort: cazul nefavorabil: - arborele de recurență devine
liniar
T(n)
T(n/2) T(n/2)
T(n/4) T(n/4) T(n/4) T(n/4)
T(1) T(1) T(1) T(1) T(1) T(1) T(1) T(1)
T (n/2k )
Ο(nlog (n ))
Ο(n2)
Paralelizarea algoritmilor
● Algoritmii "divide et impera" - pot fi paralelizați cel mai ușor
● Firele de execuție nu trebuie să se sincronizeze
● Nu facem paralelizarea în funcție de nr. de procesoare
● Paralelizare în funcție de nivelul de recurență
● La fiecare nivel de recurență putem lansa procese separate
● Arborele de procese se va suprapune arborelui de recurență al
algoritmului
Ο(np
log(np))
Paralelizarea algoritmilor
● N0 – nivelul rădăcină, apelul inițial al funcției
● N1 – rezultatul a apeluri ale funcției, fiecare pe câte o sub-listă
● N2 – rezultatul a apeluri, fiecare pe câte o sub-listă a nivelului
anterior
● La fiecare nivel putem lansa procese
N0
N1
N2
N3
21
2i
22
Paralelizarea algoritmilor
● Ne vom limita la N0 - N3, respectiv 1, 2, 4 și 8 procese
● După ce acest nivel e depășit, algoritmul la rula în mod secvențial
mai departe
● Între procese separate - comunicare (IPC) printr-un obiect de tip
coadă
● Obiectul coadă e accesibil de către procesul părinte și cei doi
copii ai săi (local)
● Între apeluri de funcție obișnuite - return
Rezultate experimentale - cum am testat
● Listă aleatoare, listă sortată crescător, listă sortată descrescător
● Fiecare algoritm a fost rulat de 10 ori pe fiecare listă de intrare
● Fiecare algoritm a fost rulat pe liste de 10.000 (10k), 100.000
(100k), 1.000.000 (1M) și 5.000.000 (5M) de elemente, nr nat.
● Rulați:
● în mod secvențial, pe 1 core
● în mod paralel 2 cores și 6 cores
● Comparați pentru corectitudine cu implementarea standard
Python (Timsort)
Rezultate experimentale – secvențial
● secvențial: Quicksort, Mergesort și Heapsort, 100k elemente
● Quicksort_first - depașește limita de recursivitate
quicksort_first quicksort_middle quicksort_avg3 quicksort_minmax mergesort heapsort0
200
400
600
800
1000
1200
1400
lista aleatoare lista sortata crescator lista sortata descrescator
ms
Rezultate experimentale – paralel
● Am selectat Quicksort_middle și Mergesort
● 2, 4 sau 8 procese pt. fiecare algoritm, 10k elemente, 2 cores
quicksort_middle, 2p mergesort, 2p quicksort_middle, 4p mergesort, 4p quicksort_middle, 8p mergesort, 8p0
200
400
600
800
1000
1200
lista aleatoare lista sortata crescator lista sortata descrescator
ms
Rezultate experimentale – paralel
● 10k elemente, 6 cores
● Diferențele sunt mult mai mici pe 6 cores
● Pe măsură ce lista de intrare devine mai mare diferențele dispar
quicksort_middle, 2p mergesort, 2p quicksort_middle, 4p mergesort, 4p quicksort_middle, 8p mergesort, 8p0
10
20
30
40
50
60
70
80
90
100
lista aleatoare lista sortata crescator lista sortata descrescator
ms
Rezultate experimentale – secvențial vs. paralel
● Eliminăm listele sortate crescător și descrecător. Random, 5M:
● Mergesort paralel vs. secvențial: 56404ms vs. 31698ms
● Quicksort paralel - performanțe slabe
quicksort_middlemergesort
quicksort_middle, 2pmergesort, 2p
quicksort_middle, 4pmergesort, 4p
quicksort_middle, 8pmergesort, 8p
0
10000
20000
30000
40000
50000
60000
70000
secvential 2 cores 6 cores
ms
Construirea algoritmilor hibrizi
● Compuși din doi algoritmi:
● unul de tip divide et impera
● unul secvențial
● Odată ce algoritmul principal trece de un anumit nivel va avea
performanțe slabe - overhead
● De la un anumit nivel vom trece la un algoritm secvențial
● Cel secvențial va avea performanțe mai bune pe liste mici
Construirea algoritmilor hibrizi
● Selection sort va avea performanțe mai bune pe liste de 1000 el.
● După 4000 elemente, performanțele sale se degradează
quicksort_middle mergesort heapsort selection0
1
2
3
4
5
6
7
8
9
lista aleatoare
ms
Construirea algoritmilor hibrizi
● Am ales nivelul de recurență 12,
Niveluri de recurență pt fiecare lungime
Lungimea listei sortate de sub-algoritm
10k≈213
100k≈217
1M≈220
5M≈222
212=4096
10k /4096≈2
100k /4096≈24
1M /4096≈244
5M /4096≈1220
Construirea algoritmilor hibrizi
Descrierea completă a algoritmului:
● până la nivelul 1, 2 sau 3 vom lansa procese separate (2, 4
respectiv 8)
● până la nivelul 12 vom rula algoritmul secvențial
● de la nivelul 12 vom rula sub-algoritmul pe liste mici
● dacă lista de intrare e mai mică de 4096, sub-algoritmul nu va
intra în funcțiune => algoritm adaptiv
Rezultate experimentale - algoritmi hibrizi
● Quicksort cu Heap și Selection
● Mergesort cu Heap și Selection
● 1M elemente, 2p
quicksortmergesort
quicksort Pmergesort P
quick_selection Hquick_heap H
merge_selection Hmerge_heap H
0
2000
4000
6000
8000
10000
12000
14000
16000
secvential 2 cores 6 cores
ms
Concluzii ale experimentelor
● Quicksort - rezultate slabe
● Mergesort - și mai rapid după hibridizare
● Mergesort cu selection sort - cel mai rapid:
● de 1.90 ori mai rapid decât mergesort secvențial în medie,
(2.14 max)
● de 1.10 ori mai rapid decât mergesort paralel simplu în
medie, (1.22 max)
● Varianta cu 4 procese - performanțe constante atât pe 2 cores cât
și pe 6 cores, varianta cu 2 procese dispusă la fluctuații
Concluzii și posibilități de îmbunătățire
● Am construit un algoritm paralel hibrid adaptiv
● Odată ce avem acest algoritm putem să-l implementăm pe
arhitecturi cum este CUDA:
● programe generale rulate pe GPU
● procesoare puternic paralele
● un nr. mare de cores (480)
● mai rapid decât CPU pt asemenea task-uri
Mulțumesc