Added more precise benchmark method

Author: audictheprogrammer

src/data/Matrix_A.txt

@@ -1,3 +1,3 @@
 2
-[ 13465026.000000 51628529.000000 ]
-[ 9778574.000000 61218860.000000 ]
+[ 3464256.000000 41961928.000000 ]
+[ 14050932.000000 45158647.000000 ]

src/data/Matrix_B.txt

@@ -0,0 +1,3 @@
+2
+[ 47333287.000000 10245261.000000 ]
+[ 8857026.000000 48800053.000000 ]

src/data/Matrix_C.txt

@@ -0,0 +1,3 @@
+2
+[ 65679586.000000 30980945.000000 ]
+[ 47825320.000000 16604839.000000 ]

src/data/benchmark_modulo_SIMD1.txt

@@ -1,3 +1,3 @@
-256 0.183045 
-512 1.668042 
-1024 14.721634 
+256 0.308110 
+512 2.604486 
+1024 24.592209 

src/data/benchmark_modulo_SIMD2.txt

@@ -1,3 +1,3 @@
-256 0.419965 
-512 3.494216 
-1024 43.159186 
+256 0.297660 
+512 2.419746 
+1024 23.314639 

src/data/benchmark_modulo_SIMD3.txt

@@ -1,3 +1,3 @@
-256 0.465952 
-512 3.660137 
-1024 46.676813 
+256 0.362122 
+512 2.807826 
+1024 26.424386 

src/data/benchmark_modulo_naive.txt

@@ -1,3 +1,3 @@
-256 0.143224 
-512 1.673726 
-1024 11.690024 
+256 0.246962 
+512 2.012571 
+1024 20.047736 

src/data/benchmark_order_ijk.txt

@@ -0,0 +1,3 @@
+256 0.120296 
+512 1.062440 
+1024 10.452757 

src/data/benchmark_order_ikj.txt

@@ -1,14 +1,3 @@
-256 0.067483 
-512 0.544910 
-1024 4.401343 
-256 0.070410 
-512 0.540539 
-1024 4.440159 
-256 0.067825 
-512 0.613097 
-1024 4.583750 
-256 0.069220 
-512 0.557678 
-256 0.068348 
-512 0.549756 
-1024 4.589121 
+256 0.111407 
+512 0.900301 
+1024 7.632323 

src/data/benchmark_order_jik.txt

@@ -1,3 +1,3 @@
-256 0.080670 
-512 0.631910 
-1024 5.759593 
+256 0.116215 
+512 0.927812 
+1024 10.074881 

src/data/benchmark_order_jki.txt

@@ -1,3 +1,3 @@
-256 0.078748 
-512 0.709504 
-1024 18.785399 
+256 0.129568 
+512 1.156672 
+1024 29.783366 

src/data/benchmark_order_kij.txt

@@ -1,3 +1,3 @@
-256 0.073515 
-512 0.571375 
-1024 4.816130 
+256 0.111931 
+512 0.919294 
+1024 7.818451 

src/data/benchmark_order_kji.txt

@@ -1,3 +1,3 @@
-256 0.082192 
-512 0.650841 
-1024 18.953033 
+256 0.129981 
+512 1.088789 
+1024 29.408653 

src/main.c

@@ -2,185 +2,176 @@
 #include "matrix_mul.h"
 #include <math.h>
 
-void benchmark_ijk(double** A, double** B, int n){
-    FILE* f = fopen("data/benchmark_order_ijk.txt", "a");
+double benchmark_ijk(double** A, double** B, int n){
     double** C = zero_matrix(n);
 
     clock_t initial = clock();
     mp_ijk(A, B, C, n);
     clock_t final = clock();
 
-    double time = ((double) (final - initial)) / CLOCKS_PER_SEC;
-    printf("IJK: n = %d time = %f \n", n, time);
-    fprintf(f, "%d %f \n", n, time);
-
-    fclose(f);
+    return ((double) (final - initial)) / CLOCKS_PER_SEC;
 }
 
-void benchmark_kij(double** A, double** B, int n){
-    FILE* f = fopen("data/benchmark_order_kij.txt", "a");
+double benchmark_kij(double** A, double** B, int n){
     double** C = zero_matrix(n);
 
     clock_t initial = clock();
     mp_kij(A, B, C, n);
     clock_t final = clock();
 
-    double time = ((double) (final - initial)) / CLOCKS_PER_SEC;
-    printf("KIJ: n = %d time = %f \n", n, time);
-    fprintf(f, "%d %f \n", n, time);
-
-    fclose(f);
+    return ((double) (final - initial)) / CLOCKS_PER_SEC;
 }
 
-void benchmark_jki(double** A, double** B, int n){
-    FILE* f = fopen("data/benchmark_order_jki.txt", "a");
+double benchmark_jki(double** A, double** B, int n){
     double** C = zero_matrix(n);
 
     clock_t initial = clock();
     mp_jki(A, B, C, n);
     clock_t final = clock();
 
-    double time = ((double) (final - initial)) / CLOCKS_PER_SEC;
-    printf("JKI: n = %d time = %f \n", n, time);
-    fprintf(f, "%d %f \n", n, time);
-
-    fclose(f);
+    return ((double) (final - initial)) / CLOCKS_PER_SEC;
 }
 
-void benchmark_ikj(double** A, double** B, int n){
-    FILE* f = fopen("data/benchmark_order_ikj.txt", "a");
+double benchmark_ikj(double** A, double** B, int n){
     double** C = zero_matrix(n);
 
     clock_t initial = clock();
     mp_ikj(A, B, C, n);
     clock_t final = clock();
 
-    double time = ((double) (final - initial)) / CLOCKS_PER_SEC;
-    printf("IKJ: n = %d time = %f \n", n, time);
-    fprintf(f, "%d %f \n", n, time);
-
-    fclose(f);
+    return ((double) (final - initial)) / CLOCKS_PER_SEC;
 }
 
-void benchmark_jik(double** A, double** B, int n){
-    FILE* f = fopen("data/benchmark_order_jik.txt", "a");
+double benchmark_jik(double** A, double** B, int n){
     double** C = zero_matrix(n);
 
     clock_t initial = clock();
     mp_jik(A, B, C, n);
     clock_t final = clock();
 
-    double time = ((double) (final - initial)) / CLOCKS_PER_SEC;
-    printf("JIK: n = %d time = %f \n", n, time);
-    fprintf(f, "%d %f \n", n, time);
-
-    fclose(f);
+    return ((double) (final - initial)) / CLOCKS_PER_SEC;
 }
 
-void benchmark_kji(double** A, double** B, int n){
-    FILE* f = fopen("data/benchmark_order_kji.txt", "a");
+double benchmark_kji(double** A, double** B, int n){
     double** C = zero_matrix(n);
 
     clock_t initial = clock();
     mp_kji(A, B, C, n);
     clock_t final = clock();
 
-    double time = ((double) (final - initial)) / CLOCKS_PER_SEC;
-    printf("KJI: n = %d time = %f \n\n", n, time);
-    fprintf(f, "%d %f \n", n, time);
-
-    fclose(f);
+    return ((double) (final - initial)) / CLOCKS_PER_SEC;
 }
 
-void benchmark_loops_order(double p){
-
-    for (int i=8; i<11; i++){
-        int n = (int) pow(2, i);
-        double**A = random_matrix(n, p);
-        double**B = random_matrix(n, p);
-        benchmark_ijk(A, B, n);
-        benchmark_kij(A, B, n);
-        benchmark_jki(A, B, n);
-        benchmark_ikj(A, B, n);
-        benchmark_jik(A, B, n);
-        benchmark_kji(A, B, n);
-    }
+void write_benchmark_time(char* filename, char* text, int n, double time){
+    FILE* f = fopen(filename, "a");
+    printf("%s: n = %d time = %f \n", text,n, time);
+    fprintf(f, "%d %f \n", n, time);
+    fclose(f);
 }
 
-void benchmark_mod_naive(double** A, double** B, int n, double p){
-    FILE* f = fopen("data/benchmark_modulo_naive.txt", "a");
+double benchmark_mod_naive(double** A, double** B, int n, double p){
     double** C = zero_matrix(n);
 
     clock_t initial = clock();
     mp_naive(A, B, C, n, p);
     clock_t final = clock();
 
-    double time = ((double) (final - initial)) / CLOCKS_PER_SEC;
-    printf("Modulo Naive: n = %d time = %f \n\n", n, time);
-    fprintf(f, "%d %f \n", n, time);
-
-    fclose(f);
+    return ((double) (final - initial)) / CLOCKS_PER_SEC;
 }
 
-void benchmark_mod_SIMD1(double** A, double** B, int n, double p, double u){
-    FILE* f = fopen("data/benchmark_modulo_SIMD1.txt", "a");
+double benchmark_mod_SIMD1(double** A, double** B, int n, double p, double u){
     double** C = zero_matrix(n);
 
     clock_t initial = clock();
     mp_SIMD1(A, B, C, n, p, u);
     clock_t final = clock();
 
-    double time = ((double) (final - initial)) / CLOCKS_PER_SEC;
-    printf("Modulo SIMD1: n = %d time = %f \n\n", n, time);
-    fprintf(f, "%d %f \n", n, time);
-
-    fclose(f);
+    return ((double) (final - initial)) / CLOCKS_PER_SEC;
 }
 
-void benchmark_mod_SIMD2(double** A, double** B, int n, double p, double u){
-    FILE* f = fopen("data/benchmark_modulo_SIMD2.txt", "a");
+double benchmark_mod_SIMD2(double** A, double** B, int n, double p, double u){
     double** C = zero_matrix(n);
 
     clock_t initial = clock();
     mp_SIMD2(A, B, C, n, p, u);
     clock_t final = clock();
 
-    double time = ((double) (final - initial)) / CLOCKS_PER_SEC;
-    printf("Modulo SIMD2: n = %d time = %f \n\n", n, time);
-    fprintf(f, "%d %f \n", n, time);
-
-    fclose(f);
+    return ((double) (final - initial)) / CLOCKS_PER_SEC;
 }
 
-void benchmark_mod_SIMD3(double** A, double** B, int n, double p, double u){
-    FILE* f = fopen("data/benchmark_modulo_SIMD3.txt", "a");
+ double benchmark_mod_SIMD3(double** A, double** B, int n, double p, double u){
     double** C = zero_matrix(n);
 
     clock_t initial = clock();
     mp_SIMD3(A, B, C, n, p, u);
     clock_t final = clock();
 
-    double time = ((double) (final - initial)) / CLOCKS_PER_SEC;
-    printf("Modulo SIMD3: n = %d time = %f \n\n", n, time);
-    fprintf(f, "%d %f \n", n, time);
+    return ((double) (final - initial)) / CLOCKS_PER_SEC;
+}
 
-    fclose(f);
+void benchmark_loops_order(double p){
+    /* Benchmarking the order of loops.
+    The most efficient one is IKJ.
+    */
+    int m = 5;  // Executes m times each algo
+    for (int i=8; i<11; i++){
+        int n = (int) pow(2, i);
+        double sum_ijk = 0;
+        double sum_kij = 0;
+        double sum_jki = 0;
+        double sum_ikj = 0;
+        double sum_jik = 0;
+        double sum_kji = 0;
+
+        for (int j=0; j<m; j++){
+            double**A = random_matrix(n, p);
+            double**B = random_matrix(n, p);
+            sum_ijk += benchmark_ijk(A, B, n);
+            sum_kij += benchmark_kij(A, B, n);
+            sum_jki += benchmark_jki(A, B, n);
+            sum_ikj += benchmark_ikj(A, B, n);
+            sum_jik += benchmark_jik(A, B, n);
+            sum_kji += benchmark_kji(A, B, n);
+        }
+        printf("\n");
+        write_benchmark_time("data/benchmark_order_ijk.txt", "IJK", n, sum_ijk/m);
+        write_benchmark_time("data/benchmark_order_kij.txt", "KIJ", n, sum_kij/m);
+        write_benchmark_time("data/benchmark_order_jki.txt", "JKI", n, sum_jki/m);
+        write_benchmark_time("data/benchmark_order_ikj.txt", "IKJ", n, sum_ikj/m);
+        write_benchmark_time("data/benchmark_order_jik.txt", "JIK", n, sum_jik/m);
+        write_benchmark_time("data/benchmark_order_kji.txt", "KJI", n, sum_kji/m);
+
+    }
 }
 
 void benchmark_modulos(double p, double u){
-
+    /* Benchmarking different modulos.
+    The most efficient one is IKJ.
+    */
+    int m = 5;  // Executes m times each algo
     for (int i=8; i<11; i++){
         int n = (int) pow(2, i);
-        double**A = random_matrix(n, p);
-        double**B = random_matrix(n, p);
-        benchmark_mod_naive(A, B, n, p);  // Worst
-        benchmark_ikj(A, B, n);  // Best
-        benchmark_mod_SIMD1(A, B, n, p, u);
-        benchmark_mod_SIMD2(A, B, n, p, u);
-        benchmark_mod_SIMD3(A, B, n, p, u);
+        double sum_mod_naive = 0;
+        double sum_mod_SIMD1 = 0;
+        double sum_mod_SIMD2 = 0;
+        double sum_mod_SIMD3 = 0;
+
+        for (int j=0; j<m; j++){
+            double**A = random_matrix(n, p);
+            double**B = random_matrix(n, p);
+            sum_mod_naive += benchmark_mod_naive(A, B, n, p);
+            sum_mod_SIMD1 += benchmark_mod_SIMD1(A, B, n, p, u);
+            sum_mod_SIMD2 += benchmark_mod_SIMD2(A, B, n, p, u);
+            sum_mod_SIMD3 += benchmark_mod_SIMD3(A, B, n, p, u);
+        }
+
+        printf("\n");
+        write_benchmark_time("data/benchmark_modulo_naive.txt", "Mod Naive", n, sum_mod_naive/m);
+        write_benchmark_time("data/benchmark_modulo_SIMD1.txt", "Mod SIMD1", n, sum_mod_SIMD1/m);
+        write_benchmark_time("data/benchmark_modulo_SIMD2.txt", "Mod SIMD2", n, sum_mod_SIMD2/m);
+        write_benchmark_time("data/benchmark_modulo_SIMD3.txt", "Mod SIMD3", n, sum_mod_SIMD3/m);
 
     }
-
 }
 
 void clean_file_loops(){
@@ -195,11 +186,10 @@ void clean_file_loops(){
 }
 
 void clean_file_modulos(){
-    char noms[5][64] = {"data/benchmark_modulo_naive.txt", "data/benchmark_order_ijk.txt",\
-                    "data/benchmark_modulo_SIMD1.txt", "data/benchmark_modulo_SIMD2.txt",\
-                    "data/benchmark_modulo_SIMD3.txt"};
+    char noms[4][64] = {"data/benchmark_modulo_naive.txt", "data/benchmark_modulo_SIMD1.txt",\
+     "data/benchmark_modulo_SIMD2.txt", "data/benchmark_modulo_SIMD3.txt"};
 
-    for (int i=0; i<5; i++){
+    for (int i=0; i<4; i++){
         FILE* f = fopen(noms[i], "w");
         fclose(f);
     }
@@ -215,6 +205,7 @@ int main(){
 
 
     // // // Testing loops order
+    // 07/07/23 13:27 I did a benchmark for 5
     // clean_file_loops();
     // benchmark_loops_order(p);