add conv random test

unit_tests/Test_ConvImpl.cpp

@@ -10,15 +10,15 @@
  ********************************************************************************/
 
 #include <array>
+#include <numeric> // std::accumulate
+#include <random>  // std::random_device, std::mt19937, std::uniform_real_distribution
 
 #include <catch2/catch_test_macros.hpp>
 
-#include "Test_cuda.hpp"
-
-#include "aidge/data/Tensor.hpp"
-
 #include "aidge/backend/cpu.hpp"
 #include "aidge/backend/cuda.hpp"
+#include "aidge/data/Tensor.hpp"
+#include "aidge/utils/TensorUtils.hpp"
 
 using namespace Aidge;
 
@@ -222,4 +222,147 @@ TEST_CASE("[gpu/operator] Conv(forward)") {
 
         delete[] computedOutput;
     }
+
+    SECTION("Random Input") {
+        constexpr std::uint16_t NBTRIALS = 10;
+        // Create a random number generator
+        std::random_device rd;
+        std::mt19937 gen(rd());
+        std::uniform_real_distribution<float> valueDist(
+            0.1f, 1.1f); // Random float distribution between 0 and 1
+        std::uniform_int_distribution<std::size_t> kernelDist(1, std::size_t(5));
+        std::uniform_int_distribution<std::size_t> dimSizeDist(1, std::size_t(10));
+
+        // To measure execution time of 'forward()'
+        std::chrono::time_point<std::chrono::system_clock> start;
+        std::chrono::time_point<std::chrono::system_clock> end;
+        std::chrono::duration<double, std::micro> duration{};
+        for (std::uint16_t trial = 0; trial < NBTRIALS; ++trial)
+        {
+            const std::size_t kernel = kernelDist(gen);
+            std::uniform_int_distribution<std::size_t> resolutionDist(std::size_t(kernel+2),
+                                                               std::size_t(10));
+            const std::size_t nbDims = 4;
+            std::vector<std::size_t> dims;
+            for (std::size_t i = 0; i < nbDims; ++i) {
+                if(i < 2)
+                    dims.push_back(dimSizeDist(gen));
+                else
+                    dims.push_back(resolutionDist(gen));
+            }
+            const std::size_t outChannels = dimSizeDist(gen);
+            const std::vector<std::size_t> dimsW{outChannels,dims[1],kernel,kernel};
+            const std::size_t inChannels = dims[1];
+
+            const std::size_t nb_elements = std::accumulate(dims.cbegin(), dims.cend(), std::size_t(1), std::multiplies<std::size_t>());
+            const std::size_t wieghtSize = std::accumulate(dimsW.cbegin(), dimsW.cend(), std::size_t(1), std::multiplies<std::size_t>());
+
+            // Create Conv Operator CUDA
+            std::shared_ptr<Node> myConvCUDA = Conv(inChannels,outChannels,{kernel,kernel}, "myconvcuda");
+            auto op_cuda = std::static_pointer_cast<OperatorTensor>(myConvCUDA -> getOperator());
+
+            // Create Conv Operator CPU
+            std::shared_ptr<Node> myConvCPU = Conv(inChannels,outChannels,{kernel,kernel}, "myconvcpu");
+            auto op_cpu = std::static_pointer_cast<OperatorTensor>(myConvCPU -> getOperator());
+            op_cpu->setDataType(DataType::Float32);
+            op_cpu->setBackend("cpu");
+
+
+            float* array0 = new float[nb_elements];
+            float* weights = new float[wieghtSize];
+            float* bias = new float[outChannels];
+
+            for (std::size_t i = 0; i < nb_elements; ++i) {
+                array0[i] = valueDist(gen);
+            }
+            for (std::size_t i = 0; i < wieghtSize; ++i) {
+                weights[i] = valueDist(gen);
+            }
+            for (std::size_t i = 0; i < outChannels; ++i) {
+                bias[i] = valueDist(gen);
+            }
+
+            // input0 CUDA
+            float* array0_d, *weight_d, *bias_d;
+            std::shared_ptr<Tensor> T0_cuda = std::make_shared<Tensor>();
+            T0_cuda->setDataType(DataType::Float32);
+            T0_cuda->setBackend("cuda");
+            T0_cuda->resize(dims);
+            op_cuda->associateInput(0, T0_cuda);
+            cudaMalloc(reinterpret_cast<void **>(&array0_d), sizeof(float) * nb_elements);
+            cudaMemcpy(array0_d, array0, sizeof(float) * nb_elements, cudaMemcpyHostToDevice);
+            T0_cuda->getImpl()->setRawPtr(array0_d, nb_elements);
+
+            // input0 CPU
+            std::shared_ptr<Tensor> T0_cpu = std::make_shared<Tensor>();
+            op_cpu->associateInput(0,T0_cpu);
+            T0_cpu->setDataType(DataType::Float32);
+            T0_cpu->setBackend("cpu");
+            T0_cpu->resize(dims);
+            T0_cpu -> getImpl() -> setRawPtr(array0, nb_elements);
+
+            // weight CUDA
+            std::shared_ptr<Tensor> Tw_cuda = std::make_shared<Tensor>();
+            Tw_cuda->setDataType(DataType::Float32);
+            Tw_cuda->setBackend("cuda");
+            Tw_cuda->resize(dimsW);
+            op_cuda->associateInput(1, Tw_cuda);
+            cudaMalloc(reinterpret_cast<void **>(&weight_d), sizeof(float) * wieghtSize);
+            cudaMemcpy(weight_d, weights, sizeof(float) * wieghtSize, cudaMemcpyHostToDevice);
+            Tw_cuda->getImpl()->setRawPtr(weight_d, wieghtSize);
+
+            // weight CPU
+            std::shared_ptr<Tensor> Tw_cpu = std::make_shared<Tensor>();
+            op_cpu->associateInput(1,Tw_cpu);
+            Tw_cpu->setDataType(DataType::Float32);
+            Tw_cpu->setBackend("cpu");
+            Tw_cpu->resize(dimsW);
+            Tw_cpu -> getImpl() -> setRawPtr(weights, wieghtSize);
+
+            // bias CUDA
+            std::shared_ptr<Tensor> Tb_cuda = std::make_shared<Tensor>();
+            Tb_cuda->setDataType(DataType::Float32);
+            Tb_cuda->setBackend("cuda");
+            Tb_cuda->resize({outChannels});
+            op_cuda->associateInput(2, Tb_cuda);
+            cudaMalloc(reinterpret_cast<void **>(&bias_d), sizeof(float) * outChannels);
+            cudaMemcpy(bias_d, bias, sizeof(float) * outChannels, cudaMemcpyHostToDevice);
+            Tb_cuda->getImpl()->setRawPtr(bias_d, outChannels);
+
+            // bias CPU
+            std::shared_ptr<Tensor> Tb_cpu = std::make_shared<Tensor>();
+            op_cpu->associateInput(2,Tb_cpu);
+            Tb_cpu->setDataType(DataType::Float32);
+            Tb_cpu->setBackend("cpu");
+            Tb_cpu->resize({outChannels});
+            Tb_cpu -> getImpl() -> setRawPtr(bias, outChannels);
+
+            // forward CUDA
+            op_cuda->setDataType(DataType::Float32);
+            op_cuda->setBackend("cuda");
+            start = std::chrono::system_clock::now();
+            op_cuda->forward();
+            end = std::chrono::system_clock::now();
+            duration += std::chrono::duration_cast<std::chrono::microseconds>(end - start);
+
+            const std::size_t outSize =  op_cuda->getOutput(0)->size();
+            float *computed_cuda = new float[outSize]();
+            cudaMemcpy(computed_cuda, op_cuda->getOutput(0)->getImpl()->rawPtr(), sizeof(float) * outSize, cudaMemcpyDeviceToHost);
+
+            // forward CPU
+            op_cpu->forward();
+            float *computed_cpu = static_cast<float*>(op_cpu->getOutput(0)->getImpl()->rawPtr());
+            REQUIRE(approxEq<float>(*computed_cuda, *computed_cpu));
+
+            delete[] array0;
+            delete[] weights;
+            delete[] bias;
+            delete[] computed_cuda;
+            cudaFree(array0_d);
+            cudaFree(weight_d);
+            cudaFree(bias_d);
+        }
+        std::cout << "total time: " << duration.count() << "μs" << std::endl;
+    }
+
 }