/* Checks the type of pointer
*
* @param dest One pointer to check
* @param source Another pointer to check
*/
bool opal_cuda_check_bufs(char *dest, char *src)
{
int res;
CUmemorytype memType = CU_MEMORYTYPE_HOST;
res = cuPointerGetAttribute(&memType, CU_POINTER_ATTRIBUTE_MEMORY_TYPE, (CUdeviceptr)dest);
if( memType == CU_MEMORYTYPE_DEVICE){
return true;
}
res = cuPointerGetAttribute(&memType, CU_POINTER_ATTRIBUTE_MEMORY_TYPE, (CUdeviceptr)src);
if( memType == CU_MEMORYTYPE_DEVICE){
return true;
}
/* Assuming it is a host pointer for all other situations */
return false;
}
static int uct_is_gdr_copy_mem_type_owned(uct_md_h md, void *addr, size_t length)
{
int memory_type;
struct cudaPointerAttributes attributes;
cudaError_t cuda_err;
CUresult cu_err;
if (addr == NULL) {
return 0;
}
cu_err = cuPointerGetAttribute(&memory_type,
CU_POINTER_ATTRIBUTE_MEMORY_TYPE,
(CUdeviceptr)addr);
if (cu_err != CUDA_SUCCESS) {
cuda_err = cudaPointerGetAttributes (&attributes, addr);
if (cuda_err == cudaSuccess) {
if (attributes.memoryType == cudaMemoryTypeDevice) {
return 1;
}
}
} else if (memory_type == CU_MEMORYTYPE_DEVICE) {
return 1;
}
return 0;
}
void mca_cuda_convertor_init(opal_convertor_t* convertor, const void *pUserBuf)
{
int res;
CUmemorytype memType;
CUdeviceptr dbuf = (CUdeviceptr)pUserBuf;
if (!initialized) {
opal_cuda_support_init();
}
res = cuPointerGetAttribute(&memType,
CU_POINTER_ATTRIBUTE_MEMORY_TYPE, dbuf);
if (res != CUDA_SUCCESS) {
/* If we cannot determine it is device pointer,
* just assume it is not. */
return;
} else if (memType == CU_MEMORYTYPE_HOST) {
/* Host memory, nothing to do here */
return;
}
/* Must be a device pointer */
assert(memType == CU_MEMORYTYPE_DEVICE);
convertor->cbmemcpy = (memcpy_fct_t)&opal_cuda_memcpy;
convertor->flags |= CONVERTOR_CUDA;
}
WEAK bool halide_validate_dev_pointer(buffer_t* buf) {
CUcontext ctx;
CUresult result = cuPointerGetAttribute(&ctx, CU_POINTER_ATTRIBUTE_CONTEXT, buf->dev);
if (result) {
fprintf(stderr, "Bad device pointer %p: cuPointerGetAttribute returned %d\n", (void *)buf->dev, result);
return false;
}
return true;
}
WEAK bool halide_validate_dev_pointer(void *user_context, buffer_t* buf, size_t size=0) {
// The technique using cuPointerGetAttribute and CU_POINTER_ATTRIBUTE_CONTEXT
// requires unified virtual addressing is enabled and that is not the case
// for 32-bit processes on Mac OS X. So for now, as a total hack, just return true
// in 32-bit. This could of course be wrong the other way for cards that only
// support 32-bit addressing in 64-bit processes, but I expect those cards do not
// support unified addressing at all.
// TODO: figure out a way to validate pointers in all cases if strictly necessary.
#ifdef BITS_32
return true;
#else
if (buf->dev == 0)
return true;
CUcontext ctx;
CUresult result = cuPointerGetAttribute(&ctx, CU_POINTER_ATTRIBUTE_CONTEXT, buf->dev);
if (result) {
halide_printf(user_context, "Bad device pointer %p: cuPointerGetAttribute returned %s\n",
(void *)buf->dev, _get_error_name(result));
return false;
}
return true;
#endif
}
