diff --git a/benchmarks/opencl/BlackScholes/BlackScholes.cl b/benchmarks/opencl/BlackScholes/BlackScholes.cl new file mode 100644 index 00000000..e094e57e --- /dev/null +++ b/benchmarks/opencl/BlackScholes/BlackScholes.cl @@ -0,0 +1,101 @@ +/* + * Copyright 1993-2010 NVIDIA Corporation. All rights reserved. + * + * Please refer to the NVIDIA end user license agreement (EULA) associated + * with this source code for terms and conditions that govern your use of + * this software. Any use, reproduction, disclosure, or distribution of + * this software and related documentation outside the terms of the EULA + * is strictly prohibited. + * + */ + +#if(0) + #define EXP(a) native_exp(a) + #define LOG(a) native_log(a) + #define SQRT(a) native_sqrt(a) +#else + #define EXP(a) exp(a) + #define LOG(a) log(a) + #define SQRT(a) sqrt(a) +#endif + + +/////////////////////////////////////////////////////////////////////////////// +// Predefine functions to avoid bug in OpenCL compiler on Mac OSX 10.7 systems +/////////////////////////////////////////////////////////////////////////////// +float CND(float d); +void BlackScholesBody(__global float *call, __global float *put, float S, + float X, float T, float R, float V); + +/////////////////////////////////////////////////////////////////////////////// +// Rational approximation of cumulative normal distribution function +/////////////////////////////////////////////////////////////////////////////// +float CND(float d){ + const float A1 = 0.31938153f; + const float A2 = -0.356563782f; + const float A3 = 1.781477937f; + const float A4 = -1.821255978f; + const float A5 = 1.330274429f; + const float RSQRT2PI = 0.39894228040143267793994605993438f; + + float + K = 1.0f / (1.0f + 0.2316419f * fabs(d)); + + float + cnd = RSQRT2PI * EXP(- 0.5f * d * d) * + (K * (A1 + K * (A2 + K * (A3 + K * (A4 + K * A5))))); + + if(d > 0) + cnd = 1.0f - cnd; + + return cnd; +} + + +/////////////////////////////////////////////////////////////////////////////// +// Black-Scholes formula for both call and put +/////////////////////////////////////////////////////////////////////////////// +void BlackScholesBody( + __global float *call, //Call option price + __global float *put, //Put option price + float S, //Current stock price + float X, //Option strike price + float T, //Option years + float R, //Riskless rate of return + float V //Stock volatility +){ + float sqrtT = SQRT(T); + float d1 = (LOG(S / X) + (R + 0.5f * V * V) * T) / (V * sqrtT); + float d2 = d1 - V * sqrtT; + float CNDD1 = CND(d1); + float CNDD2 = CND(d2); + + //Calculate Call and Put simultaneously + float expRT = EXP(- R * T); + *call = (S * CNDD1 - X * expRT * CNDD2); + *put = (X * expRT * (1.0f - CNDD2) - S * (1.0f - CNDD1)); +} + + + +__kernel void BlackScholes( + __global float *d_Call, //Call option price + __global float *d_Put, //Put option price + __global float *d_S, //Current stock price + __global float *d_X, //Option strike price + __global float *d_T, //Option years + float R, //Riskless rate of return + float V, //Stock volatility + unsigned int optN +){ + for(unsigned int opt = get_global_id(0); opt < optN; opt += get_global_size(0)) + BlackScholesBody( + &d_Call[opt], + &d_Put[opt], + d_S[opt], + d_X[opt], + d_T[opt], + R, + V + ); +} diff --git a/benchmarks/opencl/BlackScholes/main.cpp b/benchmarks/opencl/BlackScholes/main.cpp new file mode 100644 index 00000000..0ae600b5 --- /dev/null +++ b/benchmarks/opencl/BlackScholes/main.cpp @@ -0,0 +1,248 @@ +/* + * Copyright 1993-2010 NVIDIA Corporation. All rights reserved. + * + * Please refer to the NVIDIA end user license agreement (EULA) associated + * with this source code for terms and conditions that govern your use of + * this software. Any use, reproduction, disclosure, or distribution of + * this software and related documentation outside the terms of the EULA + * is strictly prohibited. + * + */ + +// standard utilities and systems includes +#include +#include +#include "oclBlackScholes_common.h" + +//////////////////////////////////////////////////////////////////////////////// +// Helper functions +//////////////////////////////////////////////////////////////////////////////// +double executionTime(cl_event &event){ + cl_ulong start, end; + + clGetEventProfilingInfo(event, CL_PROFILING_COMMAND_END, sizeof(cl_ulong), &end, NULL); + clGetEventProfilingInfo(event, CL_PROFILING_COMMAND_START, sizeof(cl_ulong), &start, NULL); + + return (double)1.0e-9 * (end - start); // convert nanoseconds to seconds on return +} + +//////////////////////////////////////////////////////////////////////////////// +// Random float helper +//////////////////////////////////////////////////////////////////////////////// +float randFloat(float low, float high){ + float t = (float)rand() / (float)RAND_MAX; + return (1.0f - t) * low + t * high; +} + +//////////////////////////////////////////////////////////////////////////////// +// Main program +//////////////////////////////////////////////////////////////////////////////// +int main(int argc, char **argv) +{ + cl_platform_id cpPlatform; //OpenCL platform + cl_device_id* cdDevices = NULL; //OpenCL devices list (array) + cl_context cxGPUContext; //OpenCL context + cl_command_queue cqCommandQueue; //OpenCL command que + cl_mem //OpenCL memory buffer objects + d_Call, + d_Put, + d_S, + d_X, + d_T; + + cl_int ciErrNum; + + float + *h_CallCPU, + *h_PutCPU, + *h_CallGPU, + *h_PutGPU, + *h_S, + *h_X, + *h_T; + + const unsigned int optionCount = 4000000; + const float R = 0.02f; + const float V = 0.30f; + + shrQAStart(argc, argv); + + // Get the NVIDIA platform + ciErrNum = oclGetPlatformID(&cpPlatform); + //oclCheckErrorEX(ciErrNum, CL_SUCCESS, NULL); + shrLog("clGetPlatformID...\n"); + + //Get all the devices + cl_uint uiNumDevices = 0; // Number of devices available + cl_uint uiTargetDevice = 0; // Default Device to compute on + cl_uint uiNumComputeUnits; // Number of compute units (SM's on NV GPU) + shrLog("Get the Device info and select Device...\n"); + ciErrNum = clGetDeviceIDs(cpPlatform, CL_DEVICE_TYPE_DEFAULT, 0, NULL, &uiNumDevices); + //oclCheckErrorEX(ciErrNum, CL_SUCCESS, NULL); + cdDevices = (cl_device_id *)malloc(uiNumDevices * sizeof(cl_device_id) ); + ciErrNum = clGetDeviceIDs(cpPlatform, CL_DEVICE_TYPE_DEFAULT, uiNumDevices, cdDevices, NULL); + //oclCheckErrorEX(ciErrNum, CL_SUCCESS, NULL); + + // Get command line device options and config accordingly + shrLog(" # of Devices Available = %u\n", uiNumDevices); + if(shrGetCmdLineArgumentu(argc, (const char**)argv, "device", &uiTargetDevice)== shrTRUE) + { + uiTargetDevice = CLAMP(uiTargetDevice, 0, (uiNumDevices - 1)); + } + shrLog(" Using Device %u: ", uiTargetDevice); + oclPrintDevName(LOGBOTH, cdDevices[uiTargetDevice]); + ciErrNum = clGetDeviceInfo(cdDevices[uiTargetDevice], CL_DEVICE_MAX_COMPUTE_UNITS, sizeof(uiNumComputeUnits), &uiNumComputeUnits, NULL); + //oclCheckErrorEX(ciErrNum, CL_SUCCESS, NULL); + shrLog("\n # of Compute Units = %u\n", uiNumComputeUnits); + + // set logfile name and start logs + shrSetLogFileName ("oclBlackScholes.txt"); + shrLog("%s Starting...\n\n", argv[0]); + + shrLog("Allocating and initializing host memory...\n"); + h_CallCPU = (float *)malloc(optionCount * sizeof(float)); + h_PutCPU = (float *)malloc(optionCount * sizeof(float)); + h_CallGPU = (float *)malloc(optionCount * sizeof(float)); + h_PutGPU = (float *)malloc(optionCount * sizeof(float)); + h_S = (float *)malloc(optionCount * sizeof(float)); + h_X = (float *)malloc(optionCount * sizeof(float)); + h_T = (float *)malloc(optionCount * sizeof(float)); + + srand(2009); + for(unsigned int i = 0; i < optionCount; i++){ + h_CallCPU[i] = -1.0f; + h_PutCPU[i] = -1.0f; + h_S[i] = randFloat(5.0f, 30.0f); + h_X[i] = randFloat(1.0f, 100.0f); + h_T[i] = randFloat(0.25f, 10.0f); + } + + shrLog("Initializing OpenCL...\n"); + // Get the NVIDIA platform + ciErrNum = oclGetPlatformID(&cpPlatform); + //oclCheckError(ciErrNum, CL_SUCCESS); + + // Get a GPU device + ciErrNum = clGetDeviceIDs(cpPlatform, CL_DEVICE_TYPE_DEFAULT, 1, &cdDevices[uiTargetDevice], NULL); + //oclCheckError(ciErrNum, CL_SUCCESS); + + // Create the context + cxGPUContext = clCreateContext(0, 1, &cdDevices[uiTargetDevice], NULL, NULL, &ciErrNum); + //oclCheckError(ciErrNum, CL_SUCCESS); + + //Create a command-queue + cqCommandQueue = clCreateCommandQueue(cxGPUContext, cdDevices[uiTargetDevice], CL_QUEUE_PROFILING_ENABLE, &ciErrNum); + //oclCheckError(ciErrNum, CL_SUCCESS); + + shrLog("Creating OpenCL memory objects...\n"); + d_Call = clCreateBuffer(cxGPUContext, CL_MEM_READ_WRITE, optionCount * sizeof(float), NULL, &ciErrNum); + //oclCheckError(ciErrNum, CL_SUCCESS); + d_Put = clCreateBuffer(cxGPUContext, CL_MEM_READ_WRITE, optionCount * sizeof(float), NULL, &ciErrNum); + //oclCheckError(ciErrNum, CL_SUCCESS); + d_S = clCreateBuffer(cxGPUContext, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, optionCount * sizeof(float), h_S, &ciErrNum); + //oclCheckError(ciErrNum, CL_SUCCESS); + d_X = clCreateBuffer(cxGPUContext, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, optionCount * sizeof(float), h_X, &ciErrNum); + //oclCheckError(ciErrNum, CL_SUCCESS); + d_T = clCreateBuffer(cxGPUContext, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, optionCount * sizeof(float), h_T, &ciErrNum); + //oclCheckError(ciErrNum, CL_SUCCESS); + + shrLog("Starting up BlackScholes...\n"); + initBlackScholes(cxGPUContext, cqCommandQueue, (const char **)argv); + + shrLog("Running OpenCL BlackScholes...\n\n"); + //Just a single run or a warmup iteration + BlackScholes( + NULL, + d_Call, + d_Put, + d_S, + d_X, + d_T, + R, + V, + optionCount + ); + +#ifdef GPU_PROFILING + const int numIterations = 16; + cl_event startMark, endMark; + ciErrNum = clEnqueueMarker(cqCommandQueue, &startMark); + ciErrNum |= clFinish(cqCommandQueue); + shrCheckError(ciErrNum, CL_SUCCESS); + shrDeltaT(0); + + for(int i = 0; i < numIterations; i++){ + BlackScholes( + cqCommandQueue, + d_Call, + d_Put, + d_S, + d_X, + d_T, + R, + V, + optionCount + ); + } + + ciErrNum = clEnqueueMarker(cqCommandQueue, &endMark); + ciErrNum |= clFinish(cqCommandQueue); + shrCheckError(ciErrNum, CL_SUCCESS); + + //Calculate performance metrics by wallclock time + double gpuTime = shrDeltaT(0) / numIterations; + shrLogEx(LOGBOTH | MASTER, 0, "oclBlackScholes, Throughput = %.4f GOptions/s, Time = %.5f s, Size = %u options, NumDevsUsed = %i, Workgroup = %u\n", + (double)(2.0 * optionCount * 1.0e-9)/gpuTime, gpuTime, (2 * optionCount), 1, 0); + + //Get profiling info + cl_ulong startTime = 0, endTime = 0; + ciErrNum = clGetEventProfilingInfo(startMark, CL_PROFILING_COMMAND_END, sizeof(cl_ulong), &startTime, NULL); + ciErrNum |= clGetEventProfilingInfo(endMark, CL_PROFILING_COMMAND_END, sizeof(cl_ulong), &endTime, NULL); + shrCheckError(ciErrNum, CL_SUCCESS); + shrLog("\nOpenCL time: %.5f s\n\n", 1.0e-9 * ((double)endTime - (double)startTime) / (double)numIterations); +#endif + + shrLog("\nReading back OpenCL BlackScholes results...\n"); + ciErrNum = clEnqueueReadBuffer(cqCommandQueue, d_Call, CL_TRUE, 0, optionCount * sizeof(float), h_CallGPU, 0, NULL, NULL); + //oclCheckError(ciErrNum, CL_SUCCESS); + ciErrNum = clEnqueueReadBuffer(cqCommandQueue, d_Put, CL_TRUE, 0, optionCount * sizeof(float), h_PutGPU, 0, NULL, NULL); + //oclCheckError(ciErrNum, CL_SUCCESS); + + shrLog("Comparing against Host/C++ computation...\n"); + BlackScholesCPU(h_CallCPU, h_PutCPU, h_S, h_X, h_T, R, V, optionCount); + double deltaCall = 0, deltaPut = 0, sumCall = 0, sumPut = 0; + double L1call, L1put; + for(unsigned int i = 0; i < optionCount; i++) + { + sumCall += fabs(h_CallCPU[i]); + sumPut += fabs(h_PutCPU[i]); + deltaCall += fabs(h_CallCPU[i] - h_CallGPU[i]); + deltaPut += fabs(h_PutCPU[i] - h_PutGPU[i]); + } + L1call = deltaCall / sumCall; + L1put = deltaPut / sumPut; + shrLog("Relative L1 (call, put) = (%.3e, %.3e)\n\n", L1call, L1put); + + shrLog("Shutting down...\n"); + closeBlackScholes(); + ciErrNum = clReleaseMemObject(d_T); + ciErrNum |= clReleaseMemObject(d_X); + ciErrNum |= clReleaseMemObject(d_S); + ciErrNum |= clReleaseMemObject(d_Put); + ciErrNum |= clReleaseMemObject(d_Call); + ciErrNum |= clReleaseCommandQueue(cqCommandQueue); + ciErrNum |= clReleaseContext(cxGPUContext); + //oclCheckError(ciErrNum, CL_SUCCESS); + + free(h_T); + free(h_X); + free(h_S); + free(h_PutGPU); + free(h_CallGPU); + free(h_PutCPU); + free(h_CallCPU); + + if(cdDevices)free(cdDevices); + + shrQAFinishExit(argc, (const char **)argv, ((L1call < 1E-6) && (L1put < 1E-6)) ? QA_PASSED : QA_FAILED ); +} diff --git a/benchmarks/opencl/BlackScholes/oclBlackScholes.pdf b/benchmarks/opencl/BlackScholes/oclBlackScholes.pdf new file mode 100644 index 00000000..a7b777d7 Binary files /dev/null and b/benchmarks/opencl/BlackScholes/oclBlackScholes.pdf differ diff --git a/benchmarks/opencl/BlackScholes/oclBlackScholes_common.h b/benchmarks/opencl/BlackScholes/oclBlackScholes_common.h new file mode 100644 index 00000000..70ec92da --- /dev/null +++ b/benchmarks/opencl/BlackScholes/oclBlackScholes_common.h @@ -0,0 +1,50 @@ +/* + * Copyright 1993-2010 NVIDIA Corporation. All rights reserved. + * + * Please refer to the NVIDIA end user license agreement (EULA) associated + * with this source code for terms and conditions that govern your use of + * this software. Any use, reproduction, disclosure, or distribution of + * this software and related documentation outside the terms of the EULA + * is strictly prohibited. + * + */ + + + +#include + + + +//////////////////////////////////////////////////////////////////////////////// +// Process an array of optN options on CPU +//////////////////////////////////////////////////////////////////////////////// +extern "C" void BlackScholesCPU( + float *h_Call, //Call option price + float *h_Put, //Put option price + float *h_S, //Current stock price + float *h_X, //Option strike price + float *h_T, //Option years + float R, //Riskless rate of return + float V, //Stock volatility + unsigned int optionCount +); + + +//////////////////////////////////////////////////////////////////////////////// +// OpenCL Black-Scholes kernel launcher +//////////////////////////////////////////////////////////////////////////////// +extern "C" void initBlackScholes(cl_context cxGPUContext, cl_command_queue cqParamCommandQue, const char **argv); + +extern "C" void closeBlackScholes(void); + +extern "C" void BlackScholes( + cl_command_queue cqCommandQueue, + cl_mem d_Call, //Call option price + cl_mem d_Put, //Put option price + cl_mem d_S, //Current stock price + cl_mem d_X, //Option strike price + cl_mem d_T, //Option years + cl_float R, //Riskless rate of return + cl_float V, //Stock volatility + cl_uint optionCount +); diff --git a/benchmarks/opencl/BlackScholes/oclBlackScholes_gold.cpp b/benchmarks/opencl/BlackScholes/oclBlackScholes_gold.cpp new file mode 100644 index 00000000..88d2473b --- /dev/null +++ b/benchmarks/opencl/BlackScholes/oclBlackScholes_gold.cpp @@ -0,0 +1,92 @@ +/* + * Copyright 1993-2010 NVIDIA Corporation. All rights reserved. + * + * Please refer to the NVIDIA end user license agreement (EULA) associated + * with this source code for terms and conditions that govern your use of + * this software. Any use, reproduction, disclosure, or distribution of + * this software and related documentation outside the terms of the EULA + * is strictly prohibited. + * + */ + + + +#include +#include "oclBlackScholes_common.h" + + + +/////////////////////////////////////////////////////////////////////////////// +// Rational approximation of cumulative normal distribution function +/////////////////////////////////////////////////////////////////////////////// +static double CND(double d){ + const double A1 = 0.31938153; + const double A2 = -0.356563782; + const double A3 = 1.781477937; + const double A4 = -1.821255978; + const double A5 = 1.330274429; + const double RSQRT2PI = 0.39894228040143267793994605993438; + + double + K = 1.0 / (1.0 + 0.2316419 * fabs(d)); + + double + cnd = RSQRT2PI * exp(- 0.5 * d * d) * + (K * (A1 + K * (A2 + K * (A3 + K * (A4 + K * A5))))); + + if(d > 0) + cnd = 1.0 - cnd; + + return cnd; +} + +/////////////////////////////////////////////////////////////////////////////// +// Black-Scholes formula for both call and put +/////////////////////////////////////////////////////////////////////////////// +static void BlackScholesBodyCPU( + float& call, //Call option price + float& put, //Put option price + float Sf, //Current stock price + float Xf, //Option strike price + float Tf, //Option years + float Rf, //Riskless rate of return + float Vf //Stock volatility +){ + double S = Sf, X = Xf, T = Tf, R = Rf, V = Vf; + + double sqrtT = sqrt(T); + double d1 = (log(S / X) + (R + 0.5 * V * V) * T) / (V * sqrtT); + double d2 = d1 - V * sqrtT; + double CNDD1 = CND(d1); + double CNDD2 = CND(d2); + + //Calculate Call and Put simultaneously + double expRT = exp(- R * T); + call = (float)(S * CNDD1 - X * expRT * CNDD2); + put = (float)(X * expRT * (1.0 - CNDD2) - S * (1.0 - CNDD1)); +} + +//////////////////////////////////////////////////////////////////////////////// +// Process an array of optN options +//////////////////////////////////////////////////////////////////////////////// +extern "C" void BlackScholesCPU( + float *h_Call, //Call option price + float *h_Put, //Put option price + float *h_S, //Current stock price + float *h_X, //Option strike price + float *h_T, //Option years + float R, //Riskless rate of return + float V, //Stock volatility + unsigned int optionCount +){ + for(unsigned int i = 0; i < optionCount; i++) + BlackScholesBodyCPU( + h_Call[i], + h_Put[i], + h_S[i], + h_X[i], + h_T[i], + R, + V + ); +} diff --git a/benchmarks/opencl/BlackScholes/oclBlackScholes_launcher.cpp b/benchmarks/opencl/BlackScholes/oclBlackScholes_launcher.cpp new file mode 100644 index 00000000..317cabbc --- /dev/null +++ b/benchmarks/opencl/BlackScholes/oclBlackScholes_launcher.cpp @@ -0,0 +1,125 @@ +/* + * Copyright 1993-2010 NVIDIA Corporation. All rights reserved. + * + * Please refer to the NVIDIA end user license agreement (EULA) associated + * with this source code for terms and conditions that govern your use of + * this software. Any use, reproduction, disclosure, or distribution of + * this software and related documentation outside the terms of the EULA + * is strictly prohibited. + * + */ + + + +#include +#include "oclBlackScholes_common.h" + +static cl_program cpBlackScholes; //OpenCL program +static cl_kernel ckBlackScholes; //OpenCL kernel +static cl_command_queue cqDefaultCommandQueue; + +extern "C" void initBlackScholes(cl_context cxGPUContext, cl_command_queue cqParamCommandQueue, const char **argv){ + cl_int ciErrNum; + size_t kernelLength; + + shrLog("...loading BlackScholes.cl\n"); + char *cPathAndName = shrFindFilePath("BlackScholes.cl", argv[0]); + shrCheckError(cPathAndName != NULL, shrTRUE); + char *cBlackScholes = oclLoadProgSource(cPathAndName, "// My comment\n", &kernelLength); + shrCheckError(cBlackScholes != NULL, shrTRUE); + + shrLog("...creating BlackScholes program\n"); + //cpBlackScholes = clCreateProgramWithSource(cxGPUContext, 1, (const char **)&cBlackScholes, &kernelLength, &ciErrNum); + cpBlackScholes = clCreateProgramWithBuiltInKernels(context, 1, &device_id, "BlackScholes", NULL); + shrCheckError(ciErrNum, CL_SUCCESS); + + shrLog("...building BlackScholes program\n"); + ciErrNum = clBuildProgram(cpBlackScholes, 0, NULL, "-cl-fast-relaxed-math -Werror", NULL, NULL); + + if(ciErrNum != CL_BUILD_SUCCESS){ + shrLog("*** Compilation failure ***\n"); + + size_t deviceNum; + cl_device_id *cdDevices; + ciErrNum = clGetContextInfo(cxGPUContext, CL_CONTEXT_DEVICES, 0, NULL, &deviceNum); + shrCheckError(ciErrNum, CL_SUCCESS); + + cdDevices = (cl_device_id *)malloc(deviceNum * sizeof(cl_device_id)); + shrCheckError(cdDevices != NULL, shrTRUE); + + ciErrNum = clGetContextInfo(cxGPUContext, CL_CONTEXT_DEVICES, deviceNum * sizeof(cl_device_id), cdDevices, NULL); + shrCheckError(ciErrNum, CL_SUCCESS); + + size_t logSize; + char *logTxt; + + ciErrNum = clGetProgramBuildInfo(cpBlackScholes, cdDevices[0], CL_PROGRAM_BUILD_LOG, 0, NULL, &logSize); + shrCheckError(ciErrNum, CL_SUCCESS); + + logTxt = (char *)malloc(logSize); + shrCheckError(logTxt != NULL, shrTRUE); + + ciErrNum = clGetProgramBuildInfo(cpBlackScholes, cdDevices[0], CL_PROGRAM_BUILD_LOG, logSize, logTxt, NULL); + shrCheckError(ciErrNum, CL_SUCCESS); + + shrLog("%s\n", logTxt); + shrLog("*** Exiting ***\n"); + free(logTxt); + free(cdDevices); + exit(666); + } + + //Save ptx code to separate file + oclLogPtx(cpBlackScholes, oclGetFirstDev(cxGPUContext), "BlackScholes.ptx"); + + shrLog("...creating BlackScholes kernels\n"); + ckBlackScholes = clCreateKernel(cpBlackScholes, "BlackScholes", &ciErrNum); + shrCheckError(ciErrNum, CL_SUCCESS); + + cqDefaultCommandQueue = cqParamCommandQueue; + free(cBlackScholes); + free(cPathAndName); +} + +extern "C" void closeBlackScholes(void){ + cl_int ciErrNum; + ciErrNum = clReleaseKernel(ckBlackScholes); + ciErrNum |= clReleaseProgram(cpBlackScholes); + shrCheckError(ciErrNum, CL_SUCCESS); +} + +//////////////////////////////////////////////////////////////////////////////// +// OpenCL Black-Scholes kernel launcher +//////////////////////////////////////////////////////////////////////////////// +extern "C" void BlackScholes( + cl_command_queue cqCommandQueue, + cl_mem d_Call, //Call option price + cl_mem d_Put, //Put option price + cl_mem d_S, //Current stock price + cl_mem d_X, //Option strike price + cl_mem d_T, //Option years + cl_float R, //Riskless rate of return + cl_float V, //Stock volatility + cl_uint optionCount +){ + cl_int ciErrNum; + + if(!cqCommandQueue) + cqCommandQueue = cqDefaultCommandQueue; + + ciErrNum = clSetKernelArg(ckBlackScholes, 0, sizeof(cl_mem), (void *)&d_Call); + ciErrNum |= clSetKernelArg(ckBlackScholes, 1, sizeof(cl_mem), (void *)&d_Put); + ciErrNum |= clSetKernelArg(ckBlackScholes, 2, sizeof(cl_mem), (void *)&d_S); + ciErrNum |= clSetKernelArg(ckBlackScholes, 3, sizeof(cl_mem), (void *)&d_X); + ciErrNum |= clSetKernelArg(ckBlackScholes, 4, sizeof(cl_mem), (void *)&d_T); + ciErrNum |= clSetKernelArg(ckBlackScholes, 5, sizeof(cl_float), (void *)&R); + ciErrNum |= clSetKernelArg(ckBlackScholes, 6, sizeof(cl_float), (void *)&V); + ciErrNum |= clSetKernelArg(ckBlackScholes, 7, sizeof(cl_uint), (void *)&optionCount); + shrCheckError(ciErrNum, CL_SUCCESS); + + //Run the kernel + size_t globalWorkSize = 60 * 1024; + size_t localWorkSize = 128; + ciErrNum = clEnqueueNDRangeKernel(cqCommandQueue, ckBlackScholes, 1, NULL, &globalWorkSize, &localWorkSize, 0, NULL, NULL); + shrCheckError(ciErrNum, CL_SUCCESS); +} diff --git a/benchmarks/opencl/BlackScholes/oclUtils.h b/benchmarks/opencl/BlackScholes/oclUtils.h new file mode 100644 index 00000000..2b109e18 --- /dev/null +++ b/benchmarks/opencl/BlackScholes/oclUtils.h @@ -0,0 +1,198 @@ +/* + * Copyright 1993-2010 NVIDIA Corporation. All rights reserved. + * + * Please refer to the NVIDIA end user license agreement (EULA) associated + * with this source code for terms and conditions that govern your use of + * this software. Any use, reproduction, disclosure, or distribution of + * this software and related documentation outside the terms of the EULA + * is strictly prohibited. + * + */ + +#ifndef OCL_UTILS_H +#define OCL_UTILS_H + +// ********************************************************************* +// Utilities specific to OpenCL samples in NVIDIA GPU Computing SDK +// ********************************************************************* + +// Common headers: Cross-API utililties and OpenCL header +#include + +// All OpenCL headers +#if defined (__APPLE__) || defined(MACOSX) + #include +#else + #include +#endif + +// Includes +#include +#include +#include + +// For systems with CL_EXT that are not updated with these extensions, we copied these +// extensions from +#ifndef CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV + /* cl_nv_device_attribute_query extension - no extension #define since it has no functions */ + #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000 + #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001 + #define CL_DEVICE_REGISTERS_PER_BLOCK_NV 0x4002 + #define CL_DEVICE_WARP_SIZE_NV 0x4003 + #define CL_DEVICE_GPU_OVERLAP_NV 0x4004 + #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005 + #define CL_DEVICE_INTEGRATED_MEMORY_NV 0x4006 +#endif + +// reminders for build output window and log +#ifdef _WIN32 + #pragma message ("Note: including shrUtils.h") + #pragma message ("Note: including opencl.h") +#endif + +// SDK Revision # +#define OCL_SDKREVISION "7027912" + +// Error and Exit Handling Macros... +// ********************************************************************* +// Full error handling macro with Cleanup() callback (if supplied)... +// (Companion Inline Function lower on page) +#define oclCheckErrorEX(a, b, c) __oclCheckErrorEX(a, b, c, __FILE__ , __LINE__) + +// Short version without Cleanup() callback pointer +// Both Input (a) and Reference (b) are specified as args +#define oclCheckError(a, b) oclCheckErrorEX(a, b, 0) + +////////////////////////////////////////////////////////////////////////////// +//! Gets the platform ID for NVIDIA if available, otherwise default to platform 0 +//! +//! @return the id +//! @param clSelectedPlatformID OpenCL platform ID +////////////////////////////////////////////////////////////////////////////// +extern "C" cl_int oclGetPlatformID(cl_platform_id* clSelectedPlatformID); + +////////////////////////////////////////////////////////////////////////////// +//! Print info about the device +//! +//! @param iLogMode enum LOGBOTH, LOGCONSOLE, LOGFILE +//! @param device OpenCL id of the device +////////////////////////////////////////////////////////////////////////////// +extern "C" void oclPrintDevInfo(int iLogMode, cl_device_id device); + +////////////////////////////////////////////////////////////////////////////// +//! Get and return device capability +//! +//! @return the 2 digit integer representation of device Cap (major minor). return -1 if NA +//! @param device OpenCL id of the device +////////////////////////////////////////////////////////////////////////////// +extern "C" int oclGetDevCap(cl_device_id device); + +////////////////////////////////////////////////////////////////////////////// +//! Print the device name +//! +//! @param iLogMode enum LOGBOTH, LOGCONSOLE, LOGFILE +//! @param device OpenCL id of the device +////////////////////////////////////////////////////////////////////////////// +extern "C" void oclPrintDevName(int iLogMode, cl_device_id device); + +////////////////////////////////////////////////////////////////////////////// +//! Gets the id of the first device from the context +//! +//! @return the id +//! @param cxGPUContext OpenCL context +////////////////////////////////////////////////////////////////////////////// +extern "C" cl_device_id oclGetFirstDev(cl_context cxGPUContext); + +////////////////////////////////////////////////////////////////////////////// +//! Gets the id of the nth device from the context +//! +//! @return the id or -1 when out of range +//! @param cxGPUContext OpenCL context +//! @param device_idx index of the device of interest +////////////////////////////////////////////////////////////////////////////// +extern "C" cl_device_id oclGetDev(cl_context cxGPUContext, unsigned int device_idx); + +////////////////////////////////////////////////////////////////////////////// +//! Gets the id of device with maximal FLOPS from the context +//! +//! @return the id +//! @param cxGPUContext OpenCL context +////////////////////////////////////////////////////////////////////////////// +extern "C" cl_device_id oclGetMaxFlopsDev(cl_context cxGPUContext); + +////////////////////////////////////////////////////////////////////////////// +//! Loads a Program file and prepends the cPreamble to the code. +//! +//! @return the source string if succeeded, 0 otherwise +//! @param cFilename program filename +//! @param cPreamble code that is prepended to the loaded file, typically a set of #defines or a header +//! @param szFinalLength returned length of the code string +////////////////////////////////////////////////////////////////////////////// +extern "C" char* oclLoadProgSource(const char* cFilename, const char* cPreamble, size_t* szFinalLength); + +////////////////////////////////////////////////////////////////////////////// +//! Get the binary (PTX) of the program associated with the device +//! +//! @param cpProgram OpenCL program +//! @param cdDevice device of interest +//! @param binary returned code +//! @param length length of returned code +////////////////////////////////////////////////////////////////////////////// +extern "C" void oclGetProgBinary( cl_program cpProgram, cl_device_id cdDevice, char** binary, size_t* length); + +////////////////////////////////////////////////////////////////////////////// +//! Get and log the binary (PTX) from the OpenCL compiler for the requested program & device +//! +//! @param cpProgram OpenCL program +//! @param cdDevice device of interest +//! @param const char* cPtxFileName optional PTX file name +////////////////////////////////////////////////////////////////////////////// +extern "C" void oclLogPtx(cl_program cpProgram, cl_device_id cdDevice, const char* cPtxFileName); + +////////////////////////////////////////////////////////////////////////////// +//! Get and log the Build Log from the OpenCL compiler for the requested program & device +//! +//! @param cpProgram OpenCL program +//! @param cdDevice device of interest +////////////////////////////////////////////////////////////////////////////// +extern "C" void oclLogBuildInfo(cl_program cpProgram, cl_device_id cdDevice); + +// Helper function for De-allocating cl objects +// ********************************************************************* +extern "C" void oclDeleteMemObjs(cl_mem* cmMemObjs, int iNumObjs); + +// Helper function to get OpenCL error string from constant +// ********************************************************************* +extern "C" const char* oclErrorString(cl_int error); + +// Helper function to get OpenCL image format string (channel order and type) from constant +// ********************************************************************* +extern "C" const char* oclImageFormatString(cl_uint uiImageFormat); + +// companion inline function for error checking and exit on error WITH Cleanup Callback (if supplied) +// ********************************************************************* +inline void __oclCheckErrorEX(cl_int iSample, cl_int iReference, void (*pCleanup)(int), const char* cFile, const int iLine) +{ + // An error condition is defined by the sample/test value not equal to the reference + if (iReference != iSample) + { + // If the sample/test value isn't equal to the ref, it's an error by defnition, so override 0 sample/test value + iSample = (iSample == 0) ? -9999 : iSample; + + // Log the error info + shrLog("\n !!! Error # %i (%s) at line %i , in file %s !!!\n\n", iSample, oclErrorString(iSample), iLine, cFile); + + // Cleanup and exit, or just exit if no cleanup function pointer provided. Use iSample (error code in this case) as process exit code. + if (pCleanup != NULL) + { + pCleanup(iSample); + } + else + { + shrLogEx(LOGBOTH | CLOSELOG, 0, "Exiting...\n"); + exit(iSample); + } + } +} + +#endif \ No newline at end of file diff --git a/benchmarks/opencl/BlackScholes/shrQATest.h b/benchmarks/opencl/BlackScholes/shrQATest.h new file mode 100644 index 00000000..245cf8dc --- /dev/null +++ b/benchmarks/opencl/BlackScholes/shrQATest.h @@ -0,0 +1,238 @@ +/* +* Copyright 1993-2010 NVIDIA Corporation. All rights reserved. +* +* Please refer to the NVIDIA end user license agreement (EULA) associated +* with this source code for terms and conditions that govern your use of +* this software. Any use, reproduction, disclosure, or distribution of +* this software and related documentation outside the terms of the EULA +* is strictly prohibited. +* +*/ + +#ifndef SHR_QATEST_H +#define SHR_QATEST_H + +// ********************************************************************* +// Generic utilities for NVIDIA GPU Computing SDK +// ********************************************************************* + +// OS dependent includes +#ifdef _WIN32 + #pragma message ("Note: including windows.h") + #pragma message ("Note: including math.h") + #pragma message ("Note: including assert.h") + #pragma message ("Note: including time.h") + +// Headers needed for Windows + #include + #include +#else + // Headers needed for Linux + #include + #include + #include + #include + #include + #include + #include + #include + #include +#endif + +#ifndef STRCASECMP +#ifdef _WIN32 +#define STRCASECMP _stricmp +#else +#define STRCASECMP strcasecmp +#endif +#endif + +#ifndef STRNCASECMP +#ifdef _WIN32 +#define STRNCASECMP _strnicmp +#else +#define STRNCASECMP strncasecmp +#endif +#endif + + +// Standardized QA Start/Finish for CUDA SDK tests +#define shrQAStart(a, b) __shrQAStart(a, b) +#define shrQAFinish(a, b, c) __shrQAFinish(a, b, c) +#define shrQAFinish2(a, b, c, d) __shrQAFinish2(a, b, c, d) + +inline int findExeNameStart(const char *exec_name) +{ + int exename_start = (int)strlen(exec_name); + + while( (exename_start > 0) && + (exec_name[exename_start] != '\\') && + (exec_name[exename_start] != '/') ) + { + exename_start--; + } + if (exec_name[exename_start] == '\\' || + exec_name[exename_start] == '/') + { + return exename_start+1; + } else { + return exename_start; + } +} + +inline int __shrQAStart(int argc, char **argv) +{ + bool bQATest = false; + // First clear the output buffer + fflush(stdout); + fflush(stdout); + + for (int i=1; i < argc; i++) { + int string_start = 0; + while (argv[i][string_start] == '-') + string_start++; + char *string_argv = &argv[i][string_start]; + + if (!STRCASECMP(string_argv, "qatest")) { + bQATest = true; + } + } + + // We don't want to print the entire path, so we search for the first + int exename_start = findExeNameStart(argv[0]); + if (bQATest) { + fprintf(stdout, "&&&& RUNNING %s", &(argv[0][exename_start])); + for (int i=1; i < argc; i++) fprintf(stdout, " %s", argv[i]); + fprintf(stdout, "\n"); + } else { + fprintf(stdout, "[%s] starting...\n", &(argv[0][exename_start])); + } + fflush(stdout); + printf("\n"); fflush(stdout); + return exename_start; +} + +enum eQAstatus { + QA_FAILED = 0, + QA_PASSED = 1, + QA_WAIVED = 2 +}; + +inline void __ExitInTime(int seconds) +{ + fprintf(stdout, "> exiting in %d seconds: ", seconds); + fflush(stdout); + time_t t; + int count; + for (t=time(0)+seconds, count=seconds; time(0) < t; count--) { + fprintf(stdout, "%d...", count); +#ifdef WIN32 + Sleep(1000); +#else + sleep(1); +#endif + } + fprintf(stdout,"done!\n\n"); + fflush(stdout); +} + + +inline void __shrQAFinish(int argc, const char **argv, int iStatus) +{ + // By default QATest is disabled and NoPrompt is Enabled (times out at seconds passed into __ExitInTime() ) + bool bQATest = false, bNoPrompt = true, bQuitInTime = true; + const char *sStatus[] = { "FAILED", "PASSED", "WAIVED", NULL }; + + for (int i=1; i < argc; i++) { + int string_start = 0; + while (argv[i][string_start] == '-') + string_start++; + + const char *string_argv = &argv[i][string_start]; + if (!STRCASECMP(string_argv, "qatest")) { + bQATest = true; + } + // For SDK individual samples that don't specify -noprompt or -prompt, + // a 3 second delay will happen before exiting, giving a user time to view results + if (!STRCASECMP(string_argv, "noprompt") || !STRCASECMP(string_argv, "help")) { + bNoPrompt = true; + bQuitInTime = false; + } + if (!STRCASECMP(string_argv, "prompt")) { + bNoPrompt = false; + bQuitInTime = false; + } + } + + int exename_start = findExeNameStart(argv[0]); + if (bQATest) { + fprintf(stdout, "&&&& %s %s", sStatus[iStatus], &(argv[0][exename_start])); + for (int i=1; i < argc; i++) fprintf(stdout, " %s", argv[i]); + fprintf(stdout, "\n"); + } else { + fprintf(stdout, "[%s] test results...\n%s\n", &(argv[0][exename_start]), sStatus[iStatus]); + } + fflush(stdout); + printf("\n"); fflush(stdout); + if (bQuitInTime) { + __ExitInTime(3); + } else { + if (!bNoPrompt) { + fprintf(stdout, "\nPress to exit...\n"); + fflush(stdout); + getchar(); + } + } +} + +inline void __shrQAFinish2(bool bQATest, int argc, const char **argv, int iStatus) +{ + bool bQuitInTime = true; + const char *sStatus[] = { "FAILED", "PASSED", "WAIVED", NULL }; + + for (int i=1; i < argc; i++) { + int string_start = 0; + while (argv[i][string_start] == '-') + string_start++; + + const char *string_argv = &argv[i][string_start]; + // For SDK individual samples that don't specify -noprompt or -prompt, + // a 3 second delay will happen before exiting, giving a user time to view results + if (!STRCASECMP(string_argv, "noprompt") || !STRCASECMP(string_argv, "help")) { + bQuitInTime = false; + } + if (!STRCASECMP(string_argv, "prompt")) { + bQuitInTime = false; + } + } + + int exename_start = findExeNameStart(argv[0]); + if (bQATest) { + fprintf(stdout, "&&&& %s %s", sStatus[iStatus], &(argv[0][exename_start])); + for (int i=1; i < argc; i++) fprintf(stdout, " %s", argv[i]); + fprintf(stdout, "\n"); + } else { + fprintf(stdout, "[%s] test results...\n%s\n", &(argv[0][exename_start]), sStatus[iStatus]); + } + fflush(stdout); + + if (bQuitInTime) { + __ExitInTime(3); + } +} + +inline void shrQAFinishExit(int argc, const char **argv, int iStatus) +{ + __shrQAFinish(argc, argv, iStatus); + + exit(iStatus ? EXIT_SUCCESS : EXIT_FAILURE); +} + +inline void shrQAFinishExit2(bool bQAtest, int argc, const char **argv, int iStatus) +{ + __shrQAFinish2(bQAtest, argc, argv, iStatus); + + exit(iStatus ? EXIT_SUCCESS : EXIT_FAILURE); +} + +#endif \ No newline at end of file diff --git a/benchmarks/opencl/BlackScholes/shrUtils.h b/benchmarks/opencl/BlackScholes/shrUtils.h new file mode 100644 index 00000000..0f2795d4 --- /dev/null +++ b/benchmarks/opencl/BlackScholes/shrUtils.h @@ -0,0 +1,642 @@ +/* +* Copyright 1993-2010 NVIDIA Corporation. All rights reserved. +* +* Please refer to the NVIDIA end user license agreement (EULA) associated +* with this source code for terms and conditions that govern your use of +* this software. Any use, reproduction, disclosure, or distribution of +* this software and related documentation outside the terms of the EULA +* is strictly prohibited. +* +*/ + +#ifndef SHR_UTILS_H +#define SHR_UTILS_H + +// ********************************************************************* +// Generic utilities for NVIDIA GPU Computing SDK +// ********************************************************************* + +// reminders for output window and build log +#ifdef _WIN32 + #pragma message ("Note: including windows.h") + #pragma message ("Note: including math.h") + #pragma message ("Note: including assert.h") +#endif + +// OS dependent includes +#ifdef _WIN32 + // Headers needed for Windows + #include +#else + // Headers needed for Linux + #include + #include + #include + #include + #include + #include + #include +#endif + +// Other headers needed for both Windows and Linux +#include +#include +#include +#include +#include + +// Un-comment the following #define to enable profiling code in SDK apps +//#define GPU_PROFILING + +// Beginning of GPU Architecture definitions +inline int ConvertSMVer2Cores(int major, int minor) +{ + // Defines for GPU Architecture types (using the SM version to determine the # of cores per SM + typedef struct { + int SM; // 0xMm (hexidecimal notation), M = SM Major version, and m = SM minor version + int Cores; + } sSMtoCores; + + sSMtoCores nGpuArchCoresPerSM[] = + { { 0x10, 8 }, // Tesla Generation (SM 1.0) G80 class + { 0x11, 8 }, // Tesla Generation (SM 1.1) G8x class + { 0x12, 8 }, // Tesla Generation (SM 1.2) G9x class + { 0x13, 8 }, // Tesla Generation (SM 1.3) GT200 class + { 0x20, 32 }, // Fermi Generation (SM 2.0) GF100 class + { 0x21, 48 }, // Fermi Generation (SM 2.1) GF10x class + { 0x30, 192}, // Fermi Generation (SM 3.0) GK10x class + { -1, -1 } + }; + + int index = 0; + while (nGpuArchCoresPerSM[index].SM != -1) { + if (nGpuArchCoresPerSM[index].SM == ((major << 4) + minor) ) { + return nGpuArchCoresPerSM[index].Cores; + } + index++; + } + printf("MapSMtoCores SM %d.%d is undefined (please update to the latest SDK)!\n", major, minor); + return -1; +} +// end of GPU Architecture definitions + + +// Defines and enum for use with logging functions +// ********************************************************************* +#define DEFAULTLOGFILE "SdkConsoleLog.txt" +#define MASTERLOGFILE "SdkMasterLog.csv" +enum LOGMODES +{ + LOGCONSOLE = 1, // bit to signal "log to console" + LOGFILE = 2, // bit to signal "log to file" + LOGBOTH = 3, // convenience union of first 2 bits to signal "log to both" + APPENDMODE = 4, // bit to set "file append" mode instead of "replace mode" on open + MASTER = 8, // bit to signal master .csv log output + ERRORMSG = 16, // bit to signal "pre-pend Error" + CLOSELOG = 32 // bit to close log file, if open, after any requested file write +}; +#define HDASHLINE "-----------------------------------------------------------\n" + +// Standardized boolean +enum shrBOOL +{ + shrFALSE = 0, + shrTRUE = 1 +}; + +// Standardized MAX, MIN and CLAMP +#define MAX(a, b) ((a > b) ? a : b) +#define MIN(a, b) ((a < b) ? a : b) +#define CLAMP(a, b, c) MIN(MAX(a, b), c) // double sided clip of input a +#define TOPCLAMP(a, b) (a < b ? a:b) // single top side clip of input a + +// Error and Exit Handling Macros... +// ********************************************************************* +// Full error handling macro with Cleanup() callback (if supplied)... +// (Companion Inline Function lower on page) +#define shrCheckErrorEX(a, b, c) __shrCheckErrorEX(a, b, c, __FILE__ , __LINE__) + +// Short version without Cleanup() callback pointer +// Both Input (a) and Reference (b) are specified as args +#define shrCheckError(a, b) shrCheckErrorEX(a, b, 0) + +// Standardized Exit Macro for leaving main()... extended version +// (Companion Inline Function lower on page) +#define shrExitEX(a, b, c) __shrExitEX(a, b, c) + +// Standardized Exit Macro for leaving main()... short version +// (Companion Inline Function lower on page) +#define shrEXIT(a, b) __shrExitEX(a, b, EXIT_SUCCESS) + +// Simple argument checker macro +#define ARGCHECK(a) if((a) != shrTRUE)return shrFALSE + +// Define for user-customized error handling +#define STDERROR "file %s, line %i\n\n" , __FILE__ , __LINE__ + +// Function to deallocate memory allocated within shrUtils +// ********************************************************************* +extern "C" void shrFree(void* ptr); + +// ********************************************************************* +// Helper function to log standardized information to Console, to File or to both +//! Examples: shrLogEx(LOGBOTH, 0, "Function A\n"); +//! : shrLogEx(LOGBOTH | ERRORMSG, ciErrNum, STDERROR); +//! +//! Automatically opens file and stores handle if needed and not done yet +//! Closes file and nulls handle on request +//! +//! @param 0 iLogMode: LOGCONSOLE, LOGFILE, LOGBOTH, APPENDMODE, MASTER, ERRORMSG, CLOSELOG. +//! LOGFILE and LOGBOTH may be | 'd with APPENDMODE to select file append mode instead of overwrite mode +//! LOGFILE and LOGBOTH may be | 'd with CLOSELOG to "write and close" +//! First 3 options may be | 'd with MASTER to enable independent write to master data log file +//! First 3 options may be | 'd with ERRORMSG to start line with standard error message +//! @param 2 dValue: +//! Positive val = double value for time in secs to be formatted to 6 decimals. +//! Negative val is an error code and this give error preformatting. +//! @param 3 cFormatString: String with formatting specifiers like printf or fprintf. +//! ALL printf flags, width, precision and type specifiers are supported with this exception: +//! Wide char type specifiers intended for wprintf (%S and %C) are NOT supported +//! Single byte char type specifiers (%s and %c) ARE supported +//! @param 4... variable args: like printf or fprintf. Must match format specifer type above. +//! @return 0 if OK, negative value on error or if error occurs or was passed in. +// ********************************************************************* +extern "C" int shrLogEx(int iLogMode, int iErrNum, const char* cFormatString, ...); + +// Short version of shrLogEx defaulting to shrLogEx(LOGBOTH, 0, +// ********************************************************************* +extern "C" int shrLog(const char* cFormatString, ...); + +// ********************************************************************* +// Delta timer function for up to 3 independent timers using host high performance counters +// Maintains state for 3 independent counters +//! Example: double dElapsedTime = shrDeltaTime(0); +//! +//! @param 0 iCounterID: Which timer to check/reset. (0, 1, 2) +//! @return delta time of specified counter since last call in seconds. Otherwise -9999.0 if error +// ********************************************************************* +extern "C" double shrDeltaT(int iCounterID); + +// Optional LogFileNameOverride function +// ********************************************************************* +extern "C" void shrSetLogFileName (const char* cOverRideName); + +// Helper function to init data arrays +// ********************************************************************* +extern "C" void shrFillArray(float* pfData, int iSize); + +// Helper function to print data arrays +// ********************************************************************* +extern "C" void shrPrintArray(float* pfData, int iSize); + +//////////////////////////////////////////////////////////////////////////// +//! Find the path for a filename +//! @return the path if succeeded, otherwise 0 +//! @param filename name of the file +//! @param executablePath optional absolute path of the executable +//////////////////////////////////////////////////////////////////////////// +extern "C" char* shrFindFilePath(const char* filename, const char* executablePath); + +//////////////////////////////////////////////////////////////////////////// +//! Read file \filename containing single precision floating point data +//! @return shrTRUE if reading the file succeeded, otherwise shrFALSE +//! @param filename name of the source file +//! @param data uninitialized pointer, returned initialized and pointing to +//! the data read +//! @param len number of data elements in data, -1 on error +//! @note If a NULL pointer is passed to this function and it is initialized +//! within shrUtils, then free() has to be used to deallocate the memory +//////////////////////////////////////////////////////////////////////////// +extern "C" shrBOOL shrReadFilef( const char* filename, float** data, unsigned int* len, + bool verbose = false); + +//////////////////////////////////////////////////////////////////////////// +//! Read file \filename containing double precision floating point data +//! @return shrTRUE if reading the file succeeded, otherwise shrFALSE +//! @param filename name of the source file +//! @param data uninitialized pointer, returned initialized and pointing to +//! the data read +//! @param len number of data elements in data, -1 on error +//! @note If a NULL pointer is passed to this function and it is +//! @note If a NULL pointer is passed to this function and it is initialized +//! within shrUtils, then free() has to be used to deallocate the memory +//////////////////////////////////////////////////////////////////////////// +extern "C" shrBOOL shrReadFiled( const char* filename, double** data, unsigned int* len, + bool verbose = false); + +//////////////////////////////////////////////////////////////////////////// +//! Read file \filename containing integer data +//! @return shrTRUE if reading the file succeeded, otherwise shrFALSE +//! @param filename name of the source file +//! @param data uninitialized pointer, returned initialized and pointing to +//! the data read +//! @param len number of data elements in data, -1 on error +//! @note If a NULL pointer is passed to this function and it is +//! @note If a NULL pointer is passed to this function and it is initialized +//! within shrUtils, then free() has to be used to deallocate the memory +//////////////////////////////////////////////////////////////////////////// +extern "C" shrBOOL shrReadFilei( const char* filename, int** data, unsigned int* len, bool verbose = false); + +//////////////////////////////////////////////////////////////////////////// +//! Read file \filename containing unsigned integer data +//! @return shrTRUE if reading the file succeeded, otherwise shrFALSE +//! @param filename name of the source file +//! @param data uninitialized pointer, returned initialized and pointing to +//! the data read +//! @param len number of data elements in data, -1 on error +//! @note If a NULL pointer is passed to this function and it is +//! @note If a NULL pointer is passed to this function and it is initialized +//! within shrUtils, then free() has to be used to deallocate the memory +//////////////////////////////////////////////////////////////////////////// +extern "C" shrBOOL shrReadFileui( const char* filename, unsigned int** data, + unsigned int* len, bool verbose = false); + +//////////////////////////////////////////////////////////////////////////// +//! Read file \filename containing char / byte data +//! @return shrTRUE if reading the file succeeded, otherwise shrFALSE +//! @param filename name of the source file +//! @param data uninitialized pointer, returned initialized and pointing to +//! the data read +//! @param len number of data elements in data, -1 on error +//! @note If a NULL pointer is passed to this function and it is +//! @note If a NULL pointer is passed to this function and it is initialized +//! within shrUtils, then free() has to be used to deallocate the memory +//////////////////////////////////////////////////////////////////////////// +extern "C" shrBOOL shrReadFileb( const char* filename, char** data, unsigned int* len, + bool verbose = false); + +//////////////////////////////////////////////////////////////////////////// +//! Read file \filename containing unsigned char / byte data +//! @return shrTRUE if reading the file succeeded, otherwise shrFALSE +//! @param filename name of the source file +//! @param data uninitialized pointer, returned initialized and pointing to +//! the data read +//! @param len number of data elements in data, -1 on error +//! @note If a NULL pointer is passed to this function and it is +//! @note If a NULL pointer is passed to this function and it is initialized +//! within shrUtils, then free() has to be used to deallocate the memory +//////////////////////////////////////////////////////////////////////////// +extern "C" shrBOOL shrReadFileub( const char* filename, unsigned char** data, + unsigned int* len, bool verbose = false); + +//////////////////////////////////////////////////////////////////////////// +//! Write a data file \filename containing single precision floating point +//! data +//! @return shrTRUE if writing the file succeeded, otherwise shrFALSE +//! @param filename name of the file to write +//! @param data pointer to data to write +//! @param len number of data elements in data, -1 on error +//! @param epsilon epsilon for comparison +//////////////////////////////////////////////////////////////////////////// +extern "C" shrBOOL shrWriteFilef( const char* filename, const float* data, unsigned int len, + const float epsilon, bool verbose = false); + +//////////////////////////////////////////////////////////////////////////// +//! Write a data file \filename containing double precision floating point +//! data +//! @return shrTRUE if writing the file succeeded, otherwise shrFALSE +//! @param filename name of the file to write +//! @param data pointer to data to write +//! @param len number of data elements in data, -1 on error +//! @param epsilon epsilon for comparison +//////////////////////////////////////////////////////////////////////////// +extern "C" shrBOOL shrWriteFiled( const char* filename, const float* data, unsigned int len, + const double epsilon, bool verbose = false); + +//////////////////////////////////////////////////////////////////////////// +//! Write a data file \filename containing integer data +//! @return shrTRUE if writing the file succeeded, otherwise shrFALSE +//! @param filename name of the file to write +//! @param data pointer to data to write +//! @param len number of data elements in data, -1 on error +//////////////////////////////////////////////////////////////////////////// +extern "C" shrBOOL shrWriteFilei( const char* filename, const int* data, unsigned int len, + bool verbose = false); + +//////////////////////////////////////////////////////////////////////////// +//! Write a data file \filename containing unsigned integer data +//! @return shrTRUE if writing the file succeeded, otherwise shrFALSE +//! @param filename name of the file to write +//! @param data pointer to data to write +//! @param len number of data elements in data, -1 on error +//////////////////////////////////////////////////////////////////////////// +extern "C" shrBOOL shrWriteFileui( const char* filename, const unsigned int* data, + unsigned int len, bool verbose = false); + +//////////////////////////////////////////////////////////////////////////// +//! Write a data file \filename containing char / byte data +//! @return shrTRUE if writing the file succeeded, otherwise shrFALSE +//! @param filename name of the file to write +//! @param data pointer to data to write +//! @param len number of data elements in data, -1 on error +//////////////////////////////////////////////////////////////////////////// +extern "C" shrBOOL shrWriteFileb( const char* filename, const char* data, unsigned int len, + bool verbose = false); + +//////////////////////////////////////////////////////////////////////////// +//! Write a data file \filename containing unsigned char / byte data +//! @return shrTRUE if writing the file succeeded, otherwise shrFALSE +//! @param filename name of the file to write +//! @param data pointer to data to write +//! @param len number of data elements in data, -1 on error +//////////////////////////////////////////////////////////////////////////// +extern "C" shrBOOL shrWriteFileub( const char* filename, const unsigned char* data, + unsigned int len, bool verbose = false); + +//////////////////////////////////////////////////////////////////////////// +//! Load PPM image file (with unsigned char as data element type), padding +//! 4th component +//! @return shrTRUE if reading the file succeeded, otherwise shrFALSE +//! @param file name of the image file +//! @param OutData handle to the data read +//! @param w width of the image +//! @param h height of the image +//! +//! Note: If *OutData is NULL this function allocates buffer that must be freed by caller +//////////////////////////////////////////////////////////////////////////// +extern "C" shrBOOL shrLoadPPM4ub(const char* file, unsigned char** OutData, + unsigned int *w, unsigned int *h); + +//////////////////////////////////////////////////////////////////////////// +//! Save PPM image file (with unsigned char as data element type, padded to +//! 4 bytes) +//! @return shrTRUE if saving the file succeeded, otherwise shrFALSE +//! @param file name of the image file +//! @param data handle to the data read +//! @param w width of the image +//! @param h height of the image +//////////////////////////////////////////////////////////////////////////// +extern "C" shrBOOL shrSavePPM4ub( const char* file, unsigned char *data, + unsigned int w, unsigned int h); + +//////////////////////////////////////////////////////////////////////////////// +//! Save PGM image file (with unsigned char as data element type) +//! @return shrTRUE if saving the file succeeded, otherwise shrFALSE +//! @param file name of the image file +//! @param data handle to the data read +//! @param w width of the image +//! @param h height of the image +//////////////////////////////////////////////////////////////////////////////// +extern "C" shrBOOL shrSavePGMub( const char* file, unsigned char *data, + unsigned int w, unsigned int h); + +//////////////////////////////////////////////////////////////////////////// +//! Load PGM image file (with unsigned char as data element type) +//! @return shrTRUE if saving the file succeeded, otherwise shrFALSE +//! @param file name of the image file +//! @param data handle to the data read +//! @param w width of the image +//! @param h height of the image +//! @note If a NULL pointer is passed to this function and it is initialized +//! within shrUtils, then free() has to be used to deallocate the memory +//////////////////////////////////////////////////////////////////////////// +extern "C" shrBOOL shrLoadPGMub( const char* file, unsigned char** data, + unsigned int *w,unsigned int *h); + +//////////////////////////////////////////////////////////////////////////// +// Command line arguments: General notes +// * All command line arguments begin with '--' followed by the token; +// token and value are seperated by '='; example --samples=50 +// * Arrays have the form --model=[one.obj,two.obj,three.obj] +// (without whitespaces) +//////////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////////// +//! Check if command line argument \a flag-name is given +//! @return shrTRUE if command line argument \a flag_name has been given, +//! otherwise shrFALSE +//! @param argc argc as passed to main() +//! @param argv argv as passed to main() +//! @param flag_name name of command line flag +//////////////////////////////////////////////////////////////////////////// +extern "C" shrBOOL shrCheckCmdLineFlag( const int argc, const char** argv, + const char* flag_name); + +//////////////////////////////////////////////////////////////////////////// +//! Get the value of a command line argument of type int +//! @return shrTRUE if command line argument \a arg_name has been given and +//! is of the requested type, otherwise shrFALSE +//! @param argc argc as passed to main() +//! @param argv argv as passed to main() +//! @param arg_name name of the command line argument +//! @param val value of the command line argument +//////////////////////////////////////////////////////////////////////////// +extern "C" shrBOOL shrGetCmdLineArgumenti( const int argc, const char** argv, + const char* arg_name, int* val); + +//////////////////////////////////////////////////////////////////////////// +//! Get the value of a command line argument of type unsigned int +//! @return shrTRUE if command line argument \a arg_name has been given and +//! is of the requested type, otherwise shrFALSE +//! @param argc argc as passed to main() +//! @param argv argv as passed to main() +//! @param arg_name name of the command line argument +//! @param val value of the command line argument +//////////////////////////////////////////////////////////////////////////// +extern "C" shrBOOL shrGetCmdLineArgumentu( const int argc, const char** argv, + const char* arg_name, unsigned int* val); + +//////////////////////////////////////////////////////////////////////////// +//! Get the value of a command line argument of type float +//! @return shrTRUE if command line argument \a arg_name has been given and +//! is of the requested type, otherwise shrFALSE +//! @param argc argc as passed to main() +//! @param argv argv as passed to main() +//! @param arg_name name of the command line argument +//! @param val value of the command line argument +//////////////////////////////////////////////////////////////////////////// +extern "C" shrBOOL shrGetCmdLineArgumentf( const int argc, const char** argv, + const char* arg_name, float* val); + +//////////////////////////////////////////////////////////////////////////// +//! Get the value of a command line argument of type string +//! @return shrTRUE if command line argument \a arg_name has been given and +//! is of the requested type, otherwise shrFALSE +//! @param argc argc as passed to main() +//! @param argv argv as passed to main() +//! @param arg_name name of the command line argument +//! @param val value of the command line argument +//////////////////////////////////////////////////////////////////////////// +extern "C" shrBOOL shrGetCmdLineArgumentstr( const int argc, const char** argv, + const char* arg_name, char** val); + +//////////////////////////////////////////////////////////////////////////// +//! Get the value of a command line argument list those element are strings +//! @return shrTRUE if command line argument \a arg_name has been given and +//! is of the requested type, otherwise shrFALSE +//! @param argc argc as passed to main() +//! @param argv argv as passed to main() +//! @param arg_name name of the command line argument +//! @param val command line argument list +//! @param len length of the list / number of elements +//////////////////////////////////////////////////////////////////////////// +extern "C" shrBOOL shrGetCmdLineArgumentListstr( const int argc, const char** argv, + const char* arg_name, char** val, + unsigned int* len); + +//////////////////////////////////////////////////////////////////////////// +//! Compare two float arrays +//! @return shrTRUEif \a reference and \a data are identical, otherwise shrFALSE +//! @param reference handle to the reference data / gold image +//! @param data handle to the computed data +//! @param len number of elements in reference and data +//////////////////////////////////////////////////////////////////////////// +extern "C" shrBOOL shrComparef( const float* reference, const float* data, + const unsigned int len); + +//////////////////////////////////////////////////////////////////////////// +//! Compare two integer arrays +//! @return shrTRUEif \a reference and \a data are identical, otherwise shrFALSE +//! @param reference handle to the reference data / gold image +//! @param data handle to the computed data +//! @param len number of elements in reference and data +//////////////////////////////////////////////////////////////////////////// +extern "C" shrBOOL shrComparei( const int* reference, const int* data, + const unsigned int len ); + +//////////////////////////////////////////////////////////////////////////////// +//! Compare two unsigned integer arrays, with epsilon and threshold +//! @return shrTRUEif \a reference and \a data are identical, otherwise shrFALSE +//! @param reference handle to the reference data / gold image +//! @param data handle to the computed data +//! @param len number of elements in reference and data +//! @param threshold tolerance % # of comparison errors (0.15f = 15%) +//////////////////////////////////////////////////////////////////////////////// +extern "C" shrBOOL shrCompareuit( const unsigned int* reference, const unsigned int* data, + const unsigned int len, const float epsilon, const float threshold ); + +//////////////////////////////////////////////////////////////////////////// +//! Compare two unsigned char arrays +//! @return shrTRUEif \a reference and \a data are identical, otherwise shrFALSE +//! @param reference handle to the reference data / gold image +//! @param data handle to the computed data +//! @param len number of elements in reference and data +//////////////////////////////////////////////////////////////////////////// +extern "C" shrBOOL shrCompareub( const unsigned char* reference, const unsigned char* data, + const unsigned int len ); + +//////////////////////////////////////////////////////////////////////////////// +//! Compare two integers with a tolernance for # of byte errors +//! @return shrTRUEif \a reference and \a data are identical, otherwise shrFALSE +//! @param reference handle to the reference data / gold image +//! @param data handle to the computed data +//! @param len number of elements in reference and data +//! @param epsilon epsilon to use for the comparison +//! @param threshold tolerance % # of comparison errors (0.15f = 15%) +//////////////////////////////////////////////////////////////////////////////// +extern "C" shrBOOL shrCompareubt( const unsigned char* reference, const unsigned char* data, + const unsigned int len, const float epsilon, const float threshold ); + +//////////////////////////////////////////////////////////////////////////////// +//! Compare two integer arrays witha n epsilon tolerance for equality +//! @return shrTRUEif \a reference and \a data are identical, otherwise shrFALSE +//! @param reference handle to the reference data / gold image +//! @param data handle to the computed data +//! @param len number of elements in reference and data +//! @param epsilon epsilon to use for the comparison +//////////////////////////////////////////////////////////////////////////////// +extern "C" shrBOOL shrCompareube( const unsigned char* reference, const unsigned char* data, + const unsigned int len, const float epsilon ); + +//////////////////////////////////////////////////////////////////////////// +//! Compare two float arrays with an epsilon tolerance for equality +//! @return shrTRUEif \a reference and \a data are identical, otherwise shrFALSE +//! @param reference handle to the reference data / gold image +//! @param data handle to the computed data +//! @param len number of elements in reference and data +//! @param epsilon epsilon to use for the comparison +//////////////////////////////////////////////////////////////////////////// +extern "C" shrBOOL shrComparefe( const float* reference, const float* data, + const unsigned int len, const float epsilon ); + +//////////////////////////////////////////////////////////////////////////////// +//! Compare two float arrays with an epsilon tolerance for equality and a +//! threshold for # pixel errors +//! @return shrTRUEif \a reference and \a data are identical, otherwise shrFALSE +//! @param reference handle to the reference data / gold image +//! @param data handle to the computed data +//! @param len number of elements in reference and data +//! @param epsilon epsilon to use for the comparison +//////////////////////////////////////////////////////////////////////////////// +extern "C" shrBOOL shrComparefet( const float* reference, const float* data, + const unsigned int len, const float epsilon, const float threshold ); + +//////////////////////////////////////////////////////////////////////////// +//! Compare two float arrays using L2-norm with an epsilon tolerance for +//! equality +//! @return shrTRUEif \a reference and \a data are identical, otherwise shrFALSE +//! @param reference handle to the reference data / gold image +//! @param data handle to the computed data +//! @param len number of elements in reference and data +//! @param epsilon epsilon to use for the comparison +//////////////////////////////////////////////////////////////////////////// +extern "C" shrBOOL shrCompareL2fe( const float* reference, const float* data, + const unsigned int len, const float epsilon ); + +//////////////////////////////////////////////////////////////////////////////// +//! Compare two PPM image files with an epsilon tolerance for equality +//! @return shrTRUEif \a reference and \a data are identical, otherwise shrFALSE +//! @param src_file filename for the image to be compared +//! @param data filename for the reference data / gold image +//! @param epsilon epsilon to use for the comparison +//! @param threshold threshold of pixels that can still mismatch to pass (i.e. 0.15f = 15% must pass) +//! $param verboseErrors output details of image mismatch to std::err +//////////////////////////////////////////////////////////////////////////////// +extern "C" shrBOOL shrComparePPM( const char *src_file, const char *ref_file, const float epsilon, const float threshold); + +//////////////////////////////////////////////////////////////////////////////// +//! Compare two PGM image files with an epsilon tolerance for equality +//! @return shrTRUEif \a reference and \a data are identical, otherwise shrFALSE +//! @param src_file filename for the image to be compared +//! @param data filename for the reference data / gold image +//! @param epsilon epsilon to use for the comparison +//! @param threshold threshold of pixels that can still mismatch to pass (i.e. 0.15f = 15% must pass) +//! $param verboseErrors output details of image mismatch to std::err +//////////////////////////////////////////////////////////////////////////////// +extern "C" shrBOOL shrComparePGM( const char *src_file, const char *ref_file, const float epsilon, const float threshold); + +extern "C" unsigned char* shrLoadRawFile(const char* filename, size_t size); + +extern "C" size_t shrRoundUp(int group_size, int global_size); + +// companion inline function for error checking and exit on error WITH Cleanup Callback (if supplied) +// ********************************************************************* +inline void __shrCheckErrorEX(int iSample, int iReference, void (*pCleanup)(int), const char* cFile, const int iLine) +{ + if (iReference != iSample) + { + shrLogEx(LOGBOTH | ERRORMSG, iSample, "line %i , in file %s !!!\n\n" , iLine, cFile); + if (pCleanup != NULL) + { + pCleanup(EXIT_FAILURE); + } + else + { + shrLogEx(LOGBOTH | CLOSELOG, 0, "Exiting...\n"); + exit(EXIT_FAILURE); + } + } +} + +// Standardized Exit +// ********************************************************************* +inline void __shrExitEX(int argc, const char** argv, int iExitCode) +{ +#ifdef WIN32 + if (!shrCheckCmdLineFlag(argc, argv, "noprompt") && !shrCheckCmdLineFlag(argc, argv, "qatest")) +#else + if (shrCheckCmdLineFlag(argc, argv, "prompt") && !shrCheckCmdLineFlag(argc, argv, "qatest")) +#endif + { + shrLogEx(LOGBOTH | CLOSELOG, 0, "\nPress to Quit...\n"); + getchar(); + } + else + { + shrLogEx(LOGBOTH | CLOSELOG, 0, "%s Exiting...\n", argv[0]); + } + fflush(stderr); + exit(iExitCode); +} + +#endif \ No newline at end of file