Merge pull request opencv#10180 from alalek:ocl_avoid_unnecessary_initialization

vpisarev · vpisarev · commit f5dba12762b8 · 2017-11-29T11:42:22.000Z
diff --git a/modules/calib3d/src/stereobm.cpp b/modules/calib3d/src/stereobm.cpp
@@ -1108,7 +1108,7 @@ class StereoBMImpl : public StereoBM
         int FILTERED = (params.minDisparity - 1) << disp_shift;
 
 #ifdef HAVE_OPENCL
-        if(ocl::useOpenCL() && disparr.isUMat() && params.textureThreshold == 0)
+        if(ocl::isOpenCLActivated() && disparr.isUMat() && params.textureThreshold == 0)
         {
             UMat left, right;
             if(ocl_prefiltering(leftarr, rightarr, left, right, &params))
diff --git a/modules/core/include/opencv2/core/opencl/ocl_defs.hpp b/modules/core/include/opencv2/core/opencl/ocl_defs.hpp
@@ -5,15 +5,30 @@
 // Copyright (C) 2014, Advanced Micro Devices, Inc., all rights reserved.
 // Third party copyrights are property of their respective owners.
 
+#ifndef OPENCV_CORE_OPENCL_DEFS_HPP
+#define OPENCV_CORE_OPENCL_DEFS_HPP
+
 #include "opencv2/core/utility.hpp"
+#include "cvconfig.h"
+
+namespace cv { namespace ocl {
+#ifdef HAVE_OPENCL
+/// Call is similar to useOpenCL() but doesn't try to load OpenCL runtime or create OpenCL context
+CV_EXPORTS bool isOpenCLActivated();
+#else
+static inline bool isOpenCLActivated() { return false; }
+#endif
+}} // namespace
+
+
 //#define CV_OPENCL_RUN_ASSERT
 
 #ifdef HAVE_OPENCL
 
 #ifdef CV_OPENCL_RUN_VERBOSE
 #define CV_OCL_RUN_(condition, func, ...)                                   \
     {                                                                       \
-        if (cv::ocl::useOpenCL() && (condition) && func)                    \
+        if (cv::ocl::isOpenCLActivated() && (condition) && func)            \
         {                                                                   \
             printf("%s: OpenCL implementation is running\n", CV_Func);      \
             fflush(stdout);                                                 \
@@ -29,7 +44,7 @@
 #elif defined CV_OPENCL_RUN_ASSERT
 #define CV_OCL_RUN_(condition, func, ...)                                   \
     {                                                                       \
-        if (cv::ocl::useOpenCL() && (condition))                            \
+        if (cv::ocl::isOpenCLActivated() && (condition))                    \
         {                                                                   \
             if(func)                                                        \
             {                                                               \
@@ -44,7 +59,7 @@
     }
 #else
 #define CV_OCL_RUN_(condition, func, ...)                                   \
-    if (cv::ocl::useOpenCL() && (condition) && func)                        \
+    if (cv::ocl::isOpenCLActivated() && (condition) && func)                \
     {                                                                       \
         CV_IMPL_ADD(CV_IMPL_OCL);                                           \
         return __VA_ARGS__;                                                 \
@@ -56,3 +71,5 @@
 #endif
 
 #define CV_OCL_RUN(condition, func) CV_OCL_RUN_(condition, func)
+
+#endif // OPENCV_CORE_OPENCL_DEFS_HPP
diff --git a/modules/core/src/convert.cpp b/modules/core/src/convert.cpp
@@ -44,6 +44,7 @@
 #include "precomp.hpp"
 
 #include "opencl_kernels_core.hpp"
+
 #include "convert.hpp"
 
 #include "opencv2/core/openvx/ovx_defs.hpp"
@@ -897,14 +898,16 @@ void cv::extractChannel(InputArray _src, OutputArray _dst, int coi)
     CV_Assert( 0 <= coi && coi < cn );
     int ch[] = { coi, 0 };
 
-    if (ocl::useOpenCL() && _src.dims() <= 2 && _dst.isUMat())
+#ifdef HAVE_OPENCL
+    if (ocl::isOpenCLActivated() && _src.dims() <= 2 && _dst.isUMat())
     {
         UMat src = _src.getUMat();
         _dst.create(src.dims, &src.size[0], depth);
         UMat dst = _dst.getUMat();
         mixChannels(std::vector<UMat>(1, src), std::vector<UMat>(1, dst), ch, 1);
         return;
     }
+#endif
 
     Mat src = _src.getMat();
     _dst.create(src.dims, &src.size[0], depth);
@@ -925,12 +928,14 @@ void cv::insertChannel(InputArray _src, InputOutputArray _dst, int coi)
     CV_Assert( 0 <= coi && coi < dcn && scn == 1 );
 
     int ch[] = { 0, coi };
-    if (ocl::useOpenCL() && _src.dims() <= 2 && _dst.isUMat())
+#ifdef HAVE_OPENCL
+    if (ocl::isOpenCLActivated() && _src.dims() <= 2 && _dst.isUMat())
     {
         UMat src = _src.getUMat(), dst = _dst.getUMat();
         mixChannels(std::vector<UMat>(1, src), std::vector<UMat>(1, dst), ch, 1);
         return;
     }
+#endif
 
     Mat src = _src.getMat(), dst = _dst.getMat();
 
diff --git a/modules/core/src/ocl.cpp b/modules/core/src/ocl.cpp
@@ -423,7 +423,7 @@ struct OpenCLBinaryCacheConfigurator
                     {
                         CV_LOG_WARNING(NULL, "- " << remove_entries[i]);
                     }
-                    CV_LOG_WARNING(NULL,"Note: You can disable this behavior via this option: CV_OPENCL_CACHE_CLEANUP=0");
+                    CV_LOG_WARNING(NULL, "Note: You can disable this behavior via this option: OPENCV_OPENCL_CACHE_CLEANUP=0");
 
                     for (size_t i = 0; i < remove_entries.size(); i++)
                     {
@@ -781,18 +781,34 @@ class BinaryProgramFile
 #endif // OPENCV_HAVE_FILESYSTEM_SUPPORT
 
 
+// true if we have initialized OpenCL subsystem with available platforms
+static bool g_isOpenCVActivated = false;
+
 bool haveOpenCL()
 {
+    CV_TRACE_FUNCTION();
 #ifdef HAVE_OPENCL
     static bool g_isOpenCLInitialized = false;
     static bool g_isOpenCLAvailable = false;
 
     if (!g_isOpenCLInitialized)
     {
+        CV_TRACE_REGION("Init_OpenCL_Runtime");
+        const char* envPath = getenv("OPENCV_OPENCL_RUNTIME");
+        if (envPath)
+        {
+            if (cv::String(envPath) == "disabled")
+            {
+                g_isOpenCLAvailable = false;
+                g_isOpenCLInitialized = true;
+            }
+        }
+        CV_LOG_INFO(NULL, "Initialize OpenCL runtime...");
         try
         {
             cl_uint n = 0;
             g_isOpenCLAvailable = ::clGetPlatformIDs(0, NULL, &n) == CL_SUCCESS;
+            g_isOpenCVActivated = n > 0;
         }
         catch (...)
         {
@@ -813,7 +829,7 @@ bool useOpenCL()
     {
         try
         {
-            data->useOpenCL = (int)haveOpenCL() && Device::getDefault().ptr() && Device::getDefault().available();
+            data->useOpenCL = (int)(haveOpenCL() && Device::getDefault().ptr() && Device::getDefault().available()) ? 1 : 0;
         }
         catch (...)
         {
@@ -823,12 +839,27 @@ bool useOpenCL()
     return data->useOpenCL > 0;
 }
 
+#ifdef HAVE_OPENCL
+bool isOpenCLActivated()
+{
+    if (!g_isOpenCVActivated)
+        return false; // prevent unnecessary OpenCL activation via useOpenCL()->haveOpenCL() calls
+    return useOpenCL();
+}
+#endif
+
 void setUseOpenCL(bool flag)
 {
-    if( haveOpenCL() )
+    CV_TRACE_FUNCTION();
+
+    CoreTLSData* data = getCoreTlsData().get();
+    if (!flag)
     {
-        CoreTLSData* data = getCoreTlsData().get();
-        data->useOpenCL = (flag && Device::getDefault().ptr() != NULL) ? 1 : 0;
+        data->useOpenCL = 0;
+    }
+    else if( haveOpenCL() )
+    {
+        data->useOpenCL = (Device::getDefault().ptr() != NULL) ? 1 : 0;
     }
 }
 
@@ -5289,9 +5320,15 @@ class OpenCLAllocator : public MatAllocator
     }
 };
 
+static OpenCLAllocator* getOpenCLAllocator_() // call once guarantee
+{
+    static OpenCLAllocator* g_allocator = new OpenCLAllocator(); // avoid destrutor call (using of this object is too wide)
+    g_isOpenCVActivated = true;
+    return g_allocator;
+}
 MatAllocator* getOpenCLAllocator()
 {
-    CV_SINGLETON_LAZY_INIT(MatAllocator, new OpenCLAllocator())
+    CV_SINGLETON_LAZY_INIT(MatAllocator, getOpenCLAllocator_())
 }
 
 }} // namespace cv::ocl
diff --git a/modules/core/src/trace.cpp b/modules/core/src/trace.cpp
@@ -8,6 +8,8 @@
 #include <opencv2/core/utils/trace.private.hpp>
 #include <opencv2/core/utils/configuration.private.hpp>
 
+#include <opencv2/core/opencl/ocl_defs.hpp>
+
 #include <cstdarg> // va_start
 
 #include <sstream>
@@ -596,7 +598,7 @@ void Region::destroy()
 #endif
 #ifdef HAVE_OPENCL
         case REGION_FLAG_IMPL_OPENCL:
-            if (param_synchronizeOpenCL && cv::ocl::useOpenCL())
+            if (param_synchronizeOpenCL && cv::ocl::isOpenCLActivated())
                 cv::ocl::finish();
             myCodePath = Impl::CODE_PATH_OPENCL;
             break;
diff --git a/modules/core/src/umatrix.cpp b/modules/core/src/umatrix.cpp
@@ -141,7 +141,7 @@ void UMatData::unlock()
 MatAllocator* UMat::getStdAllocator()
 {
 #ifdef HAVE_OPENCL
-    if( ocl::haveOpenCL() && ocl::useOpenCL() )
+    if (ocl::useOpenCL())
         return ocl::getOpenCLAllocator();
 #endif
     return Mat::getDefaultAllocator();
diff --git a/modules/features2d/src/fast.cpp b/modules/features2d/src/fast.cpp
@@ -422,33 +422,27 @@ void FAST(InputArray _img, std::vector<KeyPoint>& keypoints, int threshold, bool
 {
     CV_INSTRUMENT_REGION()
 
-#ifdef HAVE_OPENCL
-  if( ocl::useOpenCL() && _img.isUMat() && type == FastFeatureDetector::TYPE_9_16 &&
-      ocl_FAST(_img, keypoints, threshold, nonmax_suppression, 10000))
-  {
-    CV_IMPL_ADD(CV_IMPL_OCL);
-    return;
-  }
-#endif
+    CV_OCL_RUN(_img.isUMat() && type == FastFeatureDetector::TYPE_9_16,
+               ocl_FAST(_img, keypoints, threshold, nonmax_suppression, 10000));
 
     CV_OVX_RUN(true,
                openvx_FAST(_img, keypoints, threshold, nonmax_suppression, type))
 
-  switch(type) {
+    switch(type) {
     case FastFeatureDetector::TYPE_5_8:
-      FAST_t<8>(_img, keypoints, threshold, nonmax_suppression);
-      break;
+        FAST_t<8>(_img, keypoints, threshold, nonmax_suppression);
+        break;
     case FastFeatureDetector::TYPE_7_12:
-      FAST_t<12>(_img, keypoints, threshold, nonmax_suppression);
-      break;
+        FAST_t<12>(_img, keypoints, threshold, nonmax_suppression);
+        break;
     case FastFeatureDetector::TYPE_9_16:
 #ifdef HAVE_TEGRA_OPTIMIZATION
-      if(tegra::useTegra() && tegra::FAST(_img, keypoints, threshold, nonmax_suppression))
-        break;
+        if(tegra::useTegra() && tegra::FAST(_img, keypoints, threshold, nonmax_suppression))
+          break;
 #endif
-      FAST_t<16>(_img, keypoints, threshold, nonmax_suppression);
-      break;
-  }
+        FAST_t<16>(_img, keypoints, threshold, nonmax_suppression);
+        break;
+    }
 }
 
 
diff --git a/modules/features2d/src/kaze/AKAZEFeatures.cpp b/modules/features2d/src/kaze/AKAZEFeatures.cpp
@@ -520,7 +520,7 @@ convertScalePyramid(const std::vector<Evolution<MatTypeSrc> >& src, std::vector<
  */
 void AKAZEFeatures::Create_Nonlinear_Scale_Space(InputArray image)
 {
-  if (ocl::useOpenCL() && image.isUMat()) {
+  if (ocl::isOpenCLActivated() && image.isUMat()) {
     // will run OCL version of scale space pyramid
     UMatPyramid uPyr;
     // init UMat pyramid with sizes
diff --git a/modules/features2d/src/matchers.cpp b/modules/features2d/src/matchers.cpp
@@ -771,7 +771,7 @@ void BFMatcher::knnMatchImpl( InputArray _queryDescriptors, std::vector<std::vec
     Size trainDescSize = trainDescCollection.empty() ? utrainDescCollection[0].size() : trainDescCollection[0].size();
     int trainDescOffset = trainDescCollection.empty() ? (int)utrainDescCollection[0].offset : 0;
 
-    if ( ocl::useOpenCL() && _queryDescriptors.isUMat() && _queryDescriptors.dims()<=2 && trainDescVectorSize == 1 &&
+    if ( ocl::isOpenCLActivated() && _queryDescriptors.isUMat() && _queryDescriptors.dims()<=2 && trainDescVectorSize == 1 &&
         _queryDescriptors.type() == CV_32FC1 && _queryDescriptors.offset() == 0 && trainDescOffset == 0 &&
         trainDescSize.width == _queryDescriptors.size().width && masks.size() == 1 && masks[0].total() == 0 )
     {
@@ -919,7 +919,7 @@ void BFMatcher::radiusMatchImpl( InputArray _queryDescriptors, std::vector<std::
     Size trainDescSize = trainDescCollection.empty() ? utrainDescCollection[0].size() : trainDescCollection[0].size();
     int trainDescOffset = trainDescCollection.empty() ? (int)utrainDescCollection[0].offset : 0;
 
-    if ( ocl::useOpenCL() && _queryDescriptors.isUMat() && _queryDescriptors.dims()<=2 && trainDescVectorSize == 1 &&
+    if ( ocl::isOpenCLActivated() && _queryDescriptors.isUMat() && _queryDescriptors.dims()<=2 && trainDescVectorSize == 1 &&
         _queryDescriptors.type() == CV_32FC1 && _queryDescriptors.offset() == 0 && trainDescOffset == 0 &&
         trainDescSize.width == _queryDescriptors.size().width && masks.size() == 1 && masks[0].total() == 0 )
     {
diff --git a/modules/features2d/src/orb.cpp b/modules/features2d/src/orb.cpp
@@ -974,7 +974,7 @@ void ORB_Impl::detectAndCompute( InputArray _image, InputArray _mask,
     int descPatchSize = cvCeil(halfPatchSize*sqrt(2.0));
     int border = std::max(edgeThreshold, std::max(descPatchSize, HARRIS_BLOCK_SIZE/2))+1;
 
-    bool useOCL = ocl::useOpenCL() && OCL_FORCE_CHECK(_image.isUMat() || _descriptors.isUMat());
+    bool useOCL = ocl::isOpenCLActivated() && OCL_FORCE_CHECK(_image.isUMat() || _descriptors.isUMat());
 
     Mat image = _image.getMat(), mask = _mask.getMat();
     if( image.type() != CV_8UC1 )
diff --git a/modules/imgproc/src/clahe.cpp b/modules/imgproc/src/clahe.cpp
@@ -360,7 +360,7 @@ namespace
         CV_Assert( _src.type() == CV_8UC1 || _src.type() == CV_16UC1 );
 
 #ifdef HAVE_OPENCL
-        bool useOpenCL = cv::ocl::useOpenCL() && _src.isUMat() && _src.dims()<=2 && _src.type() == CV_8UC1;
+        bool useOpenCL = cv::ocl::isOpenCLActivated() && _src.isUMat() && _src.dims()<=2 && _src.type() == CV_8UC1;
 #endif
 
         int histSize = _src.type() == CV_8UC1 ? 256 : 65536;
diff --git a/modules/imgproc/src/deriv.cpp b/modules/imgproc/src/deriv.cpp
@@ -435,7 +435,7 @@ void cv::Sobel( InputArray _src, OutputArray _dst, int ddepth, int dx, int dy,
     CV_OVX_RUN(true,
                openvx_sobel(_src, _dst, dx, dy, ksize, scale, delta, borderType))
 
-    CV_IPP_RUN(!(ocl::useOpenCL() && _dst.isUMat()), ipp_Deriv(_src, _dst, dx, dy, ksize, scale, delta, borderType));
+    CV_IPP_RUN(!(ocl::isOpenCLActivated() && _dst.isUMat()), ipp_Deriv(_src, _dst, dx, dy, ksize, scale, delta, borderType));
 
     int ktype = std::max(CV_32F, std::max(ddepth, sdepth));
 
@@ -479,7 +479,7 @@ void cv::Scharr( InputArray _src, OutputArray _dst, int ddepth, int dx, int dy,
     }
 #endif
 
-    CV_IPP_RUN(!(ocl::useOpenCL() && _dst.isUMat()), ipp_Deriv(_src, _dst, dx, dy, 0, scale, delta, borderType));
+    CV_IPP_RUN(!(ocl::isOpenCLActivated() && _dst.isUMat()), ipp_Deriv(_src, _dst, dx, dy, 0, scale, delta, borderType));
 
     int ktype = std::max(CV_32F, std::max(ddepth, sdepth));
 
@@ -795,7 +795,7 @@ void cv::Laplacian( InputArray _src, OutputArray _dst, int ddepth, int ksize,
                    ocl_Laplacian3_8UC1(_src, _dst, ddepth, kernel, delta, borderType));
     }
 
-    CV_IPP_RUN(!(cv::ocl::useOpenCL() && _dst.isUMat()), ipp_Laplacian(_src, _dst, ksize, scale, delta, borderType));
+    CV_IPP_RUN(!(cv::ocl::isOpenCLActivated() && _dst.isUMat()), ipp_Laplacian(_src, _dst, ksize, scale, delta, borderType));
 
 
 #ifdef HAVE_TEGRA_OPTIMIZATION
diff --git a/modules/imgproc/src/smooth.cpp b/modules/imgproc/src/smooth.cpp
@@ -2102,7 +2102,7 @@ void cv::GaussianBlur( InputArray _src, OutputArray _dst, Size ksize,
     if(sigma1 == 0 && sigma2 == 0 && tegra::useTegra() && tegra::gaussian(src, dst, ksize, borderType))
         return;
 #endif
-    bool useOpenCL = (ocl::useOpenCL() && _dst.isUMat() && _src.dims() <= 2 &&
+    bool useOpenCL = (ocl::isOpenCLActivated() && _dst.isUMat() && _src.dims() <= 2 &&
                ((ksize.width == 3 && ksize.height == 3) ||
                (ksize.width == 5 && ksize.height == 5)) &&
                _src.rows() > ksize.height && _src.cols() > ksize.width);
diff --git a/modules/imgproc/src/sumpixels.cpp b/modules/imgproc/src/sumpixels.cpp
@@ -503,17 +503,8 @@ void cv::integral( InputArray _src, OutputArray _sum, OutputArray _sqsum, Output
          sqdepth = CV_64F;
     sdepth = CV_MAT_DEPTH(sdepth), sqdepth = CV_MAT_DEPTH(sqdepth);
 
-#ifdef HAVE_OPENCL
-    if (ocl::useOpenCL() && _sum.isUMat() && !_tilted.needed())
-    {
-        if (!_sqsum.needed())
-        {
-            CV_OCL_RUN(ocl::useOpenCL(), ocl_integral(_src, _sum, sdepth))
-        }
-        else if (_sqsum.isUMat())
-            CV_OCL_RUN(ocl::useOpenCL(), ocl_integral(_src, _sum, _sqsum, sdepth, sqdepth))
-    }
-#endif
+    CV_OCL_RUN(_sum.isUMat() && !_tilted.needed(),
+        (_sqsum.needed() ? ocl_integral(_src, _sum, _sqsum, sdepth, sqdepth) : ocl_integral(_src, _sum, sdepth)));
 
     Size ssize = _src.size(), isize(ssize.width + 1, ssize.height + 1);
     _sum.create( isize, CV_MAKETYPE(sdepth, cn) );
diff --git a/modules/objdetect/src/cascadedetect.cpp b/modules/objdetect/src/cascadedetect.cpp
diff --git a/modules/stitching/src/blenders.cpp b/modules/stitching/src/blenders.cpp
diff --git a/modules/stitching/src/matchers.cpp b/modules/stitching/src/matchers.cpp
diff --git a/modules/stitching/src/warpers.cpp b/modules/stitching/src/warpers.cpp
diff --git a/modules/video/src/bgfg_gaussmix2.cpp b/modules/video/src/bgfg_gaussmix2.cpp
diff --git a/modules/video/src/lkpyramid.cpp b/modules/video/src/lkpyramid.cpp

Original file line number	Diff line number	Diff line change
`@@ -1108,7 +1108,7 @@ class StereoBMImpl : public StereoBM`
`1108`	`1108`	`int FILTERED = (params.minDisparity - 1) << disp_shift;`
`1109`	`1109`
`1110`	`1110`	`#ifdef HAVE_OPENCL`
`1111`		`- if(ocl::useOpenCL() && disparr.isUMat() && params.textureThreshold == 0)`
	`1111`	`+ if(ocl::isOpenCLActivated() && disparr.isUMat() && params.textureThreshold == 0)`
`1112`	`1112`	`{`
`1113`	`1113`	`UMat left, right;`
`1114`	`1114`	`if(ocl_prefiltering(leftarr, rightarr, left, right, &params))`
Original file line number	Diff line number	Diff line change
`@@ -423,7 +423,7 @@ struct OpenCLBinaryCacheConfigurator`
`423`	`423`	`{`
`424`	`424`	`CV_LOG_WARNING(NULL, "- " << remove_entries[i]);`
`425`	`425`	`}`
`426`		`- CV_LOG_WARNING(NULL,"Note: You can disable this behavior via this option: CV_OPENCL_CACHE_CLEANUP=0");`
	`426`	`+ CV_LOG_WARNING(NULL, "Note: You can disable this behavior via this option: OPENCV_OPENCL_CACHE_CLEANUP=0");`
`427`	`427`
`428`	`428`	`for (size_t i = 0; i < remove_entries.size(); i++)`
`429`	`429`	`{`
`@@ -781,18 +781,34 @@ class BinaryProgramFile`
`781`	`781`	`#endif // OPENCV_HAVE_FILESYSTEM_SUPPORT`
`782`	`782`
`783`	`783`
	`784`	`+// true if we have initialized OpenCL subsystem with available platforms`
	`785`	`+static bool g_isOpenCVActivated = false;`
	`786`	`+`
`784`	`787`	`bool haveOpenCL()`
`785`	`788`	`{`
	`789`	`+ CV_TRACE_FUNCTION();`
`786`	`790`	`#ifdef HAVE_OPENCL`
`787`	`791`	`static bool g_isOpenCLInitialized = false;`
`788`	`792`	`static bool g_isOpenCLAvailable = false;`
`789`	`793`
`790`	`794`	`if (!g_isOpenCLInitialized)`
`791`	`795`	`{`
	`796`	`+ CV_TRACE_REGION("Init_OpenCL_Runtime");`
	`797`	`+ const char* envPath = getenv("OPENCV_OPENCL_RUNTIME");`
	`798`	`+ if (envPath)`
	`799`	`+ {`
	`800`	`+ if (cv::String(envPath) == "disabled")`
	`801`	`+ {`
	`802`	`+ g_isOpenCLAvailable = false;`
	`803`	`+ g_isOpenCLInitialized = true;`
	`804`	`+ }`
	`805`	`+ }`
	`806`	`+ CV_LOG_INFO(NULL, "Initialize OpenCL runtime...");`
`792`	`807`	`try`
`793`	`808`	`{`
`794`	`809`	`cl_uint n = 0;`
`795`	`810`	`g_isOpenCLAvailable = ::clGetPlatformIDs(0, NULL, &n) == CL_SUCCESS;`
	`811`	`+ g_isOpenCVActivated = n > 0;`
`796`	`812`	`}`
`797`	`813`	`catch (...)`
`798`	`814`	`{`
`@@ -813,7 +829,7 @@ bool useOpenCL()`
`813`	`829`	`{`
`814`	`830`	`try`
`815`	`831`	`{`
`816`		`- data->useOpenCL = (int)haveOpenCL() && Device::getDefault().ptr() && Device::getDefault().available();`
	`832`	`+ data->useOpenCL = (int)(haveOpenCL() && Device::getDefault().ptr() && Device::getDefault().available()) ? 1 : 0;`
`817`	`833`	`}`
`818`	`834`	`catch (...)`
`819`	`835`	`{`
`@@ -823,12 +839,27 @@ bool useOpenCL()`
`823`	`839`	`return data->useOpenCL > 0;`
`824`	`840`	`}`
`825`	`841`
	`842`	`+#ifdef HAVE_OPENCL`
	`843`	`+bool isOpenCLActivated()`
	`844`	`+{`
	`845`	`+ if (!g_isOpenCVActivated)`
	`846`	`+ return false; // prevent unnecessary OpenCL activation via useOpenCL()->haveOpenCL() calls`
	`847`	`+ return useOpenCL();`
	`848`	`+}`
	`849`	`+#endif`
	`850`	`+`
`826`	`851`	`void setUseOpenCL(bool flag)`
`827`	`852`	`{`
`828`		`- if( haveOpenCL() )`
	`853`	`+ CV_TRACE_FUNCTION();`
	`854`	`+`
	`855`	`+ CoreTLSData* data = getCoreTlsData().get();`
	`856`	`+ if (!flag)`
`829`	`857`	`{`
`830`		`- CoreTLSData* data = getCoreTlsData().get();`
`831`		`- data->useOpenCL = (flag && Device::getDefault().ptr() != NULL) ? 1 : 0;`
	`858`	`+ data->useOpenCL = 0;`
	`859`	`+ }`
	`860`	`+ else if( haveOpenCL() )`
	`861`	`+ {`
	`862`	`+ data->useOpenCL = (Device::getDefault().ptr() != NULL) ? 1 : 0;`
`832`	`863`	`}`
`833`	`864`	`}`
`834`	`865`
`@@ -5289,9 +5320,15 @@ class OpenCLAllocator : public MatAllocator`
`5289`	`5320`	`}`
`5290`	`5321`	`};`
`5291`	`5322`
	`5323`	`+static OpenCLAllocator* getOpenCLAllocator_() // call once guarantee`
	`5324`	`+{`
	`5325`	`+ static OpenCLAllocator* g_allocator = new OpenCLAllocator(); // avoid destrutor call (using of this object is too wide)`
	`5326`	`+ g_isOpenCVActivated = true;`
	`5327`	`+ return g_allocator;`
	`5328`	`+}`
`5292`	`5329`	`MatAllocator* getOpenCLAllocator()`
`5293`	`5330`	`{`
`5294`		`- CV_SINGLETON_LAZY_INIT(MatAllocator, new OpenCLAllocator())`
	`5331`	`+ CV_SINGLETON_LAZY_INIT(MatAllocator, getOpenCLAllocator_())`
`5295`	`5332`	`}`
`5296`	`5333`
`5297`	`5334`	`}} // namespace cv::ocl`
Original file line number	Diff line number	Diff line change
`@@ -141,7 +141,7 @@ void UMatData::unlock()`
`141`	`141`	`MatAllocator* UMat::getStdAllocator()`
`142`	`142`	`{`
`143`	`143`	`#ifdef HAVE_OPENCL`
`144`		`- if( ocl::haveOpenCL() && ocl::useOpenCL() )`
	`144`	`+ if (ocl::useOpenCL())`
`145`	`145`	`return ocl::getOpenCLAllocator();`
`146`	`146`	`#endif`
`147`	`147`	`return Mat::getDefaultAllocator();`
Original file line number	Diff line number	Diff line change
`@@ -520,7 +520,7 @@ convertScalePyramid(const std::vector<Evolution<MatTypeSrc> >& src, std::vector<`
`520`	`520`	`*/`
`521`	`521`	`void AKAZEFeatures::Create_Nonlinear_Scale_Space(InputArray image)`
`522`	`522`	`{`
`523`		`- if (ocl::useOpenCL() && image.isUMat()) {`
	`523`	`+ if (ocl::isOpenCLActivated() && image.isUMat()) {`
`524`	`524`	`// will run OCL version of scale space pyramid`
`525`	`525`	`UMatPyramid uPyr;`
`526`	`526`	`// init UMat pyramid with sizes`