Interface class for the rbcPermute
kernel.
More...
#include <algorithms.hpp>
Public Types | |
enum | Memory : uint8_t { Memory::H_IN_X, Memory::H_IN_ID, Memory::H_IN_RNK, Memory::H_IN_O, Memory::H_OUT_X_P, Memory::H_OUT_ID_P, Memory::D_IN_X, Memory::D_IN_ID, Memory::D_IN_RNK, Memory::D_IN_O, Memory::D_OUT_X_P, Memory::D_OUT_ID_P } |
Enumerates the memory objects handled by the class. More... | |
Public Member Functions | |
RBCPermute (clutils::CLEnv &_env, clutils::CLEnvInfo< 1 > _info) | |
Configures an OpenCL environment as specified by _info . More... | |
cl::Memory & | get (RBCPermute::Memory mem) |
Returns a reference to an internal memory object. More... | |
void | init (unsigned int _nx, unsigned int _nr, unsigned int _d=8, int _permID=0, Staging _staging=Staging::IO) |
Configures kernel execution parameters. More... | |
void | write (RBCPermute::Memory mem=RBCPermute::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 (RBCPermute::Memory mem=RBCPermute::Memory::H_OUT_X_P, 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... | |
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 |
rbc_dist_id * | hPtrInID |
cl_uint * | hPtrInRnk |
cl_uint * | hPtrInO |
cl_float * | hPtrOutXp |
rbc_dist_id * | hPtrOutIDp |
Interface class for the rbcPermute
kernel.
rbcPermute
permutes the database points to form the representative lists and allow for coalesced access pattern during the search operation. For more details, look at the kernel's documentation.
rbcPermute
kernel is available in kernels/rbc_kernels.cl
. 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 RBCPermute
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_ID | Buffer | Host | I | Staging | CL_MEM_READ_WRITE | \(n_x*sizeof\ (rbc\_dist\_id)\) |
H_IN_RNK | Buffer | Host | I | Staging | CL_MEM_READ_WRITE | \(n_x *sizeof\ (cl\_uint)\) |
H_IN_O | Buffer | Host | I | Staging | CL_MEM_READ_WRITE | \(n_r *sizeof\ (cl\_uint)\) |
H_OUT_X_P | Buffer | Host | O | Staging | CL_MEM_READ_WRITE | \(n_x*d *sizeof\ (cl\_float)\) |
H_OUT_ID_P | Buffer | Host | O | Staging | CL_MEM_READ_WRITE | \(n_x*sizeof\ (rbc\_dist\_id)\) |
D_IN_X | Buffer | Device | I | Processing | CL_MEM_READ_ONLY | \(n_x*d *sizeof\ (cl\_float)\) |
D_IN_ID | Buffer | Device | I | Processing | CL_MEM_READ_ONLY | \(n_x*sizeof\ (rbc\_dist\_id)\) |
D_IN_RNK | Buffer | Device | I | Processing | CL_MEM_READ_ONLY | \(n_x *sizeof\ (cl\_uint)\) |
D_IN_O | Buffer | Device | I | Processing | CL_MEM_READ_ONLY | \(n_r *sizeof\ (cl\_uint)\) |
D_OUT_X_P | Buffer | Device | O | Processing | CL_MEM_WRITE_ONLY | \(n_x*d *sizeof\ (cl\_float)\) |
D_OUT_ID_P | Buffer | Device | O | Processing | CL_MEM_WRITE_ONLY | \(n_x*sizeof\ (rbc\_dist\_id)\) |
C | configures the class either for Generic or Kinect data. |
|
strong |
Enumerates the memory objects handled by the class.
H_*
names refer to staging buffers on the host. D_*
names refer to buffers on the device. cl_algo::RBC::RBCPermute< C >::RBCPermute | ( | clutils::CLEnv & | _env, |
clutils::CLEnvInfo< 1 > | _info | ||
) |
Configures an OpenCL environment as specified by _info
.
[in] | _env | opencl environment. |
[in] | _info | opencl configuration. Specifies the context, queue, etc, to be used. |
cl::Memory & cl_algo::RBC::RBCPermute< C >::get | ( | RBCPermute< C >::Memory | mem | ) |
Returns a reference to an internal memory object.
This interface exists to allow CL memory sharing between different kernels.
[in] | mem | enumeration value specifying the requested memory object. |
void cl_algo::RBC::RBCPermute< C >::init | ( | unsigned int | _nx, |
unsigned int | _nr, | ||
unsigned int | _d = 8 , |
||
int | _permID = 0 , |
||
Staging | _staging = Staging::IO |
||
) |
Configures kernel execution parameters.
Sets up memory objects as necessary, and defines the kernel workspaces.
init
, then that memory will be maintained. Otherwise, a new memory object will be created.[in] | _nx | number of database points. |
[in] | _nr | number of representative points. |
[in] | _d | dimensionality of the associated points. |
[in] | _permID | flag to indicate whether or not to also permute the ID array. |
[in] | _staging | flag to indicate whether or not to instantiate the staging buffers. |
void * cl_algo::RBC::RBCPermute< C >::read | ( | RBCPermute< C >::Memory | mem = RBCPermute< C >::Memory::H_OUT_X_P , |
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.
[in] | mem | enumeration value specifying an output staging buffer. |
[in] | block | a flag to indicate whether to perform a blocking or a non-blocking operation. |
[in] | events | a wait-list of events. |
[out] | event | event associated with the read operation to the staging buffer. |
void cl_algo::RBC::RBCPermute< C >::run | ( | const std::vector< cl::Event > * | events = nullptr , |
cl::Event * | event = nullptr |
||
) |
Executes the necessary kernels.
The function call is non-blocking.
[in] | events | a wait-list of events. |
[out] | event | event associated with the last kernel execution. |
|
inline |
Executes the necessary kernels.
This run
instance is used for profiling.
[in] | timer | GPUTimer that does the profiling of the kernel executions. |
[in] | events | a wait-list of events. |
void cl_algo::RBC::RBCPermute< C >::write | ( | RBCPermute< C >::Memory | mem = RBCPermute< C >::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.
[in] | mem | enumeration value specifying an input device buffer. |
[in] | ptr | a pointer to an array holding input data. If not NULL, the data from ptr will be copied to the associated staging buffer. |
[in] | block | a flag to indicate whether to perform a blocking or a non-blocking operation. |
[in] | events | a wait-list of events. |
[out] | event | event associated with the write operation to the device buffer. |
rbc_dist_id* cl_algo::RBC::RBCPermute< C >::hPtrInID |
Mapping of the input staging buffer with the representative ids for each point.
cl_uint* cl_algo::RBC::RBCPermute< C >::hPtrInO |
Mapping of the input staging buffer with the offsets of the representative lists within the db.
cl_uint* cl_algo::RBC::RBCPermute< C >::hPtrInRnk |
Mapping of the input staging buffer with the indices of the points within each rep. list.
cl_float* cl_algo::RBC::RBCPermute< C >::hPtrInX |
Mapping of the input staging buffer for the database.
rbc_dist_id* cl_algo::RBC::RBCPermute< C >::hPtrOutIDp |
Mapping of the output staging buffer with the representative ids for each point in the permuted db.
cl_float* cl_algo::RBC::RBCPermute< C >::hPtrOutXp |
Mapping of the output staging buffer for the permuted database.