Change initialization method of tensor for iGEMM (#49)

* change init method

driver/conv_bwd_data_driver_v2.cpp

@@ -179,26 +179,38 @@ int main(int argc, char* argv[])
 
     std::size_t num_thread = std::thread::hardware_concurrency();
 
-    if(do_verification)
-    {
     switch(init_method)
     {
     case 0:
-            wei.GenerateTensorValue(GeneratorTensor_1{}, num_thread);
-            out.GenerateTensorValue(GeneratorTensor_1{}, num_thread);
+        // no initialization
         break;
     case 1:
-            wei.GenerateTensorValue(GeneratorTensor_2{-5, 5}, num_thread);
         out.GenerateTensorValue(GeneratorTensor_1{}, num_thread);
+        wei.GenerateTensorValue(GeneratorTensor_1{}, num_thread);
         break;
     case 2:
+        out.GenerateTensorValue(GeneratorTensor_1{}, num_thread);
+        wei.GenerateTensorValue(GeneratorTensor_2{-5, 5}, num_thread);
+        break;
+    case 3:
+        out.GenerateTensorValue(GeneratorTensor_2{-5, 5}, num_thread);
         wei.GenerateTensorValue(GeneratorTensor_1{}, num_thread);
+        break;
+    case 4:
         out.GenerateTensorValue(GeneratorTensor_2{-5, 5}, num_thread);
+        wei.GenerateTensorValue(GeneratorTensor_2{-5, 5}, num_thread);
+        break;
+    case 5:
+        out.GenerateTensorValue(GeneratorTensor_3<float>{0.0, 1.0}, num_thread);
+        wei.GenerateTensorValue(GeneratorTensor_3<float>{-0.5, 0.5}, num_thread);
         break;
     default:
-            wei.GenerateTensorValue(GeneratorTensor_2{-5, 5}, num_thread);
-            out.GenerateTensorValue(GeneratorTensor_2{-5, 5}, num_thread);
-        }
+        out.GenerateTensorValue(GeneratorTensor_2{1, 5}, num_thread);
+
+        auto gen_wei = [](auto... is) {
+            return GeneratorTensor_2{1, 5}(is...) * GeneratorTensor_Checkboard{}(is...);
+        };
+        wei.GenerateTensorValue(gen_wei, num_thread);
     }
 
     auto f_make_for_device_nchw = [&]() {

driver/conv_driver_v2.cpp

@@ -205,26 +205,31 @@ int main(int argc, char* argv[])
 
     std::size_t num_thread = std::thread::hardware_concurrency();
 
-    if(do_verification)
-    {
     switch(init_method)
     {
     case 0:
+        // no initialization
+        break;
+    case 1:
         in.GenerateTensorValue(GeneratorTensor_1{}, num_thread);
         wei.GenerateTensorValue(GeneratorTensor_1{}, num_thread);
         break;
-        case 1:
+    case 2:
         in.GenerateTensorValue(GeneratorTensor_1{}, num_thread);
         wei.GenerateTensorValue(GeneratorTensor_2{-5, 5}, num_thread);
         break;
-        case 2:
+    case 3:
         in.GenerateTensorValue(GeneratorTensor_2{-5, 5}, num_thread);
         wei.GenerateTensorValue(GeneratorTensor_1{}, num_thread);
         break;
-        case 3:
+    case 4:
         in.GenerateTensorValue(GeneratorTensor_2{-5, 5}, num_thread);
         wei.GenerateTensorValue(GeneratorTensor_2{-5, 5}, num_thread);
         break;
+    case 5:
+        in.GenerateTensorValue(GeneratorTensor_3<float>{0.0, 1.0}, num_thread);
+        wei.GenerateTensorValue(GeneratorTensor_3<float>{-0.5, 0.5}, num_thread);
+        break;
     default:
         in.GenerateTensorValue(GeneratorTensor_2{1, 5}, num_thread);
 
@@ -233,7 +238,6 @@ int main(int argc, char* argv[])
         };
         wei.GenerateTensorValue(gen_wei, num_thread);
     }
-    }
 
     auto f_make_for_device_nchw = [&]() {
 #if USE_DYNAMIC_MODE

driver/conv_driver_v2_olc.cpp

@@ -152,26 +152,31 @@ int main(int argc, char* argv[])
 
     std::size_t num_thread = std::thread::hardware_concurrency();
 
-    if(do_verification)
-    {
     switch(init_method)
     {
     case 0:
+        // no initialization
+        break;
+    case 1:
         in.GenerateTensorValue(GeneratorTensor_1{}, num_thread);
         wei.GenerateTensorValue(GeneratorTensor_1{}, num_thread);
         break;
-        case 1:
+    case 2:
         in.GenerateTensorValue(GeneratorTensor_1{}, num_thread);
         wei.GenerateTensorValue(GeneratorTensor_2{-5, 5}, num_thread);
         break;
-        case 2:
+    case 3:
         in.GenerateTensorValue(GeneratorTensor_2{-5, 5}, num_thread);
         wei.GenerateTensorValue(GeneratorTensor_1{}, num_thread);
         break;
-        case 3:
+    case 4:
         in.GenerateTensorValue(GeneratorTensor_2{-5, 5}, num_thread);
         wei.GenerateTensorValue(GeneratorTensor_2{-5, 5}, num_thread);
         break;
+    case 5:
+        in.GenerateTensorValue(GeneratorTensor_3<float>{0.0, 1.0}, num_thread);
+        wei.GenerateTensorValue(GeneratorTensor_3<float>{-0.5, 0.5}, num_thread);
+        break;
     default:
         in.GenerateTensorValue(GeneratorTensor_2{1, 5}, num_thread);
 
@@ -180,7 +185,6 @@ int main(int argc, char* argv[])
         };
         wei.GenerateTensorValue(gen_wei, num_thread);
     }
-    }
 
     auto f_make_for_device_nchw = [&]() {
         const auto in_lengths_dev  = make_tuple(N, C, Hi, Wi);

driver/include/host_tensor_generator.hpp

@@ -9,7 +9,7 @@ struct GeneratorTensor_1
     int value = 1;
 
     template <typename... Is>
-    double operator()(Is... is)
+    float operator()(Is... is)
     {
         return value;
     }
@@ -21,29 +21,31 @@ struct GeneratorTensor_2
     int max_value = 1;
 
     template <typename... Is>
-    double operator()(Is...)
+    float operator()(Is...)
     {
         return (std::rand() % (max_value - min_value)) + min_value;
     }
 };
 
+template <typename T>
 struct GeneratorTensor_3
 {
+    T min_value = 0;
+    T max_value = 1;
+
     template <typename... Is>
-    double operator()(Is... is)
+    float operator()(Is...)
     {
-        std::array<ck::index_t, sizeof...(Is)> dims = {{static_cast<ck::index_t>(is)...}};
-
-        auto f_acc = [](auto a, auto b) { return 10 * a + b; };
+        float tmp = float(std::rand()) / float(RAND_MAX);
 
-        return std::accumulate(dims.begin(), dims.end(), ck::index_t(0), f_acc);
+        return min_value + tmp * (max_value - min_value);
     }
 };
 
 struct GeneratorTensor_Checkboard
 {
     template <typename... Ts>
-    double operator()(Ts... Xs) const
+    float operator()(Ts... Xs) const
     {
         std::array<ck::index_t, sizeof...(Ts)> dims = {{static_cast<ck::index_t>(Xs)...}};
         return std::accumulate(dims.begin(),