Added support for multi-GPU

Author: krzysg

src/algorithm/APRConverter.hpp

@@ -421,7 +421,7 @@ inline void APRConverter<ImageType>::processOnGpu(int numOfStream, int numOfStre
     pinnedBuffer.copyFromMesh(*input_images[numOfStream]);
 
     for (int i = numOfStream; i < numOfImages; i += numOfStreams) {
-        std::cout << "Processing image " << i << " on stream " << numOfStream  << std::endl;
+        std::cout << "Processing image " << i << " on GPU " << gpt.getCudaDeviceID() << " on stream " << numOfStream  << std::endl;
 
         // ---- Send image to GPU
         gpt.sendDataToGpu();
@@ -480,13 +480,18 @@ inline bool APRConverter<ImageType>::get_apr_cuda_multistreams(std::vector<APR*>
 
     APRTimer t(true);
 
+    // Get number of available GPUs, created GPU streams will be distributed evenly on those GPUs
+    const int numberOfGpus = getNumberOfGpu();
+    std::cout << "Number of detected GPUs: " << numberOfGpus << std::endl;
+
     // Create GpuProcessingTask for each stream and link it with pinnedBuffer
     std::vector<GpuProcessingTask<ImageType>> gpts;
     t.start_timer("Creating GPTs");
     std::vector<std::future<void>> gpts_futures; gpts_futures.resize(numOfStreams);
     for (int i = 0; i < numOfStreams; ++i) {
-        //par.noise_sd_estimate = i;
-        gpts.emplace_back(GpuProcessingTask<ImageType>(pinnedBuffers[i], par, aAPRs[0]->level_max()));
+        // Create GpuProcessingTask on provided GPU (via provided Cuda ID) and bind it with pinned memory buffer used
+        // later for transfering images to GPU
+        gpts.emplace_back(GpuProcessingTask<ImageType>(pinnedBuffers[i], par, aAPRs[0]->level_max(), i % numberOfGpus));
     }
     t.stop_timer();
 
@@ -499,6 +504,7 @@ inline bool APRConverter<ImageType>::get_apr_cuda_multistreams(std::vector<APR*>
                                      std::ref(input_images), std::ref(gpts[i]), std::ref(pinnedBuffers[i]),
                                      std::ref(aAPRs), std::ref(intensities));
     }
+
     // ...and wait for all jobs to finish
     for (int i = 0; i < numOfStreams; ++i) gpts_futures[i].get();
 

src/algorithm/ComputeGradientCuda.cu

@@ -370,6 +370,11 @@ void runSampleParts(ImgType** downsampled, GenInfo &aprInfo, ImgType *parts_cuda
     }
 };
 
+int getNumberOfGpu() {
+    int deviceCount = 0;
+    checkCuda(cudaGetDeviceCount(&deviceCount));
+    return deviceCount;
+}
 
 class CudaStream {
     cudaStream_t iStream;
@@ -469,8 +474,8 @@ class GpuProcessingTask<U>::GpuProcessingTaskImpl {
 
 public:
 
-    GpuProcessingTaskImpl(const PixelData<ImgType> &inputImage, const APRParameters &parameters, int maxLevel) :
-        cudaDevID(0),  // used for now only in testing new ideas, ideally we should discover CPU/GPU architecture and assing corrct GPU to correct CPU which involves also correct memory allocation and thread affinity....
+    GpuProcessingTaskImpl(const PixelData<ImgType> &inputImage, const APRParameters &parameters, int maxLevel, int gpuCudaId) :
+        cudaDevID(gpuCudaId),  // used for now only in testing new ideas, ideally we should discover CPU/GPU architecture and assing corrct GPU to correct CPU which involves also correct memory allocation and thread affinity....
         cudaerr(cudaSetDevice(cudaDevID)),
         iCpuImage(inputImage),
         iStream(cudaStream.get()),
@@ -574,6 +579,8 @@ public:
         return std::move(lacs);
     }
 
+    int getCudaDeviceID() const { return cudaDevID; }
+
     void sendDataToGpu() {
         cudaSetDevice(cudaDevID);
         // Set it and copy first before copying the image
@@ -652,8 +659,8 @@ public:
 };
 
 template <typename ImgType>
-GpuProcessingTask<ImgType>::GpuProcessingTask(const PixelData<ImgType> &image, const APRParameters &parameters, int maxLevel)
-: impl{new GpuProcessingTaskImpl<ImgType>(image, parameters, maxLevel)} { }
+GpuProcessingTask<ImgType>::GpuProcessingTask(const PixelData<ImgType> &image, const APRParameters &parameters, int maxLevel, int gpuCudaID)
+: impl{new GpuProcessingTaskImpl<ImgType>(image, parameters, maxLevel, gpuCudaID)} { }
 
 template <typename ImgType>
 GpuProcessingTask<ImgType>::~GpuProcessingTask() { }
@@ -670,6 +677,9 @@ void GpuProcessingTask<ImgType>::processOnGpu() {impl->processOnGpu();}
 template <typename ImgType>
 void GpuProcessingTask<ImgType>::sendDataToGpu() {impl->sendDataToGpu();}
 
+template <typename ImgType>
+int GpuProcessingTask<ImgType>::getCudaDeviceID() const { return impl->getCudaDeviceID(); }
+
 // explicit instantiation of handled types
 template class GpuProcessingTask<uint8_t>;
 template class GpuProcessingTask<int>;

src/algorithm/ComputeGradientCuda.hpp

@@ -35,6 +35,8 @@ void getGradient(PixelData<ImgType> &image, PixelData<ImgType> &grad_temp, Pixel
 void cudaDownsampledGradient(PixelData<float> &input, PixelData<float> &grad, const float hx, const float hy, const float hz);
 template<typename T> std::pair<T,T> cudaRunMinMax(PixelData<T> &input_image);
 
+int getNumberOfGpu();
+
 template <typename ImgType>
 class GpuProcessingTask {
     // Using PIMPL to seperate GPU code from CPU (this file is to be included in regular code not compiled with nvcc)
@@ -43,15 +45,16 @@ class GpuProcessingTask {
 
 public:
 
-    GpuProcessingTask(const PixelData<ImgType> &image, const APRParameters &parameters, int maxLevel);
+    GpuProcessingTask(const PixelData<ImgType> &image, const APRParameters &parameters, int maxLevel, int gpuCudaID = 0);
     ~GpuProcessingTask();
     GpuProcessingTask(GpuProcessingTask&&);
 
     LinearAccessCudaStructs<ImgType> getDataFromGpu();
     void processOnGpu();
     void sendDataToGpu();
 
-    void setBsplineOffset(float bspline_offset);
+    int getCudaDeviceID() const;
+
 };
 
 #endif //LIBAPR_COMPUTEGRADIENTCUDA_HPP