BounceKernel::BounceKernel(const BounceKernel &other) :
KernelBaseCL(other),
m_position(other.m_position)
{
if (m_position)
clRetainMemObject(m_position);
};
CLBuffer::CLBuffer(const CLBuffer& copy) : m_buffer(copy.m_buffer)
{
cl_int error = clRetainMemObject(m_buffer);
if (error != CL_SUCCESS)
{
std::cout << "clRetainMemObject failed" << std::endl;
}
}
cl_int WINAPI wine_clRetainMemObject(cl_mem memobj)
{
cl_int ret;
TRACE("(%p)\n", memobj);
ret = clRetainMemObject(memobj);
TRACE("(%p)=%d\n", memobj, ret);
return ret;
}
cl_kernel
__clCloneKernel (cl_kernel kernel)
{
_cl_kernel *original_kernel_data = (_cl_kernel *) kernel;
_cl_kernel *kernel_data = NULL;
cl_uint i;
if (!original_kernel_data)
{
#ifdef OCL_DEBUG_MESSAGES
__clDebugPrint (CL_LOG_ERROR, "__clCloneKernel: invalid parameter\n");
#endif // #ifdef OCL_DEBUG_MESSAGES
return 0;
}
kernel_data = (_cl_kernel *) __clAlloc (sizeof (_cl_kernel));
if (!kernel_data)
{
#ifdef OCL_DEBUG_MESSAGES
__clDebugPrint (CL_LOG_ERROR, "__clCloneKernel: out of memory\n");
#endif // #ifdef OCL_DEBUG_MESSAGES
return (cl_kernel) 0;
}
// copy all the rest from original kernel
memcpy (kernel_data, original_kernel_data, sizeof (_cl_kernel));
kernel_data->header.ref_count = 1;
if (kernel_data->program_data)
{
// clone will reference same program as original, so increase refcount
clRetainProgram ((cl_program) kernel_data->program_data);
}
for (i = 0; i < MAX_KERNEL_ARGS; i++)
{
kernel_data->arg[i].buffer = original_kernel_data->arg[i].buffer;
if (kernel_data->arg[i].buffer)
{
// clone will reference same argument buffers, so increase refcount
clRetainMemObject (kernel_data->arg[i].buffer);
}
if (original_kernel_data->arg[i].data)
{
// make a copy of a argument data
kernel_data->arg[i].data =
__clAlloc (original_kernel_data->arg[i].datalen);
memcpy (kernel_data->arg[i].data, original_kernel_data->arg[i].data,
original_kernel_data->arg[i].datalen);
kernel_data->arg[i].datalen = original_kernel_data->arg[i].datalen;
}
}
__clListAddNode (&g_kernel_data_root, kernel_data);
return (cl_kernel) kernel_data;
}
vector (clsparseControl control, const cl_mem& mem, size_t size)
: queue(control->queue)
{
//operator = on Memory class transfers ownership which I want to avoid;
clRetainMemObject(mem);
BASE::_buff = mem;
BASE::_size = size;
}
/*!
Returns the parent of this buffer if it is a sub-buffer;
null otherwise.
\sa createSubBuffer(), offset()
*/
QCLBuffer QCLBuffer::parentBuffer() const
{
cl_mem parent;
if (clGetMemObjectInfo(memoryId(), CL_MEM_ASSOCIATED_MEMOBJECT,
sizeof(parent), &parent, 0) != CL_SUCCESS)
return QCLBuffer();
if (parent)
clRetainMemObject(parent);
return QCLBuffer(context(), parent);
}
static void inc(cl_mem & something)
{
cl_int err = clRetainMemObject(something);
VIENNACL_ERR_CHECK(err);
}
cl_int
clSetKernelArg (cl_kernel kernel,
cl_uint arg_index, size_t arg_size, const void *arg_value)
{
_cl_kernel *kernel_data = (_cl_kernel *) kernel;
_cl_mem *memobj_data = NULL;
_cl_sampler *sampler_data = NULL;
cl_int retval = CL_SUCCESS;
cl_mem *temp_memobj = NULL;
cl_sampler *temp_sampler = NULL;
if (arg_index >= MAX_KERNEL_ARGS)
{
#ifdef OCL_DEBUG_MESSAGES
__clDebugPrint (CL_LOG_ERROR, "clSetKernelArg: Invalid argument index\n");
#endif // #ifdef OCL_DEBUG_MESSAGES
return CL_INVALID_ARG_INDEX;
}
if (!kernel_data)
{
#ifdef OCL_DEBUG_MESSAGES
__clDebugPrint (CL_LOG_ERROR, "clSetKernelArg, invalid kernel (0x%08x)\n",
(int) kernel);
#endif // #ifdef OCL_DEBUG_MESSAGES
return CL_INVALID_KERNEL;
}
if (kernel_data->arg[arg_index].data)
{
// argument data already exists, free it
#ifdef OCL_DEBUG_MESSAGES
__clDebugPrint (CL_LOG_DEBUG,
"clSetKernelArg: Freeing existing argument data at index %d\n",
arg_index);
#endif // #ifdef OCL_DEBUG_MESSAGES
__clFree (kernel_data->arg[arg_index].data);
kernel_data->arg[arg_index].data = NULL;
kernel_data->arg[arg_index].datalen = 0;
}
if (kernel_data->arg[arg_index].buffer)
{
// argument data already exists, free it
#ifdef OCL_DEBUG_MESSAGES
__clDebugPrint (CL_LOG_DEBUG,
"clSetKernelArg: Freeing existing argument buffer at index %d\n",
arg_index);
#endif // #ifdef OCL_DEBUG_MESSAGES
clReleaseMemObject (kernel_data->arg[arg_index].buffer);
kernel_data->arg[arg_index].buffer = 0;
}
// check if given argument is a memory buffer
// NOTE: bubblegumbandaid
// there is a problem identifying cl_mem objects when
// they are set with clSetKernelArg function
// if normal 'int' value is passed, which value is in range
// of cl_mem that are in use, system gets confused and
// thinks that given 'int' is a 'cl_mem'.
// example:
// cl_mem mybuffer = 100; // returned from clCreateBuffer
// int myvalue = 100;
// clSetKernelArg(kernel, 0, sizeof(int), &myvalue);
// in this case, clSetKernelArg thinks that given argument is a 'mybuffer'
// cl_mem object.
// right now this is fixed by giving cl_mem objects high range of values,
// making this problem more unlikely to happen
if (arg_value)
{
temp_memobj = (cl_mem *) arg_value;
memobj_data = (_cl_mem *) (*temp_memobj);
temp_sampler = (cl_sampler *) arg_value;
sampler_data = (_cl_sampler *) (*temp_sampler);
}
if (__clPointerIsMemObject (memobj_data))
{
if (memobj_data->type == CL_MEM_OBJECT_IMAGE2D)
{
#ifdef OCL_DEBUG_MESSAGES
__clDebugPrint (CL_LOG_DEBUG,
"clSetKernelArg: Argument %d is a cl_mem image buffer (%d bytes)\n",
arg_index, memobj_data->size);
#endif // #ifdef OCL_DEBUG_MESSAGES
}
else
{
#ifdef OCL_DEBUG_MESSAGES
__clDebugPrint (CL_LOG_DEBUG,
"clSetKernelArg: Argument %d is a cl_mem buffer (0x%08x), (%d bytes)\n",
arg_index, (int)memobj_data, memobj_data->size);
#endif // #ifdef OCL_DEBUG_MESSAGES
}
kernel_data->arg[arg_index].buffer = (cl_mem) memobj_data;
kernel_data->arg[arg_index].data = NULL;
kernel_data->arg[arg_index].datalen = 0;
clRetainMemObject ((cl_mem) memobj_data);
}
else if (__clPointerIsSampler (sampler_data))
{
#ifdef OCL_DEBUG_MESSAGES
__clDebugPrint (CL_LOG_DEBUG,
"clSetKernelArg: Argument %d is a cl_sampler\n",
arg_index);
#endif // #ifdef OCL_DEBUG_MESSAGES
kernel_data->arg[arg_index].buffer = 0;
kernel_data->arg[arg_index].data = __clAlloc (sizeof (uint32_t));
kernel_data->arg[arg_index].datalen = sizeof (uint32_t);
memcpy (kernel_data->arg[arg_index].data, &sampler_data->values,
sizeof (uint32_t));
}
else
{
if (arg_value)
{
// pointer data passed
#ifdef OCL_DEBUG_MESSAGES
__clDebugPrint (CL_LOG_DEBUG,
"clSetKernelArg: Argument %d is pointer to memory (%d bytes)\n",
arg_index, (int) arg_size);
#endif // #ifdef OCL_DEBUG_MESSAGES
if (arg_size < sizeof (int))
{
// add argument boundary padding
arg_size = sizeof (int);
}
kernel_data->arg[arg_index].buffer = 0;
kernel_data->arg[arg_index].data = __clAlloc (arg_size);
memcpy (kernel_data->arg[arg_index].data, arg_value, arg_size);
kernel_data->arg[arg_index].datalen = arg_size;
}
else
{
// a NULL pointer passed as a kernel argument.
// this is a local (write only) data that can be used by the
// kernel, We create internal memory buffer to act as a fake local
// memory area
#ifdef OCL_DEBUG_MESSAGES
__clDebugPrint (CL_LOG_DEBUG,
"clSetKernelArg: Argument %d is local memory (%d bytes)\n",
arg_index, (int) arg_size);
#endif // #ifdef OCL_DEBUG_MESSAGES
kernel_data->arg[arg_index].buffer =
clCreateBuffer (kernel_data->header.context, 0, arg_size, NULL,
&retval);
if (!kernel_data->arg[arg_index].buffer)
{
#ifdef OCL_DEBUG_MESSAGES
__clDebugPrint (CL_LOG_ERROR,
"clSetKernelArg: failed to create internal local memory buffer\n");
#endif // #ifdef OCL_DEBUG_MESSAGES
return retval;
}
kernel_data->arg[arg_index].data = NULL;
kernel_data->arg[arg_index].datalen = 0;
}
}
return CL_SUCCESS;
}
pointer allocate(size_type n)
{
buffer buf(m_context, n * sizeof(T), m_mem_flags);
clRetainMemObject(buf.get());
return detail::device_ptr<T>(buf);
}
void ClMem::retain() {
if ( ! isValid) return;
cl_int status = clRetainMemObject(m);
clCheckStatusPrint(status, "clRetainMemObject");
}
