[Polly] [GPUJIT] Moved error prints to stderr

[PhilippSchaad]

Summary

Errors previously printed to stdout now get printed to stderr.

[PhilippSchaad]

Rebase

tools/GPURuntime/GPUJIT.c

 static CudaThreadSynchronizeFcnTy *CudaThreadSynchronizeFcnPtr;
 
 static void *getAPIHandle(void *Handle, const char *FuncName) {
   char *Err;
   void *FuncPtr;
   dlerror();
   FuncPtr = dlsym(Handle, FuncName);
   if ((Err = dlerror()) != 0) {
-    fprintf(stdout, "Load CUDA driver API failed: %s. \n", Err);
+    fprintf(stderr, "Load CUDA driver API failed: %s. \n", Err);
     return 0;
   }
   return FuncPtr;
 }
 
 static int initialDeviceAPILibraries() {
   HandleCuda = dlopen("libcuda.so", RTLD_LAZY);
   if (!HandleCuda) {
PollyGPUContext *polly_initContext() {
 
   static __thread PollyGPUContext *CurrentContext = NULL;
 
   if (CurrentContext)
     return CurrentContext;
 
   /* Get API handles. */
   if (initialDeviceAPIs() == 0) {
-    fprintf(stdout, "Getting the \"handle\" for the CUDA driver API failed.\n");
+    fprintf(stderr, "Getting the \"handle\" for the CUDA driver API failed.\n");
     exit(-1);
   }
 
   if (CuInitFcnPtr(0) != CUDA_SUCCESS) {
-    fprintf(stdout, "Initializing the CUDA driver API failed.\n");
+    fprintf(stderr, "Initializing the CUDA driver API failed.\n");
     exit(-1);
   }
 
   /* Get number of devices that supports CUDA. */
   CuDeviceGetCountFcnPtr(&DeviceCount);
   if (DeviceCount == 0) {
-    fprintf(stdout, "There is no device supporting CUDA.\n");
+    fprintf(stderr, "There is no device supporting CUDA.\n");
     exit(-1);
   }
 
   CuDeviceGetFcnPtr(&Device, 0);
 
   /* Get compute capabilities and the device name. */
   CuDeviceComputeCapabilityFcnPtr(&Major, &Minor, Device);
   CuDeviceGetNameFcnPtr(DeviceName, 256, Device);
   debug_print("> Running on GPU device %d : %s.\n", DeviceID, DeviceName);
 
   /* Create context on the device. */
   Context = (PollyGPUContext *)malloc(sizeof(PollyGPUContext));
   if (Context == 0) {
-    fprintf(stdout, "Allocate memory for Polly GPU context failed.\n");
+    fprintf(stderr, "Allocate memory for Polly GPU context failed.\n");
     exit(-1);
   }
   CuCtxCreateFcnPtr(&(Context->Cuda), 0, Device);
 
   CacheMode = getenv("POLLY_NOCACHE") == 0;
 
   if (CacheMode)
     CurrentContext = Context;
if (KernelCache[i] && KernelCache[i]->PTXString == PTXBuffer) {
       debug_print("  -> using cached kernel\n");
       return KernelCache[i];
     }
   }
 
   PollyGPUFunction *Function = malloc(sizeof(PollyGPUFunction));
 
   if (Function == 0) {
-    fprintf(stdout, "Allocate memory for Polly GPU function failed.\n");
+    fprintf(stderr, "Allocate memory for Polly GPU function failed.\n");
     exit(-1);
   }
 
   CUresult Res;
   CUlinkState LState;
   CUjit_option Options[6];
   void *OptionVals[6];
   float Walltime = 0;
PollyGPUFunction *polly_getKernel(const char *PTXBuffer,
   OptionVals[5] = (void *)1;
 
   memset(ErrorLog, 0, sizeof(ErrorLog));
 
   CuLinkCreateFcnPtr(6, Options, OptionVals, &LState);
   Res = CuLinkAddDataFcnPtr(LState, CU_JIT_INPUT_PTX, (void *)PTXBuffer,
                             strlen(PTXBuffer) + 1, 0, 0, 0, 0);
   if (Res != CUDA_SUCCESS) {
-    fprintf(stdout, "PTX Linker Error:\n%s\n%s", ErrorLog, InfoLog);
+    fprintf(stderr, "PTX Linker Error:\n%s\n%s", ErrorLog, InfoLog);
     exit(-1);
   }
 
   Res = CuLinkCompleteFcnPtr(LState, &CuOut, &OutSize);
   if (Res != CUDA_SUCCESS) {
-    fprintf(stdout, "Complete ptx linker step failed.\n");
-    fprintf(stdout, "\n%s\n", ErrorLog);
+    fprintf(stderr, "Complete ptx linker step failed.\n");
+    fprintf(stderr, "\n%s\n", ErrorLog);
     exit(-1);
   }
 
   debug_print("CUDA Link Completed in %fms. Linker Output:\n%s\n", Walltime,
               InfoLog);
 
   Res = CuModuleLoadDataFcnPtr(&(Function->CudaModule), CuOut);
   if (Res != CUDA_SUCCESS) {
-    fprintf(stdout, "Loading ptx assembly text failed.\n");
+    fprintf(stderr, "Loading ptx assembly text failed.\n");
     exit(-1);
   }
 
   Res = CuModuleGetFunctionFcnPtr(&(Function->Cuda), Function->CudaModule,
                                   KernelName);
   if (Res != CUDA_SUCCESS) {
-    fprintf(stdout, "Loading kernel function failed.\n");
+    fprintf(stderr, "Loading kernel function failed.\n");
     exit(-1);
   }
 
   CuLinkDestroyFcnPtr(LState);
 
   Function->PTXString = PTXBuffer;
 
   if (CacheMode) {
void polly_copyFromHostToDevice(void *HostData, PollyGPUDevicePtr *DevData,
   CuMemcpyHtoDFcnPtr(CuDevData, HostData, MemSize);
 }
 
 void polly_copyFromDeviceToHost(PollyGPUDevicePtr *DevData, void *HostData,
                                 long MemSize) {
   dump_function();
 
   if (CuMemcpyDtoHFcnPtr(HostData, DevData->Cuda, MemSize) != CUDA_SUCCESS) {
-    fprintf(stdout, "Copying results from device to host memory failed.\n");
+    fprintf(stderr, "Copying results from device to host memory failed.\n");
     exit(-1);
   }
 }
 void polly_synchronizeDevice() {
   dump_function();
   if (CuCtxSynchronizeFcnPtr() != CUDA_SUCCESS) {
-    fprintf(stdout, "Synchronizing device and host memory failed.\n");
+    fprintf(stderr, "Synchronizing device and host memory failed.\n");
     exit(-1);
   }
 }
 
 void polly_launchKernel(PollyGPUFunction *Kernel, unsigned int GridDimX,
                         unsigned int GridDimY, unsigned int BlockDimX,
                         unsigned int BlockDimY, unsigned int BlockDimZ,
                         void **Parameters) {
   dump_function();
 
   unsigned GridDimZ = 1;
   unsigned int SharedMemBytes = CU_SHARED_MEM_CONFIG_DEFAULT_BANK_SIZE;
   CUstream Stream = 0;
   void **Extra = 0;
 
   CUresult Res;
   Res = CuLaunchKernelFcnPtr(Kernel->Cuda, GridDimX, GridDimY, GridDimZ,
                              BlockDimX, BlockDimY, BlockDimZ, SharedMemBytes,
                              Stream, Parameters, Extra);
   if (Res != CUDA_SUCCESS) {
-    fprintf(stdout, "Launching CUDA kernel failed.\n");
+    fprintf(stderr, "Launching CUDA kernel failed.\n");
     exit(-1);
   }
 }
 
 void polly_freeDeviceMemory(PollyGPUDevicePtr *Allocation) {
   dump_function();
   CuMemFreeFcnPtr((CUdeviceptr)Allocation->Cuda);
   free(Allocation);
 }
 
 PollyGPUDevicePtr *polly_allocateMemoryForDevice(long MemSize) {
   dump_function();
 
   PollyGPUDevicePtr *DevData = malloc(sizeof(PollyGPUDevicePtr));
 
   if (DevData == 0) {
-    fprintf(stdout, "Allocate memory for GPU device memory pointer failed.\n");
+    fprintf(stderr, "Allocate memory for GPU device memory pointer failed.\n");
     exit(-1);
   }
 
   CUresult Res = CuMemAllocFcnPtr(&(DevData->Cuda), MemSize);
 
   if (Res != CUDA_SUCCESS) {
-    fprintf(stdout, "Allocate memory for GPU device memory pointer failed.\n");
+    fprintf(stderr, "Allocate memory for GPU device memory pointer failed.\n");
     exit(-1);
   }
 
   return DevData;
 }
 
 void *polly_getDevicePtr(PollyGPUDevicePtr *Allocation) {
   dump_function();