Merge pull request #25880 from Jamim:fix/cuda-no-fp16

Jamim · web-flow · commit 35ca2f78d66d · 2024-07-10T12:39:30.000+03:00
Fix CUDA for old GPUs without FP16 support #25880 Fixes #21461 ~This is a build-time solution that reflects https://github.com/opencv/opencv/blob/4.10.0/modules/dnn/src/cuda4dnn/init.hpp#L68-L82.~ ~We shouldn't add an invalid target while building with `CUDA_ARCH_BIN` < 53.~ _(please see [this discussion](#25880 (comment) This is a run-time solution that basically reverts [these lines](d0fe6ad#diff-757c5ab6ddf2f99cdd09f851e3cf17abff203aff4107d908c7ad3d0466f39604L245-R245). I've debugged these changes, [coupled with other fixes](gentoo/gentoo#37479), on [Gentoo Linux](https://www.gentoo.org/) and [related tests passed](https://github.com/user-attachments/files/16135391/opencv-4.10.0.20240708-224733.log.gz) on my laptop with `GeForce GTX 960M`. Alternative solution: - #21462 _Best regards!_ ### Pull Request Readiness Checklist - [x] I agree to contribute to the project under Apache 2 License. - [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV - [x] The PR is proposed to the proper branch - [x] There is a reference to the original bug report and related work - [ ] `n/a` There is accuracy test, performance test and test data in opencv_extra repository, if applicable - [ ] `n/a` The feature is well documented and sample code can be built with the project CMake
diff --git a/modules/dnn/src/cuda4dnn/init.hpp b/modules/dnn/src/cuda4dnn/init.hpp
@@ -15,7 +15,7 @@
 
 namespace cv { namespace dnn { namespace cuda4dnn {
 
-    void checkVersions()
+    inline void checkVersions()
     {
         // https://docs.nvidia.com/deeplearning/cudnn/developer-guide/index.html#programming-model
         // cuDNN API Compatibility
@@ -44,21 +44,23 @@ namespace cv { namespace dnn { namespace cuda4dnn {
         }
     }
 
-    int getDeviceCount()
+    inline int getDeviceCount()
     {
         return cuda::getCudaEnabledDeviceCount();
     }
 
-    int getDevice()
+    inline int getDevice()
     {
         int device_id = -1;
         CUDA4DNN_CHECK_CUDA(cudaGetDevice(&device_id));
         return device_id;
     }
 
-    bool isDeviceCompatible()
+    inline bool isDeviceCompatible(int device_id = -1)
     {
-        int device_id = getDevice();
+        if (device_id < 0)
+            device_id = getDevice();
+
         if (device_id < 0)
             return false;
 
@@ -76,9 +78,11 @@ namespace cv { namespace dnn { namespace cuda4dnn {
         return false;
     }
 
-    bool doesDeviceSupportFP16()
+    inline bool doesDeviceSupportFP16(int device_id = -1)
     {
-        int device_id = getDevice();
+        if (device_id < 0)
+            device_id = getDevice();
+
         if (device_id < 0)
             return false;
 
@@ -87,9 +91,7 @@ namespace cv { namespace dnn { namespace cuda4dnn {
         CUDA4DNN_CHECK_CUDA(cudaDeviceGetAttribute(&minor, cudaDevAttrComputeCapabilityMinor, device_id));
 
         int version = major * 10 + minor;
-        if (version < 53)
-            return false;
-        return true;
+        return (version >= 53);
     }
 
 }}} /* namespace cv::dnn::cuda4dnn */
diff --git a/modules/dnn/src/net_impl_backend.cpp b/modules/dnn/src/net_impl_backend.cpp
@@ -10,6 +10,10 @@
 #include "backend.hpp"
 #include "factory.hpp"
 
+#ifdef HAVE_CUDA
+#include "cuda4dnn/init.hpp"
+#endif
+
 namespace cv {
 namespace dnn {
 CV__DNN_INLINE_NS_BEGIN
@@ -242,6 +246,16 @@ void Net::Impl::setPreferableTarget(int targetId)
 #endif
         }
 
+        if (IS_DNN_CUDA_TARGET(targetId))
+        {
+            preferableTarget = DNN_TARGET_CPU;
+#ifdef HAVE_CUDA
+            if (cuda4dnn::doesDeviceSupportFP16() && targetId == DNN_TARGET_CUDA_FP16)
+                preferableTarget = DNN_TARGET_CUDA_FP16;
+            else
+                preferableTarget = DNN_TARGET_CUDA;
+#endif
+        }
 #if !defined(__arm64__) || !__arm64__
         if (targetId == DNN_TARGET_CPU_FP16)
         {
diff --git a/modules/dnn/src/registry.cpp b/modules/dnn/src/registry.cpp
@@ -18,6 +18,10 @@
 #include "backend.hpp"
 #include "factory.hpp"
 
+#ifdef HAVE_CUDA
+#include "cuda4dnn/init.hpp"
+#endif
+
 namespace cv {
 namespace dnn {
 CV__DNN_INLINE_NS_BEGIN
@@ -118,10 +122,28 @@ class BackendRegistry
 #endif
 
 #ifdef HAVE_CUDA
-        if (haveCUDA())
+        cuda4dnn::checkVersions();
+
+        bool hasCudaCompatible = false;
+        bool hasCudaFP16 = false;
+        for (int i = 0; i < cuda4dnn::getDeviceCount(); i++)
+        {
+            if (cuda4dnn::isDeviceCompatible(i))
+            {
+                hasCudaCompatible = true;
+                if (cuda4dnn::doesDeviceSupportFP16(i))
+                {
+                    hasCudaFP16 = true;
+                    break; // we already have all we need here
+                }
+            }
+        }
+
+        if (hasCudaCompatible)
         {
             backends.push_back(std::make_pair(DNN_BACKEND_CUDA, DNN_TARGET_CUDA));
-            backends.push_back(std::make_pair(DNN_BACKEND_CUDA, DNN_TARGET_CUDA_FP16));
+            if (hasCudaFP16)
+                backends.push_back(std::make_pair(DNN_BACKEND_CUDA, DNN_TARGET_CUDA_FP16));
         }
 #endif
 
diff --git a/modules/dnn/test/test_common.hpp b/modules/dnn/test/test_common.hpp
@@ -211,7 +211,7 @@ class DNNTestLayer : public TestWithParam<tuple<Backend, Target> >
             if ((!l->supportBackend(backend) || l->preferableTarget != target) && !fused)
             {
                 hasFallbacks = true;
-                std::cout << "FALLBACK: Layer [" << l->type << "]:[" << l->name << "] is expected to has backend implementation" << endl;
+                std::cout << "FALLBACK: Layer [" << l->type << "]:[" << l->name << "] is expected to have backend implementation" << endl;
             }
         }
         if (hasFallbacks && raiseError)
diff --git a/modules/dnn/test/test_onnx_conformance.cpp b/modules/dnn/test/test_onnx_conformance.cpp
@@ -1016,7 +1016,7 @@ class Test_ONNX_conformance : public TestWithParam<ONNXConfParams>
             if ((!l->supportBackend(backend) || l->preferableTarget != target) && !fused)
             {
                 hasFallbacks = true;
-                std::cout << "FALLBACK: Layer [" << l->type << "]:[" << l->name << "] is expected to has backend implementation" << endl;
+                std::cout << "FALLBACK: Layer [" << l->type << "]:[" << l->name << "] is expected to have backend implementation" << endl;
             }
         }
         return hasFallbacks;

Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@`
`15`	`15`
`16`	`16`	`namespace cv { namespace dnn { namespace cuda4dnn {`
`17`	`17`
`18`		`- void checkVersions()`
	`18`	`+ inline void checkVersions()`
`19`	`19`	`{`
`20`	`20`	`// https://docs.nvidia.com/deeplearning/cudnn/developer-guide/index.html#programming-model`
`21`	`21`	`// cuDNN API Compatibility`
`@@ -44,21 +44,23 @@ namespace cv { namespace dnn { namespace cuda4dnn {`
`44`	`44`	`}`
`45`	`45`	`}`
`46`	`46`
`47`		`- int getDeviceCount()`
	`47`	`+ inline int getDeviceCount()`
`48`	`48`	`{`
`49`	`49`	`return cuda::getCudaEnabledDeviceCount();`
`50`	`50`	`}`
`51`	`51`
`52`		`- int getDevice()`
	`52`	`+ inline int getDevice()`
`53`	`53`	`{`
`54`	`54`	`int device_id = -1;`
`55`	`55`	`CUDA4DNN_CHECK_CUDA(cudaGetDevice(&device_id));`
`56`	`56`	`return device_id;`
`57`	`57`	`}`
`58`	`58`
`59`		`- bool isDeviceCompatible()`
	`59`	`+ inline bool isDeviceCompatible(int device_id = -1)`
`60`	`60`	`{`
`61`		`- int device_id = getDevice();`
	`61`	`+ if (device_id < 0)`
	`62`	`+ device_id = getDevice();`
	`63`	`+`
`62`	`64`	`if (device_id < 0)`
`63`	`65`	`return false;`
`64`	`66`
`@@ -76,9 +78,11 @@ namespace cv { namespace dnn { namespace cuda4dnn {`
`76`	`78`	`return false;`
`77`	`79`	`}`
`78`	`80`
`79`		`- bool doesDeviceSupportFP16()`
	`81`	`+ inline bool doesDeviceSupportFP16(int device_id = -1)`
`80`	`82`	`{`
`81`		`- int device_id = getDevice();`
	`83`	`+ if (device_id < 0)`
	`84`	`+ device_id = getDevice();`
	`85`	`+`
`82`	`86`	`if (device_id < 0)`
`83`	`87`	`return false;`
`84`	`88`
`@@ -87,9 +91,7 @@ namespace cv { namespace dnn { namespace cuda4dnn {`
`87`	`91`	`CUDA4DNN_CHECK_CUDA(cudaDeviceGetAttribute(&minor, cudaDevAttrComputeCapabilityMinor, device_id));`
`88`	`92`
`89`	`93`	`int version = major * 10 + minor;`
`90`		`- if (version < 53)`
`91`		`- return false;`
`92`		`- return true;`
	`94`	`+ return (version >= 53);`
`93`	`95`	`}`
`94`	`96`
`95`	`97`	`}}} /* namespace cv::dnn::cuda4dnn */`
Original file line number	Diff line number	Diff line change
`@@ -211,7 +211,7 @@ class DNNTestLayer : public TestWithParam<tuple<Backend, Target> >`
`211`	`211`	`if ((!l->supportBackend(backend) \|\| l->preferableTarget != target) && !fused)`
`212`	`212`	`{`
`213`	`213`	`hasFallbacks = true;`
`214`		`- std::cout << "FALLBACK: Layer [" << l->type << "]:[" << l->name << "] is expected to has backend implementation" << endl;`
	`214`	`+ std::cout << "FALLBACK: Layer [" << l->type << "]:[" << l->name << "] is expected to have backend implementation" << endl;`
`215`	`215`	`}`
`216`	`216`	`}`
`217`	`217`	`if (hasFallbacks && raiseError)`
Original file line number	Diff line number	Diff line change
`@@ -1016,7 +1016,7 @@ class Test_ONNX_conformance : public TestWithParam<ONNXConfParams>`
`1016`	`1016`	`if ((!l->supportBackend(backend) \|\| l->preferableTarget != target) && !fused)`
`1017`	`1017`	`{`
`1018`	`1018`	`hasFallbacks = true;`
`1019`		`- std::cout << "FALLBACK: Layer [" << l->type << "]:[" << l->name << "] is expected to has backend implementation" << endl;`
	`1019`	`+ std::cout << "FALLBACK: Layer [" << l->type << "]:[" << l->name << "] is expected to have backend implementation" << endl;`
`1020`	`1020`	`}`
`1021`	`1021`	`}`
`1022`	`1022`	`return hasFallbacks;`