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,11 +53,10 @@ using namespace cv::cuda;
 namespace
 {
     class MemoryPool;
-}
 
-class cv::cuda::MemoryStack
+    class MemoryStack
-{
+    {
-public:
+    public:
         uchar* requestMemory(size_t size);
         void returnMemory(uchar* ptr);
 
@@ -68,13 +67,13 @@ public:
         bool isFree;
         MemoryPool* pool;
 
-#if !defined(NDEBUG)
+    #if !defined(NDEBUG)
         std::vector<size_t> allocations;
-#endif
+    #endif
-};
+    };
 
-uchar* cv::cuda::MemoryStack::requestMemory(size_t size)
+    uchar* MemoryStack::requestMemory(size_t size)
-{
+    {
         const size_t freeMem = dataend - tip;
 
         if (size > freeMem)
@@ -84,24 +83,25 @@ uchar* cv::cuda::MemoryStack::requestMemory(size_t size)
 
         tip += size;
 
-#if !defined(NDEBUG)
+    #if !defined(NDEBUG)
         allocations.push_back(size);
-#endif
+    #endif
 
         return ptr;
-}
+    }
 
-void cv::cuda::MemoryStack::returnMemory(uchar* ptr)
+    void MemoryStack::returnMemory(uchar* ptr)
-{
+    {
         CV_DbgAssert( ptr >= datastart && ptr < dataend );
 
-#if !defined(NDEBUG)
+    #if !defined(NDEBUG)
         const size_t allocSize = tip - ptr;
         CV_Assert( allocSize == allocations.back() );
         allocations.pop_back();
-#endif
+    #endif
 
         tip = ptr;
+    }
 }
 
 #endif
@@ -271,6 +271,11 @@ public:
 
 #else
 
+namespace
+{
+    class StackAllocator;
+}
+
 class cv::cuda::Stream::Impl
 {
 public:
@@ -540,10 +545,27 @@ 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)
         {
             const int deviceId = getDevice();
@@ -551,18 +573,16 @@ cv::cuda::StackAllocator::StackAllocator(cudaStream_t stream) : stream_(stream),
             DeviceInfo devInfo(deviceId);
             alignment_ = devInfo.textureAlignment();
         }
-}
+    }
 
-cv::cuda::StackAllocator::~StackAllocator()
+    StackAllocator::~StackAllocator()
-{
+    {
         cudaStreamSynchronize(stream_);
 
         if (memStack_ != 0)
             memStack_->pool->returnMemStack(memStack_);
-}
+    }
 
-namespace
-{
     size_t alignUp(size_t what, size_t alignment)
     {
         size_t alignMask = alignment-1;
@@ -570,10 +590,9 @@ 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;
 
@@ -601,24 +620,41 @@ bool cv::cuda::StackAllocator::allocate(GpuMat* mat, int rows, int cols, size_t
         mat->refcount = (int*) fastMalloc(sizeof(int));
 
         return true;
-}
+    }
 
-void cv::cuda::StackAllocator::free(GpuMat* mat)
+    void StackAllocator::free(GpuMat* mat)
-{
+    {
         if (memStack_ == 0)
             return;
 
         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