Analiza Algoritmilor de Sortare pe Arhitecturi Paralele

Analiza Algoritmilor de Sortare pe Arhitecturi Paralele

45d6aaf081e8041a8d8a530616f56651?s=128

Radu Potop

July 07, 2011
Tweet

Transcript

  1. Analiza Algoritmilor de Sortare pe Arhitecturi Paralele Radu Potop

  2. 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
  3. 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
  4. 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
  5. 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)
  6. 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 Ο( n p log( n p ))
  7. 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
  8. 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
  9. 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)
  10. 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 heapsort 0 200 400 600 800 1000 1200 1400 lista aleatoare lista sortata crescator lista sortata descrescator ms
  11. 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, 8p 0 200 400 600 800 1000 1200 lista aleatoare lista sortata crescator lista sortata descrescator ms
  12. 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, 8p 0 10 20 30 40 50 60 70 80 90 100 lista aleatoare lista sortata crescator lista sortata descrescator ms
  13. 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_middle mergesort quicksort_middle, 2p mergesort, 2p quicksort_middle, 4p mergesort, 4p quicksort_middle, 8p mergesort, 8p 0 10000 20000 30000 40000 50000 60000 70000 secvential 2 cores 6 cores ms
  14. 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
  15. 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 selection 0 1 2 3 4 5 6 7 8 9 lista aleatoare ms
  16. 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
  17. 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
  18. Rezultate experimentale - algoritmi hibrizi • Quicksort cu Heap și

    Selection • Mergesort cu Heap și Selection • 1M elemente, 2p quicksort mergesort quicksort P mergesort P quick_selection H quick_heap H merge_selection H merge_heap H 0 2000 4000 6000 8000 10000 12000 14000 16000 secvential 2 cores 6 cores ms
  19. 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
  20. 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
  21. Mulțumesc