added tuned code

examples_cuda/aobench/ao_cu.cpp

@@ -69,6 +69,211 @@ static inline double rtc(void)
   return etime;
 }
 
+/******************************/ 
+#include <cassert>
+#include <iostream>
+#include <cuda.h>
+#include "drvapi_error_string.h"
+
+#define checkCudaErrors(err)  __checkCudaErrors (err, __FILE__, __LINE__)
+// These are the inline versions for all of the SDK helper functions
+void __checkCudaErrors(CUresult err, const char *file, const int line) {
+  if(CUDA_SUCCESS != err) {
+    std::cerr << "checkCudeErrors() Driver API error = " << err << "\""
+           << getCudaDrvErrorString(err) << "\" from file <" << file
+           << ", line " << line << "\n";
+    exit(-1);
+  }
+}
+
+/**********************/
+/* Basic CUDriver API */
+CUcontext context;
+
+void createContext(const int deviceId = 0)
+{
+  CUdevice device;
+  int devCount;
+  checkCudaErrors(cuInit(0));
+  checkCudaErrors(cuDeviceGetCount(&devCount));
+  assert(devCount > 0);
+  checkCudaErrors(cuDeviceGet(&device, deviceId < devCount ? deviceId : 0));
+
+  char name[128];
+  checkCudaErrors(cuDeviceGetName(name, 128, device));
+  std::cout << "Using CUDA Device [0]: " << name << "\n";
+
+  int devMajor, devMinor;
+  checkCudaErrors(cuDeviceComputeCapability(&devMajor, &devMinor, device));
+  std::cout << "Device Compute Capability: " 
+    << devMajor << "." << devMinor << "\n";
+  if (devMajor < 2) {
+    std::cerr << "ERROR: Device 0 is not SM 2.0 or greater\n";
+    exit(1); 
+  }
+
+  // Create driver context
+  checkCudaErrors(cuCtxCreate(&context, 0, device));
+}
+void destroyContext()
+{
+  checkCudaErrors(cuCtxDestroy(context));
+}
+
+CUmodule loadModule(const char * module)
+{
+  CUmodule cudaModule;
+  // in this branch we use compilation with parameters
+
+  const unsigned int jitNumOptions = 1;
+  CUjit_option *jitOptions = new CUjit_option[jitNumOptions];
+  void **jitOptVals = new void*[jitNumOptions];
+  // set up pointer to set the Maximum # of registers for a particular kernel
+  jitOptions[0] = CU_JIT_MAX_REGISTERS;
+  int jitRegCount = 64;
+  jitOptVals[0] = (void *)(size_t)jitRegCount;
+#if 0
+
+        // set up size of compilation log buffer
+        jitOptions[0] = CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES;
+        int jitLogBufferSize = 1024;
+        jitOptVals[0] = (void *)(size_t)jitLogBufferSize;
+
+        // set up pointer to the compilation log buffer
+        jitOptions[1] = CU_JIT_INFO_LOG_BUFFER;
+        char *jitLogBuffer = new char[jitLogBufferSize];
+        jitOptVals[1] = jitLogBuffer;
+
+        // set up pointer to set the Maximum # of registers for a particular kernel
+        jitOptions[2] = CU_JIT_MAX_REGISTERS;
+        int jitRegCount = 32;
+        jitOptVals[2] = (void *)(size_t)jitRegCount;
+#endif
+
+  checkCudaErrors(cuModuleLoadDataEx(&cudaModule, module,jitNumOptions, jitOptions, (void **)jitOptVals));
+  return cudaModule;
+}
+void unloadModule(CUmodule &cudaModule)
+{
+  checkCudaErrors(cuModuleUnload(cudaModule));
+}
+
+CUfunction getFunction(CUmodule &cudaModule, const char * function)
+{
+  CUfunction cudaFunction;
+  checkCudaErrors(cuModuleGetFunction(&cudaFunction, cudaModule, function));
+  return cudaFunction;
+}
+  
+CUdeviceptr deviceMalloc(const size_t size)
+{
+  CUdeviceptr d_buf;
+  checkCudaErrors(cuMemAlloc(&d_buf, size));
+  return d_buf;
+}
+void deviceFree(CUdeviceptr d_buf)
+{
+  checkCudaErrors(cuMemFree(d_buf));
+}
+void memcpyD2H(void * h_buf, CUdeviceptr d_buf, const size_t size)
+{
+  checkCudaErrors(cuMemcpyDtoH(h_buf, d_buf, size));
+}
+void memcpyH2D(CUdeviceptr d_buf, void * h_buf, const size_t size)
+{
+  checkCudaErrors(cuMemcpyHtoD(d_buf, h_buf, size));
+}
+#define deviceLaunch(func,nbx,nby,nbz,params) \
+  checkCudaErrors(cuFuncSetCacheConfig((func), CU_FUNC_CACHE_PREFER_EQUAL)); \
+  checkCudaErrors( \
+      cuLaunchKernel( \
+        (func), \
+        ((nbx-1)/(128/32)+1), (nby), (nbz), \
+        128, 1, 1, \
+        0, NULL, (params), NULL \
+        ));
+
+typedef CUdeviceptr devicePtr;
+
+
+/**************/
+#include <vector>
+std::vector<char> readBinary(const char * filename)
+{
+  std::vector<char> buffer;
+  FILE *fp = fopen(filename, "rb");
+  if (!fp )
+  {
+    fprintf(stderr, "file %s not found\n", filename);
+    assert(0);
+  }
+#if 0
+  char c;
+  while ((c = fgetc(fp)) != EOF)
+    buffer.push_back(c);
+#else
+  fseek(fp, 0, SEEK_END); 
+  const unsigned long long size = ftell(fp);         /*calc the size needed*/
+  fseek(fp, 0, SEEK_SET); 
+  buffer.resize(size);
+
+  if (fp == NULL){ /*ERROR detection if file == empty*/
+    fprintf(stderr, "Error: There was an Error reading the file %s \n",filename);           
+    exit(1);
+  }
+  else if (fread(&buffer[0], sizeof(char), size, fp) != size){ /* if count of read bytes != calculated size of .bin file -> ERROR*/
+    fprintf(stderr, "Error: There was an Error reading the file %s \n", filename);
+    exit(1);
+  }
+#endif
+  fprintf(stderr, " read buffer of size= %d bytes \n", (int)buffer.size());
+  return buffer;
+}
+
+extern "C" 
+{
+
+  void *CUDAAlloc(void **handlePtr, int64_t size, int32_t alignment)
+  {
+    return NULL;
+  }
+  void CUDALaunch(
+      void **handlePtr, 
+      const char * module_name,
+      const char * module_1,
+      const char * func_name,
+      void **func_args, 
+      int countx, int county, int countz)
+  {
+    assert(module_name != NULL);
+    assert(module_1 != NULL);
+    assert(func_name != NULL);
+    assert(func_args != NULL);
+#if 0
+    const char * module = module_1;
+#else
+    const std::vector<char> module_str = readBinary("kernel.cubin");
+    const char *  module = &module_str[0];
+#endif
+    CUmodule   cudaModule   = loadModule(module);
+    CUfunction cudaFunction = getFunction(cudaModule, func_name);
+    deviceLaunch(cudaFunction, countx, county, countz, func_args);
+    unloadModule(cudaModule);
+  }
+  void CUDASync(void *handle)
+  {
+    checkCudaErrors(cuStreamSynchronize(0));
+  }
+  void ISPCSync(void *handle)
+  {
+    checkCudaErrors(cuStreamSynchronize(0));
+  }
+  void CUDAFree(void *handle)
+  {
+  }
+}
+/******************************/
+
 
 #define NSUBSAMPLES        2
 
@@ -158,6 +363,11 @@ int main(int argc, char **argv)
     savePPM("ao-ispc.ppm", width, height); 
 #endif
 
+    /*******************/
+  createContext();
+  /*******************/
+  devicePtr d_fimg = deviceMalloc(width*height*3*sizeof(float));
+
     //
     // Run the ispc + tasks path, test_iterations times, and report the
     // minimum time for any of them.
@@ -166,18 +376,28 @@ int main(int argc, char **argv)
     for (unsigned int i = 0; i < test_iterations; i++) {
         memset((void *)fimg, 0, sizeof(float) * width * height * 3);
         assert(NSUBSAMPLES == 2);
+        memcpyH2D(d_fimg, fimg, width*height*3*sizeof(float));
 
         reset_and_start_timer();
         const double t0 = rtc();
-        ao_ispc_tasks(width, height, NSUBSAMPLES, fimg);
+        ao_ispc_tasks(
+            width, 
+            height, 
+            NSUBSAMPLES, 
+            (float*)d_fimg);
         double t = (rtc() - t0); //get_elapsed_mcycles();
         minTimeISPCTasks = std::min(minTimeISPCTasks, t);
     }
 
+    memcpyD2H(fimg, d_fimg, width*height*3*sizeof(float));
+
     // Report results and save image
     printf("[aobench ispc + tasks]:\t\t[%.3f] million cycles (%d x %d image)\n", 
            minTimeISPCTasks, width, height);
-    savePPM("ao-ispc-tasks.ppm", width, height); 
+    savePPM("ao-cuda.ppm", width, height); 
+  /*******************/
+  destroyContext();
+  /*******************/
     return 0;
 
     //