OpenCL C++ Wrapper API 1.1
 All Classes Namespaces Files Functions Variables Typedefs Defines
Public Member Functions | Static Public Member Functions | Static Private Attributes
cl::CommandQueue Class Reference

CommandQueue interface for cl_command_queue. More...

#include <cl.hpp>

Inheritance diagram for cl::CommandQueue:
cl::detail::Wrapper< cl_command_queue >

List of all members.

Public Member Functions

 CommandQueue (cl_command_queue_properties properties, cl_int *err=NULL)
 CommandQueue (const Context &context, const Device &device, cl_command_queue_properties properties=0, cl_int *err=NULL)
 CommandQueue ()
 CommandQueue (const CommandQueue &commandQueue)
 CommandQueue (const cl_command_queue &commandQueue)
CommandQueue & operator= (const CommandQueue &rhs)
CommandQueue & operator= (const cl_command_queue &rhs)
template<typename T >
cl_int getInfo (cl_command_queue_info name, T *param) const
template<cl_int name>
detail::param_traits
< detail::cl_command_queue_info,
name >::param_type 		getInfo (cl_int *err=NULL) const
cl_int enqueueReadBuffer (const Buffer &buffer, cl_bool blocking,::size_t offset,::size_t size, void *ptr, const VECTOR_CLASS< Event > *events=NULL, Event *event=NULL) const
cl_int enqueueWriteBuffer (const Buffer &buffer, cl_bool blocking,::size_t offset,::size_t size, const void *ptr, const VECTOR_CLASS< Event > *events=NULL, Event *event=NULL) const
cl_int enqueueCopyBuffer (const Buffer &src, const Buffer &dst,::size_t src_offset,::size_t dst_offset,::size_t size, const VECTOR_CLASS< Event > *events=NULL, Event *event=NULL) const
cl_int enqueueReadImage (const Image &image, cl_bool blocking, const size_t< 3 > &origin, const size_t< 3 > &region,::size_t row_pitch,::size_t slice_pitch, void *ptr, const VECTOR_CLASS< Event > *events=NULL, Event *event=NULL) const
cl_int enqueueWriteImage (const Image &image, cl_bool blocking, const size_t< 3 > &origin, const size_t< 3 > &region,::size_t row_pitch,::size_t slice_pitch, void *ptr, const VECTOR_CLASS< Event > *events=NULL, Event *event=NULL) const
cl_int enqueueCopyImage (const Image &src, const Image &dst, const size_t< 3 > &src_origin, const size_t< 3 > &dst_origin, const size_t< 3 > &region, const VECTOR_CLASS< Event > *events=NULL, Event *event=NULL) const
cl_int enqueueCopyImageToBuffer (const Image &src, const Buffer &dst, const size_t< 3 > &src_origin, const size_t< 3 > &region,::size_t dst_offset, const VECTOR_CLASS< Event > *events=NULL, Event *event=NULL) const
cl_int enqueueCopyBufferToImage (const Buffer &src, const Image &dst,::size_t src_offset, const size_t< 3 > &dst_origin, const size_t< 3 > &region, const VECTOR_CLASS< Event > *events=NULL, Event *event=NULL) const
void * enqueueMapBuffer (const Buffer &buffer, cl_bool blocking, cl_map_flags flags,::size_t offset,::size_t size, const VECTOR_CLASS< Event > *events=NULL, Event *event=NULL, cl_int *err=NULL) const
void * enqueueMapImage (const Image &buffer, cl_bool blocking, cl_map_flags flags, const size_t< 3 > &origin, const size_t< 3 > &region,::size_t *row_pitch,::size_t *slice_pitch, const VECTOR_CLASS< Event > *events=NULL, Event *event=NULL, cl_int *err=NULL) const
cl_int enqueueUnmapMemObject (const Memory &memory, void *mapped_ptr, const VECTOR_CLASS< Event > *events=NULL, Event *event=NULL) const
cl_int enqueueNDRangeKernel (const Kernel &kernel, const NDRange &offset, const NDRange &global, const NDRange &local=NullRange, const VECTOR_CLASS< Event > *events=NULL, Event *event=NULL) const
cl_int enqueueTask (const Kernel &kernel, const VECTOR_CLASS< Event > *events=NULL, Event *event=NULL) const
cl_int enqueueNativeKernel (void(*userFptr)(void *), std::pair< void *,::size_t > args, const VECTOR_CLASS< Memory > *mem_objects=NULL, const VECTOR_CLASS< const void * > *mem_locs=NULL, const VECTOR_CLASS< Event > *events=NULL, Event *event=NULL) const
cl_int enqueueMarker (Event *event=NULL) const
cl_int enqueueWaitForEvents (const VECTOR_CLASS< Event > &events) const
cl_int enqueueAcquireGLObjects (const VECTOR_CLASS< Memory > *mem_objects=NULL, const VECTOR_CLASS< Event > *events=NULL, Event *event=NULL) const
cl_int enqueueReleaseGLObjects (const VECTOR_CLASS< Memory > *mem_objects=NULL, const VECTOR_CLASS< Event > *events=NULL, Event *event=NULL) const
cl_int enqueueBarrier () const
cl_int flush () const
cl_int finish () const

Static Public Member Functions

static CommandQueue getDefault (cl_int *err=NULL)

Static Private Attributes

static volatile int default_initialized_
static CommandQueue default_
static volatile cl_int default_error_

Detailed Description

CommandQueue interface for cl_command_queue.

Definition at line 3115 of file cl.hpp.

Constructor & Destructor Documentation

cl::CommandQueue::CommandQueue ( cl_command_queue_properties  properties,
cl_int *  err = NULL 
) [inline]

Definition at line 3122 of file cl.hpp.

    {
        cl_int error;

        Context context = Context::getDefault(&error);
        detail::errHandler(error, __CREATE_COMMAND_QUEUE_ERR);

        if (error != CL_SUCCESS) {
            if (err != NULL) {
                *err = error;
            }
        }
        else {
            Device device = context.getInfo<CL_CONTEXT_DEVICES>()[0];

            object_ = ::clCreateCommandQueue(
                context(), device(), properties, &error);

            detail::errHandler(error, __CREATE_COMMAND_QUEUE_ERR);
            if (err != NULL) {
                *err = error;
            }
        }
    }
cl::CommandQueue::CommandQueue ( const Context &  context,
const Device &  device,
cl_command_queue_properties  properties = 0,
cl_int *  err = NULL 
) [inline]

Definition at line 3149 of file cl.hpp.

    {
        cl_int error;
        object_ = ::clCreateCommandQueue(
            context(), device(), properties, &error);

        detail::errHandler(error, __CREATE_COMMAND_QUEUE_ERR);
        if (err != NULL) {
            *err = error;
        }
    }
cl::CommandQueue::CommandQueue ( ) [inline]

Definition at line 3222 of file cl.hpp.

{ }
cl::CommandQueue::CommandQueue ( const CommandQueue &  commandQueue) [inline]

Definition at line 3224 of file cl.hpp.

: detail::Wrapper<cl_type>(commandQueue) { }
cl::CommandQueue::CommandQueue ( const cl_command_queue &  commandQueue) [inline]

Definition at line 3226 of file cl.hpp.

: detail::Wrapper<cl_type>(commandQueue) { }

Member Function Documentation

cl_int cl::CommandQueue::enqueueAcquireGLObjects ( const VECTOR_CLASS< Memory > *  mem_objects = NULL,
const VECTOR_CLASS< Event > *  events = NULL,
Event *  event = NULL 
) const [inline]

Definition at line 3759 of file cl.hpp.

     {
        cl_event tmp;
        cl_int err = detail::errHandler(
             ::clEnqueueAcquireGLObjects(
                 object_,
                 (mem_objects != NULL) ? (cl_uint) mem_objects->size() : 0,
                 (mem_objects != NULL) ? (const cl_mem *) &mem_objects->front(): NULL,
                 (events != NULL) ? (cl_uint) events->size() : 0,
                 (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
                 (event != NULL) ? &tmp : NULL),
             __ENQUEUE_ACQUIRE_GL_ERR);

        if (event != NULL && err == CL_SUCCESS)
            *event = tmp;

        return err;
     }
cl_int cl::CommandQueue::enqueueBarrier ( ) const [inline]

Definition at line 3864 of file cl.hpp.

    {
        return detail::errHandler(
            ::clEnqueueBarrier(object_),
            __ENQUEUE_BARRIER_ERR);
    }
cl_int cl::CommandQueue::enqueueCopyBuffer ( const Buffer &  src,
const Buffer &  dst,
::size_t  src_offset,
::size_t  dst_offset,
::size_t  size,
const VECTOR_CLASS< Event > *  events = NULL,
Event *  event = NULL 
) const [inline]

Definition at line 3314 of file cl.hpp.

    {
        cl_event tmp;
        cl_int err = detail::errHandler(
            ::clEnqueueCopyBuffer(
                object_, src(), dst(), src_offset, dst_offset, size,
                (events != NULL) ? (cl_uint) events->size() : 0,
                (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
                (event != NULL) ? &tmp : NULL),
            __ENQEUE_COPY_BUFFER_ERR);

        if (event != NULL && err == CL_SUCCESS)
            *event = tmp;

        return err;
    }
cl_int cl::CommandQueue::enqueueCopyBufferToImage ( const Buffer &  src,
const Image &  dst,
::size_t  src_offset,
const size_t< 3 > &  dst_origin,
const size_t< 3 > &  region,
const VECTOR_CLASS< Event > *  events = NULL,
Event *  event = NULL 
) const [inline]

Definition at line 3560 of file cl.hpp.

    {
        cl_event tmp;
        cl_int err = detail::errHandler(
            ::clEnqueueCopyBufferToImage(
                object_, src(), dst(), src_offset,
                (const ::size_t *) dst_origin, (const ::size_t *) region,
                (events != NULL) ? (cl_uint) events->size() : 0,
                (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
                (event != NULL) ? &tmp : NULL),
            __ENQUEUE_COPY_BUFFER_TO_IMAGE_ERR);

        if (event != NULL && err == CL_SUCCESS)
            *event = tmp;

        return err;
    }
cl_int cl::CommandQueue::enqueueCopyImage ( const Image &  src,
const Image &  dst,
const size_t< 3 > &  src_origin,
const size_t< 3 > &  dst_origin,
const size_t< 3 > &  region,
const VECTOR_CLASS< Event > *  events = NULL,
Event *  event = NULL 
) const [inline]

Definition at line 3510 of file cl.hpp.

    {
        cl_event tmp;
        cl_int err = detail::errHandler(
            ::clEnqueueCopyImage(
                object_, src(), dst(), (const ::size_t *) src_origin,
                (const ::size_t *)dst_origin, (const ::size_t *) region,
                (events != NULL) ? (cl_uint) events->size() : 0,
                (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
                (event != NULL) ? &tmp : NULL),
            __ENQUEUE_COPY_IMAGE_ERR);

        if (event != NULL && err == CL_SUCCESS)
            *event = tmp;

        return err;
    }
cl_int cl::CommandQueue::enqueueCopyImageToBuffer ( const Image &  src,
const Buffer &  dst,
const size_t< 3 > &  src_origin,
const size_t< 3 > &  region,
::size_t  dst_offset,
const VECTOR_CLASS< Event > *  events = NULL,
Event *  event = NULL 
) const [inline]

Definition at line 3535 of file cl.hpp.

    {
        cl_event tmp;
        cl_int err = detail::errHandler(
            ::clEnqueueCopyImageToBuffer(
                object_, src(), dst(), (const ::size_t *) src_origin,
                (const ::size_t *) region, dst_offset,
                (events != NULL) ? (cl_uint) events->size() : 0,
                (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
                (event != NULL) ? &tmp : NULL),
            __ENQUEUE_COPY_IMAGE_TO_BUFFER_ERR);

        if (event != NULL && err == CL_SUCCESS)
            *event = tmp;

        return err;
    }
void* cl::CommandQueue::enqueueMapBuffer ( const Buffer &  buffer,
cl_bool  blocking,
cl_map_flags  flags,
::size_t  offset,
::size_t  size,
const VECTOR_CLASS< Event > *  events = NULL,
Event *  event = NULL,
cl_int *  err = NULL 
) const [inline]

Definition at line 3585 of file cl.hpp.

    {
        cl_int error;
        void * result = ::clEnqueueMapBuffer(
            object_, buffer(), blocking, flags, offset, size,
            (events != NULL) ? (cl_uint) events->size() : 0,
            (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
            (cl_event*) event,
            &error);

        detail::errHandler(error, __ENQUEUE_MAP_BUFFER_ERR);
        if (err != NULL) {
            *err = error;
        }
        return result;
    }
void* cl::CommandQueue::enqueueMapImage ( const Image &  buffer,
cl_bool  blocking,
cl_map_flags  flags,
const size_t< 3 > &  origin,
const size_t< 3 > &  region,
::size_t *  row_pitch,
::size_t *  slice_pitch,
const VECTOR_CLASS< Event > *  events = NULL,
Event *  event = NULL,
cl_int *  err = NULL 
) const [inline]

Definition at line 3610 of file cl.hpp.

    {
        cl_int error;
        void * result = ::clEnqueueMapImage(
            object_, buffer(), blocking, flags,
            (const ::size_t *) origin, (const ::size_t *) region,
            row_pitch, slice_pitch,
            (events != NULL) ? (cl_uint) events->size() : 0,
            (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
            (cl_event*) event,
            &error);

        detail::errHandler(error, __ENQUEUE_MAP_IMAGE_ERR);
        if (err != NULL) {
              *err = error;
        }
        return result;
    }
cl_int cl::CommandQueue::enqueueMarker ( Event *  event = NULL) const [inline]

Definition at line 3742 of file cl.hpp.

    {
        return detail::errHandler(
            ::clEnqueueMarker(object_, (cl_event*) event),
            __ENQUEUE_MARKER_ERR);
    }
cl_int cl::CommandQueue::enqueueNativeKernel ( void(*)(void *)  userFptr,
std::pair< void *,::size_t >  args,
const VECTOR_CLASS< Memory > *  mem_objects = NULL,
const VECTOR_CLASS< const void * > *  mem_locs = NULL,
const VECTOR_CLASS< Event > *  events = NULL,
Event *  event = NULL 
) const [inline]

Definition at line 3706 of file cl.hpp.

    {
        cl_mem * mems = (mem_objects != NULL && mem_objects->size() > 0) 
            ? (cl_mem*) alloca(mem_objects->size() * sizeof(cl_mem))
            : NULL;

        if (mems != NULL) {
            for (unsigned int i = 0; i < mem_objects->size(); i++) {
                mems[i] = ((*mem_objects)[i])();
            }
        }

        cl_event tmp;
        cl_int err = detail::errHandler(
            ::clEnqueueNativeKernel(
                object_, userFptr, args.first, args.second,
                (mem_objects != NULL) ? (cl_uint) mem_objects->size() : 0,
                mems,
                (mem_locs != NULL) ? (const void **) &mem_locs->front() : NULL,
                (events != NULL) ? (cl_uint) events->size() : 0,
                (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
                (event != NULL) ? &tmp : NULL),
            __ENQUEUE_NATIVE_KERNEL);

        if (event != NULL && err == CL_SUCCESS)
            *event = tmp;

        return err;
    }
cl_int cl::CommandQueue::enqueueNDRangeKernel ( const Kernel &  kernel,
const NDRange &  offset,
const NDRange &  global,
const NDRange &  local = NullRange,
const VECTOR_CLASS< Event > *  events = NULL,
Event *  event = NULL 
) const [inline]

Definition at line 3660 of file cl.hpp.

    {
        cl_event tmp;
        cl_int err = detail::errHandler(
            ::clEnqueueNDRangeKernel(
                object_, kernel(), (cl_uint) global.dimensions(),
                offset.dimensions() != 0 ? (const ::size_t*) offset : NULL,
                (const ::size_t*) global,
                local.dimensions() != 0 ? (const ::size_t*) local : NULL,
                (events != NULL) ? (cl_uint) events->size() : 0,
                (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
                (event != NULL) ? &tmp : NULL),
            __ENQUEUE_NDRANGE_KERNEL_ERR);

        if (event != NULL && err == CL_SUCCESS)
            *event = tmp;

        return err;
    }
cl_int cl::CommandQueue::enqueueReadBuffer ( const Buffer &  buffer,
cl_bool  blocking,
::size_t  offset,
::size_t  size,
void *  ptr,
const VECTOR_CLASS< Event > *  events = NULL,
Event *  event = NULL 
) const [inline]

Definition at line 3264 of file cl.hpp.

    {
        cl_event tmp;
        cl_int err = detail::errHandler(
            ::clEnqueueReadBuffer(
                object_, buffer(), blocking, offset, size,
                ptr,
                (events != NULL) ? (cl_uint) events->size() : 0,
                (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
                (event != NULL) ? &tmp : NULL),
            __ENQUEUE_READ_BUFFER_ERR);

        if (event != NULL && err == CL_SUCCESS)
            *event = tmp;

        return err;
    }
cl_int cl::CommandQueue::enqueueReadImage ( const Image &  image,
cl_bool  blocking,
const size_t< 3 > &  origin,
const size_t< 3 > &  region,
::size_t  row_pitch,
::size_t  slice_pitch,
void *  ptr,
const VECTOR_CLASS< Event > *  events = NULL,
Event *  event = NULL 
) const [inline]

Definition at line 3456 of file cl.hpp.

    {
        cl_event tmp;
        cl_int err = detail::errHandler(
            ::clEnqueueReadImage(
                object_, image(), blocking, (const ::size_t *) origin,
                (const ::size_t *) region, row_pitch, slice_pitch, ptr,
                (events != NULL) ? (cl_uint) events->size() : 0,
                (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
                (event != NULL) ? &tmp : NULL),
            __ENQUEUE_READ_IMAGE_ERR);

        if (event != NULL && err == CL_SUCCESS)
            *event = tmp;

        return err;
    }
cl_int cl::CommandQueue::enqueueReleaseGLObjects ( const VECTOR_CLASS< Memory > *  mem_objects = NULL,
const VECTOR_CLASS< Event > *  events = NULL,
Event *  event = NULL 
) const [inline]

Definition at line 3781 of file cl.hpp.

     {
        cl_event tmp;
        cl_int err = detail::errHandler(
             ::clEnqueueReleaseGLObjects(
                 object_,
                 (mem_objects != NULL) ? (cl_uint) mem_objects->size() : 0,
                 (mem_objects != NULL) ? (const cl_mem *) &mem_objects->front(): NULL,
                 (events != NULL) ? (cl_uint) events->size() : 0,
                 (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
                 (event != NULL) ? &tmp : NULL),
             __ENQUEUE_RELEASE_GL_ERR);

        if (event != NULL && err == CL_SUCCESS)
            *event = tmp;

        return err;
     }
cl_int cl::CommandQueue::enqueueTask ( const Kernel &  kernel,
const VECTOR_CLASS< Event > *  events = NULL,
Event *  event = NULL 
) const [inline]

Definition at line 3686 of file cl.hpp.

    {
        cl_event tmp;
        cl_int err = detail::errHandler(
            ::clEnqueueTask(
                object_, kernel(),
                (events != NULL) ? (cl_uint) events->size() : 0,
                (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
                (event != NULL) ? &tmp : NULL),
            __ENQUEUE_TASK_ERR);

        if (event != NULL && err == CL_SUCCESS)
            *event = tmp;

        return err;
    }
cl_int cl::CommandQueue::enqueueUnmapMemObject ( const Memory &  memory,
void *  mapped_ptr,
const VECTOR_CLASS< Event > *  events = NULL,
Event *  event = NULL 
) const [inline]

Definition at line 3639 of file cl.hpp.

    {
        cl_event tmp;
        cl_int err = detail::errHandler(
            ::clEnqueueUnmapMemObject(
                object_, memory(), mapped_ptr,
                (events != NULL) ? (cl_uint) events->size() : 0,
                (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
                (event != NULL) ? &tmp : NULL),
            __ENQUEUE_UNMAP_MEM_OBJECT_ERR);

        if (event != NULL && err == CL_SUCCESS)
            *event = tmp;

        return err;
    }
cl_int cl::CommandQueue::enqueueWaitForEvents ( const VECTOR_CLASS< Event > &  events) const [inline]

Definition at line 3749 of file cl.hpp.

    {
        return detail::errHandler(
            ::clEnqueueWaitForEvents(
                object_,
                (cl_uint) events.size(),
                (const cl_event*) &events.front()),
            __ENQUEUE_WAIT_FOR_EVENTS_ERR);
    }
cl_int cl::CommandQueue::enqueueWriteBuffer ( const Buffer &  buffer,
cl_bool  blocking,
::size_t  offset,
::size_t  size,
const void *  ptr,
const VECTOR_CLASS< Event > *  events = NULL,
Event *  event = NULL 
) const [inline]

Definition at line 3289 of file cl.hpp.

    {
        cl_event tmp;
        cl_int err = detail::errHandler(
            ::clEnqueueWriteBuffer(
                object_, buffer(), blocking, offset, size,
                ptr,
                (events != NULL) ? (cl_uint) events->size() : 0,
                (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
                (event != NULL) ? &tmp : NULL),
                __ENQUEUE_WRITE_BUFFER_ERR);

        if (event != NULL && err == CL_SUCCESS)
            *event = tmp;

        return err;
    }
cl_int cl::CommandQueue::enqueueWriteImage ( const Image &  image,
cl_bool  blocking,
const size_t< 3 > &  origin,
const size_t< 3 > &  region,
::size_t  row_pitch,
::size_t  slice_pitch,
void *  ptr,
const VECTOR_CLASS< Event > *  events = NULL,
Event *  event = NULL 
) const [inline]

Definition at line 3483 of file cl.hpp.

    {
        cl_event tmp;
        cl_int err = detail::errHandler(
            ::clEnqueueWriteImage(
                object_, image(), blocking, (const ::size_t *) origin,
                (const ::size_t *) region, row_pitch, slice_pitch, ptr,
                (events != NULL) ? (cl_uint) events->size() : 0,
                (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL,
                (event != NULL) ? &tmp : NULL),
            __ENQUEUE_WRITE_IMAGE_ERR);

        if (event != NULL && err == CL_SUCCESS)
            *event = tmp;

        return err;
    }
cl_int cl::CommandQueue::finish ( ) const [inline]

Definition at line 3876 of file cl.hpp.

    {
        return detail::errHandler(::clFinish(object_), __FINISH_ERR);
    }
cl_int cl::CommandQueue::flush ( ) const [inline]

Definition at line 3871 of file cl.hpp.

    {
        return detail::errHandler(::clFlush(object_), __FLUSH_ERR);
    }
static CommandQueue cl::CommandQueue::getDefault ( cl_int *  err = NULL) [inline, static]

Definition at line 3165 of file cl.hpp.

    {
        int state = detail::compare_exchange(
            &default_initialized_, 
            __DEFAULT_BEING_INITIALIZED, __DEFAULT_NOT_INITIALIZED);

        if (state & __DEFAULT_INITIALIZED) {
            if (err != NULL) {
                *err = default_error_;
            }
            return default_;
        }

        if (state & __DEFAULT_BEING_INITIALIZED) {
              // Assume writes will propagate eventually...
              while(default_initialized_ != __DEFAULT_INITIALIZED) {
                                ;
              }

            if (err != NULL) {
                *err = default_error_;
            }
            return default_;
        }

        cl_int error;

        Context context = Context::getDefault(&error);
        detail::errHandler(error, __CREATE_COMMAND_QUEUE_ERR);

        if (error != CL_SUCCESS) {
            if (err != NULL) {
                *err = error;
            }
        }
        else {
            Device device = context.getInfo<CL_CONTEXT_DEVICES>()[0];


            default_ = CommandQueue(context, device, 0, &error);

            detail::errHandler(error, __CREATE_COMMAND_QUEUE_ERR);
            if (err != NULL) {
                *err = error;
            }
        }

        default_error_ = error;
        // Assume writes will propagate eventually...
        default_initialized_ = __DEFAULT_INITIALIZED;
        if (err != NULL) {
            *err = default_error_;
        }
        return default_;

    }
template<typename T >
cl_int cl::CommandQueue::getInfo ( cl_command_queue_info  name,
T *  param 
) const [inline]

Definition at line 3243 of file cl.hpp.

    {
        return detail::errHandler(
            detail::getInfo(
                &::clGetCommandQueueInfo, object_, name, param),
                __GET_COMMAND_QUEUE_INFO_ERR);
    }
template<cl_int name>
detail::param_traits<detail::cl_command_queue_info, name>::param_type cl::CommandQueue::getInfo ( cl_int *  err = NULL) const [inline]

Definition at line 3253 of file cl.hpp.

    {
        typename detail::param_traits<
            detail::cl_command_queue_info, name>::param_type param;
        cl_int result = getInfo(name, &param);
        if (err != NULL) {
            *err = result;
        }
        return param;
    }
CommandQueue& cl::CommandQueue::operator= ( const CommandQueue &  rhs) [inline]

Definition at line 3228 of file cl.hpp.

    {
        if (this != &rhs) {
            detail::Wrapper<cl_type>::operator=(rhs);
        }
        return *this;
    }
CommandQueue& cl::CommandQueue::operator= ( const cl_command_queue &  rhs) [inline]

Reimplemented from cl::detail::Wrapper< cl_command_queue >.

Definition at line 3236 of file cl.hpp.

    {
        detail::Wrapper<cl_type>::operator=(rhs);
        return *this;
    }

Member Data Documentation

CommandQueue cl::CommandQueue::default_ [static, private]

Definition at line 3119 of file cl.hpp.

volatile cl_int cl::CommandQueue::default_error_ [static, private]

Definition at line 3120 of file cl.hpp.

volatile int cl::CommandQueue::default_initialized_ [static, private]

Definition at line 3118 of file cl.hpp.

The documentation for this class was generated from the following file:
 All Classes Namespaces Files Functions Variables Typedefs Defines
Generated on Sat Jul 14 2012 16:30:22 for OpenCL C++ Wrapper API 1.1 by   doxygen 1.7.6.1