ViennaCL - The Vienna Computing Library  1.5.2
Namespaces | Data Structures | Functions
viennacl::backend Namespace Reference

Namespace providing routines for handling the different memory domains. More...

Namespaces

 cpu_ram
 Provides implementations for handling memory buffers in CPU RAM.
 
 cuda
 Provides implementations for handling CUDA memory buffers.
 
 detail
 Implementation details for the generic memory backend interface.
 
 opencl
 Provides implementations for handling OpenCL memory buffers.
 

Data Structures

class  mem_handle
 Main abstraction class for multiple memory domains. Represents a buffer in either main RAM, an OpenCL context, or a CUDA device. More...
 
class  typesafe_host_array
 Helper class implementing an array on the host. Default case: No conversion necessary. More...
 
class  typesafe_host_array< T, true >
 Special host array type for conversion between OpenCL types and pure CPU types. More...
 

Functions

memory_types default_memory_type ()
 
void finish ()
 Synchronizes the execution. finish() will only return after all compute kernels (CUDA, OpenCL) have completed. More...
 
void memory_create (mem_handle &handle, vcl_size_t size_in_bytes, viennacl::context const &ctx, const void *host_ptr=NULL)
 Creates an array of the specified size. If the second argument is provided, the buffer is initialized with data from that pointer. More...
 
void memory_copy (mem_handle const &src_buffer, mem_handle &dst_buffer, vcl_size_t src_offset, vcl_size_t dst_offset, vcl_size_t bytes_to_copy)
 Copies 'bytes_to_copy' bytes from address 'src_buffer + src_offset' to memory starting at address 'dst_buffer + dst_offset'. More...
 
void memory_shallow_copy (mem_handle const &src_buffer, mem_handle &dst_buffer)
 A 'shallow' copy operation from an initialized buffer to an uninitialized buffer. The uninitialized buffer just copies the raw handle. More...
 
void memory_write (mem_handle &dst_buffer, vcl_size_t dst_offset, vcl_size_t bytes_to_write, const void *ptr, bool async=false)
 Writes data from main RAM identified by 'ptr' to the buffer identified by 'dst_buffer'. More...
 
void memory_read (mem_handle const &src_buffer, vcl_size_t src_offset, vcl_size_t bytes_to_read, void *ptr, bool async=false)
 Reads data from a buffer back to main RAM. More...
 
template<typename DataType >
void switch_memory_context (mem_handle &handle, viennacl::context new_ctx)
 Switches the active memory domain within a memory handle. Data is copied if the new active domain differs from the old one. Memory in the source handle is not free'd. More...
 
template<typename DataType >
void typesafe_memory_copy (mem_handle const &handle_src, mem_handle &handle_dst)
 Copies data of the provided 'DataType' from 'handle_src' to 'handle_dst' and converts the data if the binary representation of 'DataType' among the memory domains differs. More...
 

Detailed Description

Namespace providing routines for handling the different memory domains.

Function Documentation

memory_types viennacl::backend::default_memory_type ( )
inline
void viennacl::backend::finish ( )
inline

Synchronizes the execution. finish() will only return after all compute kernels (CUDA, OpenCL) have completed.

void viennacl::backend::memory_copy ( mem_handle const &  src_buffer,
mem_handle &  dst_buffer,
vcl_size_t  src_offset,
vcl_size_t  dst_offset,
vcl_size_t  bytes_to_copy 
)
inline

Copies 'bytes_to_copy' bytes from address 'src_buffer + src_offset' to memory starting at address 'dst_buffer + dst_offset'.

This is the generic version for CPU RAM, CUDA, and OpenCL. Copies the memory in the currently active memory domain.

Parameters
src_bufferA smart pointer to the begin of an allocated buffer
dst_bufferA smart pointer to the end of an allocated buffer
src_offsetOffset of the first byte to be written from the address given by 'src_buffer' (in bytes)
dst_offsetOffset of the first byte to be written to the address given by 'dst_buffer' (in bytes)
bytes_to_copyNumber of bytes to be copied
void viennacl::backend::memory_create ( mem_handle &  handle,
vcl_size_t  size_in_bytes,
viennacl::context const &  ctx,
const void *  host_ptr = NULL 
)
inline

Creates an array of the specified size. If the second argument is provided, the buffer is initialized with data from that pointer.

This is the generic version for CPU RAM, CUDA, and OpenCL. Creates the memory in the currently active memory domain.

Parameters
handleThe generic wrapper handle for multiple memory domains which will hold the new buffer.
size_in_bytesNumber of bytes to allocate
ctxOptional context in which the matrix is created (one out of multiple OpenCL contexts, CUDA, host)
host_ptrPointer to data which will be copied to the new array. Must point to at least 'size_in_bytes' bytes of data.
void viennacl::backend::memory_read ( mem_handle const &  src_buffer,
vcl_size_t  src_offset,
vcl_size_t  bytes_to_read,
void *  ptr,
bool  async = false 
)
inline

Reads data from a buffer back to main RAM.

This is the generic version for CPU RAM, CUDA, and OpenCL. Reads the memory from the currently active memory domain.

Parameters
src_bufferA smart pointer to the beginning of an allocated source buffer
src_offsetOffset of the first byte to be read from the beginning of src_buffer (in bytes_
bytes_to_readNumber of bytes to be read
ptrLocation in main RAM where to read data should be written to
asyncWhether the operation should be asynchronous
void viennacl::backend::memory_shallow_copy ( mem_handle const &  src_buffer,
mem_handle &  dst_buffer 
)
inline

A 'shallow' copy operation from an initialized buffer to an uninitialized buffer. The uninitialized buffer just copies the raw handle.

void viennacl::backend::memory_write ( mem_handle &  dst_buffer,
vcl_size_t  dst_offset,
vcl_size_t  bytes_to_write,
const void *  ptr,
bool  async = false 
)
inline

Writes data from main RAM identified by 'ptr' to the buffer identified by 'dst_buffer'.

This is the generic version for CPU RAM, CUDA, and OpenCL. Writes the memory in the currently active memory domain.

Parameters
dst_bufferA smart pointer to the beginning of an allocated buffer
dst_offsetOffset of the first written byte from the beginning of 'dst_buffer' (in bytes)
bytes_to_writeNumber of bytes to be written
ptrPointer to the first byte to be written
asyncWhether the operation should be asynchronous
void viennacl::backend::switch_memory_context ( mem_handle &  handle,
viennacl::context  new_ctx 
)

Switches the active memory domain within a memory handle. Data is copied if the new active domain differs from the old one. Memory in the source handle is not free'd.

void viennacl::backend::typesafe_memory_copy ( mem_handle const &  handle_src,
mem_handle &  handle_dst 
)

Copies data of the provided 'DataType' from 'handle_src' to 'handle_dst' and converts the data if the binary representation of 'DataType' among the memory domains differs.