//---------------------------------------------------------------------------//

// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com>

//

// Distributed under the Boost Software License, Version 1.0

// See accompanying file LICENSE_1_0.txt or copy at

// http://www.boost.org/LICENSE_1_0.txt

//

// See http://boostorg.github.com/compute for more information.

//---------------------------------------------------------------------------//

#ifndef BOOST_COMPUTE_COMMAND_QUEUE_HPP

#define BOOST_COMPUTE_COMMAND_QUEUE_HPP

#include <cstddef>

#include <algorithm>

#include <boost/assert.hpp>

#include <boost/compute/config.hpp>

#include <boost/compute/event.hpp>

#include <boost/compute/buffer.hpp>

#include <boost/compute/device.hpp>

#include <boost/compute/kernel.hpp>

#include <boost/compute/context.hpp>

#include <boost/compute/exception.hpp>

#include <boost/compute/image/image1d.hpp>

#include <boost/compute/image/image2d.hpp>

#include <boost/compute/image/image3d.hpp>

#include <boost/compute/image/image_object.hpp>

#include <boost/compute/utility/wait_list.hpp>

#include <boost/compute/detail/get_object_info.hpp>

#include <boost/compute/detail/assert_cl_success.hpp>

#include <boost/compute/detail/diagnostic.hpp>

#include <boost/compute/utility/extents.hpp>

namespace boost {

namespace compute {

namespace detail {

inline void BOOST_COMPUTE_CL_CALLBACK

nullary_native_kernel_trampoline(void *user_func_ptr)

{

void (*user_func)();

std::memcpy(&user_func, user_func_ptr, sizeof(user_func));

user_func();

}

} // end detail namespace

/// \class command_queue

/// \brief A command queue.

///

/// Command queues provide the interface for interacting with compute

/// devices. The command_queue class provides methods to copy data to

/// and from a compute device as well as execute compute kernels.

///

/// Command queues are created for a compute device within a compute

/// context.

///

/// For example, to create a context and command queue for the default device

/// on the system (this is the normal set up code used by almost all OpenCL

/// programs):

/// \code

/// #include <boost/compute/core.hpp>

///

/// // get the default compute device

/// boost::compute::device device = boost::compute::system::default_device();

///

/// // set up a compute context and command queue

/// boost::compute::context context(device);

/// boost::compute::command_queue queue(context, device);

/// \endcode

///

/// The default command queue for the system can be obtained with the

/// system::default_queue() method.

///

/// \see buffer, context, kernel

class command_queue

{

public:

enum properties {

enable_profiling = CL_QUEUE_PROFILING_ENABLE,

enable_out_of_order_execution = CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE

#ifdef BOOST_COMPUTE_CL_VERSION_2_0

,

on_device = CL_QUEUE_ON_DEVICE,

on_device_default = CL_QUEUE_ON_DEVICE_DEFAULT

#endif

};

enum map_flags {

map_read = CL_MAP_READ,

map_write = CL_MAP_WRITE

#ifdef BOOST_COMPUTE_CL_VERSION_1_2

,

map_write_invalidate_region = CL_MAP_WRITE_INVALIDATE_REGION

#endif

};

#ifdef BOOST_COMPUTE_CL_VERSION_1_2

enum mem_migration_flags {

migrate_to_host = CL_MIGRATE_MEM_OBJECT_HOST,

migrate_content_undefined = CL_MIGRATE_MEM_OBJECT_CONTENT_UNDEFINED

};

#endif // BOOST_COMPUTE_CL_VERSION_1_2

/// Creates a null command queue.

command_queue()

: m_queue(0)

{

}

explicit command_queue(cl_command_queue queue, bool retain = true)

: m_queue(queue)

{

if(m_queue && retain){

clRetainCommandQueue(m_queue);

}

}

/// Creates a command queue in \p context for \p device with

/// \p properties.

///

/// \see_opencl_ref{clCreateCommandQueue}

command_queue(const context &context,

const device &device,

cl_command_queue_properties properties = 0)

{

BOOST_ASSERT(device.id() != 0);

cl_int error = 0;

#ifdef BOOST_COMPUTE_CL_VERSION_2_0

if (device.check_version(2, 0)){

std::vector<cl_queue_properties> queue_properties;

if(properties){

queue_properties.push_back(CL_QUEUE_PROPERTIES);

queue_properties.push_back(cl_queue_properties(properties));

queue_properties.push_back(cl_queue_properties(0));

}

const cl_queue_properties *queue_properties_ptr =

queue_properties.empty() ? 0 : &queue_properties[0];

m_queue = clCreateCommandQueueWithProperties(

context, device.id(), queue_properties_ptr, &error

);

} else

#endif

{

// Suppress deprecated declarations warning

BOOST_COMPUTE_DISABLE_DEPRECATED_DECLARATIONS();

m_queue = clCreateCommandQueue(

context, device.id(), properties, &error

);

BOOST_COMPUTE_ENABLE_DEPRECATED_DECLARATIONS();

}

if(!m_queue){

BOOST_THROW_EXCEPTION(opencl_error(error));

}

}

/// Creates a new command queue object as a copy of \p other.

command_queue(const command_queue &other)

: m_queue(other.m_queue)

{

if(m_queue){

clRetainCommandQueue(m_queue);

}

}

/// Copies the command queue object from \p other to \c *this.

command_queue& operator=(const command_queue &other)

{

if(this != &other){

if(m_queue){

clReleaseCommandQueue(m_queue);

}

m_queue = other.m_queue;

if(m_queue){

clRetainCommandQueue(m_queue);

}

}

return *this;

}

#ifndef BOOST_COMPUTE_NO_RVALUE_REFERENCES

/// Move-constructs a new command queue object from \p other.

command_queue(command_queue&& other) BOOST_NOEXCEPT

: m_queue(other.m_queue)

{

other.m_queue = 0;

}

/// Move-assigns the command queue from \p other to \c *this.

command_queue& operator=(command_queue&& other) BOOST_NOEXCEPT

{

if(m_queue){

clReleaseCommandQueue(m_queue);

}

m_queue = other.m_queue;

other.m_queue = 0;

return *this;

}

#endif // BOOST_COMPUTE_NO_RVALUE_REFERENCES

/// Destroys the command queue.

///

/// \see_opencl_ref{clReleaseCommandQueue}

~command_queue()

{

if(m_queue){

BOOST_COMPUTE_ASSERT_CL_SUCCESS(

clReleaseCommandQueue(m_queue)

);

}

}

/// Returns the underlying OpenCL command queue.

cl_command_queue& get() const

{

return const_cast<cl_command_queue &>(m_queue);

}

/// Returns the device that the command queue issues commands to.

device get_device() const

{

return device(get_info<cl_device_id>(CL_QUEUE_DEVICE));

}

/// Returns the context for the command queue.

context get_context() const

{

return context(get_info<cl_context>(CL_QUEUE_CONTEXT));

}

/// Returns information about the command queue.

///

/// \see_opencl_ref{clGetCommandQueueInfo}

template<class T>

T get_info(cl_command_queue_info info) const

{

return detail::get_object_info<T>(clGetCommandQueueInfo, m_queue, info);

}

/// \overload

template<int Enum>

typename detail::get_object_info_type<command_queue, Enum>::type

get_info() const;

/// Returns the properties for the command queue.

cl_command_queue_properties get_properties() const

{

return get_info<cl_command_queue_properties>(CL_QUEUE_PROPERTIES);

}

#if defined(BOOST_COMPUTE_CL_VERSION_2_1) || defined(BOOST_COMPUTE_DOXYGEN_INVOKED)

/// Returns the current default device command queue for the underlying device.

///

/// \opencl_version_warning{2,1}

command_queue get_default_device_queue() const

{

return command_queue(get_info<cl_command_queue>(CL_QUEUE_DEVICE_DEFAULT));

}

/// Replaces the default device command queue for the underlying device

/// with this command queue. Command queue must have been created

/// with CL_QUEUE_ON_DEVICE flag.

///

/// \see_opencl21_ref{clSetDefaultDeviceCommandQueue}

///

/// \opencl_version_warning{2,1}

void set_as_default_device_queue() const

{

cl_int ret = clSetDefaultDeviceCommandQueue(

this->get_context().get(),

this->get_device().get(),

m_queue

);

if(ret != CL_SUCCESS){

BOOST_THROW_EXCEPTION(opencl_error(ret));

}

}

#endif // BOOST_COMPUTE_CL_VERSION_2_1

/// Enqueues a command to read data from \p buffer to host memory.

///

/// \see_opencl_ref{clEnqueueReadBuffer}

///

/// \see copy()

event enqueue_read_buffer(const buffer &buffer,

size_t offset,

size_t size,

void *host_ptr,

const wait_list &events = wait_list())

{

BOOST_ASSERT(m_queue != 0);

BOOST_ASSERT(size <= buffer.size());

BOOST_ASSERT(buffer.get_context() == this->get_context());

BOOST_ASSERT(host_ptr != 0);

event event_;

cl_int ret = clEnqueueReadBuffer(

m_queue,

buffer.get(),

CL_TRUE,

offset,

size,

host_ptr,

events.size(),

events.get_event_ptr(),

&event_.get()

);

if(ret != CL_SUCCESS){

BOOST_THROW_EXCEPTION(opencl_error(ret));

}

return event_;

}

/// Enqueues a command to read data from \p buffer to host memory. The

/// copy will be performed asynchronously.

///

/// \see_opencl_ref{clEnqueueReadBuffer}

///

/// \see copy_async()

event enqueue_read_buffer_async(const buffer &buffer,

size_t offset,

size_t size,

void *host_ptr,

const wait_list &events = wait_list())

{

BOOST_ASSERT(m_queue != 0);

BOOST_ASSERT(size <= buffer.size());

BOOST_ASSERT(buffer.get_context() == this->get_context());

BOOST_ASSERT(host_ptr != 0);

event event_;

cl_int ret = clEnqueueReadBuffer(

m_queue,

buffer.get(),

CL_FALSE,

offset,

size,

host_ptr,

events.size(),

events.get_event_ptr(),

&event_.get()

);

if(ret != CL_SUCCESS){

BOOST_THROW_EXCEPTION(opencl_error(ret));

}

return event_;

}

#if defined(BOOST_COMPUTE_CL_VERSION_1_1) || defined(BOOST_COMPUTE_DOXYGEN_INVOKED)

/// Enqueues a command to read a rectangular region from \p buffer to

/// host memory.

///

/// \see_opencl_ref{clEnqueueReadBufferRect}

///

/// \opencl_version_warning{1,1}

event enqueue_read_buffer_rect(const buffer &buffer,

const size_t buffer_origin[3],

const size_t host_origin[3],

const size_t region[3],

size_t buffer_row_pitch,

size_t buffer_slice_pitch,

size_t host_row_pitch,

size_t host_slice_pitch,

void *host_ptr,

const wait_list &events = wait_list())

{

BOOST_ASSERT(m_queue != 0);

BOOST_ASSERT(buffer.get_context() == this->get_context());

BOOST_ASSERT(host_ptr != 0);

event event_;

cl_int ret = clEnqueueReadBufferRect(

m_queue,

buffer.get(),

CL_TRUE,

buffer_origin,

host_origin,

region,

buffer_row_pitch,

buffer_slice_pitch,

host_row_pitch,

host_slice_pitch,

host_ptr,

events.size(),

events.get_event_ptr(),

&event_.get()

);

if(ret != CL_SUCCESS){

BOOST_THROW_EXCEPTION(opencl_error(ret));

}

return event_;

}

/// Enqueues a command to read a rectangular region from \p buffer to

/// host memory. The copy will be performed asynchronously.

///

/// \see_opencl_ref{clEnqueueReadBufferRect}

///

/// \opencl_version_warning{1,1}

event enqueue_read_buffer_rect_async(const buffer &buffer,

const size_t buffer_origin[3],

const size_t host_origin[3],

const size_t region[3],

size_t buffer_row_pitch,

size_t buffer_slice_pitch,

size_t host_row_pitch,

size_t host_slice_pitch,

void *host_ptr,

const wait_list &events = wait_list())

{

BOOST_ASSERT(m_queue != 0);

BOOST_ASSERT(buffer.get_context() == this->get_context());

BOOST_ASSERT(host_ptr != 0);

event event_;

cl_int ret = clEnqueueReadBufferRect(

m_queue,

buffer.get(),

CL_FALSE,

buffer_origin,

host_origin,

region,

buffer_row_pitch,

buffer_slice_pitch,

host_row_pitch,

host_slice_pitch,

host_ptr,

events.size(),

events.get_event_ptr(),

&event_.get()

);

if(ret != CL_SUCCESS){

BOOST_THROW_EXCEPTION(opencl_error(ret));

}

return event_;

}

#endif // BOOST_COMPUTE_CL_VERSION_1_1

/// Enqueues a command to write data from host memory to \p buffer.

///

/// \see_opencl_ref{clEnqueueWriteBuffer}

///

/// \see copy()

event enqueue_write_buffer(const buffer &buffer,

size_t offset,

size_t size,

const void *host_ptr,

const wait_list &events = wait_list())

{

BOOST_ASSERT(m_queue != 0);

BOOST_ASSERT(size <= buffer.size());

BOOST_ASSERT(buffer.get_context() == this->get_context());

BOOST_ASSERT(host_ptr != 0);

event event_;

cl_int ret = clEnqueueWriteBuffer(

m_queue,

buffer.get(),

CL_TRUE,

offset,

size,

host_ptr,

events.size(),

events.get_event_ptr(),

&event_.get()

);

if(ret != CL_SUCCESS){

BOOST_THROW_EXCEPTION(opencl_error(ret));

}

return event_;

}

/// Enqueues a command to write data from host memory to \p buffer.

/// The copy is performed asynchronously.

///

/// \see_opencl_ref{clEnqueueWriteBuffer}

///

/// \see copy_async()

event enqueue_write_buffer_async(const buffer &buffer,

size_t offset,

size_t size,

const void *host_ptr,

const wait_list &events = wait_list())

{

BOOST_ASSERT(m_queue != 0);

BOOST_ASSERT(size <= buffer.size());

BOOST_ASSERT(buffer.get_context() == this->get_context());

BOOST_ASSERT(host_ptr != 0);

event event_;

cl_int ret = clEnqueueWriteBuffer(

m_queue,

buffer.get(),

CL_FALSE,

offset,

size,

host_ptr,

events.size(),

events.get_event_ptr(),

&event_.get()

);

if(ret != CL_SUCCESS){

BOOST_THROW_EXCEPTION(opencl_error(ret));

}

return event_;

}

#if defined(BOOST_COMPUTE_CL_VERSION_1_1) || defined(BOOST_COMPUTE_DOXYGEN_INVOKED)

/// Enqueues a command to write a rectangular region from host memory

/// to \p buffer.

///

/// \see_opencl_ref{clEnqueueWriteBufferRect}

///

/// \opencl_version_warning{1,1}

event enqueue_write_buffer_rect(const buffer &buffer,

const size_t buffer_origin[3],

const size_t host_origin[3],

const size_t region[3],

size_t buffer_row_pitch,

size_t buffer_slice_pitch,

size_t host_row_pitch,

size_t host_slice_pitch,

void *host_ptr,

const wait_list &events = wait_list())

{

BOOST_ASSERT(m_queue != 0);

BOOST_ASSERT(buffer.get_context() == this->get_context());

BOOST_ASSERT(host_ptr != 0);

event event_;

cl_int ret = clEnqueueWriteBufferRect(

m_queue,

buffer.get(),

CL_TRUE,

buffer_origin,

host_origin,

region,

buffer_row_pitch,

buffer_slice_pitch,

host_row_pitch,

host_slice_pitch,

host_ptr,

events.size(),

events.get_event_ptr(),

&event_.get()

);

if(ret != CL_SUCCESS){

BOOST_THROW_EXCEPTION(opencl_error(ret));

}

return event_;

}

/// Enqueues a command to write a rectangular region from host memory

/// to \p buffer. The copy is performed asynchronously.

///

/// \see_opencl_ref{clEnqueueWriteBufferRect}

///

/// \opencl_version_warning{1,1}

event enqueue_write_buffer_rect_async(const buffer &buffer,

const size_t buffer_origin[3],

const size_t host_origin[3],

const size_t region[3],

size_t buffer_row_pitch,

size_t buffer_slice_pitch,

size_t host_row_pitch,

size_t host_slice_pitch,

void *host_ptr,

const wait_list &events = wait_list())

{

BOOST_ASSERT(m_queue != 0);

BOOST_ASSERT(buffer.get_context() == this->get_context());

BOOST_ASSERT(host_ptr != 0);

event event_;

cl_int ret = clEnqueueWriteBufferRect(

m_queue,

buffer.get(),

CL_FALSE,

buffer_origin,

host_origin,

region,

buffer_row_pitch,

buffer_slice_pitch,

host_row_pitch,

host_slice_pitch,

host_ptr,

events.size(),

events.get_event_ptr(),

&event_.get()

);

if(ret != CL_SUCCESS){

BOOST_THROW_EXCEPTION(opencl_error(ret));

}

return event_;

}

#endif // BOOST_COMPUTE_CL_VERSION_1_1

/// Enqueues a command to copy data from \p src_buffer to

/// \p dst_buffer.

///

/// \see_opencl_ref{clEnqueueCopyBuffer}

///

/// \see copy()

event enqueue_copy_buffer(const buffer &src_buffer,

const buffer &dst_buffer,

size_t src_offset,

size_t dst_offset,

size_t size,

const wait_list &events = wait_list())

{

BOOST_ASSERT(m_queue != 0);

BOOST_ASSERT(src_offset + size <= src_buffer.size());

BOOST_ASSERT(dst_offset + size <= dst_buffer.size());

BOOST_ASSERT(src_buffer.get_context() == this->get_context());

BOOST_ASSERT(dst_buffer.get_context() == this->get_context());

event event_;

cl_int ret = clEnqueueCopyBuffer(

m_queue,

src_buffer.get(),

dst_buffer.get(),

src_offset,

dst_offset,

size,

events.size(),

events.get_event_ptr(),

&event_.get()

);

if(ret != CL_SUCCESS){

BOOST_THROW_EXCEPTION(opencl_error(ret));

}

return event_;

}

#if defined(BOOST_COMPUTE_CL_VERSION_1_1) || defined(BOOST_COMPUTE_DOXYGEN_INVOKED)

/// Enqueues a command to copy a rectangular region from

/// \p src_buffer to \p dst_buffer.

///

/// \see_opencl_ref{clEnqueueCopyBufferRect}

///

/// \opencl_version_warning{1,1}

event enqueue_copy_buffer_rect(const buffer &src_buffer,

const buffer &dst_buffer,

const size_t src_origin[3],

const size_t dst_origin[3],

const size_t region[3],

size_t buffer_row_pitch,

size_t buffer_slice_pitch,

size_t host_row_pitch,

size_t host_slice_pitch,

const wait_list &events = wait_list())

{

BOOST_ASSERT(m_queue != 0);

BOOST_ASSERT(src_buffer.get_context() == this->get_context());

BOOST_ASSERT(dst_buffer.get_context() == this->get_context());

event event_;

cl_int ret = clEnqueueCopyBufferRect(

m_queue,

src_buffer.get(),

dst_buffer.get(),

src_origin,

dst_origin,

region,

buffer_row_pitch,

buffer_slice_pitch,

host_row_pitch,

host_slice_pitch,

events.size(),

events.get_event_ptr(),

&event_.get()

);

if(ret != CL_SUCCESS){

BOOST_THROW_EXCEPTION(opencl_error(ret));

}

return event_;

}

#endif // BOOST_COMPUTE_CL_VERSION_1_1

#if defined(BOOST_COMPUTE_CL_VERSION_1_2) || defined(BOOST_COMPUTE_DOXYGEN_INVOKED)

/// Enqueues a command to fill \p buffer with \p pattern.

///

/// \see_opencl_ref{clEnqueueFillBuffer}

///

/// \opencl_version_warning{1,2}

///

/// \see fill()

event enqueue_fill_buffer(const buffer &buffer,

const void *pattern,

size_t pattern_size,

size_t offset,

size_t size,

const wait_list &events = wait_list())

{

BOOST_ASSERT(m_queue != 0);

BOOST_ASSERT(offset + size <= buffer.size());

BOOST_ASSERT(buffer.get_context() == this->get_context());

event event_;

cl_int ret = clEnqueueFillBuffer(

m_queue,

buffer.get(),

pattern,

pattern_size,

offset,

size,

events.size(),

events.get_event_ptr(),

&event_.get()

);

if(ret != CL_SUCCESS){

BOOST_THROW_EXCEPTION(opencl_error(ret));

}

return event_;

}

#endif // BOOST_COMPUTE_CL_VERSION_1_2

/// Enqueues a command to map \p buffer into the host address space.

/// Event associated with map operation is returned through

/// \p map_buffer_event parameter.

///

/// \see_opencl_ref{clEnqueueMapBuffer}

void* enqueue_map_buffer(const buffer &buffer,

cl_map_flags flags,

size_t offset,

size_t size,

event &map_buffer_event,

const wait_list &events = wait_list())

{

BOOST_ASSERT(m_queue != 0);

BOOST_ASSERT(offset + size <= buffer.size());

BOOST_ASSERT(buffer.get_context() == this->get_context());

cl_int ret = 0;

void *pointer = clEnqueueMapBuffer(

m_queue,

buffer.get(),

CL_TRUE,

flags,

offset,

size,

events.size(),

events.get_event_ptr(),

&map_buffer_event.get(),

&ret

);

if(ret != CL_SUCCESS){

BOOST_THROW_EXCEPTION(opencl_error(ret));

}

return pointer;

}

/// \overload

void* enqueue_map_buffer(const buffer &buffer,

cl_map_flags flags,

size_t offset,

size_t size,

const wait_list &events = wait_list())

{

event event_;

return enqueue_map_buffer(buffer, flags, offset, size, event_, events);

}

/// Enqueues a command to map \p buffer into the host address space.

/// Map operation is performed asynchronously. The pointer to the mapped

/// region cannot be used until the map operation has completed.

///

/// Event associated with map operation is returned through

/// \p map_buffer_event parameter.

///

/// \see_opencl_ref{clEnqueueMapBuffer}

void* enqueue_map_buffer_async(const buffer &buffer,

cl_map_flags flags,

size_t offset,

size_t size,

event &map_buffer_event,

const wait_list &events = wait_list())

{

BOOST_ASSERT(m_queue != 0);

BOOST_ASSERT(offset + size <= buffer.size());

BOOST_ASSERT(buffer.get_context() == this->get_context());

cl_int ret = 0;

void *pointer = clEnqueueMapBuffer(

m_queue,

buffer.get(),

CL_FALSE,

flags,

offset,

size,

events.size(),

events.get_event_ptr(),

&map_buffer_event.get(),

&ret

);

if(ret != CL_SUCCESS){

BOOST_THROW_EXCEPTION(opencl_error(ret));

}

return pointer;

}

/// Enqueues a command to unmap \p buffer from the host memory space.

///

/// \see_opencl_ref{clEnqueueUnmapMemObject}

event enqueue_unmap_buffer(const buffer &buffer,

void *mapped_ptr,

const wait_list &events = wait_list())

{

BOOST_ASSERT(buffer.get_context() == this->get_context());

return enqueue_unmap_mem_object(buffer.get(), mapped_ptr, events);

}

/// Enqueues a command to unmap \p mem from the host memory space.

///

/// \see_opencl_ref{clEnqueueUnmapMemObject}

event enqueue_unmap_mem_object(cl_mem mem,

void *mapped_ptr,

const wait_list &events = wait_list())

{

BOOST_ASSERT(m_queue != 0);

event event_;

cl_int ret = clEnqueueUnmapMemObject(

m_queue,

mem,

mapped_ptr,

events.size(),

events.get_event_ptr(),

&event_.get()

);

if(ret != CL_SUCCESS){

BOOST_THROW_EXCEPTION(opencl_error(ret));

}

return event_;

}

/// Enqueues a command to read data from \p image to host memory.

///

/// \see_opencl_ref{clEnqueueReadImage}

event enqueue_read_image(const image_object& image,

const size_t *origin,

const size_t *region,

size_t row_pitch,

size_t slice_pitch,

void *host_ptr,

const wait_list &events = wait_list())

{

BOOST_ASSERT(m_queue != 0);

event event_;

cl_int ret = clEnqueueReadImage(

m_queue,

image.get(),

CL_TRUE,

origin,

region,

row_pitch,

slice_pitch,

host_ptr,

events.size(),

events.get_event_ptr(),

&event_.get()

);

if(ret != CL_SUCCESS){

BOOST_THROW_EXCEPTION(opencl_error(ret));

}

return event_;

}

/// \overload

template<size_t N>

event enqueue_read_image(const image_object& image,

const extents<N> origin,

const extents<N> region,

void *host_ptr,

size_t row_pitch = 0,

size_t slice_pitch = 0,

const wait_list &events = wait_list())

{

BOOST_ASSERT(image.get_context() == this->get_context());

size_t origin3[3] = { 0, 0, 0 };

size_t region3[3] = { 1, 1, 1 };

std::copy(origin.data(), origin.data() + N, origin3);

std::copy(region.data(), region.data() + N, region3);

return enqueue_read_image(

image, origin3, region3, row_pitch, slice_pitch, host_ptr, events

);

}

/// Enqueues a command to write data from host memory to \p image.

///

/// \see_opencl_ref{clEnqueueWriteImage}

event enqueue_write_image(image_object& image,

const size_t *origin,

const size_t *region,

const void *host_ptr,

size_t input_row_pitch = 0,

size_t input_slice_pitch = 0,

const wait_list &events = wait_list())

{

BOOST_ASSERT(m_queue != 0);

event event_;

cl_int ret = clEnqueueWriteImage(

m_queue,

image.get(),

CL_TRUE,

origin,

region,

input_row_pitch,

input_slice_pitch,

host_ptr,

events.size(),

events.get_event_ptr(),

&event_.get()

);

if(ret != CL_SUCCESS){

BOOST_THROW_EXCEPTION(opencl_error(ret));

}

return event_;

}

/// \overload

template<size_t N>

event enqueue_write_image(image_object& image,

const extents<N> origin,

const extents<N> region,

const void *host_ptr,

const size_t input_row_pitch = 0,

const size_t input_slice_pitch = 0,

const wait_list &events = wait_list())

{

BOOST_ASSERT(image.get_context() == this->get_context());

size_t origin3[3] = { 0, 0, 0 };

size_t region3[3] = { 1, 1, 1 };

std::copy(origin.data(), origin.data() + N, origin3);