Some debug prints removed

Author: krzysg

src/algorithm/ComputeGradientCuda.cu

@@ -247,6 +247,9 @@ class GpuProcessingTask<U>::GpuProcessingTaskImpl {
 
 public:
 
+    // TODO: Remove need for passing 'levels' to GpuProcessingTask
+    //       It was used during development to control internal computation like filters, gradient, levels etc. but
+    //       once all is done there is no need for it anymore
     GpuProcessingTaskImpl(const PixelData<ImgType> &inputImage, PixelData<float> &levels, const APRParameters &parameters, float bspline_offset, int maxLevel) :
         iCpuImage(inputImage),
         iCpuLevels(levels),
@@ -272,16 +275,16 @@ public:
         y_vec(nullptr, iAprInfo.getSize(), iStream)
     {
 //        std::cout << "\n=============== GpuProcessingTaskImpl ===================\n\n";
-        std::cout << iCpuImage << std::endl;
-        std::cout << iCpuLevels << std::endl;
+//        std::cout << iCpuImage << std::endl;
+//        std::cout << iCpuLevels << std::endl;
     }
 
     void sendDataToGpu() {
-        CurrentTime ct;
-        uint64_t start = ct.microseconds();
+//        CurrentTime ct;
+//        uint64_t start = ct.microseconds();
         image.copyH2D();
-        checkCuda(cudaStreamSynchronize(iStream));
-        std::cout << "SEND time: " << ct.microseconds() - start << std::endl;
+//        checkCuda(cudaStreamSynchronize(iStream));
+//        std::cout << "SEND time: " << ct.microseconds() - start << std::endl;
     }
 
     LinearAccessCudaStructs getDataFromGpu() {
@@ -313,18 +316,14 @@ public:
         getGradientCuda(iCpuImage, iCpuLevels, image.get(), gradient.get(), local_scale_temp.get(),
                          splineCudaX, splineCudaY, splineCudaZ, boundary.get(),
                         iBsplineOffset, iParameters, iStream);
-        std::cout << "1: " << ct.microseconds() - start << std::endl;
         runLocalIntensityScalePipeline(iCpuLevels, iParameters, local_scale_temp.get(), local_scale_temp2.get(), iStream);
-        std::cout << "2: " << ct.microseconds() - start << std::endl;
         float min_dim = std::min(iParameters.dy, std::min(iParameters.dx, iParameters.dz));
         float level_factor = pow(2, iMaxLevel) * min_dim;
         const float mult_const = level_factor/iParameters.rel_error;
         runComputeLevels(gradient.get(), local_scale_temp.get(), iCpuLevels.mesh.size(), mult_const, iStream);
-        std::cout << "3: " << ct.microseconds() - start << std::endl;
 
         computeOvpcCuda(local_scale_temp.get(), pctc, iAprInfo, iStream);
         computeLinearStructureCuda(y_vec.get(), pctc, iAprInfo, iParameters, lacs, iStream);
-        std::cout << iAprInfo << std::endl;
     }
 
     ~GpuProcessingTaskImpl() {
@@ -335,10 +334,10 @@ public:
 
 template <typename ImgType>
 GpuProcessingTask<ImgType>::GpuProcessingTask(const PixelData<ImgType> &image, PixelData<float> &levels, const APRParameters &parameters, float bspline_offset, int maxLevel)
-: impl{new GpuProcessingTaskImpl<ImgType>(image, levels, parameters, bspline_offset, maxLevel)} {std::cout << "GpuProcessingTask\n";}
+: impl{new GpuProcessingTaskImpl<ImgType>(image, levels, parameters, bspline_offset, maxLevel)} { }
 
 template <typename ImgType>
-GpuProcessingTask<ImgType>::~GpuProcessingTask() {std::cout << "~GpuProcessingTask\n";}
+GpuProcessingTask<ImgType>::~GpuProcessingTask() { }
 
 template <typename ImgType>
 GpuProcessingTask<ImgType>::GpuProcessingTask(GpuProcessingTask&&) = default;

src/algorithm/OVPC.cu

@@ -182,6 +182,4 @@ void computeOvpcCuda(ImgType *in, ParticleCellTreeCuda &pct, const GenInfo &gi,
     for (int l = levelMax - 1; l >= levelMin; --l) {
         runSecondStep(pct[l], pct[l+1], gi.x_num[l], gi.y_num[l], gi.z_num[l], gi.x_num[l + 1], gi.y_num[l + 1], gi.z_num[l + 1], l == levelMin, stream);
     }
-
-    std::cout << "------- RUN --------------\n";
 }

src/data_structures/APR/access/LinearAccessCuda.cu

@@ -627,10 +627,6 @@ void computeLinearStructureCuda(uint16_t *y_vec_cuda, ParticleCellTreeCuda &p_ma
         }
     }
 
-//        auto prt = [&](const auto& v){ std::cout << "size=" << v.size() << " data="; for (size_t i = 0; i < v.size(); i++) std::cout << v[i] << ", "; std::cout << std::endl; };
-//    prt(y_vec);
-//    prt(xz_end_vec);
-//    prt(level_xz_vec);
     VectorData<uint16_t> y_vec(true);
     y_vec.resize(gi.total_number_particles);
     checkCuda(cudaMemcpyAsync(y_vec.begin(), y_vec_cuda, gi.total_number_particles * sizeof(uint16_t), cudaMemcpyDeviceToHost, aStream));

test/FullPipelineCudaTest.cpp

@@ -310,9 +310,7 @@ namespace {
 
             // Initialize GPU data structures to same values as CPU
             PixelData<ImageType> mGpuImage(input_image, true);
-            PixelData<ImageType> grad_temp_GPU(grad_temp, true);
-            PixelData<float> local_scale_temp_GPU(local_scale_temp, true);
-            PixelData<float> local_scale_temp2_GPU(local_scale_temp2, true);
+            PixelData<float> local_scale_temp_GPU(local_scale_temp, false);
 
             // Prepare parameters
             APRParameters par;
@@ -346,14 +344,16 @@ namespace {
 
 
             // Calculate pipeline on GPU
-            timer.start_timer(">>>>>>>>>>>>>>>>> GPU PIPELINE");
-    //        {
             GpuProcessingTask<ImageType> gpt(mGpuImage, local_scale_temp_GPU, par, 0, maxLevel);
+            cudaDeviceSynchronize();
+
+            timer.start_timer(">>>>>>>>>>>>>>>>> GPU PIPELINE");
+            //        {
             gpt.sendDataToGpu();
             gpt.processOnGpu();
             auto linearAccessGpu = gpt.getDataFromGpu();
             giGpu.total_number_particles = linearAccessGpu.y_vec.size();
-
+            cudaDeviceSynchronize();
     //        }
             timer.stop_timer();