added BufferPool class

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

@@ -398,6 +398,7 @@ private:
     Stream(const Ptr<Impl>& impl);
 
     friend struct StreamAccessor;
+    friend class BufferPool;
 };
 
 class CV_EXPORTS Event

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

@@ -92,24 +92,36 @@ namespace cv { namespace cuda
 {
     class MemoryStack;
 
-    class CV_EXPORTS BufferAllocator : public GpuMat::Allocator
+    class CV_EXPORTS StackAllocator : public GpuMat::Allocator
     {
     public:
-        explicit BufferAllocator(Stream& stream);
-        ~BufferAllocator();
+        explicit StackAllocator(cudaStream_t stream);
+        ~StackAllocator();
 
         bool allocate(uchar** devPtr, size_t* step, int** refcount, int rows, int cols, size_t elemSize);
         void free(uchar* devPtr, int* refcount);
 
     private:
-        BufferAllocator(const BufferAllocator&);
-        BufferAllocator& operator =(const BufferAllocator&);
+        StackAllocator(const StackAllocator&);
+        StackAllocator& operator =(const StackAllocator&);
 
+        cudaStream_t stream_;
         MemoryStack* memStack_;
-        Stream stream_;
         size_t alignment_;
     };
 
+    class CV_EXPORTS BufferPool
+    {
+    public:
+        explicit BufferPool(Stream& stream);
+
+        GpuMat getBuffer(int rows, int cols, int type);
+        GpuMat getBuffer(Size size, int type) { return getBuffer(size.height, size.width, type); }
+
+    private:
+        GpuMat::Allocator* allocator_;
+    };
+
     CV_EXPORTS void setBufferAllocatorUsage(bool on);
     CV_EXPORTS void allocateMemoryPool(int deviceId, size_t stackSize, int stackCount);
 

modules/core/src/cuda_buffer_pool.cpp

@@ -299,14 +299,14 @@ namespace
 }
 
 /////////////////////////////////////////////////////////////
-/// BufferAllocator
+/// StackAllocator
 
 namespace
 {
     bool enableMemoryPool = true;
 }
 
-cv::cuda::BufferAllocator::BufferAllocator(Stream& stream) : memStack_(0), stream_(stream)
+cv::cuda::StackAllocator::StackAllocator(cudaStream_t stream) : stream_(stream), memStack_(0)
 {
     if (enableMemoryPool)
     {
@@ -318,19 +318,12 @@ cv::cuda::BufferAllocator::BufferAllocator(Stream& stream) : memStack_(0), strea
     }
 }
 
-namespace
+cv::cuda::StackAllocator::~StackAllocator()
 {
-    void CUDART_CB returnMemStackCallback(cudaStream_t, cudaError_t, void* userData)
-    {
-        MemoryStack* memStack = static_cast<MemoryStack*>(userData);
-        memStack->pool->returnMemStack(memStack);
-    }
-}
+    cudaStreamSynchronize(stream_);
 
-cv::cuda::BufferAllocator::~BufferAllocator()
-{
     if (memStack_ != 0)
-        CV_CUDEV_SAFE_CALL( cudaStreamAddCallback(StreamAccessor::getStream(stream_), returnMemStackCallback, memStack_, 0) );
+        memStack_->pool->returnMemStack(memStack_);
 }
 
 namespace
@@ -344,7 +337,7 @@ namespace
     }
 }
 
-bool cv::cuda::BufferAllocator::allocate(uchar** devPtr, size_t* step, int** refcount, int rows, int cols, size_t elemSize)
+bool cv::cuda::StackAllocator::allocate(uchar** devPtr, size_t* step, int** refcount, int rows, int cols, size_t elemSize)
 {
     if (memStack_ == 0)
         return false;
@@ -376,7 +369,7 @@ bool cv::cuda::BufferAllocator::allocate(uchar** devPtr, size_t* step, int** ref
     return true;
 }
 
-void cv::cuda::BufferAllocator::free(uchar* devPtr, int* refcount)
+void cv::cuda::StackAllocator::free(uchar* devPtr, int* refcount)
 {
     if (memStack_ == 0)
         return;
@@ -413,4 +406,14 @@ void cv::cuda::allocateMemoryPool(int deviceId, size_t stackSize, int stackCount
     setDevice(currentDevice);
 }
 
+/////////////////////////////////////////////////////////////
+/// BufferPool
+
+GpuMat cv::cuda::BufferPool::getBuffer(int rows, int cols, int type)
+{
+    GpuMat buf(allocator_);
+    buf.create(rows, cols, type);
+    return buf;
+}
+
 #endif

modules/core/src/cuda_stream.cpp

@@ -66,6 +66,7 @@ class cv::cuda::Stream::Impl
 {
 public:
     cudaStream_t stream;
+    Ptr<StackAllocator> stackAllocator_;
 
     Impl();
     Impl(cudaStream_t stream);
@@ -73,17 +74,26 @@ public:
     ~Impl();
 };
 
+cv::cuda::BufferPool::BufferPool(Stream& stream) : allocator_(stream.impl_->stackAllocator_.get())
+{
+}
+
 cv::cuda::Stream::Impl::Impl() : stream(0)
 {
     cudaSafeCall( cudaStreamCreate(&stream) );
+
+    stackAllocator_ = makePtr<StackAllocator>(stream);
 }
 
 cv::cuda::Stream::Impl::Impl(cudaStream_t stream_) : stream(stream_)
 {
+    stackAllocator_ = makePtr<StackAllocator>(stream);
 }
 
 cv::cuda::Stream::Impl::~Impl()
 {
+    stackAllocator_.release();
+
     if (stream)
         cudaStreamDestroy(stream);
 }