From 34408c3122f9eeb1b952a50bedf4523093794e00 Mon Sep 17 00:00:00 2001
From: David Anderson <davea@ssl.berkeley.edu>
Date: Thu, 13 Apr 2017 09:16:58 -0700
Subject: [PATCH] client: don't start var names with __

---
 client/gpu_amd.cpp    | 108 +++++++++++-----------
 client/gpu_nvidia.cpp | 202 +++++++++++++++++++++---------------------
 client/gpu_opencl.cpp |  94 ++++++++++----------
 3 files changed, 202 insertions(+), 202 deletions(-)

diff --git a/client/gpu_amd.cpp b/client/gpu_amd.cpp
index 966ddb0241..ec594a09b8 100644
--- a/client/gpu_amd.cpp
+++ b/client/gpu_amd.cpp
@@ -85,27 +85,27 @@ typedef int (__stdcall *ATI_STATUS) (CALdevicestatus*, CALdevice);
 typedef int (__stdcall *ATI_DEVICEOPEN) (CALdevice*, CALuint);
 typedef int (__stdcall *ATI_DEVICECLOSE) (CALdevice);
 
-ATI_ATTRIBS __calDeviceGetAttribs = NULL;
-ATI_CLOSE   __calShutdown = NULL;
-ATI_GDC     __calDeviceGetCount = NULL;
-ATI_GDI     __calInit = NULL;
-ATI_INFO    __calDeviceGetInfo = NULL;
-ATI_VER     __calGetVersion = NULL;
-ATI_STATUS  __calDeviceGetStatus = NULL;
-ATI_DEVICEOPEN  __calDeviceOpen = NULL;
-ATI_DEVICECLOSE  __calDeviceClose = NULL;
+ATI_ATTRIBS p_calDeviceGetAttribs = NULL;
+ATI_CLOSE   p_calShutdown = NULL;
+ATI_GDC     p_calDeviceGetCount = NULL;
+ATI_GDI     p_calInit = NULL;
+ATI_INFO    p_calDeviceGetInfo = NULL;
+ATI_VER     p_calGetVersion = NULL;
+ATI_STATUS  p_calDeviceGetStatus = NULL;
+ATI_DEVICEOPEN  p_calDeviceOpen = NULL;
+ATI_DEVICECLOSE  p_calDeviceClose = NULL;
 
 #else
 
-int (*__calInit)();
-int (*__calGetVersion)(CALuint*, CALuint*, CALuint*);
-int (*__calDeviceGetCount)(CALuint*);
-int (*__calDeviceGetAttribs)(CALdeviceattribs*, CALuint);
-int (*__calShutdown)();
-int (*__calDeviceGetInfo)(CALdeviceinfo*, CALuint);
-int (*__calDeviceGetStatus)(CALdevicestatus*, CALdevice);
-int (*__calDeviceOpen)(CALdevice*, CALuint);
-int (*__calDeviceClose)(CALdevice);
+int (*p_calInit)();
+int (*p_calGetVersion)(CALuint*, CALuint*, CALuint*);
+int (*p_calDeviceGetCount)(CALuint*);
+int (*p_calDeviceGetAttribs)(CALdeviceattribs*, CALuint);
+int (*p_calShutdown)();
+int (*p_calDeviceGetInfo)(CALdeviceinfo*, CALuint);
+int (*p_calDeviceGetStatus)(CALdevicestatus*, CALdevice);
+int (*p_calDeviceOpen)(CALdevice*, CALuint);
+int (*p_calDeviceClose)(CALdevice);
 
 #endif
 
@@ -146,15 +146,15 @@ void COPROC_ATI::get(
         return;
     }
 
-    __calInit = (ATI_GDI)GetProcAddress(callib, "calInit" );
-    __calGetVersion = (ATI_VER)GetProcAddress(callib, "calGetVersion" );
-    __calDeviceGetCount = (ATI_GDC)GetProcAddress(callib, "calDeviceGetCount" );
-    __calDeviceGetAttribs =(ATI_ATTRIBS)GetProcAddress(callib, "calDeviceGetAttribs" );
-    __calShutdown = (ATI_CLOSE)GetProcAddress(callib, "calShutdown" );
-    __calDeviceGetInfo = (ATI_INFO)GetProcAddress(callib, "calDeviceGetInfo" );
-    __calDeviceGetStatus = (ATI_STATUS)GetProcAddress(callib, "calDeviceGetStatus" );
-    __calDeviceOpen = (ATI_DEVICEOPEN)GetProcAddress(callib, "calDeviceOpen" );
-    __calDeviceClose = (ATI_DEVICECLOSE)GetProcAddress(callib, "calDeviceClose" );
+    p_calInit = (ATI_GDI)GetProcAddress(callib, "calInit" );
+    p_calGetVersion = (ATI_VER)GetProcAddress(callib, "calGetVersion" );
+    p_calDeviceGetCount = (ATI_GDC)GetProcAddress(callib, "calDeviceGetCount" );
+    p_calDeviceGetAttribs =(ATI_ATTRIBS)GetProcAddress(callib, "calDeviceGetAttribs" );
+    p_calShutdown = (ATI_CLOSE)GetProcAddress(callib, "calShutdown" );
+    p_calDeviceGetInfo = (ATI_INFO)GetProcAddress(callib, "calDeviceGetInfo" );
+    p_calDeviceGetStatus = (ATI_STATUS)GetProcAddress(callib, "calDeviceGetStatus" );
+    p_calDeviceOpen = (ATI_DEVICEOPEN)GetProcAddress(callib, "calDeviceOpen" );
+    p_calDeviceClose = (ATI_DEVICECLOSE)GetProcAddress(callib, "calDeviceClose" );
 
 #else
 
@@ -167,52 +167,52 @@ void COPROC_ATI::get(
 
     atirt_detected = true;
 
-    __calInit = (int(*)()) dlsym(callib, "calInit");
-    __calGetVersion = (int(*)(CALuint*, CALuint*, CALuint*)) dlsym(callib, "calGetVersion");
-    __calDeviceGetCount = (int(*)(CALuint*)) dlsym(callib, "calDeviceGetCount");
-    __calDeviceGetAttribs = (int(*)(CALdeviceattribs*, CALuint)) dlsym(callib, "calDeviceGetAttribs");
-    __calShutdown = (int(*)()) dlsym(callib, "calShutdown");
-    __calDeviceGetInfo = (int(*)(CALdeviceinfo*, CALuint)) dlsym(callib, "calDeviceGetInfo");
-    __calDeviceGetStatus = (int(*)(CALdevicestatus*, CALdevice)) dlsym(callib, "calDeviceGetStatus");
-    __calDeviceOpen = (int(*)(CALdevice*, CALuint)) dlsym(callib, "calDeviceOpen");
-    __calDeviceClose = (int(*)(CALdevice)) dlsym(callib, "calDeviceClose");
+    p_calInit = (int(*)()) dlsym(callib, "calInit");
+    p_calGetVersion = (int(*)(CALuint*, CALuint*, CALuint*)) dlsym(callib, "calGetVersion");
+    p_calDeviceGetCount = (int(*)(CALuint*)) dlsym(callib, "calDeviceGetCount");
+    p_calDeviceGetAttribs = (int(*)(CALdeviceattribs*, CALuint)) dlsym(callib, "calDeviceGetAttribs");
+    p_calShutdown = (int(*)()) dlsym(callib, "calShutdown");
+    p_calDeviceGetInfo = (int(*)(CALdeviceinfo*, CALuint)) dlsym(callib, "calDeviceGetInfo");
+    p_calDeviceGetStatus = (int(*)(CALdevicestatus*, CALdevice)) dlsym(callib, "calDeviceGetStatus");
+    p_calDeviceOpen = (int(*)(CALdevice*, CALuint)) dlsym(callib, "calDeviceOpen");
+    p_calDeviceClose = (int(*)(CALdevice)) dlsym(callib, "calDeviceClose");
 
 #endif
 
-    if (!__calInit) {
+    if (!p_calInit) {
         warnings.push_back("calInit() missing from CAL library");
         goto leave;
     }
-    if (!__calGetVersion) {
+    if (!p_calGetVersion) {
         warnings.push_back("calGetVersion() missing from CAL library");
         goto leave;
     }
-    if (!__calDeviceGetCount) {
+    if (!p_calDeviceGetCount) {
         warnings.push_back("calDeviceGetCount() missing from CAL library");
         goto leave;
     }
-    if (!__calDeviceGetAttribs) {
+    if (!p_calDeviceGetAttribs) {
         warnings.push_back("calDeviceGetAttribs() missing from CAL library");
         goto leave;
     }
-    if (!__calDeviceGetInfo) {
+    if (!p_calDeviceGetInfo) {
         warnings.push_back("calDeviceGetInfo() missing from CAL library");
         goto leave;
     }
 
-    retval = (*__calInit)();
+    retval = (*p_calInit)();
     if (retval != CAL_RESULT_OK) {
         snprintf(buf, sizeof(buf), "calInit() returned %d", retval);
         warnings.push_back(buf);
         goto leave;
     }
-    retval = (*__calDeviceGetCount)(&numDevices);
+    retval = (*p_calDeviceGetCount)(&numDevices);
     if (retval != CAL_RESULT_OK) {
         snprintf(buf, sizeof(buf), "calDeviceGetCount() returned %d", retval);
         warnings.push_back(buf);
         goto leave;
     }
-    retval = (*__calGetVersion)(&cal_major, &cal_minor, &cal_imp);
+    retval = (*p_calGetVersion)(&cal_major, &cal_minor, &cal_imp);
     if (retval != CAL_RESULT_OK) {
         snprintf(buf, sizeof(buf), "calGetVersion() returned %d", retval);
         warnings.push_back(buf);
@@ -225,13 +225,13 @@ void COPROC_ATI::get(
     }
 
     for (CALuint i=0; i<numDevices; i++) {
-        retval = (*__calDeviceGetInfo)(&info, i);
+        retval = (*p_calDeviceGetInfo)(&info, i);
         if (retval != CAL_RESULT_OK) {
             snprintf(buf, sizeof(buf), "calDeviceGetInfo() returned %d", retval);
             warnings.push_back(buf);
             goto leave;
         }
-        retval = (*__calDeviceGetAttribs)(&attribs, i);
+        retval = (*p_calDeviceGetAttribs)(&attribs, i);
         if (retval != CAL_RESULT_OK) {
             snprintf(buf, sizeof(buf), "calDeviceGetAttribs() returned %d", retval);
             warnings.push_back(buf);
@@ -383,7 +383,7 @@ void COPROC_ATI::get(
 
     // shut down CAL, otherwise Lenovo won't be able to switch to low-power GPU
     //
-    retval = (*__calShutdown)();
+    retval = (*p_calShutdown)();
 
     if (!ati_gpus.size()) {
         warnings.push_back("No ATI GPUs found");
@@ -467,20 +467,20 @@ static void get_available_ati_ram(COPROC_ATI &cc, vector<string>& warnings) {
 
     st.struct_size = sizeof(CALdevicestatus);
 
-    if (!__calDeviceOpen) {
+    if (!p_calDeviceOpen) {
         warnings.push_back("calDeviceOpen() missing from CAL library");
         return;
     }
-    if (!__calDeviceGetStatus) {
+    if (!p_calDeviceGetStatus) {
         warnings.push_back("calDeviceGetStatus() missing from CAL library");
         return;
     }
-    if (!__calDeviceClose) {
+    if (!p_calDeviceClose) {
         warnings.push_back("calDeviceClose() missing from CAL library");
         return;
     }
 
-    retval = (*__calDeviceOpen)(&dev, cc.device_num);
+    retval = (*p_calDeviceOpen)(&dev, cc.device_num);
     if (retval) {
         snprintf(buf, sizeof(buf),
             "[coproc] calDeviceOpen(%d) returned %d", cc.device_num, retval
@@ -488,16 +488,16 @@ static void get_available_ati_ram(COPROC_ATI &cc, vector<string>& warnings) {
         warnings.push_back(buf);
         return;
     }
-    retval = (*__calDeviceGetStatus)(&st, dev);
+    retval = (*p_calDeviceGetStatus)(&st, dev);
     if (retval) {
         snprintf(buf, sizeof(buf),
             "[coproc] calDeviceGetStatus(%d) returned %d",
             cc.device_num, retval
         );
         warnings.push_back(buf);
-        (*__calDeviceClose)(dev);
+        (*p_calDeviceClose)(dev);
         return;
     }
     cc.available_ram = st.availLocalRAM*MEGA;
-    (*__calDeviceClose)(dev);
+    (*p_calDeviceClose)(dev);
 }
diff --git a/client/gpu_nvidia.cpp b/client/gpu_nvidia.cpp
index 15d015ce97..21e7df607c 100644
--- a/client/gpu_nvidia.cpp
+++ b/client/gpu_nvidia.cpp
@@ -201,33 +201,33 @@ typedef int (__stdcall *CUDA_MA)(unsigned int*, size_t);
 typedef int (__stdcall *CUDA_MF)(unsigned int);
 typedef int (__stdcall *CUDA_MGI)(size_t*, size_t*);
 
-CUDA_GDC __cuDeviceGetCount = NULL;
-CUDA_GDV __cuDriverGetVersion = NULL;
-CUDA_GDI __cuInit = NULL;
-CUDA_GDG __cuDeviceGet = NULL;
-CUDA_GDA __cuDeviceGetAttribute = NULL;
-CUDA_GDN __cuDeviceGetName = NULL;
-CUDA_GDM __cuDeviceTotalMem = NULL;
-CUDA_GDCC __cuDeviceComputeCapability = NULL;
-CUDA_CC __cuCtxCreate = NULL;
-CUDA_CD __cuCtxDestroy = NULL;
-CUDA_MA __cuMemAlloc = NULL;
-CUDA_MF __cuMemFree = NULL;
-CUDA_MGI __cuMemGetInfo = NULL;
+CUDA_GDC p_cuDeviceGetCount = NULL;
+CUDA_GDV p_cuDriverGetVersion = NULL;
+CUDA_GDI p_cuInit = NULL;
+CUDA_GDG p_cuDeviceGet = NULL;
+CUDA_GDA p_cuDeviceGetAttribute = NULL;
+CUDA_GDN p_cuDeviceGetName = NULL;
+CUDA_GDM p_cuDeviceTotalMem = NULL;
+CUDA_GDCC p_cuDeviceComputeCapability = NULL;
+CUDA_CC p_cuCtxCreate = NULL;
+CUDA_CD p_cuCtxDestroy = NULL;
+CUDA_MA p_cuMemAlloc = NULL;
+CUDA_MF p_cuMemFree = NULL;
+CUDA_MGI p_cuMemGetInfo = NULL;
 #else
-int (*__cuInit)(unsigned int);
-int (*__cuDeviceGetCount)(int*);
-int (*__cuDriverGetVersion)(int*);
-int (*__cuDeviceGet)(int*, int);
-int (*__cuDeviceGetAttribute)(int*, int, int);
-int (*__cuDeviceGetName)(char*, int, int);
-int (*__cuDeviceTotalMem)(size_t*, int);
-int (*__cuDeviceComputeCapability)(int*, int*, int);
-int (*__cuCtxCreate)(void**, unsigned int, unsigned int);
-int (*__cuCtxDestroy)(void*);
-int (*__cuMemAlloc)(unsigned int*, size_t);
-int (*__cuMemFree)(unsigned int);
-int (*__cuMemGetInfo)(size_t*, size_t*);
+int (*p_cuInit)(unsigned int);
+int (*p_cuDeviceGetCount)(int*);
+int (*p_cuDriverGetVersion)(int*);
+int (*p_cuDeviceGet)(int*, int);
+int (*p_cuDeviceGetAttribute)(int*, int, int);
+int (*p_cuDeviceGetName)(char*, int, int);
+int (*p_cuDeviceTotalMem)(size_t*, int);
+int (*p_cuDeviceComputeCapability)(int*, int*, int);
+int (*p_cuCtxCreate)(void**, unsigned int, unsigned int);
+int (*p_cuCtxDestroy)(void*);
+int (*p_cuMemAlloc)(unsigned int*, size_t);
+int (*p_cuMemFree)(unsigned int);
+int (*p_cuMemGetInfo)(size_t*, size_t*);
 #endif
 
 // NVIDIA interfaces are documented here:
@@ -248,19 +248,19 @@ void COPROC_NVIDIA::get(
         warnings.push_back("No NVIDIA library found");
         return;
     }
-    __cuDeviceGetCount = (CUDA_GDC)GetProcAddress( cudalib, "cuDeviceGetCount" );
-    __cuDriverGetVersion = (CUDA_GDV)GetProcAddress( cudalib, "cuDriverGetVersion" );
-    __cuInit = (CUDA_GDI)GetProcAddress( cudalib, "cuInit" );
-    __cuDeviceGet = (CUDA_GDG)GetProcAddress( cudalib, "cuDeviceGet" );
-    __cuDeviceGetAttribute = (CUDA_GDA)GetProcAddress( cudalib, "cuDeviceGetAttribute" );
-    __cuDeviceGetName = (CUDA_GDN)GetProcAddress( cudalib, "cuDeviceGetName" );
-    __cuDeviceTotalMem = (CUDA_GDM)GetProcAddress( cudalib, "cuDeviceTotalMem" );
-    __cuDeviceComputeCapability = (CUDA_GDCC)GetProcAddress( cudalib, "cuDeviceComputeCapability" );
-    __cuCtxCreate = (CUDA_CC)GetProcAddress( cudalib, "cuCtxCreate" );
-    __cuCtxDestroy = (CUDA_CD)GetProcAddress( cudalib, "cuCtxDestroy" );
-    __cuMemAlloc = (CUDA_MA)GetProcAddress( cudalib, "cuMemAlloc" );
-    __cuMemFree = (CUDA_MF)GetProcAddress( cudalib, "cuMemFree" );
-    __cuMemGetInfo = (CUDA_MGI)GetProcAddress( cudalib, "cuMemGetInfo" );
+    p_cuDeviceGetCount = (CUDA_GDC)GetProcAddress( cudalib, "cuDeviceGetCount" );
+    p_cuDriverGetVersion = (CUDA_GDV)GetProcAddress( cudalib, "cuDriverGetVersion" );
+    p_cuInit = (CUDA_GDI)GetProcAddress( cudalib, "cuInit" );
+    p_cuDeviceGet = (CUDA_GDG)GetProcAddress( cudalib, "cuDeviceGet" );
+    p_cuDeviceGetAttribute = (CUDA_GDA)GetProcAddress( cudalib, "cuDeviceGetAttribute" );
+    p_cuDeviceGetName = (CUDA_GDN)GetProcAddress( cudalib, "cuDeviceGetName" );
+    p_cuDeviceTotalMem = (CUDA_GDM)GetProcAddress( cudalib, "cuDeviceTotalMem" );
+    p_cuDeviceComputeCapability = (CUDA_GDCC)GetProcAddress( cudalib, "cuDeviceComputeCapability" );
+    p_cuCtxCreate = (CUDA_CC)GetProcAddress( cudalib, "cuCtxCreate" );
+    p_cuCtxDestroy = (CUDA_CD)GetProcAddress( cudalib, "cuCtxDestroy" );
+    p_cuMemAlloc = (CUDA_MA)GetProcAddress( cudalib, "cuMemAlloc" );
+    p_cuMemFree = (CUDA_MF)GetProcAddress( cudalib, "cuMemFree" );
+    p_cuMemGetInfo = (CUDA_MGI)GetProcAddress( cudalib, "cuMemGetInfo" );
 
 #ifndef SIM
     NvAPI_Initialize();
@@ -297,65 +297,65 @@ void* cudalib = NULL;
         warnings.push_back(buf);
         return;
     }
-    __cuDeviceGetCount = (int(*)(int*)) dlsym(cudalib, "cuDeviceGetCount");
-    __cuDriverGetVersion = (int(*)(int*)) dlsym( cudalib, "cuDriverGetVersion" );
-    __cuInit = (int(*)(unsigned int)) dlsym( cudalib, "cuInit" );
-    __cuDeviceGet = (int(*)(int*, int)) dlsym( cudalib, "cuDeviceGet" );
-    __cuDeviceGetAttribute = (int(*)(int*, int, int)) dlsym( cudalib, "cuDeviceGetAttribute" );
-    __cuDeviceGetName = (int(*)(char*, int, int)) dlsym( cudalib, "cuDeviceGetName" );
-    __cuDeviceTotalMem = (int(*)(size_t*, int)) dlsym( cudalib, "cuDeviceTotalMem" );
-    __cuDeviceComputeCapability = (int(*)(int*, int*, int)) dlsym( cudalib, "cuDeviceComputeCapability" );
-    __cuCtxCreate = (int(*)(void**, unsigned int, unsigned int)) dlsym( cudalib, "cuCtxCreate" );
-    __cuCtxDestroy = (int(*)(void*)) dlsym( cudalib, "cuCtxDestroy" );
-    __cuMemAlloc = (int(*)(unsigned int*, size_t)) dlsym( cudalib, "cuMemAlloc" );
-    __cuMemFree = (int(*)(unsigned int)) dlsym( cudalib, "cuMemFree" );
-    __cuMemGetInfo = (int(*)(size_t*, size_t*)) dlsym( cudalib, "cuMemGetInfo" );
+    p_cuDeviceGetCount = (int(*)(int*)) dlsym(cudalib, "cuDeviceGetCount");
+    p_cuDriverGetVersion = (int(*)(int*)) dlsym( cudalib, "cuDriverGetVersion" );
+    p_cuInit = (int(*)(unsigned int)) dlsym( cudalib, "cuInit" );
+    p_cuDeviceGet = (int(*)(int*, int)) dlsym( cudalib, "cuDeviceGet" );
+    p_cuDeviceGetAttribute = (int(*)(int*, int, int)) dlsym( cudalib, "cuDeviceGetAttribute" );
+    p_cuDeviceGetName = (int(*)(char*, int, int)) dlsym( cudalib, "cuDeviceGetName" );
+    p_cuDeviceTotalMem = (int(*)(size_t*, int)) dlsym( cudalib, "cuDeviceTotalMem" );
+    p_cuDeviceComputeCapability = (int(*)(int*, int*, int)) dlsym( cudalib, "cuDeviceComputeCapability" );
+    p_cuCtxCreate = (int(*)(void**, unsigned int, unsigned int)) dlsym( cudalib, "cuCtxCreate" );
+    p_cuCtxDestroy = (int(*)(void*)) dlsym( cudalib, "cuCtxDestroy" );
+    p_cuMemAlloc = (int(*)(unsigned int*, size_t)) dlsym( cudalib, "cuMemAlloc" );
+    p_cuMemFree = (int(*)(unsigned int)) dlsym( cudalib, "cuMemFree" );
+    p_cuMemGetInfo = (int(*)(size_t*, size_t*)) dlsym( cudalib, "cuMemGetInfo" );
 #endif
 
-    if (!__cuDriverGetVersion) {
+    if (!p_cuDriverGetVersion) {
         warnings.push_back("cuDriverGetVersion() missing from NVIDIA library");
         goto leave;
     }
-    if (!__cuInit) {
+    if (!p_cuInit) {
         warnings.push_back("cuInit() missing from NVIDIA library");
         goto leave;
     }
-    if (!__cuDeviceGetCount) {
+    if (!p_cuDeviceGetCount) {
         warnings.push_back("cuDeviceGetCount() missing from NVIDIA library");
         goto leave;
     }
-    if (!__cuDeviceGet) {
+    if (!p_cuDeviceGet) {
         warnings.push_back("cuDeviceGet() missing from NVIDIA library");
         goto leave;
     }
-    if (!__cuDeviceGetAttribute) {
+    if (!p_cuDeviceGetAttribute) {
         warnings.push_back("cuDeviceGetAttribute() missing from NVIDIA library");
         goto leave;
     }
-    if (!__cuDeviceTotalMem) {
+    if (!p_cuDeviceTotalMem) {
         warnings.push_back("cuDeviceTotalMem() missing from NVIDIA library");
         goto leave;
     }
-    if (!__cuDeviceComputeCapability) {
+    if (!p_cuDeviceComputeCapability) {
         warnings.push_back("cuDeviceComputeCapability() missing from NVIDIA library");
         goto leave;
     }
-    if (!__cuMemAlloc) {
+    if (!p_cuMemAlloc) {
         warnings.push_back("cuMemAlloc() missing from NVIDIA library");
         goto leave;
     }
-    if (!__cuMemFree) {
+    if (!p_cuMemFree) {
         warnings.push_back("cuMemFree() missing from NVIDIA library");
         goto leave;
     }
 
-    retval = (*__cuInit)(0);
+    retval = (*p_cuInit)(0);
 #ifdef __APPLE__
     // If system is just booting, CUDA driver may not be ready yet
     if (retval) {
         if (get_system_uptime() < 300) {   // Retry only if system has been up for under 5 minutes
             for (int retryCount=0; retryCount<120; retryCount++) {
-                retval = (*__cuInit)(0);
+                retval = (*p_cuInit)(0);
                 if (!retval) break;
                 boinc_sleep(1.);
                 continue;
@@ -370,7 +370,7 @@ void* cudalib = NULL;
         goto leave;
     }
 
-    retval = (*__cuDriverGetVersion)(&cuda_version);
+    retval = (*p_cuDriverGetVersion)(&cuda_version);
     if (retval) {
         sprintf(buf, "cuDriverGetVersion() returned %d", retval);
         warnings.push_back(buf);
@@ -379,7 +379,7 @@ void* cudalib = NULL;
 
     have_cuda = true;
 
-    retval = (*__cuDeviceGetCount)(&cuda_ndevs);
+    retval = (*p_cuDeviceGetCount)(&cuda_ndevs);
     if (retval) {
         sprintf(buf, "cuDeviceGetCount() returned %d", retval);
         warnings.push_back(buf);
@@ -391,44 +391,44 @@ void* cudalib = NULL;
     for (j=0; j<cuda_ndevs; j++) {
         memset(&cc.prop, 0, sizeof(cc.prop));
         CUdevice device;
-        retval = (*__cuDeviceGet)(&device, j);
+        retval = (*p_cuDeviceGet)(&device, j);
         if (retval) {
             sprintf(buf, "cuDeviceGet(%d) returned %d", j, retval);
             warnings.push_back(buf);
             goto leave;
         }
-        (*__cuDeviceGetName)(cc.prop.name, 256, device);
+        (*p_cuDeviceGetName)(cc.prop.name, 256, device);
         if (retval) {
             sprintf(buf, "cuDeviceGetName(%d) returned %d", j, retval);
             warnings.push_back(buf);
             goto leave;
         }
-        (*__cuDeviceComputeCapability)(&cc.prop.major, &cc.prop.minor, device);
-        (*__cuDeviceTotalMem)(&global_mem, device);
+        (*p_cuDeviceComputeCapability)(&cc.prop.major, &cc.prop.minor, device);
+        (*p_cuDeviceTotalMem)(&global_mem, device);
         cc.prop.totalGlobalMem = (double) global_mem;
-        (*__cuDeviceGetAttribute)(&itemp, CU_DEVICE_ATTRIBUTE_SHARED_MEMORY_PER_BLOCK, device);
+        (*p_cuDeviceGetAttribute)(&itemp, CU_DEVICE_ATTRIBUTE_SHARED_MEMORY_PER_BLOCK, device);
         cc.prop.sharedMemPerBlock = (double) itemp;
-        (*__cuDeviceGetAttribute)(&cc.prop.regsPerBlock, CU_DEVICE_ATTRIBUTE_REGISTERS_PER_BLOCK, device);
-        (*__cuDeviceGetAttribute)(&cc.prop.warpSize, CU_DEVICE_ATTRIBUTE_WARP_SIZE, device);
-        (*__cuDeviceGetAttribute)(&itemp, CU_DEVICE_ATTRIBUTE_MAX_PITCH, device);
+        (*p_cuDeviceGetAttribute)(&cc.prop.regsPerBlock, CU_DEVICE_ATTRIBUTE_REGISTERS_PER_BLOCK, device);
+        (*p_cuDeviceGetAttribute)(&cc.prop.warpSize, CU_DEVICE_ATTRIBUTE_WARP_SIZE, device);
+        (*p_cuDeviceGetAttribute)(&itemp, CU_DEVICE_ATTRIBUTE_MAX_PITCH, device);
         cc.prop.memPitch = (double) itemp;
-        retval = (*__cuDeviceGetAttribute)(&cc.prop.maxThreadsPerBlock, CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK, device);
-        retval = (*__cuDeviceGetAttribute)(&cc.prop.maxThreadsDim[0], CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X, device);
-        (*__cuDeviceGetAttribute)(&cc.prop.maxThreadsDim[1], CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y, device);
-        (*__cuDeviceGetAttribute)(&cc.prop.maxThreadsDim[2], CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z, device);
-        (*__cuDeviceGetAttribute)(&cc.prop.maxGridSize[0], CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X, device);
-        (*__cuDeviceGetAttribute)(&cc.prop.maxGridSize[1], CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y, device);
-        (*__cuDeviceGetAttribute)(&cc.prop.maxGridSize[2], CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z, device);
-        (*__cuDeviceGetAttribute)(&cc.prop.clockRate, CU_DEVICE_ATTRIBUTE_CLOCK_RATE, device);
-        (*__cuDeviceGetAttribute)(&itemp, CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY, device);
+        retval = (*p_cuDeviceGetAttribute)(&cc.prop.maxThreadsPerBlock, CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK, device);
+        retval = (*p_cuDeviceGetAttribute)(&cc.prop.maxThreadsDim[0], CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X, device);
+        (*p_cuDeviceGetAttribute)(&cc.prop.maxThreadsDim[1], CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y, device);
+        (*p_cuDeviceGetAttribute)(&cc.prop.maxThreadsDim[2], CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z, device);
+        (*p_cuDeviceGetAttribute)(&cc.prop.maxGridSize[0], CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X, device);
+        (*p_cuDeviceGetAttribute)(&cc.prop.maxGridSize[1], CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y, device);
+        (*p_cuDeviceGetAttribute)(&cc.prop.maxGridSize[2], CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z, device);
+        (*p_cuDeviceGetAttribute)(&cc.prop.clockRate, CU_DEVICE_ATTRIBUTE_CLOCK_RATE, device);
+        (*p_cuDeviceGetAttribute)(&itemp, CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY, device);
         cc.prop.totalConstMem = (double) itemp;
-        (*__cuDeviceGetAttribute)(&itemp, CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT, device);
+        (*p_cuDeviceGetAttribute)(&itemp, CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT, device);
         cc.prop.textureAlignment = (double) itemp;
-        (*__cuDeviceGetAttribute)(&cc.prop.deviceOverlap, CU_DEVICE_ATTRIBUTE_GPU_OVERLAP, device);
-        (*__cuDeviceGetAttribute)(&cc.prop.multiProcessorCount, CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT, device);
-        (*__cuDeviceGetAttribute)(&cc.pci_info.bus_id, CU_DEVICE_ATTRIBUTE_PCI_BUS_ID, device);
-        (*__cuDeviceGetAttribute)(&cc.pci_info.device_id, CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID, device);
-        (*__cuDeviceGetAttribute)(&cc.pci_info.domain_id, CU_DEVICE_ATTRIBUTE_PCI_DOMAIN_ID, device);
+        (*p_cuDeviceGetAttribute)(&cc.prop.deviceOverlap, CU_DEVICE_ATTRIBUTE_GPU_OVERLAP, device);
+        (*p_cuDeviceGetAttribute)(&cc.prop.multiProcessorCount, CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT, device);
+        (*p_cuDeviceGetAttribute)(&cc.pci_info.bus_id, CU_DEVICE_ATTRIBUTE_PCI_BUS_ID, device);
+        (*p_cuDeviceGetAttribute)(&cc.pci_info.device_id, CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID, device);
+        (*p_cuDeviceGetAttribute)(&cc.pci_info.domain_id, CU_DEVICE_ATTRIBUTE_PCI_DOMAIN_ID, device);
         if (cc.prop.major <= 0) continue;  // major == 0 means emulation
         if (cc.prop.major > 100) continue;  // e.g. 9999 is an error
 #if defined(_WIN32) && !defined(SIM)
@@ -539,24 +539,24 @@ static void get_available_nvidia_ram(COPROC_NVIDIA &cc, vector<string>& warnings
     char buf[256];
     
     cc.available_ram = cc.prop.totalGlobalMem;
-    if (!__cuDeviceGet) {
+    if (!p_cuDeviceGet) {
         warnings.push_back("cuDeviceGet() missing from NVIDIA library");
         return;
     }
-    if (!__cuCtxCreate) {
+    if (!p_cuCtxCreate) {
         warnings.push_back("cuCtxCreate() missing from NVIDIA library");
         return;
     }
-    if (!__cuCtxDestroy) {
+    if (!p_cuCtxDestroy) {
         warnings.push_back("cuCtxDestroy() missing from NVIDIA library");
         return;
     }
-    if (!__cuMemGetInfo) {
+    if (!p_cuMemGetInfo) {
         warnings.push_back("cuMemGetInfo() missing from NVIDIA library");
         return;
     }
 
-    retval = (*__cuDeviceGet)(&device, cc.device_num);
+    retval = (*p_cuDeviceGet)(&device, cc.device_num);
     if (retval) {
         snprintf(buf, sizeof(buf),
             "[coproc] cuDeviceGet(%d) returned %d", cc.device_num, retval
@@ -564,7 +564,7 @@ static void get_available_nvidia_ram(COPROC_NVIDIA &cc, vector<string>& warnings
         warnings.push_back(buf);
         return;
     }
-    retval = (*__cuCtxCreate)(&ctx, 0, device);
+    retval = (*p_cuCtxCreate)(&ctx, 0, device);
     if (retval) {
         snprintf(buf, sizeof(buf),
             "[coproc] cuCtxCreate(%d) returned %d", cc.device_num, retval
@@ -572,16 +572,16 @@ static void get_available_nvidia_ram(COPROC_NVIDIA &cc, vector<string>& warnings
         warnings.push_back(buf);
         return;
     }
-    retval = (*__cuMemGetInfo)(&memfree, &memtotal);
+    retval = (*p_cuMemGetInfo)(&memfree, &memtotal);
     if (retval) {
         snprintf(buf, sizeof(buf),
             "[coproc] cuMemGetInfo(%d) returned %d", cc.device_num, retval
         );
         warnings.push_back(buf);
-        (*__cuCtxDestroy)(ctx);
+        (*p_cuCtxDestroy)(ctx);
         return;
     }
-    (*__cuCtxDestroy)(ctx);
+    (*p_cuCtxDestroy)(ctx);
     cc.available_ram = (double) memfree;
 }
 
@@ -602,11 +602,11 @@ static void get_available_nvidia_ram(COPROC_NVIDIA &cc, vector<string>& warnings
 bool COPROC_NVIDIA::check_running_graphics_app() {
     int retval, j;
     bool change = false;
-    if (!__cuDeviceGet) {
+    if (!p_cuDeviceGet) {
         warnings.push_back("cuDeviceGet() missing from NVIDIA library");
         return;
     }
-    if (!__cuDeviceGetAttribute) {
+    if (!p_cuDeviceGetAttribute) {
         warnings.push_back("cuDeviceGetAttribute() missing from NVIDIA library");
         return;
     }
@@ -614,9 +614,9 @@ bool COPROC_NVIDIA::check_running_graphics_app() {
     for (j=0; j<count; j++) {
         bool new_val = true;
         int device, kernel_timeout;
-        retval = (*__cuDeviceGet)(&device, j);
+        retval = (*p_cuDeviceGet)(&device, j);
         if (!retval) {
-            retval = (*__cuDeviceGetAttribute)(&kernel_timeout, CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT, device);
+            retval = (*p_cuDeviceGetAttribute)(&kernel_timeout, CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT, device);
             if (!retval && !kernel_timeout) {
                 new_val = false;
             }
diff --git a/client/gpu_opencl.cpp b/client/gpu_opencl.cpp
index 18b93200eb..154009b83e 100644
--- a/client/gpu_opencl.cpp
+++ b/client/gpu_opencl.cpp
@@ -57,35 +57,35 @@ typedef cl_int (__stdcall *CL_PLATFORMINFO) (cl_platform_id, cl_platform_info, s
 typedef cl_int (__stdcall *CL_DEVICEIDS)(cl_platform_id, cl_device_type, cl_uint, cl_device_id*, cl_uint*);
 typedef cl_int (__stdcall *CL_INFO) (cl_device_id, cl_device_info, size_t, void*, size_t*);
 
-CL_PLATFORMIDS  __clGetPlatformIDs = NULL;
-CL_PLATFORMINFO __clGetPlatformInfo = NULL;
-CL_DEVICEIDS    __clGetDeviceIDs = NULL;
-CL_INFO         __clGetDeviceInfo = NULL;
+CL_PLATFORMIDS  p_clGetPlatformIDs = NULL;
+CL_PLATFORMINFO p_clGetPlatformInfo = NULL;
+CL_DEVICEIDS    p_clGetDeviceIDs = NULL;
+CL_INFO         p_clGetDeviceInfo = NULL;
 
 #else
 
 void* opencl_lib = NULL;
 
-cl_int (*__clGetPlatformIDs)(
+cl_int (*p_clGetPlatformIDs)(
     cl_uint,         // num_entries,
     cl_platform_id*, // platforms
     cl_uint *        // num_platforms
 );
-cl_int (*__clGetPlatformInfo)(
+cl_int (*p_clGetPlatformInfo)(
     cl_platform_id,  // platform
     cl_platform_info, // param_name
     size_t,          // param_value_size
     void*,           // param_value
     size_t*          // param_value_size_ret
 );
-cl_int (*__clGetDeviceIDs)(
+cl_int (*p_clGetDeviceIDs)(
     cl_platform_id,  // platform
     cl_device_type,  // device_type
     cl_uint,         // num_entries
     cl_device_id*,   // devices
     cl_uint*         // num_devices
 );
-cl_int (*__clGetDeviceInfo)(
+cl_int (*p_clGetDeviceInfo)(
     cl_device_id,    // device
     cl_device_info,  // param_name
     size_t,          // param_value_size
@@ -175,10 +175,10 @@ void COPROCS::get_opencl(
         return;
     }
 
-    __clGetPlatformIDs = (CL_PLATFORMIDS)GetProcAddress( opencl_lib, "clGetPlatformIDs" );
-    __clGetPlatformInfo = (CL_PLATFORMINFO)GetProcAddress( opencl_lib, "clGetPlatformInfo" );
-    __clGetDeviceIDs = (CL_DEVICEIDS)GetProcAddress( opencl_lib, "clGetDeviceIDs" );
-    __clGetDeviceInfo = (CL_INFO)GetProcAddress( opencl_lib, "clGetDeviceInfo" );
+    p_clGetPlatformIDs = (CL_PLATFORMIDS)GetProcAddress( opencl_lib, "clGetPlatformIDs" );
+    p_clGetPlatformInfo = (CL_PLATFORMINFO)GetProcAddress( opencl_lib, "clGetPlatformInfo" );
+    p_clGetDeviceIDs = (CL_DEVICEIDS)GetProcAddress( opencl_lib, "clGetDeviceIDs" );
+    p_clGetDeviceInfo = (CL_INFO)GetProcAddress( opencl_lib, "clGetDeviceInfo" );
 #else
 #ifdef __APPLE__
     opencl_lib = dlopen("/System/Library/Frameworks/OpenCL.framework/Versions/Current/OpenCL", RTLD_NOW);
@@ -193,30 +193,30 @@ void COPROCS::get_opencl(
         warnings.push_back(buf);
         return;
     }
-    __clGetPlatformIDs = (cl_int(*)(cl_uint, cl_platform_id*, cl_uint*)) dlsym( opencl_lib, "clGetPlatformIDs" );
-    __clGetPlatformInfo = (cl_int(*)(cl_platform_id, cl_platform_info, size_t, void*, size_t*)) dlsym( opencl_lib, "clGetPlatformInfo" );
-    __clGetDeviceIDs = (cl_int(*)(cl_platform_id, cl_device_type, cl_uint, cl_device_id*, cl_uint*)) dlsym( opencl_lib, "clGetDeviceIDs" );
-    __clGetDeviceInfo = (cl_int(*)(cl_device_id, cl_device_info, size_t, void*, size_t*)) dlsym( opencl_lib, "clGetDeviceInfo" );
+    p_clGetPlatformIDs = (cl_int(*)(cl_uint, cl_platform_id*, cl_uint*)) dlsym( opencl_lib, "clGetPlatformIDs" );
+    p_clGetPlatformInfo = (cl_int(*)(cl_platform_id, cl_platform_info, size_t, void*, size_t*)) dlsym( opencl_lib, "clGetPlatformInfo" );
+    p_clGetDeviceIDs = (cl_int(*)(cl_platform_id, cl_device_type, cl_uint, cl_device_id*, cl_uint*)) dlsym( opencl_lib, "clGetDeviceIDs" );
+    p_clGetDeviceInfo = (cl_int(*)(cl_device_id, cl_device_info, size_t, void*, size_t*)) dlsym( opencl_lib, "clGetDeviceInfo" );
 #endif
 
-    if (!__clGetPlatformIDs) {
+    if (!p_clGetPlatformIDs) {
         warnings.push_back("clGetPlatformIDs() missing from OpenCL library");
         goto leave;
     }
-    if (!__clGetPlatformInfo) {
+    if (!p_clGetPlatformInfo) {
         warnings.push_back("clGetPlatformInfo() missing from OpenCL library");
         goto leave;
     }
-    if (!__clGetDeviceIDs) {
+    if (!p_clGetDeviceIDs) {
         warnings.push_back("clGetDeviceIDs() missing from OpenCL library");
         goto leave;
     }
-    if (!__clGetDeviceInfo) {
+    if (!p_clGetDeviceInfo) {
         warnings.push_back("clGetDeviceInfo() missing from OpenCL library");
         goto leave;
     }
 
-    ciErrNum = (*__clGetPlatformIDs)(MAX_OPENCL_PLATFORMS, platforms, &num_platforms);
+    ciErrNum = (*p_clGetPlatformIDs)(MAX_OPENCL_PLATFORMS, platforms, &num_platforms);
     if ((ciErrNum != CL_SUCCESS) || (num_platforms == 0)) {
         warnings.push_back("clGetPlatformIDs() failed to return any OpenCL platforms");
         goto leave;
@@ -236,7 +236,7 @@ void COPROCS::get_opencl(
     }
 
     for (platform_index=0; platform_index<num_platforms; ++platform_index) {
-        ciErrNum = (*__clGetPlatformInfo)(
+        ciErrNum = (*p_clGetPlatformInfo)(
             platforms[platform_index], CL_PLATFORM_VERSION,
             sizeof(platform_version), &platform_version, NULL
         );
@@ -249,7 +249,7 @@ void COPROCS::get_opencl(
             continue;
         }
 
-        ciErrNum = (*__clGetPlatformInfo)(
+        ciErrNum = (*p_clGetPlatformInfo)(
             platforms[platform_index], CL_PLATFORM_VENDOR,
             sizeof(platform_vendor), &platform_vendor, NULL
         );
@@ -263,7 +263,7 @@ void COPROCS::get_opencl(
 
         //////////// CPU //////////////
 
-        ciErrNum = (*__clGetDeviceIDs)(
+        ciErrNum = (*p_clGetDeviceIDs)(
             platforms[platform_index], (CL_DEVICE_TYPE_CPU),
             MAX_COPROC_INSTANCES, devices, &num_devices
         );
@@ -301,7 +301,7 @@ void COPROCS::get_opencl(
 
         //////////// GPUs and Accelerators //////////////
         
-        ciErrNum = (*__clGetDeviceIDs)(
+        ciErrNum = (*p_clGetDeviceIDs)(
             platforms[platform_index],
             (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR),
             MAX_COPROC_INSTANCES, devices, &num_devices
@@ -666,7 +666,7 @@ cl_int COPROCS::get_opencl_info(
     cl_int ciErrNum;
     char buf[256];
 
-    ciErrNum = (*__clGetDeviceInfo)(prop.device_id, CL_DEVICE_NAME, sizeof(prop.name), prop.name, NULL);
+    ciErrNum = (*p_clGetDeviceInfo)(prop.device_id, CL_DEVICE_NAME, sizeof(prop.name), prop.name, NULL);
     if ((ciErrNum != CL_SUCCESS) || (prop.name[0] == 0)) {
         snprintf(buf, sizeof(buf),
             "clGetDeviceInfo failed to get name for device %d",
@@ -676,7 +676,7 @@ cl_int COPROCS::get_opencl_info(
         return ciErrNum;
     }
 
-    ciErrNum = (*__clGetDeviceInfo)(prop.device_id, CL_DEVICE_VENDOR, sizeof(prop.vendor), prop.vendor, NULL);
+    ciErrNum = (*p_clGetDeviceInfo)(prop.device_id, CL_DEVICE_VENDOR, sizeof(prop.vendor), prop.vendor, NULL);
     if ((ciErrNum != CL_SUCCESS) || (prop.vendor[0] == 0)) {
         snprintf(buf, sizeof(buf),
             "clGetDeviceInfo failed to get vendor for device %d",
@@ -686,7 +686,7 @@ cl_int COPROCS::get_opencl_info(
         return ciErrNum;
     }
 
-    ciErrNum = (*__clGetDeviceInfo)(prop.device_id, CL_DEVICE_VENDOR_ID, sizeof(prop.vendor_id), &prop.vendor_id, NULL);
+    ciErrNum = (*p_clGetDeviceInfo)(prop.device_id, CL_DEVICE_VENDOR_ID, sizeof(prop.vendor_id), &prop.vendor_id, NULL);
     if (ciErrNum != CL_SUCCESS) {
         snprintf(buf, sizeof(buf),
             "clGetDeviceInfo failed to get vendor ID for device %d",
@@ -696,7 +696,7 @@ cl_int COPROCS::get_opencl_info(
         return ciErrNum;
     }
 
-    ciErrNum = (*__clGetDeviceInfo)(prop.device_id, CL_DEVICE_AVAILABLE, sizeof(prop.available), &prop.available, NULL);
+    ciErrNum = (*p_clGetDeviceInfo)(prop.device_id, CL_DEVICE_AVAILABLE, sizeof(prop.available), &prop.available, NULL);
     if (ciErrNum != CL_SUCCESS) {
         snprintf(buf, sizeof(buf),
             "clGetDeviceInfo failed to get availability for device %d",
@@ -706,7 +706,7 @@ cl_int COPROCS::get_opencl_info(
         return ciErrNum;
     }
 
-    ciErrNum = (*__clGetDeviceInfo)(
+    ciErrNum = (*p_clGetDeviceInfo)(
         prop.device_id, CL_DEVICE_HALF_FP_CONFIG,
         sizeof(prop.half_fp_config), &prop.half_fp_config, NULL
     );
@@ -723,7 +723,7 @@ cl_int COPROCS::get_opencl_info(
         }
     }
 
-    ciErrNum = (*__clGetDeviceInfo)(
+    ciErrNum = (*p_clGetDeviceInfo)(
         prop.device_id, CL_DEVICE_SINGLE_FP_CONFIG,
         sizeof(prop.single_fp_config), &prop.single_fp_config, NULL
     );
@@ -736,7 +736,7 @@ cl_int COPROCS::get_opencl_info(
         return ciErrNum;
     }
 
-    ciErrNum = (*__clGetDeviceInfo)(
+    ciErrNum = (*p_clGetDeviceInfo)(
         prop.device_id, CL_DEVICE_DOUBLE_FP_CONFIG,
         sizeof(prop.double_fp_config), &prop.double_fp_config, NULL
     );
@@ -753,7 +753,7 @@ cl_int COPROCS::get_opencl_info(
         }
     }
 
-    ciErrNum = (*__clGetDeviceInfo)(
+    ciErrNum = (*p_clGetDeviceInfo)(
         prop.device_id, CL_DEVICE_ENDIAN_LITTLE, sizeof(prop.endian_little),
         &prop.endian_little, NULL
     );
@@ -766,7 +766,7 @@ cl_int COPROCS::get_opencl_info(
         return ciErrNum;
     }
 
-    ciErrNum = (*__clGetDeviceInfo)(
+    ciErrNum = (*p_clGetDeviceInfo)(
         prop.device_id, CL_DEVICE_EXECUTION_CAPABILITIES,
         sizeof(prop.execution_capabilities), &prop.execution_capabilities, NULL
     );
@@ -779,7 +779,7 @@ cl_int COPROCS::get_opencl_info(
         return ciErrNum;
     }
 
-    ciErrNum = (*__clGetDeviceInfo)(
+    ciErrNum = (*p_clGetDeviceInfo)(
         prop.device_id, CL_DEVICE_EXTENSIONS, sizeof(prop.extensions),
         prop.extensions, NULL
     );
@@ -792,7 +792,7 @@ cl_int COPROCS::get_opencl_info(
         return ciErrNum;
     }
 
-    ciErrNum = (*__clGetDeviceInfo)(
+    ciErrNum = (*p_clGetDeviceInfo)(
         prop.device_id, CL_DEVICE_GLOBAL_MEM_SIZE,
         sizeof(prop.global_mem_size), &prop.global_mem_size, NULL
     );
@@ -805,7 +805,7 @@ cl_int COPROCS::get_opencl_info(
         return ciErrNum;
     }
 
-    ciErrNum = (*__clGetDeviceInfo)(
+    ciErrNum = (*p_clGetDeviceInfo)(
         prop.device_id, CL_DEVICE_LOCAL_MEM_SIZE,
         sizeof(prop.local_mem_size), &prop.local_mem_size, NULL
     );
@@ -818,7 +818,7 @@ cl_int COPROCS::get_opencl_info(
         return ciErrNum;
     }
 
-    ciErrNum = (*__clGetDeviceInfo)(
+    ciErrNum = (*p_clGetDeviceInfo)(
         prop.device_id, CL_DEVICE_MAX_CLOCK_FREQUENCY,
         sizeof(prop.max_clock_frequency), &prop.max_clock_frequency, NULL
     );
@@ -831,7 +831,7 @@ cl_int COPROCS::get_opencl_info(
         return ciErrNum;
     }
 
-    ciErrNum = (*__clGetDeviceInfo)(
+    ciErrNum = (*p_clGetDeviceInfo)(
         prop.device_id, CL_DEVICE_MAX_COMPUTE_UNITS,
         sizeof(prop.max_compute_units), &prop.max_compute_units, NULL
     );
@@ -844,7 +844,7 @@ cl_int COPROCS::get_opencl_info(
         return ciErrNum;
     }
 
-    ciErrNum = (*__clGetDeviceInfo)(prop.device_id, CL_DEVICE_VERSION, sizeof(prop.opencl_device_version), prop.opencl_device_version, NULL);
+    ciErrNum = (*p_clGetDeviceInfo)(prop.device_id, CL_DEVICE_VERSION, sizeof(prop.opencl_device_version), prop.opencl_device_version, NULL);
     if (ciErrNum != CL_SUCCESS) {
         snprintf(buf, sizeof(buf),
             "clGetDeviceInfo failed to get OpenCL version supported by device %d",
@@ -854,7 +854,7 @@ cl_int COPROCS::get_opencl_info(
         return ciErrNum;
     }
 
-    ciErrNum = (*__clGetDeviceInfo)(prop.device_id, CL_DRIVER_VERSION, sizeof(prop.opencl_driver_version), prop.opencl_driver_version, NULL);
+    ciErrNum = (*p_clGetDeviceInfo)(prop.device_id, CL_DRIVER_VERSION, sizeof(prop.opencl_driver_version), prop.opencl_driver_version, NULL);
     if (ciErrNum != CL_SUCCESS) {
         snprintf(buf, sizeof(buf),
             "clGetDeviceInfo failed to get OpenCL driver version for device %d",
@@ -867,7 +867,7 @@ cl_int COPROCS::get_opencl_info(
     // Nvidia Specific Extensions
     if (strstr(prop.extensions, "cl_nv_device_attribute_query") != NULL) {
 
-        ciErrNum = (*__clGetDeviceInfo)(prop.device_id, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof(prop.nv_compute_capability_major), &prop.nv_compute_capability_major, NULL);
+        ciErrNum = (*p_clGetDeviceInfo)(prop.device_id, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof(prop.nv_compute_capability_major), &prop.nv_compute_capability_major, NULL);
         if (ciErrNum != CL_SUCCESS) {
             snprintf(buf, sizeof(buf),
                 "clGetDeviceInfo failed to get CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV for device %d",
@@ -877,7 +877,7 @@ cl_int COPROCS::get_opencl_info(
             return ciErrNum;
         }
 
-        ciErrNum = (*__clGetDeviceInfo)(prop.device_id, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof(prop.nv_compute_capability_minor), &prop.nv_compute_capability_minor, NULL);
+        ciErrNum = (*p_clGetDeviceInfo)(prop.device_id, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof(prop.nv_compute_capability_minor), &prop.nv_compute_capability_minor, NULL);
         if (ciErrNum != CL_SUCCESS) {
             snprintf(buf, sizeof(buf),
                 "clGetDeviceInfo failed to get CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV for device %d",
@@ -892,7 +892,7 @@ cl_int COPROCS::get_opencl_info(
     // AMD Specific Extensions
     if (strstr(prop.extensions, "cl_amd_device_attribute_query") != NULL) {
 
-        ciErrNum = (*__clGetDeviceInfo)(prop.device_id, CL_DEVICE_BOARD_NAME_AMD, sizeof(buf), buf, NULL);
+        ciErrNum = (*p_clGetDeviceInfo)(prop.device_id, CL_DEVICE_BOARD_NAME_AMD, sizeof(buf), buf, NULL);
         if (strlen(buf) && ciErrNum == CL_SUCCESS) {
             safe_strcpy(prop.name, buf);
         } else if (ciErrNum != CL_SUCCESS) {
@@ -904,7 +904,7 @@ cl_int COPROCS::get_opencl_info(
             return ciErrNum;
         }
     
-        ciErrNum = (*__clGetDeviceInfo)(prop.device_id, CL_DEVICE_SIMD_PER_COMPUTE_UNIT_AMD, sizeof(prop.amd_simd_per_compute_unit), &prop.amd_simd_per_compute_unit, NULL);
+        ciErrNum = (*p_clGetDeviceInfo)(prop.device_id, CL_DEVICE_SIMD_PER_COMPUTE_UNIT_AMD, sizeof(prop.amd_simd_per_compute_unit), &prop.amd_simd_per_compute_unit, NULL);
         if (ciErrNum != CL_SUCCESS) {
             snprintf(buf, sizeof(buf),
                 "clGetDeviceInfo failed to get CL_DEVICE_SIMD_PER_COMPUTE_UNIT_AMD for device %d",
@@ -914,7 +914,7 @@ cl_int COPROCS::get_opencl_info(
             return ciErrNum;
         }
 
-        ciErrNum = (*__clGetDeviceInfo)(prop.device_id, CL_DEVICE_SIMD_WIDTH_AMD, sizeof(prop.amd_simd_width), &prop.amd_simd_width, NULL);
+        ciErrNum = (*p_clGetDeviceInfo)(prop.device_id, CL_DEVICE_SIMD_WIDTH_AMD, sizeof(prop.amd_simd_width), &prop.amd_simd_width, NULL);
         if (ciErrNum != CL_SUCCESS) {
             snprintf(buf, sizeof(buf),
                 "clGetDeviceInfo failed to get CL_DEVICE_SIMD_WIDTH_AMD for device %d",
@@ -924,7 +924,7 @@ cl_int COPROCS::get_opencl_info(
             return ciErrNum;
         }
 
-        ciErrNum = (*__clGetDeviceInfo)(prop.device_id, CL_DEVICE_SIMD_INSTRUCTION_WIDTH_AMD, sizeof(prop.amd_simd_instruction_width), &prop.amd_simd_instruction_width, NULL);
+        ciErrNum = (*p_clGetDeviceInfo)(prop.device_id, CL_DEVICE_SIMD_INSTRUCTION_WIDTH_AMD, sizeof(prop.amd_simd_instruction_width), &prop.amd_simd_instruction_width, NULL);
         if (ciErrNum != CL_SUCCESS) {
             snprintf(buf, sizeof(buf),
                 "clGetDeviceInfo failed to get CL_DEVICE_SIMD_INSTRUCTION_WIDTH_AMD for device %d",