Programowanie wsp bierzne i Marek Laskowski rok I INFns IIst, gr. 1 rozproszone niedziela, godz.

11:55 wiczenie 3: Zrwnoleglenie algorytmu sortowania. wiczenie wykonano w dniach: 12,19.12.2010 Sprawozdanie oddano dnia: 09.01.2011 ocena:

1. Cel i zakres wiczenia

Celem niniejszego wiczenia by o zbadanie i porwnanie szybko ci, sortowania ci gw liczbowych przy wykorzystaniu algorytmw sortowania b belkowego i quicksort w wersji sekwencyjnej oraz rwnoleg ej.

2. Wst p teoretyczny
Algorytm sortowania b belkowego Algorytm sortowania b belkowego, polega na porwnywaniu ze sob s siaduj cych elementw . Je eli element po lewej jest wi kszy, wtedy oba elementy zamieniamy miejscami. Ca y cykl powtarzamy tyle razy, ile elementw jest w tablicy, b d do momentu, gdy w danym przebiegu nie dokonamy adnej zamiany. Sortowanie poni szej tablicy,

przebiega nast puj co :

Sortowanie przebiega do momentu, gdy wszystkie elementy s uporz dkowane od najmniejszego do najwi kszego.

Algorytm sortowania quicksort Dzia anie algorytmu polega na wybraniu tzw. elementu osiowego tablicy, przeniesieniu mniejszych elementw na lew stron elementu osiowego, a wi kszych lub rwnych na praw stron . Nast pnie sortuje si pocz tkow i ko cow cze tablicy.

3. Algorytm sortowania b belkowego 3.1 Przebieg wiczenia

W trakcie wiczenia, zrealizowano sortowanie ci gw sk adaj cych si z elementw rozmieszczonych losowo, uporz dkowanych rosn co i malej co.

3.2 Tabele pomiarowe

Algorytm/Ilo elementw 100000 75000 50000 25000 Sekwencyjny 161,42 88,61 38 9,36 Rwnoleg y : 1 w tek 179,54 99,77 43,28 10,53 Rwnoleg y : 2 w tek 97,18 52,83 21,97 5,33 Rwnoleg y : 3 w tek 19,13 11,01 5,07 1,38 Rwnoleg y : 4 w tek 14,29 7,97 3,58 0,95
Tab.3.2.1 Zestawienie wynikw pomiarw szybko ci realizacji algorytmu. Elementy uporz dkowane losowo.

3 2 2 Zes e e y omiarw s y o ci realizacji algory mu. Eleme y uporz dkowane rosn co.
  # " !     

Tab.3.2.3 Zestawienie wynikw pomiarw szybko ci realizacji algorytmu. Elementy uporz dkowane malej co.

3.3 Obli

ni

W trakcie wyznaczania przyspieszenia algorytmu rwnoleg ego skorzystano z nast puj cego wzoru : (1) S przyspieszenie algorytmu rwnoleg ego, t1W czas wykonania zadania w systemie z jednym w tkiem, i ilo w tkw, tiW czas wykonania zadania w systemie z i-w tkami. W trakcie realizacji wiczenia obliczono przyspieszenia algorytmu rwnoleg ego, w tym celu skorzystano z wzoru (1) :

Ilo elementw Rwnoleg y : 1 w Rwnoleg y : 2 w Rwnoleg y : 3 w Rwnoleg y : 4 w

tek tek tek tek

100000 0,89 1,66 8,43 11,29

75000 0,88 1,67 8,04 11,11

(

50000 1,21 1,37 7,49 10,61

25000 0,87 1,72 6,78 9,85

Tab.3.3.1 Zestawienie wynikw oblicze przyspieszenia algorytmu. Elementy uporz dkowane losowo.

Algory m/Ilo elementw Sekwencyjny Rwnoleg y : 1 w tek Rwnoleg y : 2 w tek Rwnoleg y : 3 w tek Rwnoleg y : 4 w tek

100000 164 01 190 2 99 05 19 19 14 15

75000 90 92 105 8 53 1 11 01 8 01

50000 39 09 45 75 23 02 5 10 3 62

25000 9 56 11 29 5 63 1 39 0 94

e e e e

Algory lo ele Se e cyj y oleg y 1 oleg y 2 oleg y 3 oleg y 4

       

100000 99 11 108 26 54 72 18 53 13 89

75000 51 3 60 6 30 69 10 48 7 82

50000 21 89 26 44 13 38 4 64 3 48

25000 5 19 6 38 3 19 1 27 0 88

'

&% $

Ilo elementw Rwnoleg y : 1 w Rwnoleg y : 2 w Rwnoleg y : 3 w Rwnoleg y : 4 w

tek tek tek tek

100000 75000 50000 25000 0,91 0,84 0,82 0,81 1,81 1,67 1,63 1,62 5,34 4,89 4,71 4,08 7,13 6,56 6,29 5,89

Tab.3.3.2 Zestawienie wynikw oblicze przyspieszenia algorytmu. Elementy uporz dkowane rosn co.

Ilo elementw Rwnoleg y : 1 w Rwnoleg y : 2 w Rwnoleg y : 3 w Rwnoleg y : 4 w

tek tek tek tek

100000 75000 50000 25000 0,86 0,85 0,854 0,846 1,65 1,71 1,69 1,69 8,54 8,25 7,66 6,87 11,59 11,35 10,79 10,17

Tab.3.3.3 Zestawienie wynikw oblicze przyspieszenia algorytmu. Elementy uporz dkowane malej co.

3.4 Wykresy

Wyk.3.4.1 Czas realizacji operacji w zale no ci od u ytego algorytmu, liczby w tkw przetwarzaj cych zadanie oraz liczby elementw tablicy. Elementy uporz dkowane losowo.

Wyk.3.4.2 Czas realizacji operacji w zale no ci od u ytego algorytmu, liczby w tkw przetwarzaj cych zadanie oraz liczby elementw tablicy. Elementy uporz dkowane rosn co.

Wyk.3.4.3 Czas realizacji operacji w zale no ci od u ytego algorytmu, liczby w tkw przetwarzaj cych zadanie oraz liczby elementw tablicy. Elementy uporz dkowane malej co.

Wyk.3.4.4 Przyspieszenie w zale no ci od liczby w tkw przetwarzaj cych zadanie oraz liczby elementw tablicy. Elementy uporz dkowane losowo.

Wyk.3.4.5 Przyspieszenie w zale no ci od liczby w tkw przetwarzaj cych zadanie oraz liczby elementw tablicy. Elementy uporz dkowane rosn co.

Wyk.3.4.6 Przyspieszenie w zale no ci od liczby w tkw przetwarzaj cych zadanie oraz liczby elementw tablicy. Elementy uporz dkowane malej co.

3.5 Kod rd owy

//SORTOWANIE BABELKOWE //KOMPILACJA PROGRAMU: gcc sortowanie.c -fopenmp -o sortowanie //URUCHOMIENIE PROGRAMU: ./sortowanie #include <unistd.h> #include <stdio.h> #include <stdlib.h> #include <sys/times.h> #include <time.h> #include <math.h>

//zegar void doit(char *, clock_t ; void quicksort(double tab[], long x, long y ; void swap(int *a,int *b ;
)

int main(int argc, char *argv[] { //wskazniki tablicy

int **A; //zmienne wielkosci tablicy int N = 100000, M=1000; //zmienne indeksujace int i,j; //zmienne przechowujace czas clock_t start, end; struct tms t_start, t_end; //wlaczenie odmierzania czasu start = times(&t_start ; printf("Alokacja pamieci...\nwielkosc tablicy:\nA[%d]",N ; //alokacja pamieci A = (int** malloc(N * sizeof(int* ; for (i = 0; i < N; i++ { A[i] = (int* malloc( sizeof(int ; }
00 00 0 0 0 0 0 0

//wpisanie wartosci do tablicy for(i = 0; i < N; i++ A[i][0]=rand( % (M+1 ; //wylaczenie odmierzania czasu end = times(&t_end ; //wyswietlenie czasu inicjalizacji tablicy doit("\nCzas inicjalizacji tablicy", end - start ; //wlaczenie odmierzania czasu start = times(&t_start ; //sortowanie babelkowe - algorytm sekwencyjny for(j = 0; j < N; j++ for(i = 0; i < N - 1; i++ if(A[i][0] > A[i + 1][0] swap(&A[i][0],&A[i + 1][0] ; //wylaczenie odmierzania czasu end = times(&t_end ; doit("\nCzas wykonania przy uzyciu algorytmu sekwencyjnego", end - start ;
0 0 0 0 0 0 0 0 0 0 0

//wpisanie wartosci do tablicy for(i = 0; i < N; i++ A[i][0]=rand( % (M+1 ; //wlaczenie odmierzania czasu start = times(&t_start ;
1 1 1 1 1 1 1 1 1

#pragma omp parallel for shared(A,N private(i, j num_threads(1 for(j = 0; j < N; j++ for(i = 0; i < N - 1; i++ if(A[i][0] > A[i + 1][0] swap(&A[i][0],&A[i + 1][0] ;
1 1 1 1 1 1 1 1 1 1

//wylaczenie odmierzania czasu end = times(&t_end ; doit("\nCzas wykonania przy uzyciu algorytmu rownoleglego -1 watek", end - start ; //wpisanie wartosci do tablicy for(i = 0; i < N; i++ A[i][0]=rand( % (M+1 ; //rownolegly 2 watki start = times(&t_start ;
1 1 1 1

#pragma omp parallel for shared(A,N private(i, j num_threads(2 for(j = 0; j < N; j++ for(i = 0; i < N - 1; i++ if(A[i][0] > A[i + 1][0] swap(&A[i][0],&A[i + 1][0] ;
1 1 1 1 1

end = times(&t_end ; doit("\nCzas wykonania przy uzyciu algorytmu rownoleglego -2 watki", end - start ; //wpisanie wartosci do tablicy for(i = 0; i < N; i++ A[i][0]=rand( % (M+1 ; //rownolegly 3 watki start = times(&t_start ; #pragma omp parallel for shared(A,N private(i, j num_threads(3 for(j = 0; j < N; j++ for(i = 0; i < N - 1; i++ if(A[i][0] > A[i + 1][0] swap(&A[i][0],&A[i + 1][0] ; end = times(&t_end ;
1 1 1 1 1 1 1

1 1

doit("\nCzas wykonania przy uzyciu algorytmu rownoleglego -3 watki", end - start ; //wpisanie wartosci do tablicy for(i = 0; i < N; i++ A[i][0]=rand( % (M+1 ; //rownolegly 4 watki start = times(&t_start ; #pragma omp parallel for shared(A,N private(i, j num_threads(4 for(j = 0; j < N; j++ for(i = 0; i < N - 1; i++ if(A[i][0] > A[i + 1][0] swap(&A[i][0],&A[i + 1][0] ;
2 2 2 2 2 2 2 2 2 2 2 2 2

end = times(&t_end ; doit("\nCzas wykonania przy uzyciu algorytmu rownoleglego -4 watki", end - start ; // zwolnienie pamieci for (i = 0; i < N; i++ free(A[i] ; free(A ; return 0; } //funkcja obliczajac czas wykonania algorytmu void doit(char *str, clock_t time { long tps = sysconf(_SC_CLK_TCK ; printf("%s: %6.2f secs\n", str, (float time/tps ; }
2 2 2 2 2 2 2

4. Algorytm sortowania quicksort 4.1 Przebieg wiczenia

W trakcie wiczenia, zrealizowano sortowanie ci gw sk adaj cych si z elementw rozmieszczonych losowo. Ze wzgl du na dost pno sprz tu, zrwnoleglenie algorytmu dokonano na procesorze dwu rdzeniowym.

void swap(int* a,int* b { int c; c=*a; *a=*b; *b=c; }

10

4.2 Tabele pomiarowe

Algorytm/Ilo elementw 1000000 1100000 1200000 1300000 Sekwencyjny 0,32 0,35 0,38 0,41 Rwnoleg y : 1 w tek 0,32 0,35 0,39 0,41 Rwnoleg y : 2 w tek 0,23 0,22 0,26 0,27
Tab.4.2.1 Zestawienie wynikw pomiarw szybko ci realizacji algorytmu. Elementy uporz dkowane losowo.

4.3 Obliczenia
W trakcie wyznaczania przyspieszenia algorytmu rwnoleg ego skorzystano ze (1 i uzyskano nast puj ce wyniki : Ilo elementw 1000000 1100000 1200000 1300000 Rwnoleg y : 1 w tek 1 1 0,97 1 Rwnoleg y : 2 w tek 1,39 1,59 1,46 1,51
Tab.4.3.1 Zestawienie wynikw oblicze przyspieszenia algorytmu. Elementy uporz dkowane losowo.
3

4.4 Wykresy

Wyk.4.4.1 Czas realizacji operacji w zale no ci od u ytego algorytmu, liczby w tkw przetwarzaj cych zadanie oraz liczby elementw tablicy. Elementy uporz dkowane losowo.

11

Wyk.4.4.2 Przyspieszenie w zale no ci od liczby w tkw przetwarzaj cych zadanie oraz liczby elementw tablicy. Elementy uporz dkowane losowo.

4.5 Kod rd owy

//SORTOWANIE BABELKOWE i QUICKSORT //KOMPILACJA PROGRAMU: gcc quick2.c -fopenmp -o quick2 //URUCHOMIENIE PROGRAMU: ./quick2 #include <unistd.h> #include <stdio.h> #include <stdlib.h> #include <sys/times.h> #include <time.h> #include <math.h>

//zegar void doit(char *, clock_t ; void quicksort(double* tab, int N ; void quicksortMT(double* tab2, int N ; int main(int argc, char *argv[] { //zmienne wielkosci tablicy int N = 1000000, M=1000; //wskazniki tablicy double tablica[N];
4 4 4 4

12

//zmienne indeksujace int i,j; //zmienne przechowujace czas clock_t start, end; struct tms t_start, t_end; //wlaczenie odmierzania czasu start = times(&t_start ; printf("Alokacja pamieci...\nwielkosc tablicy:\nA[%d]\n",N ; //wpisanie wartosci do tablicy for(i = 0; i < N; i++ tablica[i]=rand( % (M+1 ; //wylaczenie odmierzania czasu end = times(&t_end ; //wyswietlenie czasu inicjalizacji tablicy doit("\nCzas inicjalizacji tablicy", end - start ; //wlaczenie odmierzania czasu start = times(&t_start ; //quicksort - algorytm sekwencyjny quicksort(tablica,N ; //wylaczenie odmierzania czasu end = times(&t_end ; doit("\nCzas wykonania przy uzyciu algorytmu sekwencyjnego", end - start ; //wpisanie wartosci do tablicy for(i = 0; i < N; i++ tablica[i]=rand( % (M+1 ; //wlaczenie odmierzania czasu omp_set_num_threads(1 ; start = times(&t_start ; quicksortMT(tablica,N ; end = times(&t_end ; doit("\nCzas wykonania przy uzyciu algorytmu rownoleglego -1 watek", end - start ; //wpisanie wartosci do tablicy for(i = 0; i < N; i++ tablica[i]=rand( % (M+1 ; //rownolegly 2 watki omp_set_num_threads(2 ; start = times(&t_start ; quicksortMT(tablica,N ; end = times(&t_end ;
5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5

13

doit("\nCzas wykonania przy uzyciu algorytmu rownoleglego -2 watki", end - start ; //wpisanie wartosci do tablicy for(i = 0; i < N; i++ tablica[i]=rand( % (M+1 ; //rownolegly 3 watki omp_set_num_threads(3 ; start = times(&t_start ; quicksortMT(tablica,N ; end = times(&t_end ; doit("\nCzas wykonania przy uzyciu algorytmu rownoleglego -3 watki", end - start ; //wpisanie wartosci do tablicy for(i = 0; i < N; i++ tablica[i]=rand( % (M+1 ; //rownolegly 4 watki omp_set_num_threads(4 ; start = times(&t_start ; quicksortMT(tablica,N ; end = times(&t_end ; doit("\nCzas wykonania przy uzyciu algorytmu rownoleglego -4 watki", end - start ; } //funkcja obliczajac czas wykonania algorytmu void doit(char *str, clock_t time { long tps = sysconf(_SC_CLK_TCK ; printf("%s: %6.2f secs\n", str, (float time/tps ; }
6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6

void quicksort(double* tab, int N { int i, j; double v,t; if(N <= 1 return;
6

// Partition elements v = tab[0]; i = 0; j = N; for(;; { while(i++ < N && tab[i] < v ; while(--j >= 0 && tab[j] > v ;
6 6 6

14

if(i >= j break; t = tab[i]; tab[i] = tab[j]; tab[j] = t; } t = tab[i-1]; tab[i-1] = tab[0]; tab[0] = t; quicksort(tab, i-1 ; quicksort(tab+i, N-i ; }
7 7 7 7

if(N <= 1 return; // Partition elements v = tab2[0]; i = 0; j = N; for(;; { while(i++ < N && tab2[i] < v ; while(--j >= 0 && tab2[j] > v ; if(i >= j break; t = tab2[i]; tab2[i] = tab2[j]; tab2[j] = t; } t = tab2[i-1]; tab2[i-1] = tab2[0]; tab2[0] = t; #pragma omp parallel sections { #pragma omp section quicksort(tab2, i-1 ; #pragma omp section quicksort(tab2+i, N-i ; } }
7 7 7 7 7 7

5. Wnioski
Algorytm sortowania b belkowego to najprostszy tego typu algorytm, ale niekoniecznie najefektywniejszy najlepiej sprawdza si podczas sortowania niewielkich ci gw i przy zrwnolegleniu z wykorzystaniem maksymalnej liczby w tkw. Implementacja zrwnoleglenia jest bardzo prosta - wystarczy zrwnoleglenie na poziomie zewn trznej p tli for. Natomiast algorytm quicksort jest niezwykle efektywny, dla d ugich ci gw. Niestety zrwnoleglenie nie zawsze dzia a tak jak powinno, a efekt, ze wzgl du na rekurencje wyst puj c w algorytmie, jest trudny do przewidzenia.

void quicksortMT(double* tab2, int N { int i, j; double v,t;

15

6. Literatura
[1] Praca zbiorowa pod redakcj A.Karbowski i E.Niewiadomska-Szynkiewicz, "Programowanie rwnoleg e i rozproszone , Warszawa 2009 OWPW [2] Bielecki W., "PRZETWARZANIE RWNOLEG E I ROZPROSZONE CZ. 1. Wydawnictwo Politechniki Szczeci skie

16