HW3: RC4 - Final results and plots added to report

homework_3/analyse/RC4-8f44cbf/serial/slurm-1920504.out

@@ -0,0 +1,15 @@
+[Log]: Code version:   V's'
+[Log]: Array size:     1048576 (Q=20)
+[Log]: Repeated sorts: 3
+[Log]: GPU:            NVIDIA A100-SXM4-40GB
+[Log]: Block size:     1024
+[Log]: Initialize array ...  Done.
+[Log]: Start sorting    ...  Done.
+[Log]: Initialize array ...  Done.
+[Log]: Start sorting    ...  Done.
+[Log]: Initialize array ...  Done.
+[Log]: Start sorting    ...  Done.
+[Timing] Total   : 74 [msec]
+[Timing] Mem-xch : 0 [usec]
+[Timing] Sorting : 0 [usec]
+[Validation] Results validation ... [PASSED] 

homework_3/analyse/RC4-8f44cbf/serial/slurm-1920505.out

@@ -0,0 +1,15 @@
+[Log]: Code version:   V's'
+[Log]: Array size:     2097152 (Q=21)
+[Log]: Repeated sorts: 3
+[Log]: GPU:            NVIDIA A100-SXM4-40GB
+[Log]: Block size:     1024
+[Log]: Initialize array ...  Done.
+[Log]: Start sorting    ...  Done.
+[Log]: Initialize array ...  Done.
+[Log]: Start sorting    ...  Done.
+[Log]: Initialize array ...  Done.
+[Log]: Start sorting    ...  Done.
+[Timing] Total   : 154 [msec]
+[Timing] Mem-xch : 0 [usec]
+[Timing] Sorting : 0 [usec]
+[Validation] Results validation ... [PASSED] 

homework_3/analyse/RC4-8f44cbf/serial/slurm-1920506.out

@@ -0,0 +1,15 @@
+[Log]: Code version:   V's'
+[Log]: Array size:     4194304 (Q=22)
+[Log]: Repeated sorts: 3
+[Log]: GPU:            NVIDIA A100-SXM4-40GB
+[Log]: Block size:     1024
+[Log]: Initialize array ...  Done.
+[Log]: Start sorting    ...  Done.
+[Log]: Initialize array ...  Done.
+[Log]: Start sorting    ...  Done.
+[Log]: Initialize array ...  Done.
+[Log]: Start sorting    ...  Done.
+[Timing] Total   : 328 [msec]
+[Timing] Mem-xch : 0 [usec]
+[Timing] Sorting : 0 [usec]
+[Validation] Results validation ... [PASSED] 

homework_3/analyse/RC4-8f44cbf/serial/slurm-1920507.out

@@ -0,0 +1,15 @@
+[Log]: Code version:   V's'
+[Log]: Array size:     8388608 (Q=23)
+[Log]: Repeated sorts: 3
+[Log]: GPU:            NVIDIA A100-SXM4-40GB
+[Log]: Block size:     1024
+[Log]: Initialize array ...  Done.
+[Log]: Start sorting    ...  Done.
+[Log]: Initialize array ...  Done.
+[Log]: Start sorting    ...  Done.
+[Log]: Initialize array ...  Done.
+[Log]: Start sorting    ...  Done.
+[Timing] Total   : 689 [msec]
+[Timing] Mem-xch : 0 [usec]
+[Timing] Sorting : 0 [usec]
+[Validation] Results validation ... [PASSED] 

homework_3/analyse/RC4-8f44cbf/serial/slurm-1920508.out

@@ -0,0 +1,15 @@
+[Log]: Code version:   V's'
+[Log]: Array size:     16777216 (Q=24)
+[Log]: Repeated sorts: 3
+[Log]: GPU:            NVIDIA A100-SXM4-40GB
+[Log]: Block size:     1024
+[Log]: Initialize array ...  Done.
+[Log]: Start sorting    ...  Done.
+[Log]: Initialize array ...  Done.
+[Log]: Start sorting    ...  Done.
+[Log]: Initialize array ...  Done.
+[Log]: Start sorting    ...  Done.
+[Timing] Total   : 1441 [msec]
+[Timing] Mem-xch : 0 [usec]
+[Timing] Sorting : 0 [usec]
+[Validation] Results validation ... [PASSED] 

homework_3/analyse/RC4-8f44cbf/serial/slurm-1920509.out

@@ -0,0 +1,15 @@
+[Log]: Code version:   V's'
+[Log]: Array size:     33554432 (Q=25)
+[Log]: Repeated sorts: 3
+[Log]: GPU:            NVIDIA A100-SXM4-40GB
+[Log]: Block size:     1024
+[Log]: Initialize array ...  Done.
+[Log]: Start sorting    ...  Done.
+[Log]: Initialize array ...  Done.
+[Log]: Start sorting    ...  Done.
+[Log]: Initialize array ...  Done.
+[Log]: Start sorting    ...  Done.
+[Timing] Total   : 3028 [msec]
+[Timing] Mem-xch : 0 [usec]
+[Timing] Sorting : 0 [usec]
+[Validation] Results validation ... [PASSED] 

homework_3/analyse/RC4-8f44cbf/serial/slurm-1920510.out

@@ -0,0 +1,15 @@
+[Log]: Code version:   V's'
+[Log]: Array size:     67108864 (Q=26)
+[Log]: Repeated sorts: 3
+[Log]: GPU:            NVIDIA A100-SXM4-40GB
+[Log]: Block size:     1024
+[Log]: Initialize array ...  Done.
+[Log]: Start sorting    ...  Done.
+[Log]: Initialize array ...  Done.
+[Log]: Start sorting    ...  Done.
+[Log]: Initialize array ...  Done.
+[Log]: Start sorting    ...  Done.
+[Timing] Total   : 6293 [msec]
+[Timing] Mem-xch : 0 [usec]
+[Timing] Sorting : 0 [usec]
+[Validation] Results validation ... [PASSED] 

homework_3/analyse/RC4-8f44cbf/serial/slurm-1920511.out

@@ -0,0 +1,15 @@
+[Log]: Code version:   V's'
+[Log]: Array size:     134217728 (Q=27)
+[Log]: Repeated sorts: 3
+[Log]: GPU:            NVIDIA A100-SXM4-40GB
+[Log]: Block size:     1024
+[Log]: Initialize array ...  Done.
+[Log]: Start sorting    ...  Done.
+[Log]: Initialize array ...  Done.
+[Log]: Start sorting    ...  Done.
+[Log]: Initialize array ...  Done.
+[Log]: Start sorting    ...  Done.
+[Timing] Total   : 13.7 [sec]
+[Timing] Mem-xch : 0 [usec]
+[Timing] Sorting : 0 [usec]
+[Validation] Results validation ... [PASSED] 

homework_3/analyse/RC4-8f44cbf/serial/slurm-1920512.out

@@ -0,0 +1,15 @@
+[Log]: Code version:   V's'
+[Log]: Array size:     268435456 (Q=28)
+[Log]: Repeated sorts: 3
+[Log]: GPU:            NVIDIA A100-SXM4-40GB
+[Log]: Block size:     1024
+[Log]: Initialize array ...  Done.
+[Log]: Start sorting    ...  Done.
+[Log]: Initialize array ...  Done.
+[Log]: Start sorting    ...  Done.
+[Log]: Initialize array ...  Done.
+[Log]: Start sorting    ...  Done.
+[Timing] Total   : 27.17 [sec]
+[Timing] Mem-xch : 0 [usec]
+[Timing] Sorting : 0 [usec]
+[Validation] Results validation ... [PASSED] 

homework_3/analyse/RC4-8f44cbf/serial/slurm-1920513.out

@@ -0,0 +1,15 @@
+[Log]: Code version:   V's'
+[Log]: Array size:     536870912 (Q=29)
+[Log]: Repeated sorts: 3
+[Log]: GPU:            NVIDIA A100-SXM4-40GB
+[Log]: Block size:     1024
+[Log]: Initialize array ...  Done.
+[Log]: Start sorting    ...  Done.
+[Log]: Initialize array ...  Done.
+[Log]: Start sorting    ...  Done.
+[Log]: Initialize array ...  Done.
+[Log]: Start sorting    ...  Done.
+[Timing] Total   : 55.34 [sec]
+[Timing] Mem-xch : 0 [usec]
+[Timing] Sorting : 0 [usec]
+[Validation] Results validation ... [PASSED] 

homework_3/analyse/RC4-8f44cbf/serial/slurm-1920514.out

@@ -0,0 +1,15 @@
+[Log]: Code version:   V's'
+[Log]: Array size:     1073741824 (Q=30)
+[Log]: Repeated sorts: 3
+[Log]: GPU:            NVIDIA A100-SXM4-40GB
+[Log]: Block size:     1024
+[Log]: Initialize array ...  Done.
+[Log]: Start sorting    ...  Done.
+[Log]: Initialize array ...  Done.
+[Log]: Start sorting    ...  Done.
+[Log]: Initialize array ...  Done.
+[Log]: Start sorting    ...  Done.
+[Timing] Total   : 115.58 [sec]
+[Timing] Mem-xch : 0 [usec]
+[Timing] Sorting : 0 [usec]
+[Validation] Results validation ... [PASSED] 

homework_3/matlab/SortTime.m

@@ -0,0 +1,27 @@
+% MATLAB script to plot Sort execution times
+
+% Define Q values
+Q = 20:30;
+
+% Define Sort execution times (converted to milliseconds)
+sort_times = [
+    3.134, 4.105, 6.074,    14,    29,    59,   120,   256,   554,  1164,  2453;  % V0 - ampere
+    1.417, 2.193, 3.699, 8.329,    17,    37,    71,   153,   351,   742,  1556;  % V1 - ampere
+    1.574, 2.411, 4.134,  8.94,    19,    40,    76,   163,   372,   788,  1650;  % V2 - ampere
+    5.419,    10,    19,    40,    85,   181,   385,   826,  1762,  3765,  8034;  % V0 - tesla
+    3.418, 6.995,    14,    30,    64,   139,   300,   648,  1394,  2992,  6411;  % V1 - tesla
+    3.264, 6.728,    13,    29,    60,   129,   280,   606,  1308,  2815,  6048;  % V2 - tesla
+       15,    30,    66,   142,   305,   654,  1408,  3009,  6445, 13750,   NaN;  % V0 - gtx1650
+    6.666,    14,    31,    67,   139,   311,   689,  1539,  3358,  7428,   NaN;  % V1 - gtx1650
+    7.294,    15,    33,    70,   148,   328,   726,  1609,  3527,  7749,   NaN   % V2 - gtx1650
+];
+
+% Plot in log scale
+figure('Name', 'Results-SortTime', 'Position', [100, 100, 1600, 900]);
+semilogy(Q, sort_times', '-o', 'LineWidth', 1.5);
+grid on;
+xlabel('Q (Memory Size)');
+ylabel('Sort Execution Time (ms)');
+title('Sort time over memory size');
+legend({'V0 ampere', 'V1 ampere', 'V2 ampere', 'V0 tesla', 'V1 tesla', 'V2 tesla', 'V0 gtx1650', 'V1 gtx1650', 'V2 gtx1650'}, 'Location', 'northwest');
+saveas(gcf, 'sort_time_plot.png');

homework_3/matlab/SpeedUp.m

@@ -0,0 +1,34 @@
+% MATLAB script to plot Speedup (Serial Time / Total Time)
+
+% Define Q values
+Q = 20:30;
+
+% Define Serial execution times (converted to milliseconds)
+serial_times = [
+       74,   154,  328,   689, 1441, 3028, 6293, 13700,  27170,  55340, 115580];
+
+% Define Total execution times (converted to milliseconds)
+total_times = [
+    8.733,     12,   59,   37,   56,   98,   229,   420,   976,   1910,  3971;  % V0 - ampere
+    2.676,  6.308,   10,   18,   34,   83,   134,   331,   664,   1364,  2938;  % V1 - ampere
+    2.883,  5.861,   12,   21,   34,   86,   135,   331,   749,   1459,  3063;  % V2 - ampere
+    6.559,     12,   23,   49,  101,  210,   442,   939,  1986,   4211,  9071;  % V0 - tesla
+    4.559,  9.014,   18,   39,   80,  169,   358,   761,  1618,   3440,  7326;  % V1 - tesla
+    4.407,  8.751,   17,   38,   75,  159,   338,   719,  1533,   3262,  6932;  % V2 - tesla
+       16,     33,   71,  153,  327,  696,  1493,  3177,  6782,  14420,   NaN;  % V0 - gtx1650
+    8.271,     17,   37,   78,  161,  353,   774,  1709,  3701,   8106,   NaN;  % V1 - gtx1650
+    8.985,     18,   38,   81,  169,  370,   810,  1779,  3864,   8424,   NaN   % V2 - gtx1650
+];
+
+% Compute Speedup
+speedup = serial_times ./ total_times;
+
+% Plot in log scale
+figure('Name', 'Results-SpeedUp', 'Position', [100, 100, 1600, 900]);
+plot(Q, speedup', '-o', 'LineWidth', 1.5);
+grid on;
+xlabel('Q (Memory Size)');
+ylabel('Speedup (Serial / Total)');
+title('Speed up over memory size');
+legend({'V0 ampere', 'V1 ampere', 'V2 ampere', 'V0 tesla', 'V1 tesla', 'V2 tesla', 'V0 gtx1650', 'V1 gtx1650', 'V2 gtx1650'}, 'Location', 'northwest');
+saveas(gcf, 'speedup_plot.png');

homework_3/matlab/TotalTime.m

@@ -0,0 +1,29 @@
+% MATLAB script to plot Total execution times
+
+% Define Q values
+Q = 20:30;
+
+% Define Total execution times (converted to milliseconds)
+total_times = [
+       74,   154,   328,  689, 1441, 3028, 6293,13700,27170,55340,115580;  % Serial
+    8.733,     12,   59,   37,   56,   98,  229,  420,  976,  1910, 3971;  % V0 - ampere
+    2.676,  6.308,   10,   18,   34,   83,  134,  331,  664,  1364, 2938;  % V1 - ampere
+    2.883,  5.861,   12,   21,   34,   86,  135,  331,  749,  1459, 3063;  % V2 - ampere
+    6.559,     12,   23,   49,  101,  210,  442,  939, 1986,  4211, 9071;  % V0 - tesla
+    4.559,  9.014,   18,   39,   80,  169,  358,  761, 1618,  3440, 7326;  % V1 - tesla
+    4.407,  8.751,   17,   38,   75,  159,  338,  719, 1533,  3262, 6932;  % V2 - tesla
+       16,     33,   71,  153,  327,  696, 1493, 3177, 6782, 14420,  NaN;  % V0 - gtx1650
+    8.271,     17,   37,   78,  161,  353,  774, 1709, 3701,  8106,  NaN;  % V1 - gtx1650
+    8.985,     18,   38,   81,  169,  370,  810, 1779, 3864,  8424,  NaN   % V2 - gtx1650
+];
+
+% Plot in log scale
+figure('Name', 'Results-TotalTime', 'Position', [100, 100, 1600, 900]);
+
+semilogy(Q, total_times', '-o', 'LineWidth', 1.5);
+grid on;
+xlabel('Q (Memory Size)');
+ylabel('Total Execution Time (ms)');
+title('Total time over memory size');
+legend({'Serial', 'V0 ampere', 'V1 ampere', 'V2 ampere', 'V0 tesla', 'V1 tesla', 'V2 tesla', 'V0 gtx1650', 'V1 gtx1650', 'V2 gtx1650'}, 'Location', 'northwest');
+saveas(gcf, 'total_time_plot.png');

homework_3/report/homework_3_report.tex

@@ -151,7 +151,7 @@
 Για πίνακα μεγέθους $2^N$ ο αλγόριθμος συνοψίζεται στα εξής:
 \begin{itemize}
     \item Εκτελούνται $N$ ακολουθίες ανταλλαγών με αύξον αριθμό: $m = 1, 2,\dots,N$.
-    \item Η κάθε ακολουθία $m$ αποτελείται από ανταλλαγές μεταξύ γειτόνων, των οποίων η απόσταση ξεκινάει από $2^{m-1}$ και μειώνεται με διαδοχικές ακέραιες διαιρέσεις με το 2, εωσότου γίνει $1$: $2^{m-1}, 2^{m-2}, ..., 1$.
+    \item Η κάθε ακολουθία $m$ αποτελείται από ανταλλαγές μεταξύ γειτόνων, των οποίων η απόσταση ξεκινάει από $2^{m-1}$ και μειώνεται με διαδοχικές ακέραιες διαιρέσεις με το 2, εωσότου γίνει $1$ ($2^{m-1}, 2^{m-2}, ..., 1$).
     \item Οι ανταλλαγές χωρίζουν τα μεγαλύτερα και τα μικρότερα στοιχεία με στόχο στο τέλος της κάθε ακολουθίας τα στοιχεία του πίνακα να αποτελούν διαδοχικές διτονικές ακολουθίες.
     Μέτά την πρώτη ακολουθία ανταλλαγών να έχουμε $\frac{N}{2}$ διτονικές ακολουθίες, μετά την δεύτερη $\frac{N}{4}$ ακολουθίες και ούτω κάθε εξής, έως ότου στην τελευταία να έχουμε $\frac{N}{2N} = \frac{1}{2}$ διτονική, δηλαδή μια πλήρως ταξινομημένη λίστα.
 \end{itemize}
@@ -265,11 +265,11 @@ for (size_t stage = 1; stage <= Stages; ++stage) {
 Ενώ βέβαια αυτό φαντάζει \textbf{ειδυλλιακό}, θα πρέπει να τονίσουμε ότι για την συγκεκριμένη βελτιστοποίηση θα χρειαστούν αρκετές παραχωρήσεις.
 Για αυτό το λόγο είδαμε αυτή την λύση με \textbf{αρκετό σκεπτικισμό}.
 
-Τα βασικά βήματα που πρέπει να ακολουθήσουμε ώστε να χρησιμοποιήσουμε τη κοινή μνήμη είναι:
+Τα βασικά βήματα που πρέπει να ακολουθήσουμε ώστε να χρησιμοποιήσουμε την κοινή μνήμη είναι:
 \begin{itemize}
     \item \textbf{Αντιγραφή} των στοιχείων που ανταλλάσσονται από τα threads του block στη shared μνήμη.
     \item \textbf{Προσαρμογή της διευθυνσιοδότησης} των threads εντός του block ώστε να αντιστοιχούν στα όρια της shared μνήμης.
-    \item \textbf{Εκτέλεση} του αλγόριθμου της έκδοσης \textbf{V1} στην τοπική μνήμη με τις προσαρμοσμένες διευθύνσεις
+    \item \textbf{Εκτέλεση} του αλγόριθμου της έκδοσης \textbf{V1} στην κοινή μνήμη με τις προσαρμοσμένες διευθύνσεις
     \item \textbf{Αντιγραφή} των στοιχείων πίσω στη global μνήμη.
 \end{itemize}
 Το σχήμα \ref{fig:V2Addressing} παρουσιάζει αυτή την προσέγγιση.
@@ -277,7 +277,7 @@ for (size_t stage = 1; stage <= Stages; ++stage) {
 \par
 Βλέπουμε λοιπόν πως \textbf{ο αλγόριθμος είναι πρακτικά ο ίδιος}, απλώς \textbf{οι ανταλλαγές} στα βήματα εντός του block \textbf{λαμβάνουν χώρα στη shared μνήμη} αντί της global.
 Επίσης πολύ εύκολα μπορούμε να αντιληφθούμε πως οι απαιτήσεις σε shared μνήμη είναι δυο φορές το μέγεθος των blocks.
-Τη μνήμη αυτή τη δεσμεύουμε δυναμικά μέσω ορίσματος στον kernel \textit{inBlockStep<<<Nbl, Nth, kernelMemSize>>>()}.
+Τη μνήμη αυτή τη δεσμεύουμε δυναμικά μέσω ορίσματος στον kernel \textit{inBlockStep\texttt{<<<}Nbl, Nth, kernelMemSize\texttt{>>>}()}.
 \par
 Η αλλαγή για την δεύτερη έκδοση βρίσκεται επί της ουσίας στη συνάρτηση \textit{inBlockStep()}.
 Η συνάρτηση \textit{interBlockStep()} παραμένει ως έχει, καθώς εργάζεται με αποστάσεις μεγαλύτερες αυτών που χωρούν στη shared μνήμη που έχουμε δεσμεύσει για τα blocks.
@@ -289,10 +289,10 @@ for (size_t stage = 1; stage <= Stages; ++stage) {
 Το κάθε thread κάνει 2 αναγνώσεις και 2 εγγραφές, ενώ στην έκδοση V1 οι εγγραφές για παράδειγμα γίνονται μόνο όταν χρειάζεται.
 Επίσης η λογική που εκτελείται εντός thread είναι περισσότερη καθώς πρέπει να γίνουν οι αντιγραφές αλλά και η προσαρμογή των διευθύνσεων.
 Θα πρέπει λοιπόν το κέρδος από τις γρήγορες ανταλλαγές στη shared μνήμη να είναι πολύ μεγάλο, ούτως ώστε να αντισταθμίσουμε αυτό το κόστος.
-Αυτός είναι και ο λόγος που όπως αναφέραμε βλέπουμε τη 2η έκδοση με σκεπτικισμό.
+Αυτός είναι και ο λόγος που όπως αναφέραμε βλέπουμε την έκδοση V2 με σκεπτικισμό.
 
 \par
-Αρχικά για να διερευνήσουμε τις επιδόσεις εκτελέσαμε τοπικά σε μία GTX 1650 τις εκδόσεις και είδαμε ότι η 2η έκδοση υστερεί κατά τι.
+Αρχικά για να διερευνήσουμε τις επιδόσεις εκτελέσαμε τοπικά σε μία GTX 1650 τις εκδόσεις και είδαμε ότι η έκδοση V2 υστερεί κατά τι.
 Έπειτα επιβεβαιώσαμε τις ανησυχίες μας στη συστοιχία όπου στην ampere A100 πάλι η V2 ήταν πιο αργή και μόνο στην Tesla P100 πιο γρήγορη.
 Για να διαπιστώσουμε όμως επακριβώς τι συμβαίνει χρησιμοποιήσαμε το εργαλείο \href{\repoProf}{ncu} ώστε να πάρουμε το προφίλ των εκτελέσεων.
 Οι έξοδοι του εργαλείου είναι διαθέσιμοι στους καταλόγους RC1 και RC2 στο αποθετήριο της εργασίας \href{\repoAnalyse}{εδώ}.
@@ -314,7 +314,7 @@ for (size_t stage = 1; stage <= Stages; ++stage) {
         smsp inst executed.avg                           &        132k &  \trd{189k} &  +43.2\% \\
         smsp inst executed.sum                           &       8.46M & \trd{12.1M} &  +43.0\% \\
     \end{tabular}
-    \caption{Σύγκριση των εκδόσεων V1 και V2.}
+    \caption{Σύγκριση της inBlockStep() των εκδόσεων V1 και V2.}
     \label{tab:profiling_v1v2}
 \end{table}
 
@@ -338,13 +338,13 @@ for (size_t stage = 1; stage <= Stages; ++stage) {
 Αν και καταβάλαμε φιλότιμη προσπάθεια να μειώσουμε τις εντολές, τελικά αυτή η κατεύθυνση δεν μας οδήγησε πουθενά.
 Αντίθετά για τα άλλα δύο σημεία προσπαθήσαμε κάποιες λύσεις.
 
-\subsection{Ελαχιστοποίηση των αρχικών \textit{inBlockStep()} κλήσεων} \label{sec:Opt_prephase}
+\subsection{Ελαχιστοποίηση των αρχικών κλήσεων της \textit{inBlockStep()} - Prephase} \label{sec:Opt_prephase}
 
 Μια βελτιστοποίηση που σκεφτήκαμε και δεν έχει να κάνει με το shared memory optimization είναι ο αριθμός των \textit{inBlockStep()} στην αρχή του αλγόριθμου.
 Αν προσέξει κανείς το σχήμα \ref{fig:V1Unrolling} εύκολα θα παρατηρήσει πως στην αρχή του αλγόριθμου ο διπλός βρόχος περιέχει βήματα που χωράνε εξολοκλήρου στο block.
 Παρόλα αυτά γίνονται ξεχωριστές κλήσεις στην \textit{inBlockStep()} χωρίς να μεσολαβεί κάποια κλήση στην \textit{interBlockStep()}.
 Μπορούμε έτσι να \textbf{συνενώσουμε όλες αυτές τις πρώτες ξεχωριστές κλήσεις της \textit{inBlockStep()} σε μία συνάρτηση} η οποία δεν χρειάζεται να επιστρέφει παρά μόνο όταν τα βήματα του βρόχου φτάσουν να χρειαστεί να καλέσουν την πρώτη \textit{interBlockStep()}.
-Η συνάρτηση αυτή είναι η \textit{prephace()}.
+Η συνάρτηση αυτή είναι η \textit{prephase()}.
 \par
 Πριν αποδεχτούμε βέβαια αυτή τη βελτιστοποίηση έπρεπε πρώτα να την μετρήσουμε.
 Η έκδοση στην οποία δοκιμάστηκε αυτή η προσέγγιση είναι η RC2 και ο αναγνώστης μπορεί να τη βρει στο αποθετήριο της εργασίας.
@@ -419,14 +419,19 @@ for (size_t stage = 1; stage <= Stages; ++stage) {
 Το οποίο για πίνακα μεγέθους q=24 θα εκτελέσει την ταξινόμηση 5 φορές, θα ελέγξει την εγκυρότητά της και θα εκτυπώσει τον ενδιάμεσο χρόνο, χρησιμοποιώντας στην πρώτη εντολή την έκδοση v1 και στη δεύτερη την έκδοση v2 αλλά και block size 512 threads.
 Δίνοντας το όρισμα \texttt{-h} ο χρήστης μπορεί να δει όλες τι επιλογές εκτέλεσης και μια μικρή τεκμηρίωση ώστε να πειραματιστεί.
 \par
-Παρακάτω παραθέτουμε τα αποτελέσματα στους τελικούς χρόνους από τη συστοιχία ampere, gpu(tesla), αλλά και από μια κάρτα GTX1650, όπου κρατήσαμε τον ενδιάμεσο χρόνο από 7 εκτελέσεις.
+Παρακάτω παραθέτουμε τα γραφήματα και τα αποτελέσματα στους τελικούς χρόνους από τη συστοιχία ampere, gpu(tesla), αλλά και από μια κάρτα GTX1650, όπου κρατήσαμε τον ενδιάμεσο χρόνο από 7 εκτελέσεις.
+
+\InsertFigure{H}{1.025}{fig:TotalTime}{../matlab/total_time_plot}{Συνολικός χρόνος εκτέλεσης της ταξινόμησης (Με μεταφορά δεδομένων).}
+\InsertFigure{H}{1.025}{fig:SortTime}{../matlab/sort_time_plot}{Χρόνος εκτέλεσης της ταξινόμησης (Χωρίς μεταφορά δεδομένων).}
+\InsertFigure{H}{1.025}{fig:SpeedUp}{../matlab/speedup_plot}{Επιτάχυνση σε σχέση με τη σειριακή έκδοση (Συστοιχία AMD 7742).}
 
 \begin{table}[H]
     \centering
     \renewcommand{\arraystretch}{1.25}
 
     \begin{tabular}{ll|rrrrrr}
-                     &       &       Q20 &        Q22 &       Q24 &        Q26 &        Q28 &        Q30  \\ \hline
+                     &       &       Q20  &        Q22 &       Q24 &        Q26 &        Q28 &        Q30  \\ \hline
+    Serial - AMD7742 & Total &    74 msec &   328 msec & 1441 msec &  6293 msec & 27.17 sec  & 115.58 sec \\ \hline
         V0 - ampere  & Total &  8733 usec &    59 msec &   56 msec &   229 msec &   976 msec &  3971 msec \\
                      & Sort  &  3134 usec &  6074 usec &   29 msec &   120 msec &   554 msec &  2453 msec \\
         V0 - tesla   & Total &  6559 usec &    23 msec &  101 msec &   442 msec &  1986 msec &  9071 msec \\
@@ -446,8 +451,26 @@ for (size_t stage = 1; stage <= Stages; ++stage) {
         V2 - gtx1650 & Total &  8985 usec &    38 msec &  169 msec &   810 msec &  3864 msec &        N/A \\
                      & Sort  &  7294 usec &    33 msec &  148 msec &   726 msec &  3527 msec &        N/A \\
     \end{tabular}
-    \caption{Τελικές μετρήσεις στη συστοιχία.}
+    \caption{Μέρος των τελικών μετρήσεων στη συστοιχία.}
     \label{tab:Final_Reults}
 \end{table}
 
+\subsection{Συμπεράσματα}
+Από τα διαγράμματα και τις μετρήσεις βλέπουμε πως:
+\begin{itemize}
+    \item Η έκδοση που επιταχύνεται από την GPU σε σχέση με την εκτέλεση στη CPU του ίδιου μηχανήματος είναι \textbf{γρηγορότερη ακόμα και για μικρό μέγεθος δεδομένων}.
+    Φυσικά, εδώ θα μπορούσαμε να συγκρίνουμε μια σειριακή εκτέλεση εντός GPU, αλλά αυτό θα εμφάνιζε κυρίως το θεωρητικό και μαθηματικό πλεονέκτημα της παραλληλοποίησης και θα εξαρτώνταν κυρίως από των αριθμό των παράλληλων threads.
+    Αντίθετα η σύγκριση με τη CPU έγινε για να αποκτηθεί μια αίσθηση από ένα πιο πιθανό σενάριο ανάγκης για επιτάχυνση από GPU.
+    \item Η κάρτα \textbf{Tesla P100-PCIE-12GB} της συστοιχίας gpu παρουσιάζει \textbf{διαφορετική συμπεριφορά για την έκδοση V2}, σε σχέση με την NVIDIA A100-SXM4-40GB της ampere, αλλά και της GTX1650.
+    \item Επίσης η \textbf{υπεροχή} της Α100 στις επιδόσεις \textbf{στη μεταφορά δεδομένων} φαίνονται έντονα στο σχήμα \ref{fig:SpeedUp}, όπου η κάρτα κερδίζει αρκετό έδαφος καθώς το μέγεθος προς ταξινόμηση μεγαλώνει.
+\end{itemize}
+
+\section{Σύνοψη}
+Κλείνοντας να πούμε πως προσπαθήσαμε να παρουσιάσουμε ένα σχετικά αποδοτικό αλγόριθμο δίνοντας βάση στην βελτιστοποίηση μέσω ανάλυσης.
+Ξεκινώντας από την έκδοση V0 η οποία χρησιμοποιεί απλή παραλληλοποίηση, περάσαμε στη V1 που μειώνει τις kernel κλήσεις μέσω loop unrolling και στη V2 που αξιοποιεί shared memory.
+Μέσα από προφίλ εκτελέσεων και ανάλυση επιδόσεων, προέκυψε αρχικά το συμπέρασμα ότι η V2 παρουσιάζει δικαιολογημένες αποκλίσεις, και στη συνέχεια η βελτιστοποίηση του prephase.
+Οι πειραματικές μετρήσεις που πραγματοποιήθηκαν σε διάφορες αρχιτεκτονικές GPU (Ampere A100, Tesla P100, GTX 1650) επιβεβαίωσαν την αποτελεσματικότητα της παραλληλοποίησης έναντι μιας σειριακής εκτέλεσης σε CPU (AMD 7742), με σημαντικό speedup, ειδικά για μεγάλα dataset sizes.
+\par
+Τέλος, αν και δεν καταφέραμε να υλοποιήσουμε όλες μας τις ιδέες, θεωρούμε πως ασχοληθήκαμε με κάποιες βελτιστοποιήσεις που ίσως να αξίζουν περισσότερης διερεύνησης, πέρα από το πλαίσιο της εργασίας.
+
 \end{document}