mirror of
https://github.com/kuhyx/WUT_Computer_Science.git
synced 2026-07-04 15:03:08 +02:00
169 lines
9.7 KiB
TeX
169 lines
9.7 KiB
TeX
\documentclass[12pt]{article}
|
||
\usepackage[polish]{babel}
|
||
\usepackage{hyperref}
|
||
\hypersetup{
|
||
colorlinks=true,
|
||
linkcolor=blue,
|
||
filecolor=magenta,
|
||
urlcolor=blue,
|
||
pdfpagemode=FullScreen,
|
||
}
|
||
\usepackage{listings}
|
||
\lstset{
|
||
basicstyle=\ttfamily\small,
|
||
keywordstyle=\color{blue}\bfseries,
|
||
commentstyle=\color{green!60!black},
|
||
stringstyle=\color{red},
|
||
numbers=left,
|
||
numberstyle=\tiny,
|
||
stepnumber=1,
|
||
numbersep=5pt,
|
||
frame=lines,
|
||
breaklines=true,
|
||
captionpos=b
|
||
}
|
||
|
||
\title{Rozwiązanie układu równań liniowych iteracyjną metodą Richardsona \\
|
||
Sprawozdanie, Etap I}
|
||
\author{Kacper Górka, Krzysztof Rudnicki, Aleksandra Sobala}
|
||
\begin{document}
|
||
\maketitle
|
||
\section{Zadanie}
|
||
\paragraph{Metoda Richardsona}
|
||
Metoda Richardsona służy do iteracyjnego rozwiązywania systemów równań liniowych postaci $Ax = b$.
|
||
\\
|
||
Pojedyńcza iteracja wygląda następująco:
|
||
\[
|
||
x^{(k+1)} = x^{(k)} + \omega (b - Ax^{(k)})
|
||
\]
|
||
Gdzie $\omega$ to skalar wybrany tak by $x^{(k)}$ zbiegało
|
||
\paragraph{Wymagania}
|
||
Mieliśmy za zadanie stworzyć program rozwiązujący układ równań dla wygenerowanych
|
||
macierzy gęstych oraz dla macierzy rzadkich: \\
|
||
\href{https://sparse.tamu.edu/Nemeth/nemeth12}{nemeth12} \\
|
||
i \\
|
||
\href{https://sparse.tamu.edu/Grund/poli3}{poli3}
|
||
|
||
\section{Baza}
|
||
\paragraph{Generowanie i zapisywanie macierzy}
|
||
Macierze gęste są przez nas generowane przy użyciu biblioteki \textbf{numpy},
|
||
aby przyśpieszyć obliczenia zapewniamy \textbf{bewzględna dominację wierszową głównej przekątnej} i
|
||
upewniamy się że wygenerowana macierz jest \textbf{symetryczna i dodatnio określona} \\
|
||
Macierze są potem zapisywane do pliku w
|
||
formacie .npz, łącznie z ich wartościami własnymi, tak by
|
||
skrócić działanie programu i ujednolicić testy
|
||
\\ \null \\
|
||
Macierze nemeth12 i poli3 są pobierane ze strony podanej wyżej, dla macierzy nemeth12 aby spełnić
|
||
warunki stosowalności metody musieliśmy przemnożyć ją przez -1
|
||
\paragraph{Testy}
|
||
Do testów wykorzystujemy biblioteki \textbf{numpy} oraz \textbf{pytest} oraz wbudowane w Pythona
|
||
narzędzia do mierzenia czasu. \\
|
||
Sprawdzamy popawność naszych algorytmów poprzez porównanie naszych wyników z wynikami policzonymi przy
|
||
wykorzystaniu funkcji np.linalg.norm z biblioteki numpy. Jeżeli nasze rozwiązanie różni się od
|
||
rozwiązania numpy o mniej niż $8 \times 10^{-3}$ akceptujemy je jako poprawne \\
|
||
Zarówno wielkośc macierzy, jej typ i typ metody użytej do zrównoleglenia Richardsona jest podawana jako
|
||
parametr testów, pozwala nam to łatwo dodawać nowe metody zrównoleglenia bez zmiany kodu testów.
|
||
\paragraph{Funkcje pomocnicze}
|
||
Wszelkie podstawowe metody operacji na macierzach takie jak mnożenie wektorów, macierzy itp,
|
||
napisaliśmy od zera, bez użycia zewnętrznych bibliotek, funkcje są zdefiniowane w pliku
|
||
\textbf{linear\_algebra\_utils.py}
|
||
\paragraph{Metoda Richardsona}
|
||
Metoda Richardsona jest zaimplementowana w pliku \textbf{richardson\_method.py}, sprowadza się ona do
|
||
pętli:
|
||
\begin{lstlisting}[language=Python, basicstyle=\ttfamily\small, breaklines=true, caption=Python Code for Iterative Solver]
|
||
for iteration in range(self.max_iterations):
|
||
Ax = self.LinAlg.matrix_vector_multiply(self.A, x)
|
||
residual = self.LinAlg.vector_vector_subtraction(self.b, Ax)
|
||
x = self.LinAlg.vector_vector_addition(
|
||
x,
|
||
self.LinAlg.scalar_vector_multiply(self.omega, residual)
|
||
)
|
||
if self.LinAlg.SequentialLinearAlgebraUtils.vector_norm(residual) < self.tol:
|
||
break
|
||
\end{lstlisting}
|
||
Dla różnych metod zrównoleglenia stosujemy różne implementacje podstawowych funkcji odpowiedzialnych za
|
||
mnożenie macierzy przez wektor, odejmowanie wektorów itp. Ponownie, dzięki temu możemy łatwo dodawać nowe
|
||
metody zrównoleglenia bez zmiany podstawowego kodu Richardsona
|
||
|
||
|
||
\section{Zrównoleglenie}
|
||
Wykorzystaliśmy 3 metody zrównoleglenia:
|
||
\begin{enumerate}
|
||
\item Tablice rozproszone
|
||
\item Wątki
|
||
\item Procesy
|
||
\end{enumerate}
|
||
\subsection{Procesy}
|
||
Aby wykonać obliczenia na wielu rdzeniach procesora \textbf{jednocześnie} wykorzystujemy model w którym różne
|
||
frakcje danych są przetwarzane przez oddzielne procesy. Dzięki temu dla dużych zbiorów danych możemy
|
||
znacznie zwiększyć wydajnośc obliczeń \\
|
||
W tym celu wykorzystujemy klasę \textbf{multiprocessing.Pool} z biblioteki \textbf{multiprocessing}.
|
||
Wykorzystujemy ją do stworzenia puli procesów które potem niezależnie wykonują funkcje na różnych frakcjach
|
||
danych.
|
||
\paragraph{Funkcje}
|
||
Procesy wykorzystujemy do:
|
||
\begin{enumerate}
|
||
\item Obliczenia iloczynu skalarnego - Metoda $dot\_product$ wykorzystuje pulę procesów do obliczenia iloczynów par elementów dwóch wektorów, a następnie sumuje te wyniki. Zrównoleglenie tej operacji jest korzystne, gdy mamy do czynienia z bardzo długimi wektorami.
|
||
\item Mnożenia macierzy przez wektor - $matrix\_vector\_multiply$, każdy wiersz macierzy jest mnożony przez wektor w osobnym procesie. Dzięki temu każde takie mnożenie może być przeprowadzane równolegle, co jest szczególnie efektywne dla macierzy o dużym rozmiarze.
|
||
\item Obliczenia normy wektora - Procesy są używane do obliczenia kwadratów poszczególnych elementów wektora, a następnie sumowanie tych wartości (także w procesach) umożliwia obliczenie pierwiastka kwadratowego z ich sumy, co daje normę wektora.
|
||
\item Działania na wektorach i macierzach - Działania takie jak dodawanie i odejmowanie wektorów, dzielenie wektora przez skalar, czy mnożenie macierzy przez skalar, są przeprowadzane w segmentach, gdzie każdy segment jest przetwarzany przez osobny proces.
|
||
\end{enumerate}
|
||
\paragraph{Wyzwania}
|
||
\begin{itemize}
|
||
\item Zarządzanie procesami jest kosztowne - tworzenie i zarządzanie procesami jest droższe od wątków ze względu na większy narzut systemowy.
|
||
\item Wymiana danych między procesami - wymaga serializacji i deserializacji danych, co może wprowadzić dodatkowe opóźnienia.
|
||
\item Brak korzyści dla małych danych - w przypadku małych macierzy, gdzie rozmiar nie przekracza 5 tysięcy x 5 tysięcy elementów, zarządzanie procesami i koszty komunikacji międzyprocesowej mogą przewyższać korzyści wynikające z równoległego przetwarzania,
|
||
\end{itemize}
|
||
|
||
\subsection{Wątki}
|
||
Do implementacji wątków użyto dwóch bibliotek, ThreadPoolExecutor która umożliwia zarządzanie pulą wątków i delegowanie zadań do wątków
|
||
w sposób równoległy oraz funkcji partial z biblioteki functools która pozwala na tworzenie częściowo zainicjalizowanych funkcji.
|
||
\paragraph{Funkcje}
|
||
Wątki zaimplementowano w mnożeniu macierzy przeez wektor, odejmowaniu wektorów, dodawaniu wektorów oraz mnożeniu wektora przez skalar, metody zostają
|
||
zrównoleglone poprzez podzielenie liczby wierszy macierzy między wątki, następnie ThreadPoolExecutor tworzy wątki i przekazuje im odpowiednie, niezależne
|
||
części pracy do wykonania.
|
||
\paragraph{Zalety}
|
||
Zalety wykorzystania wątków to przede wszystkim szybki czas tworzenia i niszczenia wątków przez system operacyjny w porównaniu do procesów.
|
||
Co więcej mają one dostęp do całej przestrzeni adresowej programu, co oszczędza niepotrzebne kopiowanie danych. Jedynie ich własny stos jest prywatny.
|
||
|
||
\subsection{Tablice rozproszone}
|
||
Tablice rozproszone dzielą macierz i przypisują każdą z jej części do konkretnego procesora.
|
||
Procesory wykonują obliczenia na danych przechowywanych w ich lokalnej pamięci, co minimalizuje konieczność przesyłania danych pomiędzy węzłami. \\
|
||
Tablice rozporoszone nie są natywnie wspierane przez Python-a, w związku z tym zostały zaimplementowane przy użyciu modułu array z biblioteki \textbf{dask}. \\
|
||
Wszystkie podstawowe funkcje wykorzystywane w Richardsonie zostały zrównoleglone przy użyciu tablic rozproszonych.
|
||
|
||
\paragraph{Wyzwania}
|
||
\begin{itemize}
|
||
\item Przy dużej zależności danych dochodzi do częstej komunikacji która obniża wydajnośc
|
||
\item Elementy tablicy należy dobrze zbalansować aby procesory były równo obciążone
|
||
\end{itemize}
|
||
|
||
\subsection{Wyniki}
|
||
\begin{table}[h!]
|
||
\centering
|
||
\begin{tabular}{|l|l|l|l|l|}
|
||
\hline
|
||
\textbf{Wielkość} & \textbf{Sekwencyjnie [s]} & \textbf{Procesy [s]} & \textbf{Wątki [s]} & \textbf{Tablice [s]} \\ \hline
|
||
2 & 7.784e-05 & 2.896e+00 & 9.772e-03 & 8.817e-02 \\ \hline
|
||
5 & 1.746e-04 & 3.897e+00 & 1.960e-02 & 9.443e-02 \\ \hline
|
||
10 & 6.769e-04 & 7.073e+00 & 2.895e-02 & 1.674e-01 \\ \hline
|
||
50 & 2.735e-02 & 2.153e+01 & 1.059e-01 & 4.899e-01 \\ \hline
|
||
100 & 1.195e-01 & 2.167e+01 & 2.067e-01 & 6.921e-01 \\ \hline
|
||
300 & 7.863e-01 & 2.363e+01 & 9.558e-01 & 7.461e-01 \\ \hline
|
||
500 & 2.206e+00 & 2.657e+01 & 2.494e+00 & 8.521e-01 \\ \hline
|
||
750 & 4.785e+00 & 2.939e+01 & 5.520e+00 & 9.408e-01 \\ \hline
|
||
1000 & 8.689e+00 & 3.259e+01 & 9.672e+00 & 1.201e+00 \\ \hline
|
||
5000 & 2.170e+02 & 9.077e+01 & 2.402e+02 & 1.368e+01 \\ \hline
|
||
10000 & 8.615e+02 & 2.378e+02 & 9.705e+02 & 4.643e+01 \\ \hline
|
||
\end{tabular}
|
||
\caption{Wyniki dla różnych zrównolegleń (procesy, wątki i tablice rozproszone)}
|
||
\label{tab:test_results_full}
|
||
\end{table}
|
||
|
||
|
||
|
||
|
||
|
||
|
||
\end{document}
|