add random engine

main.cu

@@ -3,6 +3,7 @@
 #include "cuda_runtime.h"
 #include <ctime>
 #include "chrono"
+#include <random>
 
 using namespace std::chrono;
 
@@ -19,6 +20,34 @@ void printMat(const T &mat,
     }
 }
 
+template <typename T>
+void initMat(const T &mat,
+                 const int &m,
+                 const int &n) {
+    std::default_random_engine engine;
+    std::uniform_real_distribution<double> u(0.0, 1.0);
+    for (int i = 0; i < m * n; ++i) {
+            *(mat + i) = u(engine);
+    }
+}
+
+template <typename T>
+void matMul_cpu(const T& mat_a, 
+                const T& mat_b, 
+                const T& mat_c,
+                const int &m, 
+                const int &k,
+                const int &n) {
+    for (int i = 0; i < m; ++i) {
+        for (int j = 0; j < n; ++j) {
+            *(mat_c + i * n + j) = 0;
+            for (int t = 0; t < k; ++t) {
+                *(mat_c + i * n + j) += *(mat_a + i * k + t) * *(mat_b + t * n + j);
+            }
+        }
+    }
+}
+
 int main(void) {
     int dev = 0;
     cudaDeviceProp devProp;
@@ -41,27 +70,36 @@ int main(void) {
     int nBytes_c = m * n * sizeof(float);
 
     // use Unified Memory.
-    float *mat_a, *mat_b, *mat_c;
+    float *mat_a, *mat_b, *mat_c, *mat_r;
     // cudaMallocManaged((void **)&mat_a, nBytes_a);
     // cudaMallocManaged((void **)&mat_b, nBytes_b);
     // cudaMallocManaged((void **)&mat_c, nBytes_c);
     mat_a = (float *)malloc(nBytes_a);
     mat_b = (float *)malloc(nBytes_b);
     mat_c = (float *)malloc(nBytes_c);
+    mat_r = (float *)malloc(nBytes_c);
     
+    /*
     for (int i = 0; i < m * k; i++) {
         mat_a[i] = 10;
     }
+    */
+    initMat(mat_a, m, k);
     // printMat(mat_a, m, k);
 
+    /*
     for (int i = 0; i < k * n; i++) {
         mat_b[i] = 10;
     }
+    */
+    initMat(mat_b, k, n);
     // printMat(mat_b, k, n);
 
     for (int i = 0; i < m * n; i++) {
         mat_c[i] = 0.0;
     }
+    matMul_cpu(mat_a, mat_b, mat_r, m, k, n);
+    // printMat(mat_r, m, n);
 
     float *d_a, *d_b, *d_c;
     cudaMalloc((void **)&d_a, nBytes_a);
@@ -95,13 +133,11 @@ int main(void) {
          << double(duration.count()) * microseconds::period::num / microseconds::period::den << " seconds" << std::endl;
 
     // printMat(mat_c, m, n);
-    /* 
     float maxError = 0.0;
     for (int i = 0; i < m * n; i++) {
-        maxError = fmax(maxError, fabs(*(mat_c + i) - 100.0));
+        maxError = fmax(maxError, fabs(*(mat_c + i) - *(mat_r + i)));
     }
     std::cout << "Max Error: " << maxError << std::endl;
-    */
 
     cudaFree(d_a);
     cudaFree(d_b);