Conv2d: Add custom batch size support

model-inference/convolutional-neural-network/README.md

@@ -57,7 +57,7 @@ Once you start the netsDB system [Start Cluster](https://github.com/asu-cactus/n
 ### The version based on UDF-encapsulation 
 
 ```
-bin/Conv2dProjTest whetherToLoadData whetherToCreateSet numImages conv2D-mode(aten-conv2d or eigen-spatial) inputDimension kernelDimension
+bin/Conv2dProjTest whetherToLoadData whetherToCreateSet numImages conv2D-mode(aten-conv2d or eigen-spatial) inputDimension kernelDimension stride
 ```
 
 You can pass the command line parameters or modify variables in the example application source to control the block shape and the size of the word2vec layer.

src/conf/headers/Configuration.h

@@ -24,7 +24,7 @@ using namespace std;
 #endif
 
 #ifndef DEFAULT_MAX_PAGE_SIZE
-#define DEFAULT_MAX_PAGE_SIZE ((size_t)(1024) * (size_t)(1024) * (size_t)(1024))
+#define DEFAULT_MAX_PAGE_SIZE ((size_t)(2047) * (size_t)(1024) * (size_t)(1024))
 #endif
 
 #ifndef DEFAULT_NET_PAGE_SIZE

src/conv2d_proj/headers/Conv2DSelect.h

@@ -9,6 +9,7 @@
 //LA libraries:
 #include <eigen3/unsupported/Eigen/CXX11/Tensor>
 #include <cmath>
+#include <fstream>
 
 //ATen libraries:
 #include <ATen/ATen.h>
@@ -60,9 +61,10 @@ class Conv2DSelect: public SelectionComp<pdb::TensorData, pdb::TensorData>{
     }
 
 
-    Handle<TensorData> runEigenSpatial(TensorData& input,  int z, int y, int x, int stride) {
+    Handle<TensorData> runEigenSpatial(TensorData& input,  int n, int z, int y, int x, int stride) {
 
-        Eigen::TensorMap<Eigen::Tensor<float, 3>> a (input.rawData->c_ptr(), z, y, x);
+        std::cout << "---------------------------runEigenSpatial-------------------------:" << n << " " << z << " "<< y << " "<< x << " " << stride << std::endl;
+        Eigen::TensorMap<Eigen::Tensor<float, 4>> a (input.rawData->c_ptr(), n, z, y, x);
 
         //Eigen::Tensor<float, 3> c = a.convolve(b1)
 
@@ -92,13 +94,13 @@ class Conv2DSelect: public SelectionComp<pdb::TensorData, pdb::TensorData>{
         //pre_contract_dims
         Eigen::array<int, 2> pre_contract_dims;
         pre_contract_dims[0] = zk * yk * xk;
-        pre_contract_dims[1] = (oy) * (ox);
+        pre_contract_dims[1] = (oy) * (ox) * x;
 
         //post_contract_dims
         Eigen::array<int, 3> post_contract_dims;
         post_contract_dims[0] = nk;
         post_contract_dims[1] = (oy);
-        post_contract_dims[2] = (ox);
+        post_contract_dims[2] = (ox) * x;
 
         //kernel dims
         Eigen::array<int, 2> kernel_dims;
@@ -108,19 +110,20 @@ class Conv2DSelect: public SelectionComp<pdb::TensorData, pdb::TensorData>{
 
         //create the output
 
-        Handle<Vector<unsigned int>> dimensions = makeObject<Vector<unsigned int>>(3);
-
+        Handle<Vector<unsigned int>> dimensions = makeObject<Vector<unsigned int>>(4);
+        dimensions->push_back(n);
+
         dimensions->push_back(nk);
 
         dimensions->push_back(oy);
 
         dimensions->push_back(ox);
 
-        Handle<TensorData> out = makeObject<TensorData>(3, dimensions);
+        Handle<TensorData> out = makeObject<TensorData>(4, dimensions);
 
-       float * mempool = (float *) malloc (nk * oy * ox * sizeof(float));
+       float * mempool = (float *) malloc (n * nk * oy * ox * sizeof(float));
 
-        Eigen::TensorMap<Eigen::Tensor<float, 3>> c (mempool, nk, oy, ox); 
+        Eigen::TensorMap<Eigen::Tensor<float, 4>> c (mempool, n, nk, oy, ox); 
 
         c = b1.reshape(kernel_dims)
               .contract(
@@ -139,38 +142,66 @@ class Conv2DSelect: public SelectionComp<pdb::TensorData, pdb::TensorData>{
 
         */
 
-       memcpy (out->rawData->c_ptr(), mempool, nk * oy * ox * sizeof(float));
+       memcpy (out->rawData->c_ptr(), mempool, n * nk * oy * ox * sizeof(float));
 
        return out;
     }
 
-    Handle<TensorData> runAtenConv2d(TensorData& input, int z, int y, int x, int stride) {
-
+    Handle<TensorData> runAtenConv2d(TensorData& input, int n, int z, int y, int x, int stride) {
+        try {
+        std::cout << "---------------------------RunAtendConv2d-------------------------:" << n << " " << z << " "<< y << " "<< x << " " << stride << std::endl;
         //input data
-        at::Tensor a = at::from_blob(input.rawData->c_ptr(), {1, z, y, x});
+        // std::cout << "---------------------------input size ----------------------------:" << input.size << std::endl;
+        at::Tensor a = at::from_blob(input.rawData->c_ptr(), {n, z, y, x});
 
         at::Tensor b = at::from_blob(kernel->rawData->c_ptr(), {nk, zk, yk, xk});
 
-        // bias length = kernel count = nk
+        // bias length = kernel Count = nk
         at::Tensor bias = at::zeros({nk}, at::kFloat);
         //perform the convolutional operation
+        auto begin = std::chrono::high_resolution_clock::now();
+        // auto c = at::conv2d(a, b);
         auto c = at::conv2d(a, b, bias, stride);
 
+        auto end = std::chrono::high_resolution_clock::now();
+
+        std::cout << "-------------------------------------------------------------------------Inside RunAten Time Duration: "
+            << std::chrono::duration_cast<std::chrono::duration<float>>(end - begin).count()
+            << " secs." << std::endl;
+
+        // pdb::makeObjectAllocatorBlock(2047 * 1024 * 1024, true);
         //create the output
         int oy = calculateOutputDimension(y, yk, stride);
         int ox = calculateOutputDimension(x, xk, stride);
-        Handle<Vector<unsigned int>> dimensions = makeObject<Vector<unsigned int>>(3);
+        Handle<Vector<unsigned int>> dimensions = makeObject<Vector<unsigned int>>(4);
+
+        dimensions->push_back(n);
 
         dimensions->push_back(nk);
 
         dimensions->push_back(oy);
 
         dimensions->push_back(ox);
 
-        Handle<TensorData> out = makeObject<TensorData>(3, dimensions);
-        memcpy(out->rawData->c_ptr(), c.storage().data(), nk * (oy) * (ox) * sizeof(float));
+        Handle<TensorData> out = makeObject<TensorData>(4, dimensions);
+        memcpy(out->rawData->c_ptr(), c.storage().data(), (long long)n * nk * (oy) * (ox) * sizeof(float));
 
+        // Write output to file
+        // ofstream myfile;
+        // std::time_t result = std::time(nullptr);
+        // myfile.open ("conv2d_output_aten" + to_string(result) + ".txt");
+        // for (int i = 0; i < n * nk * oy * ox; i++) {
+        //     myfile << (*(out->rawData))[i] << endl;
+        // }
+        // myfile.close();
         return out;
+        } catch (NotEnoughSpace &e) {
+            std::cout<<"------------------inside not enough space allocation-----------------:" << '\n';
+            exit(1);
+        } catch (std::exception &e) {
+            std::cerr << "-----------------------------exception caught--------------------------------------------------------: " << e.what() << '\n';
+            exit(1);
+        }
     }
 
 
@@ -182,24 +213,29 @@ class Conv2DSelect: public SelectionComp<pdb::TensorData, pdb::TensorData>{
 
             TensorData input = *checkMe;
 
-            assert (input.numRanks = 3);
+            assert (input.numRanks = 4);
 
             //set up input dimensions
 
+            //N
+            int n = (*(input.dimensions))[0];
+
             //C
-            int z = (*(input.dimensions))[0];
+            int z = (*(input.dimensions))[1];
 
             //H
-            int y = (*(input.dimensions))[1];
+            int y = (*(input.dimensions))[2];
 
             //W
-            int x = (*(input.dimensions))[2];
+            int x = (*(input.dimensions))[3];
 
+            std::cout << "------------------------------------------------------------------Before calling runAtenConv2d--------------------------------------------------" << std::endl;
+            std::cout << "n =" << n << "z =" << z << "y =" << y << "x =" << x << std::endl;
 
             if (conv2dMode == "eigen-spatial") {
-                return runEigenSpatial(input, z, y, x, stride);
+                return runEigenSpatial(input, n, z, y, x, stride);
             } else {
-                return runAtenConv2d(input, z, y, x, stride);
+                return runAtenConv2d(input, n, z, y, x, stride);
             }
         });
     }
@@ -226,8 +262,8 @@ class Conv2DSelect: public SelectionComp<pdb::TensorData, pdb::TensorData>{
 
     unsigned int stride;
 
-    static int calculateOutputDimension(int inputDimention, int filterDimention, int stride) {
-        return (inputDimention - filterDimention) / stride + 1;
+    static int calculateOutputDimension(int inputDimension, int filterDimension, int stride) {
+        return (inputDimension - filterDimension) / stride + 1;
     }
 
 };