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"); }