Dodano dokumentcje

DergunPiotr-WaskoDominik/zad4/dok.tex

@@ -60,39 +60,49 @@ Grupa 1 & Piotr Dergun, Dominik Waśko & \ddmmyyyydate\today \tabularnewline
 \end{tabular}
 
 
-\section*{Zadanie 1 - Macierze OMP}
+\section*{Zadanie 4 - Rozmycie Gaussa w OpenMP}
 
-Celem zadania jest obliczenie iloczynu dwóch macierzy prostokątnych na konkretnej liczbie wątków (dane te podane jako parametry programu). Istotą problemu są trzy pętle, których złożoność obliczeniowa jest O($n^3$)
+Celem zadania jest wykonanie rozmycia obrazu za pomocą algorytmu  Gaussa o rozmiarze maski 5x5
 
 \begin{lstlisting}
-	#pragma omp parallel for default(none) shared(A, B, C) firstprivate(rozmiar)private(i, j)
-	for (i=0; i<rozmiar; ++i) 
-		for (j=0; j<rozmiar; ++j)
-		{
-			C[i][j] = 0;
-			for (long k=0; k<rozmiar; ++k)
-				C[i][j] += A[i][k]*B[k][j];
-		}	
+	#pragma omp parallel for private(i, j, k, l, m, n, sumka_r, sumka_g, sumka_b)
+	for (i=0; i<img.rows; ++i){
+		for (j=0; j<img.cols; ++j){
+			if (i<2 || i>img.rows-3 || j<2 || j>img.cols-3){
+				img_out.at<Vec3b>(i, j)[0] = img.at<Vec3b>(i, j)[0];
+				img_out.at<Vec3b>(i, j)[1] = img.at<Vec3b>(i, j)[1];
+				img_out.at<Vec3b>(i, j)[2] = img.at<Vec3b>(i, j)[2];
+			}
+			else{
+				sumka_r = 0;
+				sumka_g = 0;
+				sumka_b = 0;
+				m=i-2;
+				for (k=0; k<RX; ++k,++m){
+					n=j-2;
+					for (l=0; l<RY; ++l,++n){
+						sumka_b += ratio[k][l] * img.at<Vec3b>(m, n)[0]; 
+						sumka_g += ratio[k][l] * img.at<Vec3b>(m, n)[1]; 
+						sumka_r += ratio[k][l] * img.at<Vec3b>(m, n)[2]; 
+					}	
+				}
+				img_out.at<Vec3b>(i, j).val[0] = sumka_b / suma_wag;
+				img_out.at<Vec3b>(i, j).val[1] = sumka_g / suma_wag;
+				img_out.at<Vec3b>(i, j).val[2] = sumka_r / suma_wag;
+			}
+		}
+	}
 \end{lstlisting}
 
-Zmienna \textit{i} ma za zadanie przechodzić po wierszach macierzy wyjściowej, a zmienna \textit{j} - jej kolumnach. Za przemnażanie wszystkich elementów z wektora macierzy A (po wierszach) i wektora macierzy B (po kolumnach) odpowiedzialna jest wewnętrzna pętla.
+Zmienne \textit{i} oraz \textit{j}  służą do iteracji po wszystkich  pikselach obrazu. W przypadkach brzegowych tzn. 2 piksele od krawędzi obrazu,  piksele są pozostawiane bez zmian. Jest to spowodowane tym, że w przypadku tych pikseli nie można zastosować maski 5x5. Wartość pozostałych pikseli jest zmieniana przy pomocy algorytmu Gaussa.
 
-Poniższa dyrektywa:
-\begin{lstlisting}
-#pragma omp parallel for default(shared)  
-\end{lstlisting}
-oznacza, że wszystkie zmienne w przetwarzanym równolegle bloku kodu będą zmiennymi współdzielonymi, z wyjątkiem liczników pętli
+Do wczytania obrazu użyto biblioteki OpenCV. 
 
-Natomiast dyrektywa
-\begin{lstlisting}
-#pragma omp parallel for default(none) shared(A, B, C)
-firstprivate(rozmiar)private(i, j)
-\end{lstlisting}
-oznacza, że współdzielone będą wskaźniki tablic (A,C,B), zmienna   \textit{rozmiar} jest prywatna dla każdego wątki i gdy jest tworzona jest kopią zmiennej globalnej. Zmienne  \textit{i} i \textit{j} są prywatne.
+Zadanie zostało uruchomione na komputerze  MacPro3,1 wyposażonym w  2 procesor Xeon E5462, przy czym do dyspozycji było 6 rdzeni.  
 
-Program został skompilowany i uruchomiony z następującymi parametrami: macierz 1500x1500, ilość wątków 1-15, dla każdego wątku wykonano 10 powtórzeń. Z otrzymanych wyników obliczono przyspieszenie oraz średni czas liczenia macierzy. 
+Program został uruchomiony dla obrazu o rozmiarze AxB. Obliczenia przeprowadzono tworząc od 1 do 15 wątków, dla każdej ilości wykonano 10 powtórzeń. Z otrzymanych wyników obliczono przyspieszenie oraz średni czas obliczania rozmycia. 
 
-Rysunek 1 przedstawia wykres zależności przyspieszenia od ilości wątków. Można na nim zauważać że wzrost przyspieszenia uzyskuje się tylko do momentu gdy liczba wątków jest mniejsza lub równa 4. Spowodowane jest to tym, że komputer na którym obliczane było zadanie posiada procesor o 4 rdzeniach oraz wykorzystuje technologię HyperThreading która pozwala na prace w sumie ośmiu wątków. Rysunek 2. przedstawia wykres zależności czasu obliczeń od liczby wątków.  Można zobaczyć na nim, że powyżej 4 wątków czas obliczeń nie ulega już skróceniu. 
+Rysunek 1 przedstawia wykres zależności przyspieszenia od ilości wątków. Można na nim zauważać że wzrost przyspieszenia uzyskuje się tylko do momentu gdy liczba wątków jest mniejsza lub równa ilości rdzeni. Powyżej sześciu następuje już przetwarzanie współbieżne. Rysunek 2. przedstawia wykres zależności czasu obliczeń od liczby wątków.  Można zobaczyć na nim, że powyżej 6 wątków czas obliczeń nie ulega już skróceniu. 
 
 Z powyższych obserwacji wynika, że wykorzystanie większej liczby wątków pozwala znacząco skrócić czas wykonania programu. Jednak zwiększanie liczby wątków ponad to co oferuje procesor nie powoduje wzrostu wydajności i wymusza współbieżne liczenie.