class cv::cuda::HostMem

Overview

Class with reference counting wrapping special memory type allocation functions from CUDA. More…

#include <cuda.hpp>

class HostMem
{
public:
    // enums

    enum AllocType;

    // fields

    AllocType alloc_type;
    int cols;
    uchar* data;
    const uchar* dataend;
    uchar* datastart;
    int flags;
    int* refcount;
    int rows;
    size_t step;

    // construction

    HostMem(AllocType alloc_type = PAGE_LOCKED);
    HostMem(const HostMem& m);

    HostMem(
        int rows,
        int cols,
        int type,
        AllocType alloc_type = PAGE_LOCKED
        );

    HostMem(
        Size size,
        int type,
        AllocType alloc_type = PAGE_LOCKED
        );

    HostMem(
        InputArray arr,
        AllocType alloc_type = PAGE_LOCKED
        );

    // methods

    static
    MatAllocator*
    getAllocator(AllocType alloc_type = PAGE_LOCKED);

    int
    channels() const;

    HostMem
    clone() const;

    void
    create(
        int rows,
        int cols,
        int type
        );

    void
    create(
        Size size,
        int type
        );

    GpuMat
    createGpuMatHeader() const;

    Mat
    createMatHeader() const;

    int
    depth() const;

    size_t
    elemSize() const;

    size_t
    elemSize1() const;

    bool
    empty() const;

    bool
    isContinuous() const;

    HostMem&
    operator=(const HostMem& m);

    void
    release();

    HostMem
    reshape(
        int cn,
        int rows = 0
        ) const;

    Size
    size() const;

    size_t
    step1() const;

    void
    swap(HostMem& b);

    int
    type() const;
};

Detailed Documentation

Class with reference counting wrapping special memory type allocation functions from CUDA.

Its interface is also Mat-like but with additional memory type parameters.

• PAGE_LOCKED sets a page locked memory type used commonly for fast and asynchronous uploading/downloading data from/to GPU.
• SHARED specifies a zero copy memory allocation that enables mapping the host memory to GPU address space, if supported.
• WRITE_COMBINED sets the write combined buffer that is not cached by CPU. Such buffers are used to supply GPU with data when GPU only reads it. The advantage is a better CPU cache utilization.

Allocation size of such memory types is usually limited. For more details, see CUDA 2.2 Pinned Memory APIs document or CUDA C Programming Guide.

Construction

HostMem(
    InputArray arr,
    AllocType alloc_type = PAGE_LOCKED
    )

creates from host memory with coping data

Methods

HostMem
clone() const

returns deep copy of the matrix, i.e. the data is copied

void
create(
    int rows,
    int cols,
    int type
    )

allocates new matrix data unless the matrix already has specified size and type.

GpuMat
createGpuMatHeader() const

Maps CPU memory to GPU address space and creates the cuda::GpuMat header without reference counting for it.

This can be done only if memory was allocated with the SHARED flag and if it is supported by the hardware. Laptops often share video and CPU memory, so address spaces can be mapped, which eliminates an extra copy.

Mat
createMatHeader() const

returns matrix header with disabled reference counting for HostMem data.

void
release()

decrements reference counter and released memory if needed.

HostMem
reshape(
    int cn,
    int rows = 0
    ) const

creates alternative HostMem header for the same data, with different number of channels and/or different number of rows

void
swap(HostMem& b)

swaps with other smart pointer