size_t initContext(JNIEnv * env, jint max_blocks_per_proc, jint max_threads_per_block)
{
size_t to_space_size;
int status;
int deviceCount = 0;
size_t f_mem;
size_t t_mem;
jint num_blocks;
status = cuDeviceGetCount(&deviceCount);
CHECK_STATUS_RTN(env,"error in cuDeviceGetCount",status, 0);
getBestDevice(env);
status = cuCtxCreate(&cuContext, CU_CTX_MAP_HOST, cuDevice);
CHECK_STATUS_RTN(env,"error in cuCtxCreate",status, 0)
status = cuMemGetInfo (&f_mem, &t_mem);
CHECK_STATUS_RTN(env,"error in cuMemGetInfo",status, 0)
to_space_size = f_mem;
//space for 100 types in the scene
classMemSize = sizeof(jint)*100;
num_blocks = numMultiProcessors * max_threads_per_block * max_blocks_per_proc;
gc_space_size = 1024;
to_space_size -= (num_blocks * sizeof(jlong));
to_space_size -= (num_blocks * sizeof(jlong));
to_space_size -= gc_space_size;
to_space_size -= classMemSize;
return to_space_size;
}
void printout_devices( )
{
int ndevices;
cuDeviceGetCount( &ndevices );
for( int idevice = 0; idevice < ndevices; idevice++ )
{
char name[200];
#if CUDA_VERSION > 3010
size_t totalMem;
#else
unsigned int totalMem;
#endif
int clock;
CUdevice dev;
cuDeviceGet( &dev, idevice );
cuDeviceGetName( name, sizeof(name), dev );
cuDeviceTotalMem( &totalMem, dev );
cuDeviceGetAttribute( &clock,
CU_DEVICE_ATTRIBUTE_CLOCK_RATE, dev );
printf( "device %d: %s, %.1f MHz clock, %.1f MB memory\n",
idevice, name, clock/1000.f, totalMem/1024.f/1024.f );
}
}
main()
{
/* initialize CUDA */
CUresult res;
res = cuInit(0);
MY_CUDA_CHECK(res, "cuInit()");
/* check GPU is setted or not */
int device_num;
res = cuDeviceGetCount(&device_num);
MY_CUDA_CHECK(res, "cuDeviceGetCount()");
if (device_num == 0) { // no GPU is detected
fprintf(stderr, "no CUDA capable GPU is detected...\n");
exit(1);
}
printf("%d GPUs are detected\n", device_num);
for (int i=0; i<device_num; i++)
{
/* get device handle of GPU No.i */
CUdevice dev;
res = cuDeviceGet(&dev, i);
MY_CUDA_CHECK(res, "cuDeviceGet()");
/* search compute capability of GPU No.i */
int major=0, minor=0;
res = cuDeviceComputeCapability(&major, &minor, dev);
MY_CUDA_CHECK(res, "cuDeviceComputeCapability()");
printf("GPU[%d] : actual compute capability is : %d%d\n", i, major, minor);
}
}
static bool
nvptx_init (void)
{
CUresult r;
int ndevs;
if (instantiated_devices != 0)
return true;
r = cuInit (0);
if (r != CUDA_SUCCESS)
GOMP_PLUGIN_fatal ("cuInit error: %s", cuda_error (r));
ptx_events = NULL;
pthread_mutex_init (&ptx_event_lock, NULL);
r = cuDeviceGetCount (&ndevs);
if (r != CUDA_SUCCESS)
GOMP_PLUGIN_fatal ("cuDeviceGetCount error: %s", cuda_error (r));
ptx_devices = GOMP_PLUGIN_malloc_cleared (sizeof (struct ptx_device *)
* ndevs);
return true;
}
static int
nvptx_get_num_devices (void)
{
int n;
CUresult r;
/* PR libgomp/65099: Currently, we only support offloading in 64-bit
configurations. */
if (sizeof (void *) != 8)
return 0;
/* This function will be called before the plugin has been initialized in
order to enumerate available devices, but CUDA API routines can't be used
until cuInit has been called. Just call it now (but don't yet do any
further initialization). */
if (instantiated_devices == 0)
{
r = cuInit (0);
/* This is not an error: e.g. we may have CUDA libraries installed but
no devices available. */
if (r != CUDA_SUCCESS)
return 0;
}
r = cuDeviceGetCount (&n);
if (r!= CUDA_SUCCESS)
GOMP_PLUGIN_fatal ("cuDeviceGetCount error: %s", cuda_error (r));
return n;
}
/*===========================================================================*/
int Device::Count()
{
int count = 0;
KVS_CU_CALL( cuDeviceGetCount( &count ) );
return count;
}
std::pair< std::vector<context>, std::vector<command_queue> >
queue_list(DevFilter &&filter, unsigned queue_flags = 0)
{
cuda_check( do_init() );
std::vector<context> ctx;
std::vector<command_queue> queue;
int ndev;
cuda_check( cuDeviceGetCount(&ndev) );
for(int d = 0; d < ndev; ++d) {
try {
CUdevice dev;
cuda_check( cuDeviceGet(&dev, d) );
if (!filter(dev)) continue;
context c(dev);
command_queue q(c, dev, queue_flags);
ctx.push_back(c);
queue.push_back(q);
} catch(const error&) { }
}
return std::make_pair(ctx, queue);
}
int main(int argc, char* argv[])
{
cuInit(0);
int devs = 0;
cuDeviceGetCount(&devs);
assert(devs > 0);
CUdevice dev;
CUresult status;
CUcontext ctx = 0;
cuDeviceGet(&dev, 0);
cuCtxCreate(&ctx, 0, dev);
{
size_t f = 0, t = 0;
CUresult r = cuMemGetInfo(&f, &t);
fprintf( stderr, "Do cuMemGetInfo: %d, %zu/%zu\n", r, f, t );
}
__init("\n");
printf("\nPress any key to exit...");
char c;
scanf("%c", &c);
return 0;
}
int main() {
int ngpu;
CUdevice cuDevice;
CUcontext cuContext;
cuInit(0);
cuDeviceGetCount(&ngpu);
//printf("ngpu = %d\n", ngpu);
size_t *totals, *frees ;
totals = (size_t *) calloc (ngpu, sizeof(size_t));
frees = (size_t *) calloc (ngpu, sizeof(size_t));
int tid;
omp_set_num_threads(ngpu);
#pragma omp parallel private(tid, cuDevice, cuContext) shared(frees, totals)
{
tid = omp_get_thread_num();
//printf("nthreads = %d, tid = %d\n", omp_get_num_threads(), tid);
cuDeviceGet(&cuDevice, tid);
cuCtxCreate(&cuContext, tid, cuDevice);
cuMemGetInfo((size_t*)&frees[tid], (size_t*)&totals[tid]);
}
printf ("\ttotal\t\tfree\t\tused\n");
for(int i=0; i<ngpu; i++) {
printf("GPU %d\t%lu\t%lu\t%lu\n", i, (size_t)totals[i], (size_t)frees[i], (size_t)totals[i]-(size_t)frees[i]);
}
return 0;
}
void setdevice(void)
{
#if 0
/* variables */
int num_devices;
int device;
/* work */
cuDeviceGetCount(&num_devices);
if (num_devices > 1) {
// variables
int max_multiprocessors;
int max_device;
cudaDeviceProp properties;
// initialize variables
max_multiprocessors = 0;
max_device = 0;
for (device = 0; device < num_devices; device++) {
cudaGetDeviceProperties(&properties, device);
if (max_multiprocessors < properties.multiProcessorCount) {
max_multiprocessors = properties.multiProcessorCount;
max_device = device;
}
}
cudaSetDevice(max_device);
}
#endif
}
Object cuda_over_map(Object self, int nparts, int *argcv,
Object *argv, int flags) {
CUresult error;
cuInit(0);
int deviceCount = 0;
error = cuDeviceGetCount(&deviceCount);
if (deviceCount == 0) {
raiseError("No CUDA devices found");
}
CUdevice cuDevice;
CUcontext cuContext;
CUmodule cuModule;
CUfunction cuFunc;
error = cuDeviceGet(&cuDevice, 0);
error = cuCtxCreate(&cuContext, 0, cuDevice);
CUdeviceptr d_A;
CUdeviceptr d_B;
CUdeviceptr d_res;
errcheck(cuModuleLoad(&cuModule, grcstring(argv[argcv[0]])));
CUdeviceptr dps[argcv[0]];
void *args[argcv[0]+2];
int size = INT_MAX;
for (int i=0; i<argcv[0]; i++) {
struct CudaFloatArray *a = (struct CudaFloatArray *)argv[i];
if (a->size < size)
size = a->size;
errcheck(cuMemAlloc(&dps[i], size * sizeof(float)));
errcheck(cuMemcpyHtoD(dps[i], &a->data, size * sizeof(float)));
args[i+1] = &dps[i];
}
struct CudaFloatArray *r =
(struct CudaFloatArray *)(alloc_CudaFloatArray(size));
int fsize = sizeof(float) * size;
errcheck(cuMemAlloc(&d_res, fsize));
errcheck(cuMemcpyHtoD(d_res, &r->data, fsize));
args[0] = &d_res;
args[argcv[0]+1] = &size;
int threadsPerBlock = 256;
int blocksPerGrid = (size + threadsPerBlock - 1) / threadsPerBlock;
char name[256];
strcpy(name, "block");
strcat(name, grcstring(argv[argcv[0]]) + strlen("_cuda/"));
for (int i=0; name[i] != 0; i++)
if (name[i] == '.') {
name[i] = 0;
break;
}
errcheck(cuModuleGetFunction(&cuFunc, cuModule, name));
errcheck(cuLaunchKernel(cuFunc, blocksPerGrid, 1, 1,
threadsPerBlock, 1, 1,
0,
NULL, args, NULL));
errcheck(cuMemcpyDtoH(&r->data, d_res, fsize));
cuMemFree(d_res);
for (int i=0; i<argcv[0]; i++)
cuMemFree(dps[i]);
return (Object)r;
}
/*===========================================================================*/
bool Device::IsEnabled()
{
int count = 0;
CUresult error = cuDeviceGetCount( &count );
if ( error != CUDA_SUCCESS ) return false;
return count > 0;
}
/**
* This measures the overhead in launching a kernel function on each GPU in the
* system.
*
* It does this by executing a small kernel (copying 1 value in global memory) a
* very large number of times and taking the average execution time. This
* program uses the CUDA driver API.
*/
int main() {
CU_ERROR_CHECK(cuInit(0));
int count;
CU_ERROR_CHECK(cuDeviceGetCount(&count));
float x = 5.0f;
for (int d = 0; d < count; d++) {
CUdevice device;
CU_ERROR_CHECK(cuDeviceGet(&device, d));
CUcontext context;
CU_ERROR_CHECK(cuCtxCreate(&context, 0, device));
CUdeviceptr in, out;
CU_ERROR_CHECK(cuMemAlloc(&in, sizeof(float)));
CU_ERROR_CHECK(cuMemAlloc(&out, sizeof(float)));
CU_ERROR_CHECK(cuMemcpyHtoD(in, &x, sizeof(float)));
CUmodule module;
CU_ERROR_CHECK(cuModuleLoadData(&module, imageBytes));
CUfunction function;
CU_ERROR_CHECK(cuModuleGetFunction(&function, module, "kernel"));
void * params[] = { &in, &out };
CUevent start, stop;
CU_ERROR_CHECK(cuEventCreate(&start, 0));
CU_ERROR_CHECK(cuEventCreate(&stop, 0));
CU_ERROR_CHECK(cuEventRecord(start, 0));
for (int i = 0; i < ITERATIONS; i++)
CU_ERROR_CHECK(cuLaunchKernel(function, 1, 1, 1, 1, 1, 1, 0, 0, params, NULL));
CU_ERROR_CHECK(cuEventRecord(stop, 0));
CU_ERROR_CHECK(cuEventSynchronize(stop));
float time;
CU_ERROR_CHECK(cuEventElapsedTime(&time, start, stop));
CU_ERROR_CHECK(cuEventDestroy(start));
CU_ERROR_CHECK(cuEventDestroy(stop));
CU_ERROR_CHECK(cuMemFree(in));
CU_ERROR_CHECK(cuMemFree(out));
fprintf(stdout, "Device %d: %fms\n", d, (time / (double)ITERATIONS));
CU_ERROR_CHECK(cuModuleUnload(module));
CU_ERROR_CHECK(cuCtxDestroy(context));
}
return 0;
}
value spoc_getCudaDevicesCount()
{
CAMLparam0();
int nb_devices;
if (noCuda) CAMLreturn (Val_int(0));
cuDeviceGetCount (&nb_devices);
nbCudaDevices = nb_devices;
CAMLreturn (Val_int(nb_devices));
}
void print_GetProperties(CUdevice cuDevice)
{
int count = 0;
cuDeviceGetCount(&count);
printf ("cuDevice(%d)GetCount = %d\n", cuDevice, count);
int len = 1024;
char* dev_name = (char*)malloc(sizeof(char) * len);
cuDeviceGetName(dev_name, len, cuDevice);
printf("cuda-devicename = %s\n", dev_name);
free(dev_name);
int mj_v = 0, mn_v = 0;
cuDeviceComputeCapability(&mj_v, &mn_v, cuDevice);
printf("compute capability = mj:%d, mn:%d\n", mj_v, mn_v);
size_t byt_mem = 0;
cuDeviceTotalMem(&byt_mem, cuDevice);
printf("total mem = %d\n", byt_mem);
CUdevprop cp;
cuDeviceGetProperties(&cp, cuDevice);
printf("Thd/blk = %d, thrdDim xyz = (%d, %d, %d:threads), GridSz xyz = (%d, %d, %d:blocks), shrdmem/blk = %d, constmem = %d bytes, simdwidth = %d, mempitch = %d, regsPerBlock = %d, clockRate = %d, textureAlign = %d \n",
cp.maxThreadsPerBlock, cp.maxThreadsDim[0], cp.maxThreadsDim[1], cp.maxThreadsDim[2], cp.maxGridSize[0], cp.maxGridSize[1], cp.maxGridSize[2], cp.sharedMemPerBlock, cp.totalConstantMemory, cp.SIMDWidth, cp.memPitch, cp.regsPerBlock, cp.clockRate, cp.textureAlign);
int ip;
cuDeviceGetAttribute(&ip, CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK, cuDevice);
printf ("Attrib - CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK = %d\n", ip);
cuDeviceGetAttribute(&ip, CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X, cuDevice);
printf ("Attrib - CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X = %d\n", ip);
cuDeviceGetAttribute(&ip, CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y, cuDevice);
printf ("Attrib - CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y = %d\n", ip);
cuDeviceGetAttribute(&ip, CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z, cuDevice);
printf ("Attrib - CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z = %d\n", ip);
cuDeviceGetAttribute(&ip, CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X, cuDevice);
printf ("Attrib - CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X = %d\n", ip);
cuDeviceGetAttribute(&ip, CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y, cuDevice);
printf ("Attrib - CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y = %d\n", ip);
cuDeviceGetAttribute(&ip, CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z, cuDevice);
printf ("Attrib - CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z = %d\n", ip);
cuDeviceGetAttribute(&ip, CU_DEVICE_ATTRIBUTE_SHARED_MEMORY_PER_BLOCK, cuDevice);
printf ("Attrib - CU_DEVICE_ATTRIBUTE_SHARED_MEMORY_PER_BLOCK = %d\n", ip);
cuDeviceGetAttribute(&ip, CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY, cuDevice);
printf ("Attrib - CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY = %d\n", ip);
cuDeviceGetAttribute(&ip, CU_DEVICE_ATTRIBUTE_WARP_SIZE, cuDevice);
printf ("Attrib - CU_DEVICE_ATTRIBUTE_WARP_SIZE = %d\n", ip);
cuDeviceGetAttribute(&ip, CU_DEVICE_ATTRIBUTE_MAX_PITCH, cuDevice);
printf ("Attrib - CU_DEVICE_ATTRIBUTE_MAX_PITCH = %d\n", ip);
cuDeviceGetAttribute(&ip, CU_DEVICE_ATTRIBUTE_REGISTERS_PER_BLOCK, cuDevice);
printf ("Attrib - CU_DEVICE_ATTRIBUTE_REGISTERS_PER_BLOCK = %d\n", ip);
cuDeviceGetAttribute(&ip, CU_DEVICE_ATTRIBUTE_CLOCK_RATE, cuDevice);
printf ("Attrib - CU_DEVICE_ATTRIBUTE_CLOCK_RATE = %d\n", ip);
cuDeviceGetAttribute(&ip, CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT, cuDevice);
printf ("Attrib - CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT = %d\n", ip);
}
Object cuda_computeCapability(Object self, int nparts, int *argcv,
Object *argv, int flags) {
cuInit(0);
int deviceCount = 0;
cuDeviceGetCount(&deviceCount);
if (deviceCount == 0) {
raiseError("No CUDA devices found");
}
CUdevice cuDevice;
int major, minor;
cuDeviceComputeCapability(&major, &minor, cuDevice);
return alloc_Float64(major + minor / 10.0);
}
Impl()
{
// Initialize CUDA.
check_cuda_error(cuInit(0));
int device_count;
check_cuda_error(cuDeviceGetCount(&device_count));
m_devices.reserve(static_cast<std::size_t>(device_count));
m_contexts.resize(static_cast<std::size_t>(device_count), nullptr);
for (int i = 0; i < device_count; ++i)
m_devices.emplace_back(i);
}
Object cuda_deviceName(Object self, int nparts, int *argcv,
Object *argv, int flags) {
cuInit(0);
int deviceCount = 0;
cuDeviceGetCount(&deviceCount);
if (deviceCount == 0) {
raiseError("No CUDA devices found");
}
CUdevice cuDevice;
cuDeviceGet(&cuDevice, 0);
char name[100];
cuDeviceGetName(name, 100, cuDevice);
return alloc_String(name);
}
void device_t<CUDA>::appendAvailableDevices(std::vector<device> &dList){
cuda::init();
int deviceCount;
OCCA_CUDA_CHECK("Finding Number of Devices",
cuDeviceGetCount(&deviceCount));
for(int i = 0; i < deviceCount; ++i){
device d;
d.setup("CUDA", i, 0);
dList.push_back(d);
}
}
int findGraphicsGPU(char *name)
{
int nGraphicsGPU = 0;
int deviceCount = 0;
bool bFoundGraphics = false;
char firstGraphicsName[256], temp[256];
CUresult err = cuInit(0);
checkCudaErrors(cuDeviceGetCount(&deviceCount));
// This function call returns 0 if there are no CUDA capable devices.
if (deviceCount == 0)
{
printf("> There are no device(s) supporting CUDA\n");
return false;
}
else
{
printf("> Found %d CUDA Capable Device(s)\n", deviceCount);
}
for (int dev = 0; dev < deviceCount; ++dev)
{
bool bGraphics = !checkHW(temp, "Tesla", dev);
printf("> %s\t\tGPU %d: %s\n", (bGraphics ? "Graphics" : "Compute"), dev, temp);
if (bGraphics)
{
if (!bFoundGraphics)
{
STRCPY(firstGraphicsName, strlen(temp), temp);
}
nGraphicsGPU++;
}
}
if (nGraphicsGPU)
{
STRCPY(name, strlen(firstGraphicsName), firstGraphicsName);
}
else
{
STRCPY(name, strlen("this hardware"), "this hardware");
}
return nGraphicsGPU;
}
static PyObject *
cuda_cuDeviceGetCount(PyObject *self, PyObject *args)
{
int count;
CUresult res = cuDeviceGetCount(&count);
if(res != CUDA_SUCCESS){
PyErr_SetString(CudaError, findErrorMsg(res));
return NULL;
}
PyObject *valueobj;
valueobj = Py_BuildValue("i",count);
if (valueobj != NULL){
Py_INCREF(valueobj);
}
return valueobj;
}
Object cuda_cores(Object self, int nparts, int *argcv,
Object *argv, int flags) {
cuInit(0);
int deviceCount = 0;
cuDeviceGetCount(&deviceCount);
if (deviceCount == 0) {
raiseError("No CUDA devices found");
}
CUdevice cuDevice;
int mpcount;
cuDeviceGetAttribute(&mpcount, CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT,
cuDevice);
int major, minor;
cuDeviceComputeCapability(&major, &minor, cuDevice);
mpcount *= coreMultiplicand(major, minor);
return alloc_Float64(mpcount);
}
int main(int argc,char **argv){
int count,devno;
//CUdeviceptr p;
CUresult cerr;
char str[80];
CUdevice c;
if(argc > 1){
usage(*argv);
exit(EXIT_FAILURE);
}
if( (cerr = cuInit(0)) ){
fprintf(stderr,"Couldn't initialize CUDA (%d)\n",cerr);
exit(EXIT_FAILURE);
}
printf("CUDA initialized.\n");
if( (cerr = cuDeviceGetCount(&count)) ){
fprintf(stderr,"Couldn't get device count (%d)\n",cerr);
exit(EXIT_FAILURE);
}else if(count == 0){
fprintf(stderr,"Couldn't find any devices\n");
exit(EXIT_FAILURE);
}
printf("We have %d device%s.\n",count,count == 1 ? "" : "s");
for(devno = 0 ; devno < count ; ++devno){
if( (cerr = cuDeviceGet(&c,devno)) ){
fprintf(stderr,"Couldn't reference device %d (%d)\n",devno,cerr);
exit(EXIT_FAILURE);
}
if(get_all_attributes(c)){
exit(EXIT_FAILURE);
}
if( (cerr = cuDeviceGetName(str,sizeof(str),c)) ){
fprintf(stderr,"Error determining device name (%d)\n",cerr);
exit(EXIT_FAILURE);
}
printf("Device %d: %s\n",devno,str);
/*
if( (cerr = cuMemAlloc(&p,sizeof(p))) ){
fprintf(stderr,"Couldn't allocate %zub (%d)\n",sizeof(p),cerr);
exit(EXIT_FAILURE);
}*/
}
exit(EXIT_SUCCESS);
}
static void *cuda_init(int ord, int flags, int *ret) {
CUdevice dev;
cuda_context *res;
static int init_done = 0;
if (ord == -2) {
CUcontext ctx;
/* Grab the ambient context */
err = cuCtxGetCurrent(&ctx);
CHKFAIL(NULL);
/* If somebody made a context, then the api is initialized */
init_done = 1;
res = cuda_make_ctx(ctx, DONTFREE);
if (res == NULL) {
FAIL(NULL, GA_IMPL_ERROR);
}
res->flags |= flags;
return res;
}
if (!init_done) {
err = cuInit(0);
CHKFAIL(NULL);
init_done = 1;
}
if (ord == -1) {
int i, c;
err = cuDeviceGetCount(&c);
CHKFAIL(NULL);
for (i = 0; i < c; i++) {
err = cuDeviceGet(&dev, i);
CHKFAIL(NULL);
res = do_init(dev, flags, NULL);
if (res != NULL)
return res;
}
FAIL(NULL, GA_NODEV_ERROR);
} else {
err = cuDeviceGet(&dev, ord);
CHKFAIL(NULL);
return do_init(dev, flags, ret);
}
}
void getBestDevice(){
int num_devices;
int status;
int i;
CUdevice temp_device;
int curr_multiprocessors;
int max_multiprocessors = -1;
int max_i = -1;
status = cuDeviceGetCount(&num_devices);
if (CUDA_SUCCESS != status)
{
printf("error in cuDeviceGetCount\n");
}
for(i = 0; i < num_devices; ++i){
status = cuDeviceGet(&temp_device, i);
if (CUDA_SUCCESS != status)
{
printf("error in cuDeviceGet\n");
}
status = cuDeviceGetAttribute(&curr_multiprocessors, CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT, temp_device);
if (CUDA_SUCCESS != status)
{
printf("error in cuDeviceGetAttribute CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT\n");
}
if(curr_multiprocessors > max_multiprocessors)
{
max_multiprocessors = curr_multiprocessors;
max_i = i;
}
}
status = cuDeviceGet(&cuDevice, max_i);
if (CUDA_SUCCESS != status)
{
printf("error in cuDeviceGetName\n");
}
status = cuDeviceGetAttribute(&maxGridDim, CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X, cuDevice);
if (CUDA_SUCCESS != status)
{
printf("error in cuDeviceGetAttribute CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X\n");
}
numMultiProcessors = max_multiprocessors;
}
std::vector<device> device_list(DevFilter&& filter) {
cuda_check( do_init() );
std::vector<device> device;
int ndev;
cuda_check( cuDeviceGetCount(&ndev) );
for(int d = 0; d < ndev; ++d) {
try {
CUdevice dev;
cuda_check( cuDeviceGet(&dev, d) );
if (!filter(dev)) continue;
device.push_back(dev);
} catch(const error&) { }
}
return device;
}
int main(int argc, char ** argv)
{
int dev_count = 0;
CUdevice device;
CUcontext context;
CUmodule module;
CUfunction function;
cuInit(0);
cuDeviceGetCount(&dev_count);
if (dev_count < 1) return -1;
cuDeviceGet( &device, 0 );
cuCtxCreate( &context, 0, device );
cuModuleLoad( &module, "hello.cuda_runtime.ptx" );
cuModuleGetFunction( &function, module, "_Z6kernelPf" );
int N = 512;
CUdeviceptr pData;
cuMemAlloc( &pData, N * sizeof(float) );
cuFuncSetBlockShape( function, N, 1, 1 );
cuParamSeti( function, 0, pData );
cuParamSetSize( function, 4 );
cuLaunchGrid( function, 1, 1 );
float * pHostData = new float[N];
cuMemcpyDtoH( pHostData, pData, N * sizeof( float) );
cuMemFree( pData );
delete [] pHostData;
return 0;
}
int GPUInterface::Initialize() {
#ifdef BEAGLE_DEBUG_FLOW
fprintf(stderr,"\t\t\tEntering GPUInterface::Initialize\n");
#endif
resourceMap = new std::map<int, int>;
// Driver init; CUDA manual: "Currently, the Flags parameter must be 0."
CUresult error = cuInit(0);
if (error == CUDA_ERROR_NO_DEVICE) {
return 0;
} else if (error != CUDA_SUCCESS) {
fprintf(stderr, "CUDA error: \"%s\" from file <%s>, line %i.\n",
GetCUDAErrorDescription(error), __FILE__, __LINE__);
exit(-1);
}
int numDevices = 0;
SAFE_CUDA(cuDeviceGetCount(&numDevices));
CUdevice tmpCudaDevice;
int capabilityMajor;
int capabilityMinor;
int currentDevice = 0;
for (int i=0; i < numDevices; i++) {
SAFE_CUDA(cuDeviceGet(&tmpCudaDevice, i));
SAFE_CUDA(cuDeviceComputeCapability(&capabilityMajor, &capabilityMinor, tmpCudaDevice));
if ((capabilityMajor > 1 && capabilityMinor != 9999) || (capabilityMajor == 1 && capabilityMinor > 0)) {
resourceMap->insert(std::make_pair(currentDevice++, i));
}
}
#ifdef BEAGLE_DEBUG_FLOW
fprintf(stderr,"\t\t\tLeaving GPUInterface::Initialize\n");
#endif
return 1;
}
static int init_cuda(NvEncoder*enc)
{
NVENCSTATUS nvResult;
CUresult cuResult;
int devid;
cuResult=cuInit(0);
CHK_CUDA_ERR(cuResult);
cuResult=cuDeviceGetCount(&enc->devcnt);
CHK_CUDA_ERR(cuResult);
fprintf(stderr,"Device Count = %d\n",enc->devcnt);
devid=enc->encCfg.deviceID;//default is 0
if(devid==-1 || devid>=enc->devcnt){
devid=get_next_core();
fprintf(stderr,"\033[33mAuto Select DevID:= %d\n\033[0m",devid);
enc->encCfg.deviceID=devid;
}else{
fprintf(stderr,"\033[33mGiven DevID:= %d\n\033[0m",devid);
}
cuResult=cuDeviceGet(&enc->cuDevice,devid);
CHK_CUDA_ERR(cuResult);
cuResult=cuCtxCreate(&enc->cuContext,0,enc->cuDevice);
CHK_CUDA_ERR(cuResult);
return 0;
}
CUdevice CudaModule::selectDevice(void)
{
CUresult res = CUDA_SUCCESS;
int numDevices;
checkError("cuDeviceGetCount", cuDeviceGetCount(&numDevices));
CUdevice device = 0;
S32 bestScore = FW_S32_MIN;
for (int i=0; i<numDevices; ++i)
{
CUdevice dev;
checkError("cuDeviceGet", cuDeviceGet(&dev, i));
int clockRate;
res = cuDeviceGetAttribute(&clockRate, CU_DEVICE_ATTRIBUTE_CLOCK_RATE, dev);
checkError("cuDeviceGetAttribute", res);
int numProcessors;
res = cuDeviceGetAttribute(&numProcessors,
CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT, dev);
checkError("cuDeviceGetAttribute", res);
S32 score = clockRate * numProcessors;
if (score > bestScore)
{
device = dev;
bestScore = score;
}
}
if (bestScore == FW_S32_MIN) {
fail("No appropriate CUDA device found!");
}
return device;
}
