generic-library/opencv
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

fixed bugs in page locked memory allocation

Browse Source 
avoid extra gpu memory allocation in BP and CSBP
This commit is contained in:
Anatoly Baksheev
2010-08-17 10:39:18 +00:00
parent ba713f28f9
commit 9a669b1ceb
6 changed files with 95 additions and 100 deletions
Download Patch File Download Diff File Expand all files Collapse all files

56
modules/gpu/include/opencv2/gpu/gpu.hpp
View File

@@ -68,7 +68,7 @@ namespace cv
//////////////////////////////// GpuMat ////////////////////////////////
class Stream;
class MatPL;
class CudaMem;
//! Smart pointer for GPU memory with reference counting. Its interface is mostly similar with cv::Mat.
class CV_EXPORTS GpuMat
@@ -111,12 +111,16 @@ namespace cv
//! pefroms blocking upload data to GpuMat. .
void upload(const cv::Mat& m);
void upload(const MatPL& m, Stream& stream);
//! Downloads data from device to host memory. Blocking calls.
//! upload async
void upload(const CudaMem& m, Stream& stream);
//! downloads data from device to host memory. Blocking calls.
operator Mat() const;
void download(cv::Mat& m) const;
void download(MatPL& m, Stream& stream) const;
//! download async
void download(CudaMem& m, Stream& stream) const;
//! returns a new GpuMatrix header for the specified row
GpuMat row(int y) const;
@@ -223,52 +227,50 @@ namespace cv
uchar* dataend;
};
//////////////////////////////// MatPL ////////////////////////////////
// MatPL is limited cv::Mat with page locked memory allocation.
//////////////////////////////// CudaMem ////////////////////////////////
// CudaMem is limited cv::Mat with page locked memory allocation.
// Page locked memory is only needed for async and faster coping to GPU.
// It is convertable to cv::Mat header without reference counting
// so you can use it with other opencv functions.
class CV_EXPORTS MatPL
class CV_EXPORTS CudaMem
{
public:
public:
enum { ALLOC_PAGE_LOCKED = 1, ALLOC_ZEROCOPY = 2, ALLOC_WRITE_COMBINED = 4 };
//Supported. Now behaviour is like ALLOC_DEFAULT.
enum { ALLOC_PAGE_LOCKED = 0, ALLOC_ZEROCOPY = 1, ALLOC_WRITE_COMBINED = 4 };
CudaMem();
CudaMem(const CudaMem& m);
MatPL();
MatPL(const MatPL& m);
MatPL(int _rows, int _cols, int _type, int type_alloc = ALLOC_PAGE_LOCKED);
MatPL(Size _size, int _type, int type_alloc = ALLOC_PAGE_LOCKED);
CudaMem(int _rows, int _cols, int _type, int _alloc_type = ALLOC_PAGE_LOCKED);
CudaMem(Size _size, int _type, int _alloc_type = ALLOC_PAGE_LOCKED);
//! creates from cv::Mat with coping data
explicit MatPL(const Mat& m, int type_alloc = ALLOC_PAGE_LOCKED);
explicit CudaMem(const Mat& m, int _alloc_type = ALLOC_PAGE_LOCKED);
~MatPL();
~CudaMem();
MatPL& operator = (const MatPL& m);
CudaMem& operator = (const CudaMem& m);
//! returns deep copy of the matrix, i.e. the data is copied
MatPL clone() const;
CudaMem clone() const;
//! allocates new matrix data unless the matrix already has specified size and type.
void create(int _rows, int _cols, int _type, int type_alloc = ALLOC_PAGE_LOCKED);
void create(Size _size, int _type, int type_alloc = ALLOC_PAGE_LOCKED);
void create(int _rows, int _cols, int _type, int _alloc_type = ALLOC_PAGE_LOCKED);
void create(Size _size, int _type, int _alloc_type = ALLOC_PAGE_LOCKED);
//! decrements reference counter and released memory if needed.
void release();
//! returns matrix header with disabled reference counting for MatPL data.
//! returns matrix header with disabled reference counting for CudaMem data.
Mat createMatHeader() const;
operator Mat() const;
operator GpuMat() const;
//returns if host memory can be mapperd to gpu address space;
static bool can_device_map_to_host();
// Please see cv::Mat for descriptions
bool isContinuous() const;
size_t elemSize() const;
@@ -314,13 +316,13 @@ namespace cv
void waitForCompletion();
//! downloads asynchronously.
// Warning! cv::Mat must point to page locked memory (i.e. to MatPL data or to its subMat)
void enqueueDownload(const GpuMat& src, MatPL& dst);
// Warning! cv::Mat must point to page locked memory (i.e. to CudaMem data or to its subMat)
void enqueueDownload(const GpuMat& src, CudaMem& dst);
void enqueueDownload(const GpuMat& src, Mat& dst);
//! uploads asynchronously.
// Warning! cv::Mat must point to page locked memory (i.e. to MatPL data or to its ROI)
void enqueueUpload(const MatPL& src, GpuMat& dst);
// Warning! cv::Mat must point to page locked memory (i.e. to CudaMem data or to its ROI)
void enqueueUpload(const CudaMem& src, GpuMat& dst);
void enqueueUpload(const Mat& src, GpuMat& dst);
void enqueueCopy(const GpuMat& src, GpuMat& dst);

54
modules/gpu/include/opencv2/gpu/matrix_operations.hpp
View File

@@ -339,43 +339,43 @@ static inline void swap( GpuMat& a, GpuMat& b ) { a.swap(b); }
///////////////////////////////////////////////////////////////////////
//////////////////////////////// MatPL ////////////////////////////////
//////////////////////////////// CudaMem ////////////////////////////////
///////////////////////////////////////////////////////////////////////
inline MatPL::MatPL() : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0) {}
inline MatPL::MatPL(int _rows, int _cols, int _type, int type_alloc) : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0)
inline CudaMem::CudaMem() : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0), alloc_type(0) {}
inline CudaMem::CudaMem(int _rows, int _cols, int _type, int _alloc_type) : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0), alloc_type(0)
{
if( _rows > 0 && _cols > 0 )
create( _rows, _cols, _type , type_alloc);
create( _rows, _cols, _type, _alloc_type);
}
inline MatPL::MatPL(Size _size, int _type, int type_alloc) : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0)
inline CudaMem::CudaMem(Size _size, int _type, int _alloc_type) : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0), alloc_type(0)
{
if( _size.height > 0 && _size.width > 0 )
create( _size.height, _size.width, _type, type_alloc );
create( _size.height, _size.width, _type, _alloc_type);
}
inline MatPL::MatPL(const MatPL& m) : flags(m.flags), rows(m.rows), cols(m.cols), step(m.step), data(m.data), refcount(m.refcount), datastart(0), dataend(0)
inline CudaMem::CudaMem(const CudaMem& m) : flags(m.flags), rows(m.rows), cols(m.cols), step(m.step), data(m.data), refcount(m.refcount), datastart(m.datastart), dataend(m.dataend), alloc_type(m.alloc_type)
{
if( refcount )
CV_XADD(refcount, 1);
}
inline MatPL::MatPL(const Mat& m, int type_alloc) : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0)
inline CudaMem::CudaMem(const Mat& m, int _alloc_type) : flags(0), rows(0), cols(0), step(0), data(0), refcount(0), datastart(0), dataend(0), alloc_type(0)
{
if( m.rows > 0 && m.cols > 0 )
create( m.size(), m.type() , type_alloc);
create( m.size(), m.type(), _alloc_type);
Mat tmp = createMatHeader();
m.copyTo(tmp);
}
inline MatPL::~MatPL()
inline CudaMem::~CudaMem()
{
release();
}
inline MatPL& MatPL::operator = (const MatPL& m)
inline CudaMem& CudaMem::operator = (const CudaMem& m)
{
if( this != &m )
{
@@ -393,31 +393,31 @@ inline MatPL& MatPL::operator = (const MatPL& m)
return *this;
}
inline MatPL MatPL::clone() const
inline CudaMem CudaMem::clone() const
{
MatPL m(size(), type());
CudaMem m(size(), type(), alloc_type);
Mat to = m;
Mat from = *this;
from.copyTo(to);
return m;
}
inline void MatPL::create(Size _size, int _type, int type_alloc) { create(_size.height, _size.width, _type, type_alloc); }
//CCP void MatPL::create(int _rows, int _cols, int _type);
//CPP void MatPL::release();
inline void CudaMem::create(Size _size, int _type, int _alloc_type) { create(_size.height, _size.width, _type, _alloc_type); }
//CCP void CudaMem::create(int _rows, int _cols, int _type, int _alloc_type);
//CPP void CudaMem::release();
inline Mat MatPL::createMatHeader() const { return Mat(size(), type(), data); }
inline MatPL::operator Mat() const { return createMatHeader(); }
inline Mat CudaMem::createMatHeader() const { return Mat(size(), type(), data); }
inline CudaMem::operator Mat() const { return createMatHeader(); }
inline bool MatPL::isContinuous() const { return (flags & Mat::CONTINUOUS_FLAG) != 0; }
inline size_t MatPL::elemSize() const { return CV_ELEM_SIZE(flags); }
inline size_t MatPL::elemSize1() const { return CV_ELEM_SIZE1(flags); }
inline int MatPL::type() const { return CV_MAT_TYPE(flags); }
inline int MatPL::depth() const { return CV_MAT_DEPTH(flags); }
inline int MatPL::channels() const { return CV_MAT_CN(flags); }
inline size_t MatPL::step1() const { return step/elemSize1(); }
inline Size MatPL::size() const { return Size(cols, rows); }
inline bool MatPL::empty() const { return data == 0; }
inline bool CudaMem::isContinuous() const { return (flags & Mat::CONTINUOUS_FLAG) != 0; }
inline size_t CudaMem::elemSize() const { return CV_ELEM_SIZE(flags); }
inline size_t CudaMem::elemSize1() const { return CV_ELEM_SIZE1(flags); }
inline int CudaMem::type() const { return CV_MAT_TYPE(flags); }
inline int CudaMem::depth() const { return CV_MAT_DEPTH(flags); }
inline int CudaMem::channels() const { return CV_MAT_CN(flags); }
inline size_t CudaMem::step1() const { return step/elemSize1(); }
inline Size CudaMem::size() const { return Size(cols, rows); }
inline bool CudaMem::empty() const { return data == 0; }
} /* end of namespace gpu */