src/ext_cuda.c

   1 /**
   2  * Author......: Jens Steube <jens.steube@gmail.com>
   3  * License.....: MIT
   4  */
   5
   6 #include <ext_cuda.h>
   7
   8 void hc_cuDeviceGetCount (int *count)
   9 {
  10   CUresult CU_err = cuDeviceGetCount (count);
  11
  12   if (CU_err != CUDA_SUCCESS)
  13   {
  14     log_error ("ERROR: %s %d\n", "cuDeviceGetCount()", CU_err);
  15
  16     exit (-1);
  17   }
  18 }
  19
  20 void hc_cuDeviceGet (CUdevice *device, int ordinal)
  21 {
  22   CUresult CU_err = cuDeviceGet (device, ordinal);
  23
  24   if (CU_err != CUDA_SUCCESS)
  25   {
  26     log_error ("ERROR: %s %d\n", "cuDeviceGet()", CU_err);
  27
  28     exit (-1);
  29   }
  30 }
  31
  32 void hc_cuDeviceGetName (char *name, int len, CUdevice dev)
  33 {
  34   CUresult CU_err = cuDeviceGetName (name, len, dev);
  35
  36   if (CU_err != CUDA_SUCCESS)
  37   {
  38     log_error ("ERROR: %s %d\n", "cuDeviceGetName()", CU_err);
  39
  40     exit (-1);
  41   }
  42 }
  43
  44 void hc_cuDeviceTotalMem (size_t *bytes, CUdevice dev)
  45 {
  46   CUresult CU_err = cuDeviceTotalMem (bytes, dev);
  47
  48   if (CU_err != CUDA_SUCCESS)
  49   {
  50     log_error ("ERROR: %s %d\n", "cuDeviceTotalMem()", CU_err);
  51
  52     exit (-1);
  53   }
  54 }
  55
  56 void hc_cuDeviceGetAttribute (int *pi, CUdevice_attribute attrib, CUdevice dev)
  57 {
  58   CUresult CU_err = cuDeviceGetAttribute (pi, attrib, dev);
  59
  60   if (CU_err != CUDA_SUCCESS)
  61   {
  62     log_error ("ERROR: %s %d\n", "cuDeviceGetAttribute()", CU_err);
  63
  64     exit (-1);
  65   }
  66 }
  67
  68 void hc_cuCtxCreate (CUcontext *pctx, unsigned int flags, CUdevice dev)
  69 {
  70   CUresult CU_err = cuCtxCreate (pctx, flags, dev);
  71
  72   if (CU_err != CUDA_SUCCESS)
  73   {
  74     log_error ("ERROR: %s %d\n", "cuCtxCreate()", CU_err);
  75
  76     exit (-1);
  77   }
  78 }
  79
  80 void hc_cuMemAllocHost (void **pp, size_t bytesize)
  81 {
  82   CUresult CU_err = cuMemAllocHost (pp, bytesize);
  83
  84   if (CU_err != CUDA_SUCCESS)
  85   {
  86     log_error ("ERROR: %s %d\n", "cuMemAllocHost()", CU_err);
  87
  88     exit (-1);
  89   }
  90 }
  91
  92 void hc_cuMemAlloc (CUdeviceptr *dptr, size_t bytesize)
  93 {
  94   CUresult CU_err = cuMemAlloc (dptr, bytesize);
  95
  96   if (CU_err != CUDA_SUCCESS)
  97   {
  98     log_error ("ERROR: %s %d\n", "cuMemAlloc()", CU_err);
  99
 100     exit (-1);
 101   }
 102 }
 103
 104 void hc_cuMemsetD8 (CUdeviceptr dstDevice, unsigned char uc, unsigned int N)
 105 {
 106   CUresult CU_err = cuMemsetD8 (dstDevice, uc, N);
 107
 108   if (CU_err != CUDA_SUCCESS)
 109   {
 110     log_error ("ERROR: %s %d\n", "cuMemsetD8()", CU_err);
 111
 112     exit (-1);
 113   }
 114 }
 115
 116 void hc_cuMemsetD32 (CUdeviceptr dstDevice, unsigned int ui, unsigned int N)
 117 {
 118   CUresult CU_err = cuMemsetD32 (dstDevice, ui, N);
 119
 120   if (CU_err != CUDA_SUCCESS)
 121   {
 122     log_error ("ERROR: %s %d\n", "cuMemsetD32()", CU_err);
 123
 124     exit (-1);
 125   }
 126 }
 127
 128 void hc_cuMemcpyDtoD (CUdeviceptr dstDevice, CUdeviceptr srcDevice, size_t ByteCount)
 129 {
 130   CUresult CU_err = cuMemcpyDtoD (dstDevice, srcDevice, ByteCount);
 131
 132   if (CU_err != CUDA_SUCCESS)
 133   {
 134     log_error ("ERROR: %s %d\n", "cuMemcpyDtoD()", CU_err);
 135
 136     exit (-1);
 137   }
 138 }
 139
 140 void hc_cuMemcpyDtoDAsync (CUdeviceptr dstDevice, CUdeviceptr srcDevice, size_t ByteCount, CUstream hStream)
 141 {
 142   CUresult CU_err = cuMemcpyDtoDAsync (dstDevice, srcDevice, ByteCount, hStream);
 143
 144   if (CU_err != CUDA_SUCCESS)
 145   {
 146     log_error ("ERROR: %s %d\n", "cuMemcpyDtoDAsync()", CU_err);
 147
 148     exit (-1);
 149   }
 150 }
 151
 152 void hc_cuMemcpyHtoD (CUdeviceptr dstDevice, const void *srcHost, size_t ByteCount)
 153 {
 154   CUresult CU_err = cuMemcpyHtoD (dstDevice, srcHost, ByteCount);
 155
 156   if (CU_err != CUDA_SUCCESS)
 157   {
 158     log_error ("ERROR: %s %d\n", "cuMemcpyHtoD()", CU_err);
 159
 160     exit (-1);
 161   }
 162 }
 163
 164 void hc_cuMemcpyHtoDAsync (CUdeviceptr dstDevice, const void *srcHost, size_t ByteCount, CUstream hStream)
 165 {
 166   CUresult CU_err = cuMemcpyHtoDAsync (dstDevice, srcHost, ByteCount, hStream);
 167
 168   if (CU_err != CUDA_SUCCESS)
 169   {
 170     log_error ("ERROR: %s %d\n", "cuMemcpyHtoDAsync()", CU_err);
 171
 172     exit (-1);
 173   }
 174 }
 175
 176 void hc_cuMemcpyDtoH (void *dstHost, CUdeviceptr srcDevice, size_t ByteCount)
 177 {
 178   CUresult CU_err = cuMemcpyDtoH (dstHost, srcDevice, ByteCount);
 179
 180   if (CU_err != CUDA_SUCCESS)
 181   {
 182     log_error ("ERROR: %s %d\n", "cuMemcpyDtoH()", CU_err);
 183
 184     exit (-1);
 185   }
 186 }
 187
 188 void hc_cuMemcpyDtoHAsync (void *dstHost, CUdeviceptr srcDevice, size_t ByteCount, CUstream hStream)
 189 {
 190   CUresult CU_err = cuMemcpyDtoHAsync (dstHost, srcDevice, ByteCount, hStream);
 191
 192   if (CU_err != CUDA_SUCCESS)
 193   {
 194     log_error ("ERROR: %s %d\n", "cuMemcpyDtoHAsync()", CU_err);
 195
 196     exit (-1);
 197   }
 198 }
 199
 200 void hc_cuEventCreate (CUevent *phEvent, unsigned int Flags)
 201 {
 202   CUresult CU_err = cuEventCreate (phEvent, Flags);
 203
 204   if (CU_err != CUDA_SUCCESS)
 205   {
 206     log_error ("ERROR: %s %d\n", "cuEventCreate()", CU_err);
 207
 208     exit (-1);
 209   }
 210 }
 211
 212 void hc_cuStreamCreate (CUstream *phStream, unsigned int Flags)
 213 {
 214   CUresult CU_err = cuStreamCreate (phStream, Flags);
 215
 216   if (CU_err != CUDA_SUCCESS)
 217   {
 218     log_error ("ERROR: %s %d\n", "cuStreamCreate()", CU_err);
 219
 220     exit (-1);
 221   }
 222 }
 223
 224 void hc_cuDeviceComputeCapability (int *major, int *minor, CUdevice dev)
 225 {
 226   CUresult CU_err = cuDeviceComputeCapability (major, minor, dev);
 227
 228   if (CU_err != CUDA_SUCCESS)
 229   {
 230     log_error ("ERROR: %s %d\n", "cuDeviceComputeCapability()", CU_err);
 231
 232     exit (-1);
 233   }
 234 }
 235
 236 void hc_cuModuleLoad (CUmodule *module, const char *fname)
 237 {
 238   CUresult CU_err = cuModuleLoad (module, fname);
 239
 240   if (CU_err != CUDA_SUCCESS)
 241   {
 242     log_error ("ERROR: %s %d\n", "cuModuleLoad()", CU_err);
 243
 244     exit (-1);
 245   }
 246 }
 247
 248 void hc_cuModuleLoadData (CUmodule *module, const void *image)
 249 {
 250   CUresult CU_err = cuModuleLoadData (module, image);
 251
 252   if (CU_err != CUDA_SUCCESS)
 253   {
 254     log_error ("ERROR: %s %d\n", "cuModuleLoadData()", CU_err);
 255
 256     exit (-1);
 257   }
 258 }
 259
 260 void hc_cuModuleGetFunction (CUfunction *hfunc, CUmodule hmod, const char *name)
 261 {
 262   CUresult CU_err = cuModuleGetFunction (hfunc, hmod, name);
 263
 264   if (CU_err != CUDA_SUCCESS)
 265   {
 266     log_error ("ERROR: %s %d\n", "cuModuleGetFunction()", CU_err);
 267
 268     exit (-1);
 269   }
 270 }
 271
 272 void hc_cuFuncSetBlockShape (CUfunction hfunc, int x, int y, int z)
 273 {
 274   CUresult CU_err = cuFuncSetBlockShape (hfunc, x, y, z);
 275
 276   if (CU_err != CUDA_SUCCESS)
 277   {
 278     log_error ("ERROR: %s %d\n", "cuFuncSetBlockShape()", CU_err);
 279
 280     exit (-1);
 281   }
 282 }
 283
 284 void hc_cuParamSetSize (CUfunction hfunc, unsigned int numbytes)
 285 {
 286   CUresult CU_err = cuParamSetSize (hfunc, numbytes);
 287
 288   if (CU_err != CUDA_SUCCESS)
 289   {
 290     log_error ("ERROR: %s %d\n", "cuParamSetSize()", CU_err);
 291
 292     exit (-1);
 293   }
 294 }
 295
 296 void hc_cuParamSetv (CUfunction hfunc, int offset, void *ptr, unsigned int numbytes)
 297 {
 298   CUresult CU_err = cuParamSetv (hfunc, offset, ptr, numbytes);
 299
 300   if (CU_err != CUDA_SUCCESS)
 301   {
 302     log_error ("ERROR: %s %d\n", "cuParamSetv()", CU_err);
 303
 304     exit (-1);
 305   }
 306 }
 307
 308 void hc_cuParamSeti (CUfunction hfunc, int offset, unsigned int value)
 309 {
 310   CUresult CU_err = cuParamSeti (hfunc, offset, value);
 311
 312   if (CU_err != CUDA_SUCCESS)
 313   {
 314     log_error ("ERROR: %s %d\n", "cuParamSeti()", CU_err);
 315
 316     exit (-1);
 317   }
 318 }
 319
 320 void hc_cuModuleGetGlobal (CUdeviceptr *dptr, size_t *bytes, CUmodule hmod, const char *name)
 321 {
 322   CUresult CU_err = cuModuleGetGlobal (dptr, bytes, hmod, name);
 323
 324   if (CU_err != CUDA_SUCCESS)
 325   {
 326     log_error ("ERROR: %s %d\n", "cuModuleGetGlobal()", CU_err);
 327
 328     exit (-1);
 329   }
 330 }
 331
 332 void hc_cuCtxPopCurrent (CUcontext *pctx)
 333 {
 334   CUresult CU_err = cuCtxPopCurrent (pctx);
 335
 336   if (CU_err != CUDA_SUCCESS)
 337   {
 338     log_error ("ERROR: %s %d\n", "cuCtxPopCurrent()", CU_err);
 339
 340     exit (-1);
 341   }
 342 }
 343
 344 void hc_cuCtxPushCurrent (CUcontext ctx)
 345 {
 346   CUresult CU_err = cuCtxPushCurrent (ctx);
 347
 348   if (CU_err != CUDA_SUCCESS)
 349   {
 350     log_error ("ERROR: %s %d\n", "cuCtxPushCurrent()", CU_err);
 351
 352     exit (-1);
 353   }
 354 }
 355
 356 void hc_cuLaunchKernel (CUfunction f, unsigned int gridDimX, unsigned int gridDimY, unsigned int gridDimZ, unsigned int blockDimX, unsigned int blockDimY, unsigned int blockDimZ, unsigned int sharedMemBytes, CUstream hStream, void **kernelParams, void **extra)
 357 {
 358   CUresult CU_err = cuLaunchKernel (f, gridDimX, gridDimY, gridDimZ, blockDimX, blockDimY, blockDimZ, sharedMemBytes, hStream, kernelParams, extra);
 359
 360   if (CU_err != CUDA_SUCCESS)
 361   {
 362     log_error ("ERROR: %s %d\n", "cuLaunchKernel()", CU_err);
 363
 364     exit (-1);
 365   }
 366 }
 367
 368 void hc_cuLaunchGrid (CUfunction f, int grid_width, int grid_height)
 369 {
 370   CUresult CU_err = cuLaunchGrid (f, grid_width, grid_height);
 371
 372   if (CU_err != CUDA_SUCCESS)
 373   {
 374     log_error ("ERROR: %s %d\n", "cuLaunchGrid()", CU_err);
 375
 376     exit (-1);
 377   }
 378 }
 379
 380 void hc_cuLaunchGridAsync (CUfunction f, int grid_width, int grid_height, CUstream hStream)
 381 {
 382   CUresult CU_err = cuLaunchGridAsync (f, grid_width, grid_height, hStream);
 383
 384   if (CU_err != CUDA_SUCCESS)
 385   {
 386     log_error ("ERROR: %s %d\n", "cuLaunchGridAsync()", CU_err);
 387
 388     exit (-1);
 389   }
 390 }
 391
 392 void hc_cuEventSynchronize (CUevent hEvent)
 393 {
 394   CUresult CU_err = cuEventSynchronize (hEvent);
 395
 396   if (CU_err != CUDA_SUCCESS)
 397   {
 398     log_error ("ERROR: %s %d\n", "cuEventSynchronize()", CU_err);
 399
 400     exit (-1);
 401   }
 402 }
 403
 404 void hc_cuStreamSynchronize (CUstream hStream)
 405 {
 406   CUresult CU_err = cuStreamSynchronize (hStream);
 407
 408   if (CU_err != CUDA_SUCCESS)
 409   {
 410     log_error ("ERROR: %s %d\n", "cuStreamSynchronize()", CU_err);
 411
 412     exit (-1);
 413   }
 414 }
 415
 416 void hc_cuMemFreeHost (void *p)
 417 {
 418   CUresult CU_err = cuMemFreeHost (p);
 419
 420   if (CU_err != CUDA_SUCCESS)
 421   {
 422     log_error ("ERROR: %s %d\n", "cuMemFreeHost()", CU_err);
 423
 424     exit (-1);
 425   }
 426 }
 427
 428 void hc_cuMemFree (CUdeviceptr dptr)
 429 {
 430   CUresult CU_err = cuMemFree (dptr);
 431
 432   if (CU_err != CUDA_SUCCESS)
 433   {
 434     log_error ("ERROR: %s %d\n", "cuMemFree()", CU_err);
 435
 436     exit (-1);
 437   }
 438 }
 439
 440 void hc_cuEventDestroy (CUevent hEvent)
 441 {
 442   CUresult CU_err = cuEventDestroy (hEvent);
 443
 444   if (CU_err != CUDA_SUCCESS)
 445   {
 446     log_error ("ERROR: %s %d\n", "cuEventDestroy()", CU_err);
 447
 448     exit (-1);
 449   }
 450 }
 451
 452 void hc_cuStreamDestroy (CUstream hStream)
 453 {
 454   CUresult CU_err = cuStreamDestroy (hStream);
 455
 456   if (CU_err != CUDA_SUCCESS)
 457   {
 458     log_error ("ERROR: %s %d\n", "cuStreamDestroy()", CU_err);
 459
 460     exit (-1);
 461   }
 462 }
 463
 464 void hc_cuModuleUnload (CUmodule hmod)
 465 {
 466   CUresult CU_err = cuModuleUnload (hmod);
 467
 468   if (CU_err != CUDA_SUCCESS)
 469   {
 470     log_error ("ERROR: %s %d\n", "cuModuleUnload()", CU_err);
 471
 472     exit (-1);
 473   }
 474 }
 475
 476 void hc_cuCtxDestroy (CUcontext ctx)
 477 {
 478   CUresult CU_err = cuCtxDestroy (ctx);
 479
 480   if (CU_err != CUDA_SUCCESS)
 481   {
 482     log_error ("ERROR: %s %d\n", "cuCtxDestroy()", CU_err);
 483
 484     exit (-1);
 485   }
 486 }
 487
 488 void hc_cuCtxAttach (CUcontext *pctx, unsigned int flags)
 489 {
 490   CUresult CU_err = cuCtxAttach (pctx, flags);
 491
 492   if (CU_err != CUDA_SUCCESS)
 493   {
 494     log_error ("ERROR: %s %d\n", "cuCtxAttach()", CU_err);
 495
 496     exit (-1);
 497   }
 498 }
 499
 500 void hc_cuCtxDetach (CUcontext ctx)
 501 {
 502   CUresult CU_err = cuCtxDetach (ctx);
 503
 504   if (CU_err != CUDA_SUCCESS)
 505   {
 506     log_error ("ERROR: %s %d\n", "cuCtxDetach()", CU_err);
 507
 508     exit (-1);
 509   }
 510 }
 511
 512 void hc_cuCtxSynchronize (void)
 513 {
 514   CUresult CU_err = cuCtxSynchronize ();
 515
 516   if (CU_err != CUDA_SUCCESS)
 517   {
 518     log_error ("ERROR: %s %d\n", "cuCtxSynchronize()", CU_err);
 519
 520     exit (-1);
 521   }
 522 }
 523
 524 void hc_cuCtxSetCacheConfig (CUfunc_cache config)
 525 {
 526   CUresult CU_err = cuCtxSetCacheConfig (config);
 527
 528   if (CU_err != CUDA_SUCCESS)
 529   {
 530     log_error ("ERROR: %s %d\n", "cuCtxSetCacheConfig()", CU_err);
 531
 532     exit (-1);
 533   }
 534 }
 535
 536 void hc_cuDriverGetVersion (int *driverVersion)
 537 {
 538   CUresult CU_err = cuDriverGetVersion (driverVersion);
 539
 540   if (CU_err != CUDA_SUCCESS)
 541   {
 542     log_error ("ERROR: %s %d\n", "cuDriverGetVersion()", CU_err);
 543
 544     exit (-1);
 545   }
 546 }
 547
 548 void hc_cuModuleLoadDataEx (CUmodule *module, const void *image, unsigned int numOptions, CUjit_option *options, void **optionValues)
 549 {
 550   CUresult CU_err = cuModuleLoadDataEx (module, image, numOptions, options, optionValues);
 551
 552   if (CU_err != CUDA_SUCCESS)
 553   {
 554     log_error ("ERROR: %s %d\n", "cuModuleLoadDataEx()", CU_err);
 555
 556     exit (-1);
 557   }
 558 }