RandomBallCover  1.2.1
 Hosted by GitHub
Public Types | Public Member Functions | Public Attributes | List of all members
cl_algo::RBC::RBCComputeDists< K > Class Template Reference

Interface class for the rbcComputeDists kernels. More...

#include <algorithms.hpp>

Public Types

enum  Memory : uint8_t {
  Memory::H_IN_X, Memory::H_IN_R, Memory::H_OUT_D, Memory::D_IN_X,
  Memory::D_IN_R, Memory::D_OUT_D
}
 Enumerates the memory objects handled by the class. More...
 

Public Member Functions

 RBCComputeDists (clutils::CLEnv &_env, clutils::CLEnvInfo< 1 > _info)
 Configures an OpenCL environment as specified by _info. More...
 
cl::Memory & get (RBCComputeDists::Memory mem)
 Returns a reference to an internal memory object. More...
 
void init (unsigned int _nx, unsigned int _nr, unsigned int _d=8, float _a=1.f, Staging _staging=Staging::IO)
 Configures kernel execution parameters. More...
 
void write (RBCComputeDists::Memory mem=RBCComputeDists::Memory::D_IN_X, void *ptr=nullptr, bool block=CL_FALSE, const std::vector< cl::Event > *events=nullptr, cl::Event *event=nullptr)
 Performs a data transfer to a device buffer. More...
 
void * read (RBCComputeDists::Memory mem=RBCComputeDists::Memory::H_OUT_D, bool block=CL_TRUE, const std::vector< cl::Event > *events=nullptr, cl::Event *event=nullptr)
 Performs a data transfer to a staging buffer. More...
 
void run (const std::vector< cl::Event > *events=nullptr, cl::Event *event=nullptr)
 Executes the necessary kernels. More...
 
float getAlpha ()
 Gets the scaling factor \( \alpha \). More...
 
void setAlpha (float _a)
 Sets the scaling factor \( \alpha \). More...
 
template<typename period >
double run (clutils::GPUTimer< period > &timer, const std::vector< cl::Event > *events=nullptr)
 Executes the necessary kernels. More...
 

Public Attributes

cl_float * hPtrInX
 
cl_float * hPtrInR
 
cl_float * hPtrOutD
 

Detailed Description

template<KernelTypeC K = KernelTypeC::SHARED_NONE>
class cl_algo::RBC::RBCComputeDists< K >

Interface class for the rbcComputeDists kernels.

The rbcComputeDists kernels compute the distances between two sets of points in a brute force way. For more details, look at the kernel's documentation.

Note
The rbcComputeDists kernels are available in kernels/rbc_kernels.cl.
The class creates its own buffers. If you would like to provide your own buffers, call get to get references to the placeholders within the class and assign them to your buffers. You will have to do this strictly before the call to init. You can also call get (after the call to init) to get a reference to a buffer within the class and assign it to another kernel class instance further down in your task pipeline.

The following input/output OpenCL memory objects are created by a RBCComputeDists instance:

Name Type Placement I/O Use Properties Size
H_IN_X Buffer Host I Staging CL_MEM_READ_WRITE \(n_x*d * sizeof\ (cl\_float)\)
H_IN_R Buffer Host I Staging CL_MEM_READ_WRITE \(n_r*d * sizeof\ (cl\_float)\)
H_OUT_DBuffer Host O Staging CL_MEM_READ_WRITE \(n_x*n_r*sizeof\ (cl\_float)\)
D_IN_X Buffer Device I Processing CL_MEM_READ_ONLY \(n_x*d * sizeof\ (cl\_float)\)
D_IN_R Buffer Device I Processing CL_MEM_READ_ONLY \(n_r*d * sizeof\ (cl\_float)\)
D_OUT_DBuffer Device O Processing CL_MEM_WRITE_ONLY \(n_x*n_r*sizeof\ (cl\_float)\)
Template Parameters
Kconfigures the class for using one of the available kernels.

Member Enumeration Documentation

template<KernelTypeC K = KernelTypeC::SHARED_NONE>
enum cl_algo::RBC::RBCComputeDists::Memory : uint8_t
strong

Enumerates the memory objects handled by the class.

Note
H_* names refer to staging buffers on the host.
D_* names refer to buffers on the device.
Enumerator
H_IN_X 

Input staging buffer.

H_IN_R 

Input staging buffer.

H_OUT_D 

Output staging buffer for channel R.

D_IN_X 

Input buffer.

D_IN_R 

Input buffer.

D_OUT_D 

Output buffer for channel R.

Constructor & Destructor Documentation

template<KernelTypeC K>
cl_algo::RBC::RBCComputeDists< K >::RBCComputeDists ( clutils::CLEnv &  _env,
clutils::CLEnvInfo< 1 >  _info 
)

Configures an OpenCL environment as specified by _info.

Parameters
[in]_envopencl environment.
[in]_infoopencl configuration. Specifies the context, queue, etc, to be used.

Member Function Documentation

template<KernelTypeC K>
cl::Memory & cl_algo::RBC::RBCComputeDists< K >::get ( RBCComputeDists< K >::Memory  mem)

Returns a reference to an internal memory object.

This interface exists to allow CL memory sharing between different kernels.

Parameters
[in]memenumeration value specifying the requested memory object.
Returns
A reference to the requested memory object.
template<KernelTypeC K>
float cl_algo::RBC::RBCComputeDists< K >::getAlpha ( )

Gets the scaling factor \( \alpha \).

Note
If the template parameter, K, has the value SHARED_NONE, SHARED_R, or SHARED_X_R, the parameter \( \alpha \) is not applicable and the value returned is \( \infty \).
Returns
The scaling factor \( \alpha \).
template<KernelTypeC K>
void cl_algo::RBC::RBCComputeDists< K >::init ( unsigned int  _nx,
unsigned int  _nr,
unsigned int  _d = 8,
float  _a = 1.f,
Staging  _staging = Staging::IO 
)

Configures kernel execution parameters.

Sets up memory objects as necessary, and defines the kernel workspaces.

Note
If you have assigned a memory object to one member variable of the class before the call to init, then that memory will be maintained. Otherwise, a new memory object will be created.
Parameters
[in]_nxnumber of database points.
[in]_nrnumber of representative points.
[in]_ddimensionality of the associated points.
[in]_afactor scaling the results of the distance calculations for the geometric \( x_g \) and photometric \( x_p \) dimensions of the \( x\epsilon\mathbb{R}^8 \) points. That is, \( \|x-x'\|_2^2= f_g(a)\|x_g-x'_g\|_2^2+f_p(a)\|x_p-x'_p\|_2^2 \). This parameter is applicable when involving the "Kinect" kernels. That is, when the template parameter, K, gets the value KINECT, KINECT_R, or KINECT_X_R. For more details, take a look at euclideanSquaredMetric8 in kernels/rbc_kernels.cl.
[in]_stagingflag to indicate whether or not to instantiate the staging buffers.
template<KernelTypeC K>
void * cl_algo::RBC::RBCComputeDists< K >::read ( RBCComputeDists< K >::Memory  mem = RBCComputeDists< K >::Memory::H_OUT_D,
bool  block = CL_TRUE,
const std::vector< cl::Event > *  events = nullptr,
cl::Event *  event = nullptr 
)

Performs a data transfer to a staging buffer.

The transfer happens from a device buffer to the associated (specified) staging buffer on the host.

Parameters
[in]memenumeration value specifying an output staging buffer.
[in]blocka flag to indicate whether to perform a blocking or a non-blocking operation.
[in]eventsa wait-list of events.
[out]eventevent associated with the read operation to the staging buffer.
template<KernelTypeC K>
void cl_algo::RBC::RBCComputeDists< K >::run ( const std::vector< cl::Event > *  events = nullptr,
cl::Event *  event = nullptr 
)

Executes the necessary kernels.

The function call is non-blocking.

Parameters
[in]eventsa wait-list of events.
[out]eventevent associated with the kernel execution.
template<KernelTypeC K = KernelTypeC::SHARED_NONE>
template<typename period >
double cl_algo::RBC::RBCComputeDists< K >::run ( clutils::GPUTimer< period > &  timer,
const std::vector< cl::Event > *  events = nullptr 
)
inline

Executes the necessary kernels.

This run instance is used for profiling.

Parameters
[in]timerGPUTimer that does the profiling of the kernel executions.
[in]eventsa wait-list of events.
Returns
Τhe total execution time measured by the timer.
template<KernelTypeC K>
void cl_algo::RBC::RBCComputeDists< K >::setAlpha ( float  _a)

Sets the scaling factor \( \alpha \).

Updates the kernel argument for the scaling factor \( \alpha \).

Note
If the template parameter, K, has the value SHARED_NONE, SHARED_R, or SHARED_X_R, the parameter \( \alpha \) is not applicable and the function has no effect.
Parameters
[in]_ascaling factor \( \alpha \).
template<KernelTypeC K>
void cl_algo::RBC::RBCComputeDists< K >::write ( RBCComputeDists< K >::Memory  mem = RBCComputeDists< K >::Memory::D_IN_X,
void *  ptr = nullptr,
bool  block = CL_FALSE,
const std::vector< cl::Event > *  events = nullptr,
cl::Event *  event = nullptr 
)

Performs a data transfer to a device buffer.

The transfer happens from a staging buffer on the host to the associated (specified) device buffer.

Parameters
[in]memenumeration value specifying an input device buffer.
[in]ptra pointer to an array holding input data. If not NULL, the data from ptr will be copied to the associated staging buffer.
[in]blocka flag to indicate whether to perform a blocking or a non-blocking operation.
[in]eventsa wait-list of events.
[out]eventevent associated with the write operation to the device buffer.

Member Data Documentation

template<KernelTypeC K = KernelTypeC::SHARED_NONE>
cl_float* cl_algo::RBC::RBCComputeDists< K >::hPtrInR

Mapping of the input staging buffer for R.

template<KernelTypeC K = KernelTypeC::SHARED_NONE>
cl_float* cl_algo::RBC::RBCComputeDists< K >::hPtrInX

Mapping of the input staging buffer for X.

template<KernelTypeC K = KernelTypeC::SHARED_NONE>
cl_float* cl_algo::RBC::RBCComputeDists< K >::hPtrOutD

Mapping of the output staging buffer.


The documentation for this class was generated from the following files: