static void cuda_error(CUresult rc, const char *apiname)
{
const char *errName;
const char *errStr;
cuGetErrorName(rc, &errName);
cuGetErrorString(rc, &errStr);
fprintf(stderr, "failed on %s: %s - %s\n", apiname, errName, errStr);
exit(1);
}
static void
pocl_cuda_abort_on_error (CUresult result, unsigned line, const char *func,
const char *code, const char *api)
{
if (result != CUDA_SUCCESS)
{
const char *err_name;
const char *err_string;
cuGetErrorName (result, &err_name);
cuGetErrorString (result, &err_string);
POCL_MSG_PRINT2 (func, line, "Error during %s\n", api);
POCL_ABORT ("%s: %s\n", err_name, err_string);
}
}
static int check_cu(AVCodecContext *avctx, CUresult err, const char *func)
{
const char *err_name;
const char *err_string;
av_log(avctx, AV_LOG_TRACE, "Calling %s\n", func);
if (err == CUDA_SUCCESS)
return 0;
cuGetErrorName(err, &err_name);
cuGetErrorString(err, &err_string);
av_log(avctx, AV_LOG_ERROR, "%s failed", func);
if (err_name && err_string)
av_log(avctx, AV_LOG_ERROR, " -> %s: %s", err_name, err_string);
av_log(avctx, AV_LOG_ERROR, "\n");
return AVERROR_EXTERNAL;
}
cl_int
pocl_cuda_alloc_mem_obj (cl_device_id device, cl_mem mem_obj, void *host_ptr)
{
cuCtxSetCurrent (((pocl_cuda_device_data_t *)device->data)->context);
CUresult result;
void *b = NULL;
/* if memory for this global memory is not yet allocated -> do it */
if (mem_obj->device_ptrs[device->global_mem_id].mem_ptr == NULL)
{
cl_mem_flags flags = mem_obj->flags;
if (flags & CL_MEM_USE_HOST_PTR)
{
#if defined __arm__
// cuMemHostRegister is not supported on ARN
// Allocate device memory and perform explicit copies
// before and after running a kernel
result = cuMemAlloc ((CUdeviceptr *)&b, mem_obj->size);
CUDA_CHECK (result, "cuMemAlloc");
#else
result = cuMemHostRegister (host_ptr, mem_obj->size,
CU_MEMHOSTREGISTER_DEVICEMAP);
if (result != CUDA_SUCCESS
&& result != CUDA_ERROR_HOST_MEMORY_ALREADY_REGISTERED)
CUDA_CHECK (result, "cuMemHostRegister");
result = cuMemHostGetDevicePointer ((CUdeviceptr *)&b, host_ptr, 0);
CUDA_CHECK (result, "cuMemHostGetDevicePointer");
#endif
}
else if (flags & CL_MEM_ALLOC_HOST_PTR)
{
result = cuMemHostAlloc (&mem_obj->mem_host_ptr, mem_obj->size,
CU_MEMHOSTREGISTER_DEVICEMAP);
CUDA_CHECK (result, "cuMemHostAlloc");
result = cuMemHostGetDevicePointer ((CUdeviceptr *)&b,
mem_obj->mem_host_ptr, 0);
CUDA_CHECK (result, "cuMemHostGetDevicePointer");
}
else
{
result = cuMemAlloc ((CUdeviceptr *)&b, mem_obj->size);
if (result != CUDA_SUCCESS)
{
const char *err;
cuGetErrorName (result, &err);
POCL_MSG_PRINT2 (__FUNCTION__, __LINE__,
"-> Failed to allocate memory: %s\n", err);
return CL_MEM_OBJECT_ALLOCATION_FAILURE;
}
}
if (flags & CL_MEM_COPY_HOST_PTR)
{
result = cuMemcpyHtoD ((CUdeviceptr)b, host_ptr, mem_obj->size);
CUDA_CHECK (result, "cuMemcpyHtoD");
}
mem_obj->device_ptrs[device->global_mem_id].mem_ptr = b;
mem_obj->device_ptrs[device->global_mem_id].global_mem_id
= device->global_mem_id;
}
/* copy already allocated global mem info to devices own slot */
mem_obj->device_ptrs[device->dev_id]
= mem_obj->device_ptrs[device->global_mem_id];
return CL_SUCCESS;
}
inline const char *cuda_get_status (const CUresult &status)
{ const char** pStr = (const char**)calloc(128, sizeof(char*)); // TODO
cuGetErrorName (status, pStr);
return *pStr;
}
