diff --git a/DergunPiotr-WaskoDominik/zad5/dane/czas.jpg b/DergunPiotr-WaskoDominik/zad5/dane/czas.jpg
index c68ed9f..e42b418 100644
Binary files a/DergunPiotr-WaskoDominik/zad5/dane/czas.jpg and b/DergunPiotr-WaskoDominik/zad5/dane/czas.jpg differ
diff --git a/DergunPiotr-WaskoDominik/zad5/dane/przyspieszenie.jpg b/DergunPiotr-WaskoDominik/zad5/dane/przyspieszenie.jpg
index 8c9acaf..8a69020 100644
Binary files a/DergunPiotr-WaskoDominik/zad5/dane/przyspieszenie.jpg and b/DergunPiotr-WaskoDominik/zad5/dane/przyspieszenie.jpg differ
diff --git a/DergunPiotr-WaskoDominik/zad5/dane/wykres.gnuplot b/DergunPiotr-WaskoDominik/zad5/dane/wykres.gnuplot
index 0da603a..4d3aac5 100644
--- a/DergunPiotr-WaskoDominik/zad5/dane/wykres.gnuplot
+++ b/DergunPiotr-WaskoDominik/zad5/dane/wykres.gnuplot
@@ -1,7 +1,7 @@
 #set terminal x11
 set terminal jpeg
-set xrange [0:16]
-set yrange [0:7]
+set xrange [0:26]
+set yrange [0:16]
 
 set xlabel "Liczba watkow [n]"
 set ylabel "Przyspieszenie [n]"
@@ -13,7 +13,7 @@ plot \
 
 set out "czas.jpg"
 set ylabel "Czas obliczen [ms]"
-set yrange [0:16000]
+set yrange [0:4000]
 plot \
  "wyniki.txt" using 1:2 with points ls 3 lc rgb "red" title "czas", \
  "wyniki.txt" using 1:2 with lines ls 3 lc rgb "blue" notitle
\ No newline at end of file
diff --git a/DergunPiotr-WaskoDominik/zad5/dane/wyniki.txt b/DergunPiotr-WaskoDominik/zad5/dane/wyniki.txt
index 54eee6d..338e675 100644
--- a/DergunPiotr-WaskoDominik/zad5/dane/wyniki.txt
+++ b/DergunPiotr-WaskoDominik/zad5/dane/wyniki.txt
@@ -1,15 +1,25 @@
-1	13230	1.0
-2	6706	1.9729
-3	4462	2.965
-4	3344	3.9563
-5	2690	4.9182
-6	2271	5.8256
-7	2689	4.92
-8	2529	5.2313
-9	2459	5.3802
-10	2358	5.6107
-11	2348	5.6346
-12	2257	5.8618
-13	2351	5.6274
-14	2327	5.6854
-15	2310	5.7273
\ No newline at end of file
+1	2800	1.0
+2	1433	1.9539
+3	961	2.9136
+4	724	3.8674
+5	646	4.3344
+6	516	5.4264
+7	604	4.6358
+8	464	6.0345
+9	397	7.0529
+10	415	6.747
+11	386	7.2539
+12	364	7.6923
+13	382	7.3298
+14	253	11.0672
+15	279	10.0358
+16	271	10.3321
+17	278	10.0719
+18	235	11.9149
+19	266	10.5263
+20	229	12.2271
+21	212	13.2075
+22	226	12.3894
+23	248	11.2903
+24	190	14.7368
+25	347	8.0692
diff --git a/DergunPiotr-WaskoDominik/zad5/dok.tex b/DergunPiotr-WaskoDominik/zad5/dok.tex
index 444b3fe..f54a83a 100644
--- a/DergunPiotr-WaskoDominik/zad5/dok.tex
+++ b/DergunPiotr-WaskoDominik/zad5/dok.tex
@@ -60,37 +60,63 @@ Grupa 1 & Piotr Dergun, Dominik Waśko & \ddmmyyyydate\today \tabularnewline
 \end{tabular}
 
 
-\section*{Zadanie 4 - Rozmycie Gaussa w OpenMP}
+\section*{Zadanie 5 - Rozmycie Gaussa w MPI}
 
 Celem zadania jest wykonanie rozmycia obrazu za pomocą algorytmu  Gaussa o rozmiarze maski 5x5
 
 \begin{lstlisting}
-	#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];
+	for (i=0; i<ntasks; ++i)
+	{
+		chunk_order[i] = (i == 0) ? 0 : chunk_order[i-1] + chunk_sizes[i-1];
+		chunk_sizes[i] = porcja*img.cols*3;
+		
+		if (i == ntasks-1)
+			chunk_sizes[i] = (img.rows - porcja*(ntasks-1))*img.cols*3;
+	}
+	(...)
+	MPI::COMM_WORLD.Gatherv(&img_part_out.data[0], porcja*img.cols*3, MPI::CHAR, &img_out.data[0], chunk_sizes, chunk_order, MPI::CHAR, 0);
+\end{lstlisting}
+
+Problem jest dzielony w ten sposób, że każdy z procesów dostaje określoną ilość wierszy do przetworzenia (zmienna porcja). Porcja jest obliczania jako stosunek liczby wierszy do liczby procesów. Ostatni proces może przetwarzać inną liczbę procesów, wyrażoną jako różnicę liczby wierszy i iloczynu pozostałych wątków oraz porcji. Ze względu na to, ostatni proces może mieć mniej lub więcej wierszy do liczenia. Do odsyłania nowych obrazów posłużono się funkcją MPI\_Gatherv, która pozwala scalać kawałki różnej długości.
+
+\begin{lstlisting}
+	int start_pos = taskid*porcja;
+	int stop_pos = (taskid+1)*porcja;
+	(...)
+	for (i=start_pos; i<stop_pos; ++i)
+	{
+		q = 0;
+		for (j=0; j<img.cols; ++j)
+		{
+			if (i<2 || i>img.rows-3 || j<2 || j>img.cols-3)
+			{
+				img_part_out.at<Vec3b>(p, q)[0] = img.at<Vec3b>(i, j)[0];
+				img_part_out.at<Vec3b>(p, q)[1] = img.at<Vec3b>(i, j)[1];
+				img_part_out.at<Vec3b>(p, q)[2] = img.at<Vec3b>(i, j)[2];
 			}
-			else{
+			else
+			{
 				sumka_r = 0;
 				sumka_g = 0;
 				sumka_b = 0;
 				m=i-2;
-				for (k=0; k<RX; ++k,++m){
+				for (k=0; k<RX; ++k,++m)
+				{
 					n=j-2;
-					for (l=0; l<RY; ++l,++n){
+					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;
+				img_part_out.at<Vec3b>(p, q).val[0] = sumka_b / suma_wag;
+				img_part_out.at<Vec3b>(p, q).val[1] = sumka_g / suma_wag;
+				img_part_out.at<Vec3b>(p, q).val[2] = sumka_r / suma_wag;
 			}
+			++q;
 		}
+		++p;
 	}
 \end{lstlisting}
 
@@ -98,11 +124,9 @@ Zmienne \textit{i} oraz \textit{j}  służą do iteracji po wszystkich  pikselac
 
 Do wczytania obrazu użyto biblioteki OpenCV. 
 
-Zadanie zostało uruchomione na komputerze  MacPro3,1 wyposażonym w  2 procesory Xeon E5462, przy czym do dyspozycji było 6 rdzeni.  
-
-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. 
+Zadanie zostało uruchomione dla obrazu o rozmiarze 2592x13824 px, na klastrze składającym się z 3 komputerów MacPro3,1 z dwoma procesorami Xeon E5462 oraz z 3 komputerów iMac14,2 z procesorem i5-4570. Taka konfiguracja daje w sumie 30 rdzeni bez Hyper Threading. Na potrzeby tego zadania wykorzystano jednak tylko 24, ponieważ pozostałe rdzenie były wykorzystywane do innych obliczeń. Obliczenia przeprowadzono tworząc od 1 do 25 procesó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 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. 
+Rysunek 1 przedstawia wykres zależności przyspieszenia od ilości procesów. Można na nim zauważać że wzrost przyspieszenia uzyskuje się tylko do momentu gdy liczba procesów jest mniejsza lub równa ilości rdzeni. Powyżej 24 następuje już przetwarzanie współbieżne. Dla pewnych liczb procesów można zauważyć nierównomierne przyspieszanie, tzw. „schodki”. Jest to spowodowane tym, że synchronizacja sieciowa obejmuje kolejne maszyny, a czas obliczeń tak naprawdę jest czasem obliczeń najwolniejszej maszyny. W związku z tym, jeżeli któraś z maszyn chwilowo była zajęta przetwarzaniem innych informacji i zadanie cząstkowe na jakiejś maszynie liczyło się przez krótki okres czasu współbieżnie, zaważy to na stabilności czasów dla całego zadania. Rysunek 2. przedstawia wykres zależności czasu obliczeń od liczby procesów.  Można zobaczyć na nim, że powyżej 24 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.