move StackAllocator to cpp file

it is internal class, no need to export it

modules/core/include/opencv2/core/private.cuda.hpp

@@ -92,26 +92,6 @@ static inline void throw_no_cuda() { CV_Error(cv::Error::StsNotImplemented, "The
 
 namespace cv { namespace cuda
 {
-    class MemoryStack;
-
-    class CV_EXPORTS StackAllocator : public GpuMat::Allocator
-    {
-    public:
-        explicit StackAllocator(cudaStream_t stream);
-        ~StackAllocator();
-
-        bool allocate(GpuMat* mat, int rows, int cols, size_t elemSize);
-        void free(GpuMat* mat);
-
-    private:
-        StackAllocator(const StackAllocator&);
-        StackAllocator& operator =(const StackAllocator&);
-
-        cudaStream_t stream_;
-        MemoryStack* memStack_;
-        size_t alignment_;
-    };
-
     class CV_EXPORTS BufferPool
     {
     public:
@@ -120,6 +100,8 @@ namespace cv { namespace cuda
         GpuMat getBuffer(int rows, int cols, int type);
         GpuMat getBuffer(Size size, int type) { return getBuffer(size.height, size.width, type); }
 
+        GpuMat::Allocator* getAllocator() const { return allocator_; }
+
     private:
         GpuMat::Allocator* allocator_;
     };

modules/core/src/cuda_stream.cpp

@@ -53,9 +53,8 @@ using namespace cv::cuda;
 namespace
 {
     class MemoryPool;
-}
 
-class cv::cuda::MemoryStack
+    class MemoryStack
     {
     public:
         uchar* requestMemory(size_t size);
@@ -73,7 +72,7 @@ public:
     #endif
     };
 
-uchar* cv::cuda::MemoryStack::requestMemory(size_t size)
+    uchar* MemoryStack::requestMemory(size_t size)
     {
         const size_t freeMem = dataend - tip;
 
@@ -91,7 +90,7 @@ uchar* cv::cuda::MemoryStack::requestMemory(size_t size)
         return ptr;
     }
 
-void cv::cuda::MemoryStack::returnMemory(uchar* ptr)
+    void MemoryStack::returnMemory(uchar* ptr)
     {
         CV_DbgAssert( ptr >= datastart && ptr < dataend );
 
@@ -103,6 +102,7 @@ void cv::cuda::MemoryStack::returnMemory(uchar* ptr)
 
         tip = ptr;
     }
+}
 
 #endif
 
@@ -271,6 +271,11 @@ public:
 
 #else
 
+namespace
+{
+    class StackAllocator;
+}
+
 class cv::cuda::Stream::Impl
 {
 public:
@@ -540,9 +545,26 @@ cudaStream_t cv::cuda::StreamAccessor::getStream(const Stream& stream)
 namespace
 {
     bool enableMemoryPool = true;
-}
 
-cv::cuda::StackAllocator::StackAllocator(cudaStream_t stream) : stream_(stream), memStack_(0)
+    class StackAllocator : public GpuMat::Allocator
+    {
+    public:
+        explicit StackAllocator(cudaStream_t stream);
+        ~StackAllocator();
+
+        bool allocate(GpuMat* mat, int rows, int cols, size_t elemSize);
+        void free(GpuMat* mat);
+
+    private:
+        StackAllocator(const StackAllocator&);
+        StackAllocator& operator =(const StackAllocator&);
+
+        cudaStream_t stream_;
+        MemoryStack* memStack_;
+        size_t alignment_;
+    };
+
+    StackAllocator::StackAllocator(cudaStream_t stream) : stream_(stream), memStack_(0)
     {
         if (enableMemoryPool)
         {
@@ -553,7 +575,7 @@ cv::cuda::StackAllocator::StackAllocator(cudaStream_t stream) : stream_(stream),
         }
     }
 
-cv::cuda::StackAllocator::~StackAllocator()
+    StackAllocator::~StackAllocator()
     {
         cudaStreamSynchronize(stream_);
 
@@ -561,8 +583,6 @@ cv::cuda::StackAllocator::~StackAllocator()
             memStack_->pool->returnMemStack(memStack_);
     }
 
-namespace
-{
     size_t alignUp(size_t what, size_t alignment)
     {
         size_t alignMask = alignment-1;
@@ -570,9 +590,8 @@ namespace
         size_t res = (what + alignMask) & inverseAlignMask;
         return res;
     }
-}
 
-bool cv::cuda::StackAllocator::allocate(GpuMat* mat, int rows, int cols, size_t elemSize)
+    bool StackAllocator::allocate(GpuMat* mat, int rows, int cols, size_t elemSize)
     {
         if (memStack_ == 0)
             return false;
@@ -603,7 +622,7 @@ bool cv::cuda::StackAllocator::allocate(GpuMat* mat, int rows, int cols, size_t
         return true;
     }
 
-void cv::cuda::StackAllocator::free(GpuMat* mat)
+    void StackAllocator::free(GpuMat* mat)
     {
         if (memStack_ == 0)
             return;
@@ -611,14 +630,31 @@ void cv::cuda::StackAllocator::free(GpuMat* mat)
         memStack_->returnMemory(mat->datastart);
         fastFree(mat->refcount);
     }
+}
+
+#endif
+
+/////////////////////////////////////////////////////////////
+/// BufferPool
 
 void cv::cuda::setBufferPoolUsage(bool on)
 {
+#ifndef HAVE_CUDA
+    (void)on;
+    throw_no_cuda();
+#else
     enableMemoryPool = on;
+#endif
 }
 
 void cv::cuda::setBufferPoolConfig(int deviceId, size_t stackSize, int stackCount)
 {
+#ifndef HAVE_CUDA
+    (void)deviceId;
+    (void)stackSize;
+    (void)stackCount;
+    throw_no_cuda();
+#else
     const int currentDevice = getDevice();
 
     if (deviceId >= 0)
@@ -638,12 +674,8 @@ void cv::cuda::setBufferPoolConfig(int deviceId, size_t stackSize, int stackCoun
     }
 
     setDevice(currentDevice);
-}
-
 #endif
-
-/////////////////////////////////////////////////////////////
-/// BufferPool
+}
 
 #ifdef HAVE_CUDA