merge fixes

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
+        );
+}

benchmarks/opencl/BlackScholes/Makefile

@@ -0,0 +1,65 @@
+RISCV_TOOL_PATH ?= $(wildcard ../../../../riscv-gnu-toolchain/drops)
+POCL_CC_PATH ?= $(wildcard ../../../../pocl/drops_riscv_cc)
+POCL_INC_PATH ?= $(wildcard ../include)
+POCL_LIB_PATH ?= $(wildcard ../lib)
+VX_RT_PATH ?= $(wildcard ../../../runtime)
+VX_SIMX_PATH ?= $(wildcard ../../../simX/obj_dir)
+
+CC  = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-gcc
+CXX = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-g++
+DMP = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-objdump
+HEX = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-objcopy
+GDB = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-gdb
+
+VX_SRCS =  $(VX_RT_PATH)/newlib/newlib.c
+VX_SRCS += $(VX_RT_PATH)/startup/vx_start.S
+VX_SRCS += $(VX_RT_PATH)/intrinsics/vx_intrinsics.S
+VX_SRCS += $(VX_RT_PATH)/io/vx_io.S $(VX_RT_PATH)/io/vx_io.c
+VX_SRCS += $(VX_RT_PATH)/fileio/fileio.S
+VX_SRCS += $(VX_RT_PATH)/tests/tests.c
+VX_SRCS += $(VX_RT_PATH)/vx_api/vx_api.c
+
+VX_CFLAGS = -nostartfiles -Wl,-Bstatic,-T,$(VX_RT_PATH)/startup/vx_link.ld
+
+CXXFLAGS =  -g -O0 -march=rv32im -mabi=ilp32
+CXXFLAGS += -ffreestanding # program may not begin at main()
+CXXFLAGS += -Wl,--gc-sections # enable garbage collection of unused input sections
+CXXFLAGS += -fno-rtti -fno-non-call-exceptions # disable RTTI and exceptions
+CXXFLAGS += -I$(POCL_INC_PATH) -I.
+
+VX_LIBS = -Wl,--whole-archive lib$(PROJECT).a -Wl,--no-whole-archive $(POCL_LIB_PATH)/libOpenCL.a
+QEMU_LIBS = $(VX_RT_PATH)/qemu/vx_api.c -Wl,--whole-archive lib$(PROJECT).a -Wl,--no-whole-archive $(POCL_LIB_PATH)/libOpenCL.a
+
+PROJECT=BlackScholes
+
+all: $(PROJECT).dump $(PROJECT).hex
+
+lib$(PROJECT).a: BlackScholes.cl
+	POCL_DEBUG=all POCL_DEBUG_LLVM_PASSES=1 LD_LIBRARY_PATH=$(RISCV_TOOL_PATH)/lib:$(POCL_CC_PATH)/lib $(POCL_CC_PATH)/bin/poclcc -o lib$(PROJECT).a kernel.cl
+
+$(PROJECT).elf: main.cc lib$(PROJECT).a
+	$(CXX) $(CXXFLAGS) $(VX_CFLAGS) $(VX_SRCS) main.cc oclBlackScholes_common.h oclBlackScholes_launcher.cpp oclBlackScholes_gold.cpp $(VX_LIBS) -o $(PROJECT).elf
+
+$(PROJECT).qemu: main.cc lib$(PROJECT).a
+	$(CXX) $(CXXFLAGS) main.cc $(QEMU_LIBS) -o $(PROJECT).qemu
+
+$(PROJECT).hex: $(PROJECT).elf
+	$(HEX) -O ihex $(PROJECT).elf $(PROJECT).hex
+
+$(PROJECT).dump: $(PROJECT).elf
+	$(DMP) -D $(PROJECT).elf > $(PROJECT).dump
+
+run: $(PROJECT).hex
+	POCL_DEBUG=all $(VX_SIMX_PATH)/Vcache_simX -E -a rv32i --core $(PROJECT).hex -s -b 1> emulator.debug
+
+qemu: $(PROJECT).qemu
+	POCL_DEBUG=all $(RISCV_TOOL_PATH)/bin/qemu-riscv32 -d in_asm -D debug.log $(PROJECT).qemu
+
+gdb-s: $(PROJECT).qemu
+	POCL_DEBUG=all $(RISCV_TOOL_PATH)/bin/qemu-riscv32 -g 1234 -d in_asm -D debug.log $(PROJECT).qemu
+
+gdb-c: $(PROJECT).qemu
+	$(GDB) $(PROJECT).qemu
+
+clean:
+	rm -rf *.elf *.dump *.hex

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 <oclUtils.h>
+#include <shrQATest.h>
+#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 );
+}

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 <oclUtils.h>
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// 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
+);

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 <math.h>
+#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
+        );
+}

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 <oclUtils.h>
+#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);
+}

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 <shrUtils.h>
+
+// All OpenCL headers
+#if defined (__APPLE__) || defined(MACOSX)
+    #include <OpenCL/opencl.h>
+#else
+    #include <CL/opencl.h>
+#endif 
+
+// Includes
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+// For systems with CL_EXT that are not updated with these extensions, we copied these
+// extensions from <CL/cl_ext.h>
+#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

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 <windows.h>
+	#include <time.h>
+#else
+    // Headers needed for Linux
+    #include <sys/stat.h>
+    #include <sys/types.h>
+    #include <sys/time.h>
+    #include <stdio.h>
+    #include <stdlib.h>
+    #include <string.h>
+    #include <stdarg.h>
+    #include <unistd.h>
+    #include <time.h>
+#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 <Enter> 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

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 <windows.h>
+#else
+    // Headers needed for Linux
+    #include <sys/stat.h>
+    #include <sys/types.h>
+    #include <sys/time.h>
+    #include <stdio.h>
+    #include <stdlib.h>
+    #include <string.h>
+    #include <stdarg.h>
+#endif
+
+// Other headers needed for both Windows and Linux
+#include <math.h>
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+// 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 <Enter> to Quit...\n");                  
+        getchar();                                                           
+    }       
+    else 
+    {
+        shrLogEx(LOGBOTH | CLOSELOG, 0, "%s Exiting...\n", argv[0]); 
+    }
+    fflush(stderr);                                                         
+    exit(iExitCode);
+}
+
+#endif

benchmarks/opencl/DotProduct/DotProduct.cl

@@ -0,0 +1,29 @@
+/*
+ * 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.
+ *
+ */
+ 
+ __kernel void DotProduct (__global float* a, __global float* b, __global float* c, int iNumElements)
+{
+    // find position in global arrays
+    int iGID = get_global_id(0);
+
+    // bound check (equivalent to the limit on a 'for' loop for standard/serial C code
+    if (iGID >= iNumElements)
+    {   
+        return; 
+    }
+
+    // process 
+    int iInOffset = iGID << 2;
+    c[iGID] = a[iInOffset] * b[iInOffset] 
+               + a[iInOffset + 1] * b[iInOffset + 1]
+               + a[iInOffset + 2] * b[iInOffset + 2]
+               + a[iInOffset + 3] * b[iInOffset + 3];
+}

benchmarks/opencl/DotProduct/Makefile

@@ -0,0 +1,65 @@
+RISCV_TOOL_PATH ?= $(wildcard ../../../../riscv-gnu-toolchain/drops)
+POCL_CC_PATH ?= $(wildcard ../../../../pocl/drops_riscv_cc)
+POCL_INC_PATH ?= $(wildcard ../include)
+POCL_LIB_PATH ?= $(wildcard ../lib)
+VX_RT_PATH ?= $(wildcard ../../../runtime)
+VX_SIMX_PATH ?= $(wildcard ../../../simX/obj_dir)
+
+CC  = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-gcc
+CXX = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-g++
+DMP = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-objdump
+HEX = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-objcopy
+GDB = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-gdb
+
+VX_SRCS =  $(VX_RT_PATH)/newlib/newlib.c
+VX_SRCS += $(VX_RT_PATH)/startup/vx_start.S
+VX_SRCS += $(VX_RT_PATH)/intrinsics/vx_intrinsics.S
+VX_SRCS += $(VX_RT_PATH)/io/vx_io.S $(VX_RT_PATH)/io/vx_io.c
+VX_SRCS += $(VX_RT_PATH)/fileio/fileio.S
+VX_SRCS += $(VX_RT_PATH)/tests/tests.c
+VX_SRCS += $(VX_RT_PATH)/vx_api/vx_api.c
+
+VX_CFLAGS = -nostartfiles -Wl,-Bstatic,-T,$(VX_RT_PATH)/startup/vx_link.ld
+
+CXXFLAGS =  -g -O0 -march=rv32im -mabi=ilp32 
+CXXFLAGS += -ffreestanding # program may not begin at main()
+CXXFLAGS += -Wl,--gc-sections # enable garbage collection of unused input sections
+CXXFLAGS += -fno-rtti -fno-non-call-exceptions # disable RTTI and exceptions
+CXXFLAGS += -I$(POCL_INC_PATH) -I.
+
+VX_LIBS = -Wl,--whole-archive lib$(PROJECT).a -Wl,--no-whole-archive $(POCL_LIB_PATH)/libOpenCL.a
+QEMU_LIBS = $(VX_RT_PATH)/qemu/vx_api.c -Wl,--whole-archive lib$(PROJECT).a -Wl,--no-whole-archive $(POCL_LIB_PATH)/libOpenCL.a
+
+PROJECT=DotProduct
+
+all: $(PROJECT).dump $(PROJECT).hex
+
+lib$(PROJECT).a: DotProduct.cl
+	POCL_DEBUG=all POCL_DEBUG_LLVM_PASSES=1 LD_LIBRARY_PATH=$(RISCV_TOOL_PATH)/lib:$(POCL_CC_PATH)/lib $(POCL_CC_PATH)/bin/poclcc -o lib$(PROJECT).a kernel.cl
+
+$(PROJECT).elf: main.cc lib$(PROJECT).a
+	$(CXX) $(CXXFLAGS) $(VX_CFLAGS) $(VX_SRCS) main.cc $(VX_LIBS) -o $(PROJECT).elf
+
+$(PROJECT).qemu: main.cc lib$(PROJECT).a
+	$(CXX) $(CXXFLAGS) main.cc $(QEMU_LIBS) -o $(PROJECT).qemu
+
+$(PROJECT).hex: $(PROJECT).elf
+	$(HEX) -O ihex $(PROJECT).elf $(PROJECT).hex
+
+$(PROJECT).dump: $(PROJECT).elf
+	$(DMP) -D $(PROJECT).elf > $(PROJECT).dump
+
+run: $(PROJECT).hex
+	POCL_DEBUG=all $(VX_SIMX_PATH)/Vcache_simX -E -a rv32i --core $(PROJECT).hex -s -b 1> emulator.debug
+
+qemu: $(PROJECT).qemu
+	POCL_DEBUG=all $(RISCV_TOOL_PATH)/bin/qemu-riscv32 -d in_asm -D debug.log $(PROJECT).qemu
+
+gdb-s: $(PROJECT).qemu
+	POCL_DEBUG=all $(RISCV_TOOL_PATH)/bin/qemu-riscv32 -g 1234 -d in_asm -D debug.log $(PROJECT).qemu
+
+gdb-c: $(PROJECT).qemu
+	$(GDB) $(PROJECT).qemu
+
+clean:
+	rm -rf *.elf *.dump *.hex

benchmarks/opencl/DotProduct/main.cc

@@ -0,0 +1,270 @@
+/*
+ * 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.
+ *
+ */
+
+// *********************************************************************
+// oclDotProduct Notes:  
+//
+// A simple OpenCL API demo application that implements a
+// vector dot product computation between 2 float arrays. 
+//
+// Runs computations with OpenCL on the GPU device and then checks results 
+// against basic host CPU/C++ computation.
+//
+// Uses 'shr' and 'ocl' functions from oclUtils and shrUtils libraries for compactness. 
+// But these are NOT required libs for OpenCL developement in general.
+// *********************************************************************
+
+// standard utilities and systems includes
+#include <oclUtils.h>
+#include <shrQATest.h>
+
+// Name of the file with the source code for the computation kernel
+// *********************************************************************
+const char* cSourceFile = "DotProduct.cl";
+
+// Host buffers for demo
+// *********************************************************************
+void *srcA, *srcB, *dst;        // Host buffers for OpenCL test
+void* Golden;                   // Host buffer for host golden processing cross check
+
+// OpenCL Vars
+cl_platform_id cpPlatform;      // OpenCL platform
+cl_device_id   *cdDevices;      // OpenCL device
+cl_context cxGPUContext;        // OpenCL context
+cl_command_queue cqCommandQueue;// OpenCL command que
+cl_program program;           // OpenCL program
+cl_kernel ckKernel;             // OpenCL kernel
+cl_mem cmDevSrcA;               // OpenCL device source buffer A
+cl_mem cmDevSrcB;               // OpenCL device source buffer B 
+cl_mem cmDevDst;                // OpenCL device destination buffer 
+size_t szGlobalWorkSize;        // Total # of work items in the 1D range
+size_t szLocalWorkSize;		    // # of work items in the 1D work group	
+size_t szParmDataBytes;			// Byte size of context information
+size_t szKernelLength;			// Byte size of kernel code
+cl_int ciErrNum;			    // Error code var
+char* cPathAndName = NULL;      // var for full paths to data, src, etc.
+char* cSourceCL = NULL;         // Buffer to hold source for compilation 
+const char* cExecutableName = NULL;
+
+// demo config vars
+int iNumElements= 1277944;	    // Length of float arrays to process (odd # for illustration)
+shrBOOL bNoPrompt = shrFALSE;  
+
+// Forward Declarations
+// *********************************************************************
+void DotProductHost(const float* pfData1, const float* pfData2, float* pfResult, int iNumElements);
+void Cleanup (int iExitCode);
+void (*pCleanup)(int) = &Cleanup;
+
+int *gp_argc = NULL;
+char ***gp_argv = NULL;
+
+// Main function 
+// *********************************************************************
+int main(int argc, char **argv)
+{
+    gp_argc = &argc;
+    gp_argv = &argv;
+
+    shrQAStart(argc, argv);
+
+    // Get the NVIDIA platform
+    ciErrNum = oclGetPlatformID(&cpPlatform);
+    //oclCheckErrorEX(ciErrNum, CL_SUCCESS, NULL);
+    shrLog("clGetPlatformID...\n"); 
+
+    // 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); 
+
+    // get command line arg for quick test, if provided
+    bNoPrompt = shrCheckCmdLineFlag(argc, (const char**)argv, "noprompt");
+
+    // start logs
+	cExecutableName = argv[0];
+    shrSetLogFileName ("oclDotProduct.txt");
+    shrLog("%s Starting...\n\n# of float elements per Array \t= %u\n", argv[0], iNumElements); 
+
+    // set and log Global and Local work size dimensions
+    szLocalWorkSize = 256;
+    szGlobalWorkSize = shrRoundUp((int)szLocalWorkSize, iNumElements);  // rounded up to the nearest multiple of the LocalWorkSize
+    shrLog("Global Work Size \t\t= %u\nLocal Work Size \t\t= %u\n# of Work Groups \t\t= %u\n\n", 
+           szGlobalWorkSize, szLocalWorkSize, (szGlobalWorkSize % szLocalWorkSize + szGlobalWorkSize/szLocalWorkSize)); 
+
+    // Allocate and initialize host arrays
+    shrLog( "Allocate and Init Host Mem...\n"); 
+    srcA = (void *)malloc(sizeof(cl_float4) * szGlobalWorkSize);
+    srcB = (void *)malloc(sizeof(cl_float4) * szGlobalWorkSize);
+    dst = (void *)malloc(sizeof(cl_float) * szGlobalWorkSize);
+    Golden = (void *)malloc(sizeof(cl_float) * iNumElements);
+    shrFillArray((float*)srcA, 4 * iNumElements);
+    shrFillArray((float*)srcB, 4 * iNumElements);
+
+    // Get the NVIDIA platform
+    ciErrNum = oclGetPlatformID(&cpPlatform);
+    //oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup);
+
+    // Get a GPU device
+    ciErrNum = clGetDeviceIDs(cpPlatform, CL_DEVICE_TYPE_DEFAULT, 1, &cdDevices[uiTargetDevice], NULL);
+    //oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup);
+
+    // Create the context
+    cxGPUContext = clCreateContext(0, 1, &cdDevices[uiTargetDevice], NULL, NULL, &ciErrNum);
+    //oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup);
+
+    // Create a command-queue
+    shrLog("clCreateCommandQueue...\n"); 
+    cqCommandQueue = clCreateCommandQueue(cxGPUContext, cdDevices[uiTargetDevice], 0, &ciErrNum);
+    //oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup);
+
+    // Allocate the OpenCL buffer memory objects for source and result on the device GMEM
+    shrLog("clCreateBuffer (SrcA, SrcB and Dst in Device GMEM)...\n"); 
+    cmDevSrcA = clCreateBuffer(cxGPUContext, CL_MEM_READ_ONLY, sizeof(cl_float) * szGlobalWorkSize * 4, NULL, &ciErrNum);
+    //oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup);
+    cmDevSrcB = clCreateBuffer(cxGPUContext, CL_MEM_READ_ONLY, sizeof(cl_float) * szGlobalWorkSize * 4, NULL, &ciErrNum);
+    //oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup);
+    cmDevDst = clCreateBuffer(cxGPUContext, CL_MEM_WRITE_ONLY, sizeof(cl_float) * szGlobalWorkSize, NULL, &ciErrNum);
+    //oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup);
+
+    // Read the OpenCL kernel in from source file
+    shrLog("oclLoadProgSource (%s)...\n", cSourceFile); 
+    cPathAndName = shrFindFilePath(cSourceFile, argv[0]);
+    //oclCheckErrorEX(cPathAndName != NULL, shrTRUE, pCleanup);
+    cSourceCL = oclLoadProgSource(cPathAndName, "", &szKernelLength);
+    //oclCheckErrorEX(cSourceCL != NULL, shrTRUE, pCleanup);
+
+    // Create the program
+    shrLog("clCreateProgramWithSource...\n"); 
+    //program = clCreateProgramWithSource(cxGPUContext, 1, (const char **)&cSourceCL, &szKernelLength, &ciErrNum);
+    cl_program program =
+      clCreateProgramWithBuiltInKernels(context, 1, &device_id, "sgemm", NULL);
+        // Build the program with 'mad' Optimization option
+    #ifdef MAC
+        char* flags = "-cl-fast-relaxed-math -DMAC";
+    #else
+        char* flags = "-cl-fast-relaxed-math";
+    #endif
+    shrLog("clBuildProgram...\n"); 
+    ciErrNum = clBuildProgram(program, 0, NULL, NULL, NULL, NULL);
+    if (ciErrNum != CL_SUCCESS)
+    {
+        // write out standard error, Build Log and PTX, then cleanup and exit
+        shrLogEx(LOGBOTH | ERRORMSG, ciErrNum, STDERROR);
+        oclLogBuildInfo(program, oclGetFirstDev(cxGPUContext));
+        oclLogPtx(program, oclGetFirstDev(cxGPUContext), "oclDotProduct.ptx");
+        Cleanup(EXIT_FAILURE); 
+    }
+
+    // Create the kernel
+    shrLog("clCreateKernel (DotProduct)...\n"); 
+    ckKernel = clCreateKernel(program, "DotProduct", &ciErrNum);
+
+    // Set the Argument values
+    shrLog("clSetKernelArg 0 - 3...\n\n"); 
+    ciErrNum = clSetKernelArg(ckKernel, 0, sizeof(cl_mem), (void*)&cmDevSrcA);
+    ciErrNum |= clSetKernelArg(ckKernel, 1, sizeof(cl_mem), (void*)&cmDevSrcB);
+    ciErrNum |= clSetKernelArg(ckKernel, 2, sizeof(cl_mem), (void*)&cmDevDst);
+    ciErrNum |= clSetKernelArg(ckKernel, 3, sizeof(cl_int), (void*)&iNumElements);
+    //oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup);
+
+    // --------------------------------------------------------
+    // Core sequence... copy input data to GPU, compute, copy results back
+
+    // Asynchronous write of data to GPU device
+    shrLog("clEnqueueWriteBuffer (SrcA and SrcB)...\n"); 
+    ciErrNum = clEnqueueWriteBuffer(cqCommandQueue, cmDevSrcA, CL_FALSE, 0, sizeof(cl_float) * szGlobalWorkSize * 4, srcA, 0, NULL, NULL);
+    ciErrNum |= clEnqueueWriteBuffer(cqCommandQueue, cmDevSrcB, CL_FALSE, 0, sizeof(cl_float) * szGlobalWorkSize * 4, srcB, 0, NULL, NULL);
+    //oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup);
+
+    // Launch kernel
+    shrLog("clEnqueueNDRangeKernel (DotProduct)...\n"); 
+    ciErrNum = clEnqueueNDRangeKernel(cqCommandQueue, ckKernel, 1, NULL, &szGlobalWorkSize, &szLocalWorkSize, 0, NULL, NULL);
+    //oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup);
+
+    // Read back results and check accumulated errors
+    shrLog("clEnqueueReadBuffer (Dst)...\n\n"); 
+    ciErrNum = clEnqueueReadBuffer(cqCommandQueue, cmDevDst, CL_TRUE, 0, sizeof(cl_float) * szGlobalWorkSize, dst, 0, NULL, NULL);
+    //oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup);
+
+    // Compute and compare results for golden-host and report errors and pass/fail
+    shrLog("Comparing against Host/C++ computation...\n\n"); 
+    DotProductHost ((const float*)srcA, (const float*)srcB, (float*)Golden, iNumElements);
+    shrBOOL bMatch = shrComparefet((const float*)Golden, (const float*)dst, (unsigned int)iNumElements, 0.0f, 0);
+
+    // Cleanup and leave
+    Cleanup (EXIT_SUCCESS);
+}
+
+// "Golden" Host processing dot product function for comparison purposes
+// *********************************************************************
+void DotProductHost(const float* pfData1, const float* pfData2, float* pfResult, int iNumElements)
+{
+    int i, j, k;
+    for (i = 0, j = 0; i < iNumElements; i++) 
+    {
+        pfResult[i] = 0.0f;
+        for (k = 0; k < 4; k++, j++) 
+        {
+            pfResult[i] += pfData1[j] * pfData2[j]; 
+        } 
+    }
+}
+
+// Cleanup and exit code
+// *********************************************************************
+void Cleanup(int iExitCode)
+{
+    // Cleanup allocated objects
+    shrLog("Starting Cleanup...\n\n");
+    if(cPathAndName)free(cPathAndName);
+    if(cSourceCL)free(cSourceCL);
+	if(ckKernel)clReleaseKernel(ckKernel);  
+    if(program)clReleaseProgram(program);
+    if(cqCommandQueue)clReleaseCommandQueue(cqCommandQueue);
+    if(cxGPUContext)clReleaseContext(cxGPUContext);
+    if (cmDevSrcA)clReleaseMemObject(cmDevSrcA);
+    if (cmDevSrcB)clReleaseMemObject(cmDevSrcB);
+    if (cmDevDst)clReleaseMemObject(cmDevDst);
+
+    // Free host memory
+    free(srcA); 
+    free(srcB);
+    free (dst);
+    free(Golden);
+
+    if (cdDevices) free(cdDevices);
+
+    shrQAFinishExit(*gp_argc, (const char **)*gp_argv, (iExitCode == EXIT_SUCCESS) ? QA_PASSED : QA_FAILED);
+}

benchmarks/opencl/DotProduct/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 <shrUtils.h>
+
+// All OpenCL headers
+#if defined (__APPLE__) || defined(MACOSX)
+    #include <OpenCL/opencl.h>
+#else
+    #include <CL/opencl.h>
+#endif 
+
+// Includes
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+// For systems with CL_EXT that are not updated with these extensions, we copied these
+// extensions from <CL/cl_ext.h>
+#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

benchmarks/opencl/DotProduct/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 <windows.h>
+	#include <time.h>
+#else
+    // Headers needed for Linux
+    #include <sys/stat.h>
+    #include <sys/types.h>
+    #include <sys/time.h>
+    #include <stdio.h>
+    #include <stdlib.h>
+    #include <string.h>
+    #include <stdarg.h>
+    #include <unistd.h>
+    #include <time.h>
+#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 <Enter> 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

benchmarks/opencl/DotProduct/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 <windows.h>
+#else
+    // Headers needed for Linux
+    #include <sys/stat.h>
+    #include <sys/types.h>
+    #include <sys/time.h>
+    #include <stdio.h>
+    #include <stdlib.h>
+    #include <string.h>
+    #include <stdarg.h>
+#endif
+
+// Other headers needed for both Windows and Linux
+#include <math.h>
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+// 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 <Enter> to Quit...\n");                  
+        getchar();                                                           
+    }       
+    else 
+    {
+        shrLogEx(LOGBOTH | CLOSELOG, 0, "%s Exiting...\n", argv[0]); 
+    }
+    fflush(stderr);                                                         
+    exit(iExitCode);
+}
+
+#endif

benchmarks/opencl/VectorHypot/Makefile

@@ -0,0 +1,65 @@
+RISCV_TOOL_PATH ?= $(wildcard ../../../../riscv-gnu-toolchain/drops)
+POCL_CC_PATH ?= $(wildcard ../../../../pocl/drops_riscv_cc)
+POCL_INC_PATH ?= $(wildcard ../include)
+POCL_LIB_PATH ?= $(wildcard ../lib)
+VX_RT_PATH ?= $(wildcard ../../../runtime)
+VX_SIMX_PATH ?= $(wildcard ../../../simX/obj_dir)
+
+CC  = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-gcc
+CXX = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-g++
+DMP = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-objdump
+HEX = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-objcopy
+GDB = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-gdb
+
+VX_SRCS =  $(VX_RT_PATH)/newlib/newlib.c
+VX_SRCS += $(VX_RT_PATH)/startup/vx_start.S
+VX_SRCS += $(VX_RT_PATH)/intrinsics/vx_intrinsics.S
+VX_SRCS += $(VX_RT_PATH)/io/vx_io.S $(VX_RT_PATH)/io/vx_io.c
+VX_SRCS += $(VX_RT_PATH)/fileio/fileio.S
+VX_SRCS += $(VX_RT_PATH)/tests/tests.c
+VX_SRCS += $(VX_RT_PATH)/vx_api/vx_api.c
+
+VX_CFLAGS = -nostartfiles -Wl,-Bstatic,-T,$(VX_RT_PATH)/startup/vx_link.ld
+
+CXXFLAGS =  -g -O0 -march=rv32im -mabi=ilp32 
+CXXFLAGS += -ffreestanding # program may not begin at main()
+CXXFLAGS += -Wl,--gc-sections # enable garbage collection of unused input sections
+CXXFLAGS += -fno-rtti -fno-non-call-exceptions # disable RTTI and exceptions
+CXXFLAGS += -I$(POCL_INC_PATH) -I.
+
+VX_LIBS = -Wl,--whole-archive lib$(PROJECT).a -Wl,--no-whole-archive $(POCL_LIB_PATH)/libOpenCL.a
+QEMU_LIBS = $(VX_RT_PATH)/qemu/vx_api.c -Wl,--whole-archive lib$(PROJECT).a -Wl,--no-whole-archive $(POCL_LIB_PATH)/libOpenCL.a
+
+PROJECT=VectorHypot
+
+all: $(PROJECT).dump $(PROJECT).hex
+
+lib$(PROJECT).a: VectorHypot.cl
+	POCL_DEBUG=all POCL_DEBUG_LLVM_PASSES=1 LD_LIBRARY_PATH=$(RISCV_TOOL_PATH)/lib:$(POCL_CC_PATH)/lib $(POCL_CC_PATH)/bin/poclcc -o lib$(PROJECT).a kernel.cl
+
+$(PROJECT).elf: main.cc lib$(PROJECT).a
+	$(CXX) $(CXXFLAGS) $(VX_CFLAGS) $(VX_SRCS) main.cc $(VX_LIBS) -o $(PROJECT).elf
+
+$(PROJECT).qemu: main.cc lib$(PROJECT).a
+	$(CXX) $(CXXFLAGS) main.cc $(QEMU_LIBS) -o $(PROJECT).qemu
+
+$(PROJECT).hex: $(PROJECT).elf
+	$(HEX) -O ihex $(PROJECT).elf $(PROJECT).hex
+
+$(PROJECT).dump: $(PROJECT).elf
+	$(DMP) -D $(PROJECT).elf > $(PROJECT).dump
+
+run: $(PROJECT).hex
+	POCL_DEBUG=all $(VX_SIMX_PATH)/Vcache_simX -E -a rv32i --core $(PROJECT).hex -s -b 1> emulator.debug
+
+qemu: $(PROJECT).qemu
+	POCL_DEBUG=all $(RISCV_TOOL_PATH)/bin/qemu-riscv32 -d in_asm -D debug.log $(PROJECT).qemu
+
+gdb-s: $(PROJECT).qemu
+	POCL_DEBUG=all $(RISCV_TOOL_PATH)/bin/qemu-riscv32 -g 1234 -d in_asm -D debug.log $(PROJECT).qemu
+
+gdb-c: $(PROJECT).qemu
+	$(GDB) $(PROJECT).qemu
+
+clean:
+	rm -rf *.elf *.dump *.hex

benchmarks/opencl/VectorHypot/VectorHypot.cl

@@ -0,0 +1,41 @@
+/*
+ * 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.
+ *
+ */
+ 
+// OpenCL Kernel Function Naive Implementation for hyptenuse
+__kernel void VectorHypot(__global float4* fg4A, __global float4* fg4B, __global float4* fg4Hypot, unsigned int uiOffset, int iInnerLoopCount, unsigned int uiNumElements)
+{
+    // get index into global data array
+    size_t szGlobalOffset = get_global_id(0) + uiOffset;
+
+    // bound check 
+    if (szGlobalOffset >= uiNumElements)
+    {   
+        return; 
+    }
+
+    // Processing 4 elements per work item, so read fgA and fgB source values from GMEM
+    float4 f4A = fg4A[szGlobalOffset];
+    float4 f4B = fg4B[szGlobalOffset];
+    float4 f4H = (float4)0.0f;
+     
+    // Get the hypotenuses the vectors of 'legs', but exaggerate the time needed with loop  
+    for (int i = 0; i < iInnerLoopCount; i++)  
+    {
+        // compute the 4 hypotenuses using built-in function
+        f4H.x = hypot (f4A.x, f4B.x);
+        f4H.y = hypot (f4A.y, f4B.y);
+        f4H.z = hypot (f4A.z, f4B.z);
+        f4H.w = hypot (f4A.w, f4B.w);
+    }
+    
+    // Write 4 result values back out to GMEM
+    fg4Hypot[szGlobalOffset] = f4H;
+}

benchmarks/opencl/VectorHypot/main.cc

@@ -0,0 +1,686 @@
+/*
+ * 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.
+ *
+ */
+
+// *********************************************************************
+// oclCopyComputeOverlap Notes:  
+//
+// OpenCL API demo application for NVIDIA CUDA GPU's that implements a
+// element by element vector hyptenuse computation using 2 input float arrays
+// and 1 output float array.
+//
+// Demonstrates host->GPU and GPU->host copies that are asynchronous/overlapped
+// with respect to GPU computation (and with respect to host thread). 
+//
+// Because the overlap acheivable for this computation and data set on a given system depends upon the GPU being used and the
+// GPU/Host bandwidth, the sample adjust the computation duration to test the most ideal case and test against a consistent standard.
+// This sample should be able to achieve up to 30% overlap on GPU's arch 1.2 and 1.3, and up to 50% on arch 2.0+ (Fermi) GPU's.
+//
+// After setup, warmup and calibration to the system, the sample runs 4 scenarios:  
+//      A) Computations with 2 command queues on GPU
+//         A multiple-cycle sequence is executed, timed and compared against the host
+//      B) Computations with 1 command queue on GPU
+//         A multiple-cycle sequence is executed, timed and compared against the host
+//
+//      The 2-command queue approach ought to be substantially faster
+//
+// For developmental purposes, the "iInnerLoopCount" variable passes into kernel and independently 
+// increases compute time without increasing data size (via a loop inside the kernel)
+//
+//      At some value of iInnerLoopCount, # of elements, workgroup size, etc the Overlap percentage should reach 30%:
+//      (This ~naively assumes time H2D bandwidth is the same as D2H bandwidth, but this is close on most systems)
+//
+//      If we name the time to copy single input vector H2D (or outpute vector D2H) as "T", then the optimum comparison case is:
+//        
+//          Single Queue with all the data and all the work  
+//             Ttot (serial)        = 4T + 4T + 2T      = 10T    
+//
+//          Dual Queue, where each queue has 1/2 the data and 1/2 the work 
+//             Tq0  (overlap)       = 2T + 2T + T .... 
+//             Tq1  (overlap)       = .... 2T + 2T + T
+//
+//             Ttot (elapsed, wall) = 2T + 2T + 2T + T  = 7T
+//
+//          Best Overlap % = 100.0 * (10T - 7T)/10T = 30.0 %	(Tesla arch 1.2 or 1.3, single copy engine)
+//
+//			For multiple independent cycles using arch >= 2.0 with 2 copy engines, input and output copies can also be overlapped.
+//			This doesn't help for the first cycle, but theoretically can lead to 50% overlap over many independent cycles.			
+// *********************************************************************
+
+// common SDK header for standard utilities and system libs 
+#include <oclUtils.h>
+#include <shrQATest.h>
+
+// Best possible and Min ratio of compute/copy overlap timing benefit to pass the test
+// values greater than 0.0f represent a speed-up relative to non-overlapped
+#define EXPECTED_OVERLAP 30.0f
+#define EXPECTED_OVERLAP_FERMI 45.0f
+#define PASS_FACTOR 0.60f
+#define RETRIES_ON_FAILURE 1
+
+// Base sizes for parameters manipulated dynamically or on the command line
+#define BASE_WORK_ITEMS 64
+#define BASE_ARRAY_LENGTH 40000
+#define BASE_LOOP_COUNT 32
+
+// Vars
+// *********************************************************************
+cl_platform_id cpPlatform;                          // OpenCL platform
+cl_context cxGPUContext;                            // OpenCL context
+cl_command_queue cqCommandQueue[2];                 // OpenCL command queues
+cl_device_id* cdDevices;                            // OpenCL device list  
+cl_program cpProgram;                               // OpenCL program
+cl_kernel ckKernel[2];                              // OpenCL kernel, 1 per queue
+cl_mem cmPinnedSrcA;                                // OpenCL pinned host source buffer A
+cl_mem cmPinnedSrcB;                                // OpenCL pinned host source buffer B 
+cl_mem cmPinnedResult;                              // OpenCL pinned host result buffer 
+float* fSourceA = NULL;                             // Mapped pointer for pinned Host source A buffer
+float* fSourceB = NULL;                             // Mapped pointer for pinned Host source B buffer
+float* fResult = NULL;                              // Mapped pointer for pinned Host result buffer 
+cl_mem cmDevSrcA;                                   // OpenCL device source buffer A
+cl_mem cmDevSrcB;                                   // OpenCL device source buffer B 
+cl_mem cmDevResult;                                 // OpenCL device result buffer 
+size_t szBuffBytes;                                 // Size of main buffers
+size_t szGlobalWorkSize;                            // 1D var for Total # of work items in the launched ND range
+size_t szLocalWorkSize = BASE_WORK_ITEMS;           // initial # of work items in the work group	
+cl_int ciErrNum;			                        // Error code var
+char* cPathAndName = NULL;                          // Var for full paths to data, src, etc.
+char* cSourceCL = NULL;                             // Buffer to hold source for compilation 
+const char* cExecutableName = NULL;
+
+// demo config vars
+const char* cSourceFile = "VectorHypot.cl";         // OpenCL computation kernel source code
+float* Golden = NULL;                               // temp buffer to hold golden results for cross check    
+bool bNoPrompt = false;                             // Command line switch to skip exit prompt
+bool bQATest = false;                               // Command line switch to test
+
+// Forward Declarations
+// *********************************************************************
+double DualQueueSequence(int iCycles, unsigned int uiNumElements, bool bShowConfig);
+double OneQueueSequence(int iCycles, unsigned int uiNumElements, bool bShowConfig);
+int AdjustCompute(cl_device_id cdTargetDevice, unsigned int uiNumElements, int iInitialLoopCount, int iCycles); 
+void VectorHypotHost(const float* pfData1, const float* pfData2, float* pfResult, unsigned int uiNumElements, int iInnerLoopCount);
+void Cleanup (int iExitCode);
+void (*pCleanup)(int) = &Cleanup;
+
+int *gp_argc = 0;
+const char *** gp_argv = NULL;
+
+// Main function 
+// *********************************************************************
+int main(int argc, const char **argv)
+{
+    //Locals
+    size_t szKernelLength;                      // Byte size of kernel code
+    double dBuildTime;                          // Compile time
+    cl_uint uiTargetDevice = 0;	                // Default Device to compute on
+    cl_uint uiNumDevsUsed = 1;                  // Number of devices used in this sample   
+    cl_uint uiNumDevices;                       // Number of devices available 
+    int iDevCap = -1;                           // Capability of device
+    int iInnerLoopCount = BASE_LOOP_COUNT;      // Varies "compute intensity" per data within the kernel 
+    const int iTestCycles = 10;                 // How many times to run the external test loop 
+    const int iWarmupCycles = 8;                // How many times to run the warmup sequence 
+    cl_uint uiWorkGroupMultiple = 4;            // Command line var (using "workgroupmult=<n>") to optionally increase workgroup size
+    cl_uint uiNumElements = BASE_ARRAY_LENGTH;  // initial # of elements per array to process (note: procesing 4 per work item)
+    cl_uint uiSizeMultiple = 4;                 // Command line var (using "sizemult=<n>") to optionally increase vector sizes
+    bool bPassFlag = false;                     // Var to accumulate test pass/fail
+    shrBOOL bMatch = shrFALSE;                  // Cross check result
+	shrBOOL bTestOverlap = shrFALSE;
+	double dAvgGPUTime[2] = {0.0, 0.0};         // Average time of iTestCycles calls for 2-Queue and 1-Queue test
+    double dHostTime[2] = {0.0, 0.0};           // Host computation time (2nd test is redundant but a good stability indicator)
+    float fMinPassCriteria[2] = {0.0f, 0.0f};	// Test pass cireria, adjusted dependant on GPU arch
+
+    gp_argc = &argc;
+    gp_argv = &argv;
+
+    shrQAStart(argc, (char **)argv);
+
+    // start logs 
+	cExecutableName = argv[0];
+    shrSetLogFileName ("oclCopyComputeOverlap.txt");
+    shrLog("%s Starting...\n\n", argv[0]); 
+
+    // get basic command line args 
+    bNoPrompt = (shrTRUE == shrCheckCmdLineFlag(argc, argv, "noprompt"));
+    bQATest   = (shrTRUE == shrCheckCmdLineFlag(argc, argv, "qatest"));
+    shrGetCmdLineArgumentu(argc, argv, "device", &uiTargetDevice);
+
+    // Optional Command-line multiplier for vector size 
+    //   Default val of 4 gives 10.24 million float elements per vector
+    //   Range of 3 - 16 (7.68 to 40.96 million floats) is reasonable range (if system and GPU have enough memory)
+    shrGetCmdLineArgumentu(argc, argv, "sizemult", &uiSizeMultiple);
+    uiSizeMultiple = CLAMP(uiSizeMultiple, 1, 50);  
+    uiNumElements = uiSizeMultiple * BASE_ARRAY_LENGTH * BASE_WORK_ITEMS;
+    shrLog("Array sizes = %u float elements\n", uiNumElements); 
+
+    // Optional Command-line multiplier for workgroup size (x 64 work items)
+    //   Default val of 4 gives szLocalWorkSize of 256.
+    //   Range of 1 - 8 (resulting in workgroup sizes of 64 to 512) is reasonable range
+    shrGetCmdLineArgumentu(argc, argv, "workgroupmult", &uiWorkGroupMultiple);
+    uiWorkGroupMultiple = CLAMP(uiWorkGroupMultiple, 1, 10); 
+    szLocalWorkSize = uiWorkGroupMultiple * BASE_WORK_ITEMS;
+    shrLog("Workgroup Size = %u\n\n", szLocalWorkSize); 
+
+    // Get the NVIDIA platform if available, otherwise use default
+    shrLog("Get the Platform ID...\n\n");
+    ciErrNum = oclGetPlatformID(&cpPlatform);
+    //oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup);
+
+    // Get OpenCL platform name and version
+    char cBuffer[256];
+    ciErrNum = clGetPlatformInfo (cpPlatform, CL_PLATFORM_NAME, sizeof(cBuffer), cBuffer, NULL);
+    //oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup);
+    shrLog("Platform Name = %s\n\n", cBuffer);
+
+    // Get all the devices
+    shrLog("Get the Device info and select Device...\n");
+    ciErrNum = clGetDeviceIDs(cpPlatform, CL_DEVICE_TYPE_DEFAULT, 0, NULL, &uiNumDevices);
+    //oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup);
+    cdDevices = (cl_device_id*)malloc(uiNumDevices * sizeof(cl_device_id));
+
+    // Ethans changes
+    CL_CHECK(clGetPlatformIDs(1, &platform_id, NULL));
+    CL_CHECK(clGetDeviceIDs(platform_id, CL_DEVICE_TYPE_DEFAULT, 1, &device_id, NULL));
+    //ciErrNum = clGetDeviceIDs(cpPlatform, CL_DEVICE_TYPE_GPU, uiNumDevices, cdDevices, NULL);
+    //oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup);
+
+    // Set target device and check capabilities 
+    shrLog(" # of Devices Available = %u\n", uiNumDevices); 
+    uiTargetDevice = CLAMP(uiTargetDevice, 0, (uiNumDevices - 1));
+    shrLog(" Using Device %u, ", uiTargetDevice); 
+    oclPrintDevName(LOGBOTH, cdDevices[uiTargetDevice]);  
+    iDevCap = oclGetDevCap(cdDevices[uiTargetDevice]);
+    if (iDevCap > 0) {
+       shrLog(", Capability = %d.%d\n\n", iDevCap/10, iDevCap%10);
+    } else {
+       shrLog("\n\n", iDevCap); 
+    }
+    if (strstr(cBuffer, "NVIDIA") != NULL)
+    {
+        if (iDevCap < 12)
+        {
+            shrLog("Device doesn't have overlap capability.  Skipping test...\n"); 
+            Cleanup (EXIT_SUCCESS);
+        }
+
+		// Device and Platform eligible for overlap testing
+		bTestOverlap = shrTRUE;
+
+        // If device has overlap capability, proceed
+        fMinPassCriteria[0] = PASS_FACTOR * EXPECTED_OVERLAP;               // 1st cycle overlap is same for 1 or 2 copy engines
+        if (iDevCap != 20) 
+        {
+            // Single copy engine
+            fMinPassCriteria[1] = PASS_FACTOR * EXPECTED_OVERLAP;            // avg of many cycles
+        }
+        else 
+        {
+            char cDevName[1024];
+            clGetDeviceInfo(cdDevices[uiTargetDevice], CL_DEVICE_NAME, sizeof(cDevName), &cDevName, NULL);
+            if(strstr(cDevName, "Quadro")!=0 || strstr(cDevName, "Tesla")!=0)
+            {
+                // Tesla or Quadro (arch = 2.0) ... Dual copy engine 
+                fMinPassCriteria[1] = PASS_FACTOR * EXPECTED_OVERLAP_FERMI;  // average of many cycles
+            }
+            else
+            {
+                // Geforce ... Single copy engine
+                fMinPassCriteria[1] = PASS_FACTOR * EXPECTED_OVERLAP;        // average of many cycles
+            }
+        }
+    }   
+
+    // Create the context
+    shrLog("clCreateContext...\n"); 
+    cxGPUContext = clCreateContext(0, uiNumDevsUsed, &cdDevices[uiTargetDevice], NULL, NULL, &ciErrNum);
+    //oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup);
+    
+    // Create 2 command-queues
+    cqCommandQueue[0] = clCreateCommandQueue(cxGPUContext, cdDevices[uiTargetDevice], 0, &ciErrNum);
+    //oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup);
+    shrLog("clCreateCommandQueue [0]...\n"); 
+    cqCommandQueue[1] = clCreateCommandQueue(cxGPUContext, cdDevices[uiTargetDevice], 0, &ciErrNum);
+    //oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup);
+    shrLog("clCreateCommandQueue [1]...\n"); 
+
+    // Allocate the OpenCL source and result buffer memory objects on GPU device GMEM
+    szBuffBytes = sizeof(cl_float) * uiNumElements;
+    cmDevSrcA = clCreateBuffer(cxGPUContext, CL_MEM_READ_ONLY, szBuffBytes, NULL, &ciErrNum);
+    //oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup);
+    cmDevSrcB = clCreateBuffer(cxGPUContext, CL_MEM_READ_ONLY, szBuffBytes, NULL, &ciErrNum);
+    //oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup);
+    cmDevResult = clCreateBuffer(cxGPUContext, CL_MEM_WRITE_ONLY, szBuffBytes, NULL, &ciErrNum);
+    //oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup);
+    shrLog("clCreateBuffer (Src A, Src B and Result GPU Device GMEM, 3 x %u floats) ...\n", uiNumElements); 
+
+    // Allocate pinned source and result host buffers:  
+    //   Note: Pinned (Page Locked) memory is needed for async host<->GPU memory copy operations ***
+    cmPinnedSrcA = clCreateBuffer(cxGPUContext, CL_MEM_READ_WRITE | CL_MEM_ALLOC_HOST_PTR, szBuffBytes, NULL, &ciErrNum);
+    //oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup);
+    cmPinnedSrcB = clCreateBuffer(cxGPUContext, CL_MEM_READ_WRITE | CL_MEM_ALLOC_HOST_PTR, szBuffBytes, NULL, &ciErrNum);
+    //oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup);
+    cmPinnedResult = clCreateBuffer(cxGPUContext, CL_MEM_READ_WRITE | CL_MEM_ALLOC_HOST_PTR, szBuffBytes, NULL, &ciErrNum);
+    //oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup);
+    shrLog("clCreateBuffer (Src A, Src B and Result Pinned Host buffers, 3 x %u floats)...\n\n", uiNumElements); 
+
+    // Get mapped pointers to pinned input host buffers
+    //   Note:  This allows general (non-OpenCL) host functions to access pinned buffers using standard pointers
+    fSourceA = (cl_float*)clEnqueueMapBuffer(cqCommandQueue[0], cmPinnedSrcA, CL_TRUE, CL_MAP_WRITE, 0, szBuffBytes, 0, NULL, NULL, &ciErrNum);
+    //oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup);
+    fSourceB = (cl_float*)clEnqueueMapBuffer(cqCommandQueue[0], cmPinnedSrcB, CL_TRUE, CL_MAP_WRITE, 0, szBuffBytes, 0, NULL, NULL, &ciErrNum);
+    //oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup);
+    fResult = (cl_float*)clEnqueueMapBuffer(cqCommandQueue[0], cmPinnedResult, CL_TRUE, CL_MAP_READ, 0, szBuffBytes, 0, NULL, NULL, &ciErrNum);
+    //oclCheckErrorEX (ciErrNum, CL_SUCCESS, pCleanup);
+    shrLog("clEnqueueMapBuffer (Pointers to 3 pinned host buffers)...\n"); 
+
+    // Alloc temp golden buffer for cross checks
+    Golden = (float*)malloc(szBuffBytes);
+    //oclCheckErrorEX(Golden != NULL, shrTRUE, pCleanup);
+
+    // Read the OpenCL kernel in from source file
+    cPathAndName = shrFindFilePath(cSourceFile, argv[0]);
+    //oclCheckError(cPathAndName != NULL, shrTRUE);
+    cSourceCL = oclLoadProgSource(cPathAndName, "", &szKernelLength);
+   // oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup);
+    shrLog("oclLoadProgSource (%s)...\n", cSourceFile); 
+
+    // Create the program object
+    //cpProgram = clCreateProgramWithSource(cxGPUContext, 1, (const char **)&cSourceCL, &szKernelLength, &ciErrNum);
+    //oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup);
+    shrLog("clCreateProgramWithSource...\n"); 
+    cl_program program =
+      clCreateProgramWithBuiltInKernels(context, 1, &device_id, "VectorHypot", NULL);
+    // Build the program for the target device
+    clFinish(cqCommandQueue[0]);
+    shrDeltaT(0);
+    ciErrNum = clBuildProgram(program, uiNumDevsUsed, &cdDevices[uiTargetDevice], "-cl-fast-relaxed-math", NULL, NULL);
+    shrLog("clBuildProgram..."); 
+    if (ciErrNum != CL_SUCCESS)
+    {
+        // write out standard error, Build Log and PTX, then cleanup and exit
+        shrLogEx(LOGBOTH | ERRORMSG, (double)ciErrNum, STDERROR);
+        oclLogBuildInfo(program, oclGetFirstDev(cxGPUContext));
+        oclLogPtx(program, oclGetFirstDev(cxGPUContext), "VectorHypot.ptx");
+        Cleanup(EXIT_FAILURE);
+    }
+    dBuildTime = shrDeltaT(0);
+
+    // Ethan - Kernel Addition
+
+    if (program == NULL) {
+        std::cerr << "Failed to write program binary" << std::endl;
+        Cleanup(context, queue, program, kernel, memObjects);
+        return 1;
+    } else {
+        std::cout << "Read program from binary." << std::endl;
+    }
+
+    // Create the kernel
+    ckKernel[0] = clCreateKernel(program, "VectorHypot", &ciErrNum);
+    //oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup);
+    ckKernel[1] = clCreateKernel(program, "VectorHypot", &ciErrNum);
+    //oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup);
+    shrLog("clCreateKernel (ckKernel[2])...\n"); 
+
+    // Offsets for 2 queues
+    cl_uint uiOffset[2] = {0, uiNumElements / (2 * 4)};
+
+    // Set the Argument values for the 1st kernel instance (queue 0)
+    ciErrNum = clSetKernelArg(ckKernel[0], 0, sizeof(cl_mem), (void*)&cmDevSrcA);
+    ciErrNum |= clSetKernelArg(ckKernel[0], 1, sizeof(cl_mem), (void*)&cmDevSrcB);
+    ciErrNum |= clSetKernelArg(ckKernel[0], 2, sizeof(cl_mem), (void*)&cmDevResult);
+    ciErrNum |= clSetKernelArg(ckKernel[0], 3, sizeof(cl_uint), (void*)&uiOffset[0]);
+    ciErrNum |= clSetKernelArg(ckKernel[0], 4, sizeof(cl_int), (void*)&iInnerLoopCount);
+    ciErrNum |= clSetKernelArg(ckKernel[0], 5, sizeof(cl_uint), (void*)&uiNumElements);
+    shrLog("clSetKernelArg ckKernel[0] args 0 - 5...\n"); 
+
+    // Set the Argument values for the 2d kernel instance (queue 1)
+    ciErrNum |= clSetKernelArg(ckKernel[1], 0, sizeof(cl_mem), (void*)&cmDevSrcA);
+    ciErrNum |= clSetKernelArg(ckKernel[1], 1, sizeof(cl_mem), (void*)&cmDevSrcB);
+    ciErrNum |= clSetKernelArg(ckKernel[1], 2, sizeof(cl_mem), (void*)&cmDevResult);
+    ciErrNum |= clSetKernelArg(ckKernel[1], 3, sizeof(cl_uint), (void*)&uiOffset[1]);
+    ciErrNum |= clSetKernelArg(ckKernel[1], 4, sizeof(cl_int), (void*)&iInnerLoopCount);
+    ciErrNum |= clSetKernelArg(ckKernel[1], 5, sizeof(cl_uint), (void*)&uiNumElements);
+    oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup);
+    shrLog("clSetKernelArg ckKernel[1] args 0 - 5...\n\n"); 
+
+    //*******************************************
+    // Warmup the driver with dual queue sequence
+    //*******************************************
+
+    // Warmup with dual queue sequence for iTestCycles
+    shrLog("Warmup with 2-Queue sequence, %d cycles...\n", iWarmupCycles);
+    DualQueueSequence(iWarmupCycles, uiNumElements, false);
+
+    // Use single queue config to adjust compute intensity 
+    shrLog("Adjust compute for GPU / system...\n");
+    iInnerLoopCount = AdjustCompute(cdDevices[uiTargetDevice], uiNumElements, iInnerLoopCount, iTestCycles); 
+    shrLog("  Kernel inner loop count = %d\n", iInnerLoopCount); 
+
+    //*******************************************
+    // Run and time with 2 command-queues
+    //*******************************************
+	for( int iRun =0; iRun <= RETRIES_ON_FAILURE; ++iRun ) {
+	
+	// Run the sequence iTestCycles times
+    dAvgGPUTime[0] = DualQueueSequence(iTestCycles, uiNumElements, false);
+
+    // Warmup then Compute on host iTestCycles times (using mapped standard pointer to pinned host cl_mem buffer) 
+    shrLog("  Device vs Host Result Comparison\t: "); 
+    VectorHypotHost(fSourceA, fSourceB, Golden, uiNumElements, iInnerLoopCount);   
+    shrDeltaT(0);
+    for (int i = 0; i < iTestCycles; i++)
+    {
+        VectorHypotHost (fSourceA, fSourceB, Golden, uiNumElements, iInnerLoopCount);   
+    }
+    dHostTime[0] = shrDeltaT(0)/iTestCycles;
+
+    // Compare host and GPU results (using mapped standard pointer to pinned host cl_mem buffer) 
+    bMatch = shrComparefet(Golden, fResult, uiNumElements, 0.0f, 0);
+    shrLog("gpu %s cpu\n", (bMatch == shrTRUE) ? "MATCHES" : "DOESN'T MATCH"); 
+    bPassFlag = (bMatch == shrTRUE);
+
+    //*******************************************
+    // Run and time with 1 command queue
+    //*******************************************
+    // Run the sequence iTestCycles times
+    dAvgGPUTime[1] = OneQueueSequence(iTestCycles, uiNumElements, false);
+
+    // Compute on host iTestCycles times (using mapped standard pointer to pinned host cl_mem buffer) 
+    shrLog("  Device vs Host Result Comparison\t: "); 
+    shrDeltaT(0);
+    for (int i = 0; i < iTestCycles; i++)
+    {
+        VectorHypotHost(fSourceA, fSourceB, Golden, (int)uiNumElements, iInnerLoopCount);   
+    }
+    dHostTime[1] = shrDeltaT(0)/iTestCycles;
+
+    // Compare host and GPU results (using mapped standard pointer to pinned host cl_mem buffer) 
+    bMatch = shrComparefet(Golden, fResult, uiNumElements, 0.0f, 0);
+    shrLog("gpu %s cpu\n", (bMatch == shrTRUE) ? "MATCHES" : "DOESN'T MATCH"); 
+    bPassFlag &= (bMatch == shrTRUE);
+
+    //*******************************************
+
+    // Compare Single and Dual queue timing 
+    shrLog("\nResult Summary:\n"); 
+
+    // Log GPU and CPU Time for 2-queue scenario
+    shrLog("  Avg GPU Elapsed Time for 2-Queues\t= %.5f s\n", dAvgGPUTime[0]);
+    shrLog("  Avg Host Elapsed Time\t\t\t= %.5f s\n\n", dHostTime[0]);
+
+    // Log GPU and CPU Time for 1-queue scenario
+    shrLog("  Avg GPU Elapsed Time for 1-Queue\t= %.5f s\n", dAvgGPUTime[1]);
+    shrLog("  Avg Host Elapsed Time\t\t\t= %.5f s\n\n", dHostTime[1]);
+
+    // Log overlap % for GPU (comparison of 2-queue and 1 queue scenarios) and status
+    double dAvgOverlap = 100.0 * (1.0 - dAvgGPUTime[0]/dAvgGPUTime[1]);
+    
+	if( bTestOverlap ) {
+		bool bAvgOverlapOK = (dAvgOverlap >= fMinPassCriteria[1]);
+		if( iRun == RETRIES_ON_FAILURE || bAvgOverlapOK ) {
+			shrLog("  Measured and (Acceptable) Avg Overlap\t= %.1f %% (%.1f %%)  -> Measured Overlap is %s\n\n", dAvgOverlap, fMinPassCriteria[1], bAvgOverlapOK ? "Acceptable" : "NOT Acceptable");
+
+			// Log info to master log in standard format
+			shrLogEx(LOGBOTH | MASTER, 0, "oclCopyComputeOverlap-Avg, Throughput = %.4f OverlapPercent, Time = %.5f s, Size = %u Elements, NumDevsUsed = %u, Workgroup = %u\n", 
+			dAvgOverlap, dAvgGPUTime[0], uiNumElements, uiNumDevsUsed, szLocalWorkSize); 
+			
+			bPassFlag &= bAvgOverlapOK;
+			break;
+		}
+	} 
+
+		shrLog("  Measured and (Acceptable) Avg Overlap\t= %.1f %% (%.1f %%)  -> Retry %d more time(s)...\n\n", dAvgOverlap, fMinPassCriteria[1], RETRIES_ON_FAILURE - iRun);
+	}
+
+
+    //*******************************************
+    // Report pass/fail, cleanup and exit
+    Cleanup (bPassFlag ? EXIT_SUCCESS : EXIT_FAILURE);
+}
+
+// Run 1 queue sequence for n cycles
+// *********************************************************************
+double OneQueueSequence(int iCycles, unsigned int uiNumElements, bool bShowConfig)
+{
+    // Use fresh source Data: (re)initialize pinned host array buffers (using mapped standard pointer to pinned host cl_mem buffer) 
+    shrFillArray(fSourceA, (int)uiNumElements);
+    shrFillArray(fSourceB, (int)uiNumElements);
+
+    // Reset Global work size for 1 command-queue, and log work sizes & dimensions
+    szGlobalWorkSize = shrRoundUp((int)szLocalWorkSize, (int)(uiNumElements/4));
+
+    // *** Make sure queues are empty and then start timer 
+    double dAvgTime = 0.0;
+    clFinish(cqCommandQueue[0]);
+    clFinish(cqCommandQueue[1]);  
+    shrDeltaT(0);
+
+    // Run the sequence iCycles times
+    for (int i = 0; i < iCycles; i++)
+    {
+        // Nonblocking Write of all of input data from host to device in command-queue 0 
+        ciErrNum = clEnqueueWriteBuffer(cqCommandQueue[0], cmDevSrcA, CL_FALSE, 0, szBuffBytes, (void*)&fSourceA[0], 0, NULL, NULL);
+        ciErrNum |= clEnqueueWriteBuffer(cqCommandQueue[0], cmDevSrcB, CL_FALSE, 0, szBuffBytes, (void*)&fSourceB[0], 0, NULL, NULL);
+        shrCheckError(ciErrNum, CL_SUCCESS);
+
+        // Launch kernel computation, command-queue 0 
+        ciErrNum = clEnqueueNDRangeKernel(cqCommandQueue[0], ckKernel[0], 1, NULL, &szGlobalWorkSize, &szLocalWorkSize, 0, NULL, NULL);
+        //oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup);
+
+        // Non Blocking Read of output data from device to host, command-queue 0 
+        ciErrNum = clEnqueueReadBuffer(cqCommandQueue[0], cmDevResult, CL_FALSE, 0, szBuffBytes, (void*)&fResult[0], 0, NULL, NULL);
+        shrCheckError(ciErrNum, CL_SUCCESS);
+
+        // Flush sequence to device (may not be necessary on Linux or WinXP or when using the NVIDIA Tesla Computing Cluster driver)
+        clFlush(cqCommandQueue[0]);
+    }
+    
+    // *** Assure sync to host and return average sequence time
+    clFinish(cqCommandQueue[0]);
+    dAvgTime = shrDeltaT(0)/(double)iCycles;
+
+    // Log config if asked for
+    if (bShowConfig)
+    {
+        shrLog("\n1-Queue sequence Configuration:\n");
+        shrLog("  Global Work Size (per command-queue)\t= %u\n  Local Work Size \t\t\t= %u\n  # of Work Groups (per command-queue)\t= %u\n  # of command-queues\t\t\t= 1\n", 
+           szGlobalWorkSize, szLocalWorkSize, szGlobalWorkSize/szLocalWorkSize); 
+    }
+    return dAvgTime;
+}
+
+// Run 2 queue sequence for n cycles
+// *********************************************************************
+double DualQueueSequence(int iCycles, unsigned int uiNumElements, bool bShowConfig)
+{
+    // Locals
+    size_t szHalfBuffer = szBuffBytes / 2;
+    size_t szHalfOffset = szHalfBuffer / sizeof(float);
+    double dAvgTime = 0.0;
+
+    // Use fresh source Data: (re)initialize pinned host array buffers (using mapped standard pointer to pinned host cl_mem buffer) 
+    shrFillArray(fSourceA, (int)uiNumElements);
+    shrFillArray(fSourceB, (int)uiNumElements);
+
+    // Set Global work size for 2 command-queues, and log work sizes & dimensions
+    szGlobalWorkSize = shrRoundUp((int)szLocalWorkSize, (int)(uiNumElements/(2 * 4)));
+
+    // Make sure queues are empty and then start timer 
+    clFinish(cqCommandQueue[0]);
+    clFinish(cqCommandQueue[1]);
+    shrDeltaT(0);
+
+    for (int i = 0; i < iCycles; i++)
+    {
+        // Mid Phase 0 
+        // Nonblocking Write of 1st half of input data from host to device in command-queue 0 
+        ciErrNum = clEnqueueWriteBuffer(cqCommandQueue[0], cmDevSrcA, CL_FALSE, 0, szHalfBuffer, (void*)&fSourceA[0], 0, NULL, NULL);
+        ciErrNum |= clEnqueueWriteBuffer(cqCommandQueue[0], cmDevSrcB, CL_FALSE, 0, szHalfBuffer, (void*)&fSourceB[0], 0, NULL, NULL);
+        shrCheckError(ciErrNum, CL_SUCCESS);
+
+        // Push out the write for queue 0 (and prior read from queue 1 at end of loop) to the driver 
+        // (not necessary on Linux, Mac OSX or WinXP)
+        clFlush(cqCommandQueue[0]);
+        clFlush(cqCommandQueue[1]);
+
+        // Start Phase 1 ***********************************
+
+        // Launch kernel computation, command-queue 0
+        // (Note:  The order MATTERS here on Fermi !  THE KERNEL IN THIS PHASE SHOULD BE LAUNCHED BEFORE THE WRITE)
+        ciErrNum = clEnqueueNDRangeKernel(cqCommandQueue[0], ckKernel[0], 1, NULL, &szGlobalWorkSize, &szLocalWorkSize, 0, NULL, NULL);
+        oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup);
+
+        // Nonblocking Write of 2nd half of input data from host to device in command-queue 1 
+        // (Note:  The order MATTERS here on Fermi !  THE KERNEL IN THIS PHASE SHOULD BE LAUNCHED BEFORE THE WRITE)
+        ciErrNum = clEnqueueWriteBuffer(cqCommandQueue[1], cmDevSrcA, CL_FALSE, szHalfBuffer, szHalfBuffer, (void*)&fSourceA[szHalfOffset], 0, NULL, NULL);
+        ciErrNum |= clEnqueueWriteBuffer(cqCommandQueue[1], cmDevSrcB, CL_FALSE, szHalfBuffer, szHalfBuffer, (void*)&fSourceB[szHalfOffset], 0, NULL, NULL);
+        shrCheckError(ciErrNum, CL_SUCCESS);
+
+        // Push out the compute for queue 0 and write for queue 1 to the driver
+        // (not necessary on Linux, Mac OSX or WinXP)
+        clFlush(cqCommandQueue[0]);
+        clFlush(cqCommandQueue[1]);
+
+        // Start Phase 2 ***********************************
+
+        // Launch kernel computation, command-queue 1 
+        ciErrNum = clEnqueueNDRangeKernel(cqCommandQueue[1], ckKernel[1], 1, NULL, &szGlobalWorkSize, &szLocalWorkSize, 0, NULL, NULL);
+        //oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup);
+
+        // Non Blocking Read of 1st half of output data from device to host, command-queue 0 
+        ciErrNum = clEnqueueReadBuffer(cqCommandQueue[0], cmDevResult, CL_FALSE, 0, szHalfBuffer, (void*)&fResult[0], 0, NULL, NULL);
+        shrCheckError(ciErrNum, CL_SUCCESS);
+
+        // Push out the compute for queue 1 and the read for queue 0 to the driver 
+        // (not necessary on Linux, Mac OSX or WinXP)
+        clFlush(cqCommandQueue[0]);
+        clFlush(cqCommandQueue[1]);
+
+        // Start Phase 0 (Rolls over) ***********************************
+
+        // Non Blocking Read of 2nd half of output data from device to host, command-queue 1 
+        ciErrNum = clEnqueueReadBuffer(cqCommandQueue[1], cmDevResult, CL_FALSE, szHalfBuffer, szHalfBuffer, (void*)&fResult[szHalfOffset], 0, NULL, NULL);
+        shrCheckError(ciErrNum, CL_SUCCESS);
+    }
+
+    // *** Sync to host and get average sequence time
+    clFinish(cqCommandQueue[0]);
+    clFinish(cqCommandQueue[1]);    
+    dAvgTime = shrDeltaT(0)/(double)iCycles;
+
+    // Log config if asked for
+    if (bShowConfig)
+    {
+        shrLog("\n2-Queue sequence Configuration:\n");
+        shrLog("  Global Work Size (per command-queue)\t= %u\n  Local Work Size \t\t\t= %u\n  # of Work Groups (per command-queue)\t= %u\n  # of command-queues\t\t\t= 2\n", 
+           szGlobalWorkSize, szLocalWorkSize, szGlobalWorkSize/szLocalWorkSize); 
+    }
+
+    return dAvgTime;
+}
+
+// Function to adjust compute task according to device capability
+// This allows a consistent overlap % across a wide variety of GPU's for test purposes
+// It also implitly illustrates the relationship between compute capability and overlap at fixed work size
+// *********************************************************************
+int AdjustCompute(cl_device_id cdTargetDevice, unsigned int uiNumElements, int iInitLoopCount, int iCycles)
+{
+    // Locals
+    double dCopyTime, dComputeTime;
+    int iComputedLoopCount; 
+
+    // Change Source Data
+    shrFillArray(fSourceA, (int)uiNumElements);
+    shrFillArray(fSourceB, (int)uiNumElements);
+
+    // Reset Global work size for 1 command-queue, and log work sizes & dimensions
+    szGlobalWorkSize = shrRoundUp((int)szLocalWorkSize, (int)(uiNumElements/4));
+
+    // *** Make sure queues are empty and then start timer 
+    clFinish(cqCommandQueue[0]);
+    clFinish(cqCommandQueue[1]);  
+    shrDeltaT(0);
+
+    // Run the copy iCycles times and measure copy time on this system
+    for (int i = 0; i < iCycles; i++)
+    {
+        // Nonblocking Write of all of input data from host to device in command-queue 0 
+        ciErrNum = clEnqueueWriteBuffer(cqCommandQueue[0], cmDevSrcA, CL_FALSE, 0, szBuffBytes, (void*)&fSourceA[0], 0, NULL, NULL);
+        ciErrNum |= clEnqueueWriteBuffer(cqCommandQueue[0], cmDevSrcB, CL_FALSE, 0, szBuffBytes, (void*)&fSourceB[0], 0, NULL, NULL);
+        ciErrNum |= clFlush(cqCommandQueue[0]);
+        shrCheckError(ciErrNum, CL_SUCCESS);
+    }
+    clFinish(cqCommandQueue[0]);
+    dCopyTime = shrDeltaT(0);
+
+    // Run the compute iCycles times and measure compute time on this system
+    for (int i = 0; i < iCycles; i++)
+    {
+        // Launch kernel computation, command-queue 0 
+        ciErrNum = clEnqueueNDRangeKernel(cqCommandQueue[0], ckKernel[0], 1, NULL, &szGlobalWorkSize, &szLocalWorkSize, 0, NULL, NULL);
+        ciErrNum |= clFlush(cqCommandQueue[0]);
+        oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup);
+    }
+    clFinish(cqCommandQueue[0]);
+    dComputeTime = shrDeltaT(0);
+
+    // Determine number of core loop cycles proportional to copy/compute time ratio
+    dComputeTime = MAX(dComputeTime, 1.0e-6);
+    iComputedLoopCount = CLAMP(2, (int)((dCopyTime/dComputeTime) * (double)iInitLoopCount), (iInitLoopCount * 4));
+    ciErrNum |= clSetKernelArg(ckKernel[0], 4, sizeof(cl_int), (void*)&iComputedLoopCount);
+    ciErrNum |= clSetKernelArg(ckKernel[1], 4, sizeof(cl_int), (void*)&iComputedLoopCount);
+    oclCheckErrorEX(ciErrNum, CL_SUCCESS, pCleanup);
+    return (iComputedLoopCount);
+} 
+
+// Cleanup/Exit function 
+// *********************************************************************
+void Cleanup (int iExitCode)
+{
+    // Cleanup allocated objects
+    shrLog("Starting Cleanup...\n\n");
+    if(cPathAndName)free(cPathAndName);
+    if(cSourceCL)free(cSourceCL);
+    if(Golden)free(Golden);
+    if(ckKernel[0])clReleaseKernel(ckKernel[0]);
+    if(ckKernel[1])clReleaseKernel(ckKernel[1]);
+    if(program)clReleaseProgram(program);
+    if(fSourceA)clEnqueueUnmapMemObject(cqCommandQueue[0], cmPinnedSrcA, (void*)fSourceA, 0, NULL, NULL);
+    if(fSourceB)clEnqueueUnmapMemObject(cqCommandQueue[0], cmPinnedSrcB, (void*)fSourceB, 0, NULL, NULL);
+    if(fResult)clEnqueueUnmapMemObject(cqCommandQueue[0], cmPinnedResult, (void*)fResult, 0, NULL, NULL);
+    if(cmDevSrcA)clReleaseMemObject(cmDevSrcA);
+    if(cmDevSrcB)clReleaseMemObject(cmDevSrcB);
+    if(cmDevResult)clReleaseMemObject(cmDevResult);
+    if(cmPinnedSrcA)clReleaseMemObject(cmPinnedSrcA);
+    if(cmPinnedSrcB)clReleaseMemObject(cmPinnedSrcB);
+    if(cmPinnedResult)clReleaseMemObject(cmPinnedResult);
+    if(cqCommandQueue[0])clReleaseCommandQueue(cqCommandQueue[0]);
+    if(cqCommandQueue[1])clReleaseCommandQueue(cqCommandQueue[1]);
+    if(cxGPUContext)clReleaseContext(cxGPUContext);
+    if(cdDevices)free(cdDevices);
+
+    // Master status Pass/Fail (all tests)
+    shrQAFinishExit( *gp_argc, (const char **)*gp_argv, (iExitCode == EXIT_SUCCESS) ? QA_PASSED : QA_FAILED );
+}
+
+// "Golden" Host processing vector hyptenuse function for comparison purposes
+// *********************************************************************
+void VectorHypotHost(const float* pfData1, const float* pfData2, float* pfResult, unsigned int uiNumElements, int iInnerLoopCount)
+{
+    for (unsigned int i = 0; i < uiNumElements; i++) 
+    {
+        float fA = pfData1[i];
+        float fB = pfData2[i];
+        float fC = sqrtf(fA * fA + fB * fB);
+
+        pfResult[i] = fC;
+    }
+}

benchmarks/opencl/VectorHypot/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 <shrUtils.h>
+
+// All OpenCL headers
+#if defined (__APPLE__) || defined(MACOSX)
+    #include <OpenCL/opencl.h>
+#else
+    #include <CL/opencl.h>
+#endif 
+
+// Includes
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+// For systems with CL_EXT that are not updated with these extensions, we copied these
+// extensions from <CL/cl_ext.h>
+#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

benchmarks/opencl/VectorHypot/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 <windows.h>
+	#include <time.h>
+#else
+    // Headers needed for Linux
+    #include <sys/stat.h>
+    #include <sys/types.h>
+    #include <sys/time.h>
+    #include <stdio.h>
+    #include <stdlib.h>
+    #include <string.h>
+    #include <stdarg.h>
+    #include <unistd.h>
+    #include <time.h>
+#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 <Enter> 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

benchmarks/opencl/VectorHypot/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 <windows.h>
+#else
+    // Headers needed for Linux
+    #include <sys/stat.h>
+    #include <sys/types.h>
+    #include <sys/time.h>
+    #include <stdio.h>
+    #include <stdlib.h>
+    #include <string.h>
+    #include <stdarg.h>
+#endif
+
+// Other headers needed for both Windows and Linux
+#include <math.h>
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+// 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 <Enter> to Quit...\n");                  
+        getchar();                                                           
+    }       
+    else 
+    {
+        shrLogEx(LOGBOTH | CLOSELOG, 0, "%s Exiting...\n", argv[0]); 
+    }
+    fflush(stderr);                                                         
+    exit(iExitCode);
+}
+
+#endif

benchmarks/opencl/cutcp/Makefile

@@ -0,0 +1,67 @@
+RISCV_TOOL_PATH ?= $(wildcard ../../../../riscv-gnu-toolchain/drops)
+POCL_CC_PATH ?= $(wildcard ../../../../pocl/drops_riscv_cc)
+POCL_INC_PATH ?= $(wildcard ../include)
+POCL_LIB_PATH ?= $(wildcard ../lib)
+VX_RT_PATH ?= $(wildcard ../../../runtime)
+VX_SIMX_PATH ?= $(wildcard ../../../simX/obj_dir)
+
+CC  = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-gcc
+CXX = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-g++
+DMP = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-objdump
+HEX = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-objcopy
+GDB = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-gdb
+
+VX_SRCS =  $(VX_RT_PATH)/newlib/newlib.c
+VX_SRCS += $(VX_RT_PATH)/startup/vx_start.S
+VX_SRCS += $(VX_RT_PATH)/intrinsics/vx_intrinsics.S
+VX_SRCS += $(VX_RT_PATH)/io/vx_io.S $(VX_RT_PATH)/io/vx_io.c
+VX_SRCS += $(VX_RT_PATH)/fileio/fileio.S
+VX_SRCS += $(VX_RT_PATH)/tests/tests.c
+VX_SRCS += $(VX_RT_PATH)/vx_api/vx_api.c
+
+VX_CFLAGS = -nostartfiles -Wl,-Bstatic,-T,$(VX_RT_PATH)/startup/vx_link.ld
+
+CXXFLAGS =  -g -O0 -march=rv32im -mabi=ilp32 
+CXXFLAGS += -ffreestanding # program may not begin at main()
+CXXFLAGS += -Wl,--gc-sections # enable garbage collection of unused input sections
+CXXFLAGS += -fno-rtti -fno-non-call-exceptions # disable RTTI and exceptions
+CXXFLAGS += -I$(POCL_INC_PATH) -I.
+
+VX_LIBS = -Wl,--whole-archive lib$(PROJECT).a -Wl,--no-whole-archive $(POCL_LIB_PATH)/libOpenCL.a
+QEMU_LIBS = $(VX_RT_PATH)/qemu/vx_api.c -Wl,--whole-archive lib$(PROJECT).a -Wl,--no-whole-archive $(POCL_LIB_PATH)/libOpenCL.a
+
+PROJECT = cutcp
+
+SRCS = main.cc args.c parboil_opencl.c ocl.c gpu_info.c cutoff.c cutcpu.c output.c readatom.c excl.c
+
+all: $(PROJECT).dump $(PROJECT).hex
+
+lib$(PROJECT).a: kernel.cl
+	POCL_DEBUG=all POCL_DEBUG_LLVM_PASSES=1 LD_LIBRARY_PATH=$(RISCV_TOOL_PATH)/lib:$(POCL_CC_PATH)/lib $(POCL_CC_PATH)/bin/poclcc -o lib$(PROJECT).a kernel.cl
+
+$(PROJECT).elf: $(SRCS) lib$(PROJECT).a
+	$(CXX) $(CXXFLAGS) $(VX_CFLAGS) $(VX_SRCS) $(SRCS) $(VX_LIBS) -o $(PROJECT).elf
+
+$(PROJECT).qemu: $(SRCS) lib$(PROJECT).a
+	$(CXX) $(CXXFLAGS) $(SRCS) $(QEMU_LIBS) -o $(PROJECT).qemu
+
+$(PROJECT).hex: $(PROJECT).elf
+	$(HEX) -O ihex $(PROJECT).elf $(PROJECT).hex
+
+$(PROJECT).dump: $(PROJECT).elf
+	$(DMP) -D $(PROJECT).elf > $(PROJECT).dump
+
+run: $(PROJECT).hex
+	POCL_DEBUG=all $(VX_SIMX_PATH)/Vcache_simX -E -a rv32i --core $(PROJECT).hex -s -b 1> emulator.debug
+
+qemu: $(PROJECT).qemu
+	POCL_DEBUG=all $(RISCV_TOOL_PATH)/bin/qemu-riscv32 -d in_asm -D debug.log $(PROJECT).qemu
+
+gdb-s: $(PROJECT).qemu
+	POCL_DEBUG=all $(RISCV_TOOL_PATH)/bin/qemu-riscv32 -g 1234 -d in_asm -D debug.log $(PROJECT).qemu
+
+gdb-c: $(PROJECT).qemu
+	$(GDB) $(PROJECT).qemu
+
+clean:
+	rm -rf *.o *.elf *.dump *.hex *.qemu *.log *.debug

benchmarks/opencl/cutcp/args.c

@@ -0,0 +1,617 @@
+
+#include <parboil.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+/*****************************************************************************/
+/* Memory management routines */
+
+/* Free an array of owned strings. */
+void
+pb_FreeStringArray(char **string_array)
+{
+  char **p;
+
+  if (!string_array) return;
+  for (p = string_array; *p; p++) free(*p);
+  free(string_array);
+}
+
+struct pb_PlatformParam *
+pb_PlatformParam(char *name, char *version)
+{
+  if (name == NULL) {
+    fprintf(stderr, "pb_PlatformParam: Invalid argument\n");
+    exit(-1);
+  }
+
+  struct pb_PlatformParam *ret =
+    (struct pb_PlatformParam *)malloc(sizeof (struct pb_PlatformParam));
+
+  ret->name = name;
+  ret->version = version;
+  return ret;
+}
+
+void
+pb_FreePlatformParam(struct pb_PlatformParam *p)
+{
+  if (p == NULL) return;
+
+  free(p->name);
+  free(p->version);
+  free(p);
+}
+
+struct pb_DeviceParam *
+pb_DeviceParam_index(int index)
+{
+  struct pb_DeviceParam *ret =
+    (struct pb_DeviceParam *)malloc(sizeof (struct pb_DeviceParam));
+  ret->criterion = pb_Device_INDEX;
+  ret->index = index;
+  return ret;
+}
+
+struct pb_DeviceParam *
+pb_DeviceParam_cpu(void)
+{
+  struct pb_DeviceParam *ret =
+    (struct pb_DeviceParam *)malloc(sizeof (struct pb_DeviceParam));
+  ret->criterion = pb_Device_CPU;
+  return ret;
+}
+
+struct pb_DeviceParam *
+pb_DeviceParam_gpu(void)
+{
+  struct pb_DeviceParam *ret =
+    (struct pb_DeviceParam *)malloc(sizeof (struct pb_DeviceParam));
+  ret->criterion = pb_Device_GPU;
+  return ret;
+}
+
+struct pb_DeviceParam *
+pb_DeviceParam_accelerator(void)
+{
+  struct pb_DeviceParam *ret =
+    (struct pb_DeviceParam *)malloc(sizeof (struct pb_DeviceParam));
+  ret->criterion = pb_Device_ACCELERATOR;
+  return ret;
+}
+
+struct pb_DeviceParam *
+pb_DeviceParam_name(char *name)
+{
+  struct pb_DeviceParam *ret =
+    (struct pb_DeviceParam *)malloc(sizeof (struct pb_DeviceParam));
+  ret->criterion = pb_Device_NAME;
+  ret->name = name;
+  return ret;
+}
+
+void
+pb_FreeDeviceParam(struct pb_DeviceParam *p)
+{
+  if (p == NULL) return;
+
+  switch(p->criterion) {
+  case pb_Device_NAME:
+    free(p->name);
+    break;
+  case pb_Device_INDEX:
+  case pb_Device_CPU:
+  case pb_Device_ACCELERATOR:
+    break;
+  default:
+    fprintf(stderr, "pb_FreeDeviceParam: Invalid argument\n");
+    exit(-1);
+  }
+}
+
+void
+pb_FreeParameters(struct pb_Parameters *p)
+{
+  free(p->outFile);
+  pb_FreeStringArray(p->inpFiles);
+  pb_FreePlatformParam(p->platform);
+  pb_FreeDeviceParam(p->device);
+  free(p);
+}
+
+/*****************************************************************************/
+
+/* Parse a comma-delimited list of strings into an
+ * array of strings. */
+static char ** 
+read_string_array(char *in)
+{
+  char **ret;
+  int i;
+  int count;			/* Number of items in the input */
+  char *substring;		/* Current substring within 'in' */
+
+  /* Count the number of items in the string */
+  count = 1;
+  for (i = 0; in[i]; i++) if (in[i] == ',') count++;
+
+  /* Allocate storage */
+  ret = (char **)malloc((count + 1) * sizeof(char *));
+
+  /* Create copies of the strings from the list */
+  substring = in;
+  for (i = 0; i < count; i++) {
+    char *substring_end;
+    int substring_length;
+
+    /* Find length of substring */
+    for (substring_end = substring;
+	 (*substring_end != ',') && (*substring_end != 0);
+	 substring_end++);
+
+    substring_length = substring_end - substring;
+
+    /* Allocate memory and copy the substring */
+    ret[i] = (char *)malloc(substring_length + 1);
+    memcpy(ret[i], substring, substring_length);
+    ret[i][substring_length] = 0;
+
+    /* go to next substring */
+    substring = substring_end + 1;
+  }
+  ret[i] = NULL;		/* Write the sentinel value */
+
+  return ret;
+}
+
+static void
+report_parse_error(const char *str)
+{
+  fputs(str, stderr);
+}
+
+/* Interpret a string as a 'pb_DeviceParam' value.
+ * Return a pointer to a new value, or NULL on failure.
+ */
+static struct pb_DeviceParam *
+read_device_param(char *str)
+{  
+  /* Try different ways of interpreting 'device_string' until one works */
+
+  /* If argument is an integer, then interpret it as a device index */
+  errno = 0;
+  char *end;
+  long device_int = strtol(str, &end, 10);
+  if (!errno) {
+    /* Negative numbers are not valid */
+    if (device_int < 0 || device_int > INT_MAX) return NULL;
+
+    return pb_DeviceParam_index(device_int);
+  }
+
+  /* Match against predefined strings */
+  if (strcmp(str, "CPU") == 0)
+    return pb_DeviceParam_cpu();
+  if (strcmp(str, "GPU") == 0)
+    return pb_DeviceParam_gpu();
+  if (strcmp(str, "ACCELERATOR") == 0)
+    return pb_DeviceParam_accelerator();
+
+  /* Assume any other string is a device name */
+  return pb_DeviceParam_name(strdup(str));
+}
+
+/* Interpret a string as a 'pb_PlatformParam' value.
+ * Return a pointer to a new value, or NULL on failure.
+ */
+static struct pb_PlatformParam *
+read_platform_param(char *str)
+{
+  int separator_index;          /* Index of the '-' character separating
+                                 * name and version number.  It's -1 if
+                                 * there's no '-' character. */
+
+  /* Find the last occurrence of '-' in 'str' */
+  {
+    char *cur;
+    separator_index = -1;
+    for (cur = str; *cur; cur++) {
+      if (*cur == '-') separator_index = cur - str;
+    }
+  }
+
+  /* The platform name is either the entire string, or all characters before
+   * the separator */
+  int name_length = separator_index == -1 ? strlen(str) : separator_index;
+  char *name_str = (char *)malloc(name_length + 1);
+  memcpy(name_str, str, name_length);
+  name_str[name_length] = 0;
+
+  /* The version is either NULL, or all characters after the separator */
+  char *version_str;
+  if (separator_index == -1) {
+    version_str = NULL;
+  }
+  else {
+    const char *version_input_str = str + separator_index + 1;
+    int version_length = strlen(version_input_str);
+
+    version_str = (char *)malloc(version_length + 1);
+    memcpy(version_str, version_input_str, version_length);
+    version_str[version_length] = 0;
+  }
+
+  /* Create output structure */
+  return pb_PlatformParam(name_str, version_str);
+}
+
+/****************************************************************************/
+/* Argument parsing state */
+
+/* Argument parsing state.
+ *
+ * Arguments that are interpreted by the argument parser are removed from
+ * the list.  Variables 'argc' and 'argn' do not count arguments that have
+ * been removed.
+ *
+ * During argument parsing, the array of arguments is compacted, overwriting
+ * the erased arguments.  Variable 'argv_put' points to the array element
+ * where the next argument will be written.  Variable 'argv_get' points to
+ * the array element where the next argument will be read from.
+ */
+struct argparse {
+  int argc;			/* Number of arguments.  Mutable. */
+  int argn;			/* Current argument index. */
+  char **argv_get;		/* Argument value being read. */
+  char **argv_put;		/* Argument value being written.
+				 * argv_put <= argv_get. */
+};
+
+static void
+initialize_argparse(struct argparse *ap, int argc, char **argv)
+{
+  ap->argc = argc;
+  ap->argn = 0;
+  ap->argv_get = ap->argv_put = argv;
+}
+
+/* Finish argument parsing, without processing the remaining arguments.
+ * Write new argument count into _argc. */
+static void
+finalize_argparse(struct argparse *ap, int *_argc, char **argv)
+{
+  /* Move the remaining arguments */
+  for(; ap->argn < ap->argc; ap->argn++)
+    *ap->argv_put++ = *ap->argv_get++;
+
+  /* Update the argument count */
+  *_argc = ap->argc;
+
+  /* Insert a terminating NULL */
+  argv[ap->argc] = NULL;
+}
+
+/* Delete the current argument.  The argument will not be visible
+ * when argument parsing is done. */
+static void
+delete_argument(struct argparse *ap)
+{
+  if (ap->argn >= ap->argc) {
+    fprintf(stderr, "delete_argument\n");
+  }
+  ap->argc--;
+  ap->argv_get++;
+}
+
+/* Go to the next argument.  Also, move the current argument to its
+ * final location in argv. */
+static void
+next_argument(struct argparse *ap)
+{
+  if (ap->argn >= ap->argc) {
+    fprintf(stderr, "next_argument\n");
+  }
+  /* Move argument to its new location. */
+  *ap->argv_put++ = *ap->argv_get++;
+  ap->argn++;
+}
+
+static int
+is_end_of_arguments(struct argparse *ap)
+{
+  return ap->argn == ap->argc;
+}
+
+/* Get the current argument */
+static char *
+get_argument(struct argparse *ap)
+{
+  return *ap->argv_get;
+}
+
+/* Get the current argument, and also delete it */
+static char *
+consume_argument(struct argparse *ap)
+{
+  char *ret = get_argument(ap);
+  delete_argument(ap);
+  return ret;
+}
+
+/****************************************************************************/
+
+/* The result of parsing a command-line argument */
+typedef enum {
+  ARGPARSE_OK,                  /* Success */
+  ARGPARSE_ERROR,               /* Error */
+  ARGPARSE_DONE                 /* Success, and do not continue parsing */
+} result;
+
+typedef result parse_action(struct argparse *ap, struct pb_Parameters *params);
+
+
+/* A command-line option */
+struct option {
+  char short_name;              /* If not 0, the one-character
+                                 * name of this option */
+  const char *long_name;        /* If not NULL, the long name of this option */
+  parse_action *action;       /* What to do when this option occurs.
+                               * Sentinel value is NULL.
+                               */
+};
+
+/* Output file
+ *
+ * -o FILE
+ */
+static result
+parse_output_file(struct argparse *ap, struct pb_Parameters *params)
+{
+  if (is_end_of_arguments(ap))
+    {
+      report_parse_error("Expecting file name after '-o'\n");
+      return ARGPARSE_ERROR;
+    }
+
+  /* Replace the output file name */
+  free(params->outFile);
+  params->outFile = strdup(consume_argument(ap));
+
+  return ARGPARSE_OK;
+}
+
+/* Input files
+ *
+ * -i FILE,FILE,...
+ */
+static result
+parse_input_files(struct argparse *ap, struct pb_Parameters *params)
+{
+  if (is_end_of_arguments(ap))
+    {
+      report_parse_error("Expecting file name after '-i'\n");
+      return ARGPARSE_ERROR;
+    }
+
+  /* Replace the input file list */
+  pb_FreeStringArray(params->inpFiles);
+  params->inpFiles = read_string_array(consume_argument(ap));
+  return ARGPARSE_OK;
+}
+
+/* End of options
+ *
+ * --
+ */
+
+static result
+parse_end_options(struct argparse *ap, struct pb_Parameters *params)
+{
+  return ARGPARSE_DONE;
+}
+
+/* OpenCL device
+ *
+ * --device X
+ */
+
+static result
+parse_device(struct argparse *ap, struct pb_Parameters *params)
+{
+  /* Read the next argument, which specifies a device */
+
+  if (is_end_of_arguments(ap))
+    {
+      report_parse_error("Expecting device specification after '--device'\n");
+      return ARGPARSE_ERROR;
+    }
+
+  char *device_string = consume_argument(ap);
+  struct pb_DeviceParam *device_param = read_device_param(device_string);
+
+  if (!device_param) {
+    report_parse_error("Unrecognized device specification format on command line\n");
+    return ARGPARSE_ERROR;
+  }
+
+  /* Save the result */
+  pb_FreeDeviceParam(params->device);
+  params->device = device_param;
+
+  return ARGPARSE_OK;
+}
+
+static result
+parse_platform(struct argparse *ap, struct pb_Parameters *params)
+{
+  /* Read the next argument, which specifies a platform */
+
+  if (is_end_of_arguments(ap))
+    {
+      report_parse_error("Expecting device specification after '--platform'\n");
+      return ARGPARSE_ERROR;
+    }
+
+  char *platform_string = consume_argument(ap);
+  struct pb_PlatformParam *platform_param = read_platform_param(platform_string);
+
+  if (!platform_param) {
+    report_parse_error("Unrecognized platform specification format on command line\n");
+    return ARGPARSE_ERROR;
+  }
+
+  /* Save the result */
+  pb_FreePlatformParam(params->platform);
+  params->platform = platform_param;
+
+  return ARGPARSE_OK;
+}
+  
+
+static struct option options[] = {
+  { 'o', NULL, &parse_output_file },
+  { 'i', NULL, &parse_input_files },
+  { '-', NULL, &parse_end_options },
+  { 0, "device", &parse_device },
+  { 0, "platform", &parse_platform },
+  { 0, NULL, NULL }
+};
+
+static int
+is_last_option(struct option *op)
+{
+  return op->action == NULL;
+}
+
+/****************************************************************************/
+
+/* Parse command-line parameters.
+ * Return zero on error, nonzero otherwise.
+ * On error, the other outputs may be invalid.
+ *
+ * The information collected from parameters is used to update
+ * 'ret'.  'ret' should be initialized.
+ *
+ * '_argc' and 'argv' are updated to contain only the unprocessed arguments.
+ */
+static int
+pb_ParseParameters (struct pb_Parameters *ret, int *_argc, char **argv)
+{
+  char *err_message;
+  struct argparse ap;
+
+  /* Each argument */
+  initialize_argparse(&ap, *_argc, argv);
+  while(!is_end_of_arguments(&ap)) {
+    result arg_result;          /* Result of parsing this option */
+    char *arg = get_argument(&ap);
+
+    /* Process this argument */
+    if (arg[0] == '-') {
+      /* Single-character flag */
+      if ((arg[1] != 0) && (arg[2] == 0)) {
+        delete_argument(&ap);	/* This argument is consumed here */
+
+        /* Find a matching short option */
+        struct option *op;
+        for (op = options; !is_last_option(op); op++) {
+          if (op->short_name == arg[1]) {
+            arg_result = (*op->action)(&ap, ret);
+            goto option_was_processed;
+          }
+        }
+
+        /* No option matches */
+        report_parse_error("Unexpected command-line parameter\n");
+        arg_result = ARGPARSE_ERROR;
+        goto option_was_processed;
+      }
+
+      /* Long flag */
+      if (arg[1] == '-') {
+        delete_argument(&ap);	/* This argument is consumed here */
+
+        /* Find a matching long option */
+        struct option *op;
+        for (op = options; !is_last_option(op); op++) {
+          if (op->long_name && strcmp(&arg[2], op->long_name) == 0) {
+            arg_result = (*op->action)(&ap, ret);
+            goto option_was_processed;
+          }
+        }
+
+        /* No option matches */
+        report_parse_error("Unexpected command-line parameter\n");
+        arg_result = ARGPARSE_ERROR;
+        goto option_was_processed;
+      }
+    }
+    else {
+      /* Other arguments are ignored */
+      next_argument(&ap);
+      arg_result = ARGPARSE_OK;
+      goto option_was_processed;
+    }
+
+  option_was_processed:
+    /* Decide what to do next based on 'arg_result' */
+    switch(arg_result) {
+    case ARGPARSE_OK:
+      /* Continue processing */
+      break;
+
+    case ARGPARSE_ERROR:
+      /* Error exit from the function */
+      return 0;
+
+    case ARGPARSE_DONE:
+      /* Normal exit from the argument parsing loop */
+      goto end_of_options;
+    }
+  } /* end for each argument */
+
+  /* If all arguments were processed, then normal exit from the loop */
+
+ end_of_options:
+  finalize_argparse(&ap, _argc, argv);
+  return 1;
+}
+
+/*****************************************************************************/
+/* Other exported functions */
+
+struct pb_Parameters *
+pb_ReadParameters(int *_argc, char **argv)
+{
+  struct pb_Parameters *ret =
+    (struct pb_Parameters *)malloc(sizeof(struct pb_Parameters));
+
+  /* Initialize the parameters structure */
+  ret->outFile = NULL;
+  ret->inpFiles = (char **)malloc(sizeof(char *));
+  ret->inpFiles[0] = NULL;
+  ret->platform = NULL;
+  ret->device = NULL;
+
+  /* Read parameters and update _argc, argv */
+  if (!pb_ParseParameters(ret, _argc, argv)) {
+    /* Parse error */
+    pb_FreeParameters(ret);
+    return NULL;
+  }
+
+  return ret;
+}
+
+int
+pb_Parameters_CountInputs(struct pb_Parameters *p)
+{
+  int n;
+
+  for (n = 0; p->inpFiles[n]; n++);
+  return n;
+}
+

benchmarks/opencl/cutcp/atom.h

@@ -0,0 +1,37 @@
+/***************************************************************************
+ *cr
+ *cr            (C) Copyright 2008-2010 The Board of Trustees of the
+ *cr                        University of Illinois
+ *cr                         All Rights Reserved
+ *cr
+ ***************************************************************************/
+
+#ifndef ATOM_H
+#define ATOM_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+  typedef struct Atom_t {
+    float x, y, z, q;
+  } Atom;
+
+  typedef struct Atoms_t {
+    Atom *atoms;
+    int size;
+  } Atoms;
+
+  typedef struct Vec3_t {
+    float x, y, z;
+  } Vec3;
+
+  Atoms *read_atom_file(const char *fname);
+  void free_atom(Atoms *atom);
+  void get_atom_extent(Vec3 *lo, Vec3 *hi, Atoms *atom);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ATOM_H */

benchmarks/opencl/cutcp/cutcpu.c

@@ -0,0 +1,195 @@
+/***************************************************************************
+ *cr
+ *cr            (C) Copyright 2008-2010 The Board of Trustees of the
+ *cr                        University of Illinois
+ *cr                         All Rights Reserved
+ *cr
+ ***************************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <parboil.h>
+#include "atom.h"
+#include "cutoff.h"
+
+#undef DEBUG_PASS_RATE
+#define CHECK_CYLINDER_CPU
+
+#define CELLEN      4.f
+#define INV_CELLEN  (1.f/CELLEN)
+
+extern int cpu_compute_cutoff_potential_lattice(
+    Lattice *lattice,                  /* the lattice */
+    float cutoff,                      /* cutoff distance */
+    Atoms *atoms                       /* array of atoms */
+    )
+{
+  int nx = lattice->dim.nx;
+  int ny = lattice->dim.ny;
+  int nz = lattice->dim.nz;
+  float xlo = lattice->dim.lo.x;
+  float ylo = lattice->dim.lo.y;
+  float zlo = lattice->dim.lo.z;
+  float gridspacing = lattice->dim.h;
+  int natoms = atoms->size;
+  Atom *atom = atoms->atoms;
+
+  const float a2 = cutoff * cutoff;
+  const float inv_a2 = 1.f / a2;
+  float s;
+  const float inv_gridspacing = 1.f / gridspacing;
+  const int radius = (int) ceilf(cutoff * inv_gridspacing) - 1;
+    /* lattice point radius about each atom */
+
+  int n;
+  int i, j, k;
+  int ia, ib, ic;
+  int ja, jb, jc;
+  int ka, kb, kc;
+  int index;
+  int koff, jkoff;
+
+  float x, y, z, q;
+  float dx, dy, dz;
+  float dz2, dydz2, r2;
+  float e;
+  float xstart, ystart;
+
+  float *pg;
+
+  int gindex;
+  int ncell, nxcell, nycell, nzcell;
+  int *first, *next;
+  float inv_cellen = INV_CELLEN;
+  Vec3 minext, maxext;		/* Extent of atom bounding box */
+  float xmin, ymin, zmin;
+  float xmax, ymax, zmax;
+
+#if DEBUG_PASS_RATE
+  unsigned long long pass_count = 0;
+  unsigned long long fail_count = 0;
+#endif
+
+  /* find min and max extent */
+  get_atom_extent(&minext, &maxext, atoms);
+
+  /* number of cells in each dimension */
+  nxcell = (int) floorf((maxext.x-minext.x) * inv_cellen) + 1;
+  nycell = (int) floorf((maxext.y-minext.y) * inv_cellen) + 1;
+  nzcell = (int) floorf((maxext.z-minext.z) * inv_cellen) + 1;
+  ncell = nxcell * nycell * nzcell;
+
+  /* allocate for cursor link list implementation */
+  first = (int *) malloc(ncell * sizeof(int));
+  for (gindex = 0;  gindex < ncell;  gindex++) {
+    first[gindex] = -1;
+  }
+  next = (int *) malloc(natoms * sizeof(int));
+  for (n = 0;  n < natoms;  n++) {
+    next[n] = -1;
+  }
+
+  /* geometric hashing */
+  for (n = 0;  n < natoms;  n++) {
+    if (0==atom[n].q) continue;  /* skip any non-contributing atoms */
+    i = (int) floorf((atom[n].x - minext.x) * inv_cellen);
+    j = (int) floorf((atom[n].y - minext.y) * inv_cellen);
+    k = (int) floorf((atom[n].z - minext.z) * inv_cellen);
+    gindex = (k*nycell + j)*nxcell + i;
+    next[n] = first[gindex];
+    first[gindex] = n;
+  }
+
+  /* traverse the grid cells */
+  for (gindex = 0;  gindex < ncell;  gindex++) {
+    for (n = first[gindex];  n != -1;  n = next[n]) {
+      x = atom[n].x - xlo;
+      y = atom[n].y - ylo;
+      z = atom[n].z - zlo;
+      q = atom[n].q;
+
+      /* find closest grid point with position less than or equal to atom */
+      ic = (int) (x * inv_gridspacing);
+      jc = (int) (y * inv_gridspacing);
+      kc = (int) (z * inv_gridspacing);
+
+      /* find extent of surrounding box of grid points */
+      ia = ic - radius;
+      ib = ic + radius + 1;
+      ja = jc - radius;
+      jb = jc + radius + 1;
+      ka = kc - radius;
+      kb = kc + radius + 1;
+
+      /* trim box edges so that they are within grid point lattice */
+      if (ia < 0)   ia = 0;
+      if (ib >= nx) ib = nx-1;
+      if (ja < 0)   ja = 0;
+      if (jb >= ny) jb = ny-1;
+      if (ka < 0)   ka = 0;
+      if (kb >= nz) kb = nz-1;
+
+      /* loop over surrounding grid points */
+      xstart = ia*gridspacing - x;
+      ystart = ja*gridspacing - y;
+      dz = ka*gridspacing - z;
+      for (k = ka;  k <= kb;  k++, dz += gridspacing) {
+        koff = k*ny;
+        dz2 = dz*dz;
+        dy = ystart;
+        for (j = ja;  j <= jb;  j++, dy += gridspacing) {
+          jkoff = (koff + j)*nx;
+          dydz2 = dy*dy + dz2;
+#ifdef CHECK_CYLINDER_CPU
+          if (dydz2 >= a2) continue;
+#endif
+
+          dx = xstart;
+          index = jkoff + ia;
+          pg = lattice->lattice + index;
+
+#if defined(__INTEL_COMPILER)
+          for (i = ia;  i <= ib;  i++, pg++, dx += gridspacing) {
+            r2 = dx*dx + dydz2;
+            s = (1.f - r2 * inv_a2) * (1.f - r2 * inv_a2);
+            e = q * (1/sqrtf(r2)) * s;
+            *pg += (r2 < a2 ? e : 0);  /* LOOP VECTORIZED!! */
+          }
+#else
+          for (i = ia;  i <= ib;  i++, pg++, dx += gridspacing) {
+            r2 = dx*dx + dydz2;
+            if (r2 >= a2)
+		{
+#ifdef DEBUG_PASS_RATE
+		  fail_count++;
+#endif
+		  continue;
+		}
+#ifdef DEBUG_PASS_RATE
+	    pass_count++;
+#endif
+            s = (1.f - r2 * inv_a2);
+            e = q * (1/sqrtf(r2)) * s * s;
+            *pg += e;
+          }
+#endif
+        }
+      } /* end loop over surrounding grid points */
+
+    } /* end loop over atoms in a gridcell */
+  } /* end loop over gridcells */
+
+  /* free memory */
+  free(next);
+  free(first);
+
+  /* For debugging: print the number of times that the test passed/failed */
+#ifdef DEBUG_PASS_RATE
+  printf ("Pass :%lld\n", pass_count);
+  printf ("Fail :%lld\n", fail_count);
+#endif
+
+  return 0;
+}

benchmarks/opencl/cutcp/cutoff.c

@@ -0,0 +1,499 @@
+/***************************************************************************
+ *cr
+ *cr            (C) Copyright 2008-2010 The Board of Trustees of the
+ *cr                        University of Illinois
+ *cr                         All Rights Reserved
+ *cr
+ ***************************************************************************/
+
+#include <CL/cl.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <parboil.h>
+
+#include "atom.h"
+#include "cutoff.h"
+#include "macros.h"
+#include "ocl.h"
+
+// OpenCL 1.1 support for int3 is not uniform on all implementations, so
+// we use int4 instead.  Only the 'x', 'y', and 'z' fields of xyz are used.
+typedef cl_int4 xyz;
+
+//extern "C" int gpu_compute_cutoff_potential_lattice(
+int gpu_compute_cutoff_potential_lattice(
+    struct pb_TimerSet *timers,
+    Lattice *lattice,                  /* the lattice */
+    float cutoff,                      /* cutoff distance */
+    Atoms *atoms,                      /* array of atoms */
+    int verbose,                        /* print info/debug messages */
+    struct pb_Parameters *parameters
+    )
+{
+  int nx = lattice->dim.nx;
+  int ny = lattice->dim.ny;
+  int nz = lattice->dim.nz;
+  float xlo = lattice->dim.lo.x;
+  float ylo = lattice->dim.lo.y;
+  float zlo = lattice->dim.lo.z;
+  float h = lattice->dim.h;
+  int natoms = atoms->size;
+  Atom *atom = atoms->atoms;
+
+  xyz nbrlist[NBRLIST_MAXLEN];
+  int nbrlistlen = 0;
+
+  int binHistoFull[BIN_DEPTH+1] = { 0 };   /* clear every array element */
+  int binHistoCover[BIN_DEPTH+1] = { 0 };  /* clear every array element */
+  int num_excluded = 0;
+
+  int xRegionDim, yRegionDim, zRegionDim;
+  int xRegionIndex, yRegionIndex, zRegionIndex;
+  int xOffset, yOffset, zOffset;
+  int lnx, lny, lnz, lnall;
+  float *regionZeroAddr, *thisRegion;
+  cl_mem regionZeroCl;
+  int index, indexRegion;
+
+  int c;
+  xyz binDim;
+  int nbins;
+  cl_float4 *binBaseAddr, *binZeroAddr;
+  cl_mem binBaseCl, binZeroCl;
+  int *bincntBaseAddr, *bincntZeroAddr;
+  Atoms *extra = NULL;
+
+  cl_mem NbrListLen;
+  cl_mem NbrList;
+
+  int i, j, k, n;
+  int sum, total;
+
+  float avgFillFull, avgFillCover;
+  const float cutoff2 = cutoff * cutoff;
+  const float inv_cutoff2 = 1.f / cutoff2;
+
+  size_t gridDim[3], blockDim[3];
+
+  // The "compute" timer should be active upon entry to this function
+
+  /* pad lattice to be factor of 8 in each dimension */
+  xRegionDim = (int) ceilf(nx/8.f);
+  yRegionDim = (int) ceilf(ny/8.f);
+  zRegionDim = (int) ceilf(nz/8.f);
+
+  lnx = 8 * xRegionDim;
+  lny = 8 * yRegionDim;
+  lnz = 8 * zRegionDim;
+  lnall = lnx * lny * lnz;
+
+  /* will receive energies from OpenCL */
+  regionZeroAddr = (float *) malloc(lnall * sizeof(float));
+
+  /* create bins */
+  c = (int) ceil(cutoff * BIN_INVLEN);  /* count extra bins around lattice */
+  binDim.x = (int) ceil(lnx * h * BIN_INVLEN) + 2*c;
+  binDim.y = (int) ceil(lny * h * BIN_INVLEN) + 2*c;
+  binDim.z = (int) ceil(lnz * h * BIN_INVLEN) + 2*c;
+  nbins = binDim.x * binDim.y * binDim.z;
+  binBaseAddr = (cl_float4 *) calloc(nbins * BIN_DEPTH, sizeof(cl_float4));
+  binZeroAddr = binBaseAddr + ((c * binDim.y + c) * binDim.x + c) * BIN_DEPTH;
+
+  bincntBaseAddr = (int *) calloc(nbins, sizeof(int));
+  bincntZeroAddr = bincntBaseAddr + (c * binDim.y + c) * binDim.x + c;
+
+  /* create neighbor list */
+  if (ceilf(BIN_LENGTH / (8*h)) == floorf(BIN_LENGTH / (8*h))) {
+    float s = sqrtf(3);
+    float r2 = (cutoff + s*BIN_LENGTH) * (cutoff + s*BIN_LENGTH);
+    int cnt = 0;
+    /* develop neighbor list around 1 cell */
+    if (2*c + 1 > NBRLIST_DIM) {
+      fprintf(stderr, "must have cutoff <= %f\n",
+          (NBRLIST_DIM-1)/2 * BIN_LENGTH);
+      return -1;
+    }
+    for (k = -c;  k <= c;  k++) {
+      for (j = -c;  j <= c;  j++) {
+        for (i = -c;  i <= c;  i++) {
+          if ((i*i + j*j + k*k)*BIN_LENGTH*BIN_LENGTH >= r2) continue;
+          nbrlist[cnt].x = i;
+          nbrlist[cnt].y = j;
+          nbrlist[cnt].z = k;
+          cnt++;
+        }
+      }
+    }
+    nbrlistlen = cnt;
+  }
+  else if (8*h <= 2*BIN_LENGTH) {
+    float s = 2.f*sqrtf(3);
+    float r2 = (cutoff + s*BIN_LENGTH) * (cutoff + s*BIN_LENGTH);
+    int cnt = 0;
+    /* develop neighbor list around 3-cube of cells */
+    if (2*c + 3 > NBRLIST_DIM) {
+      fprintf(stderr, "must have cutoff <= %f\n",
+          (NBRLIST_DIM-3)/2 * BIN_LENGTH);
+      return -1;
+    }
+    for (k = -c;  k <= c;  k++) {
+      for (j = -c;  j <= c;  j++) {
+        for (i = -c;  i <= c;  i++) {
+          if ((i*i + j*j + k*k)*BIN_LENGTH*BIN_LENGTH >= r2) continue;
+          nbrlist[cnt].x = i;
+          nbrlist[cnt].y = j;
+          nbrlist[cnt].z = k;
+          cnt++;
+        }
+      }
+    }
+    nbrlistlen = cnt;
+  }
+  else {
+    fprintf(stderr, "must have h <= %f\n", 0.25 * BIN_LENGTH);
+    return -1;
+  }
+
+  /* perform geometric hashing of atoms into bins */
+  {
+    /* array of extra atoms, permit average of one extra per bin */
+    Atom *extra_atoms = (Atom *) calloc(nbins, sizeof(Atom));
+    int extra_len = 0;
+    
+    for (n = 0;  n < natoms;  n++) {
+      cl_float4 p;
+      p.x = atom[n].x - xlo;
+      p.y = atom[n].y - ylo;
+      p.z = atom[n].z - zlo;
+      p.w = atom[n].q;
+      i = (int) floorf(p.x * BIN_INVLEN);
+      j = (int) floorf(p.y * BIN_INVLEN);
+      k = (int) floorf(p.z * BIN_INVLEN);
+      if (i >= -c && i < binDim.x - c &&
+	  j >= -c && j < binDim.y - c &&
+	  k >= -c && k < binDim.z - c &&
+	  atom[n].q != 0) {
+	int index = (k * binDim.y + j) * binDim.x + i;
+	cl_float4 *bin = binZeroAddr + index * BIN_DEPTH;
+	int bindex = bincntZeroAddr[index];
+	if (bindex < BIN_DEPTH) {
+	  /* copy atom into bin and increase counter for this bin */
+	  bin[bindex] = p;
+	  bincntZeroAddr[index]++;
+	}
+	else {
+	  /* add index to array of extra atoms to be computed with CPU */
+	  if (extra_len >= nbins) {
+	    fprintf(stderr, "exceeded space for storing extra atoms\n");
+	    return -1;
+	  }
+	  extra_atoms[extra_len] = atom[n];
+	  extra_len++;
+	}
+      }
+      else {
+	/* excluded atoms are either outside bins or neutrally charged */
+	num_excluded++;
+      }
+    }
+
+    /* Save result */
+    extra = (Atoms *)malloc(sizeof(Atoms));
+    extra->atoms = extra_atoms;
+    extra->size = extra_len;
+  }
+
+  /* bin stats */
+  sum = total = 0;
+  for (n = 0;  n < nbins;  n++) {
+    binHistoFull[ bincntBaseAddr[n] ]++;
+    sum += bincntBaseAddr[n];
+    total += BIN_DEPTH;
+  }
+  avgFillFull = sum / (float) total;
+  sum = total = 0;
+  for (k = 0;  k < binDim.z - 2*c;  k++) {
+    for (j = 0;  j < binDim.y - 2*c;  j++) {
+      for (i = 0;  i < binDim.x - 2*c;  i++) {
+        int index = (k * binDim.y + j) * binDim.x + i;
+        binHistoCover[ bincntZeroAddr[index] ]++;
+        sum += bincntZeroAddr[index];
+        total += BIN_DEPTH;
+      }
+    }
+  }
+  avgFillCover = sum / (float) total;
+
+  if (verbose) {
+    /* report */
+    printf("number of atoms = %d\n", natoms);
+    printf("lattice spacing = %g\n", h);
+    printf("cutoff distance = %g\n", cutoff);
+    printf("\n");
+    printf("requested lattice dimensions = %d %d %d\n", nx, ny, nz);
+    printf("requested space dimensions = %g %g %g\n", nx*h, ny*h, nz*h);
+    printf("expanded lattice dimensions = %d %d %d\n", lnx, lny, lnz);
+    printf("expanded space dimensions = %g %g %g\n", lnx*h, lny*h, lnz*h);
+    printf("number of bytes for lattice data = %u\n", (unsigned int) (lnall*sizeof(float)));
+    printf("\n");
+    printf("bin padding thickness = %d\n", c);
+    printf("bin cover dimensions = %d %d %d\n",
+        binDim.x - 2*c, binDim.y - 2*c, binDim.z - 2*c);
+    printf("bin full dimensions = %d %d %d\n", binDim.x, binDim.y, binDim.z);
+    printf("number of bins = %d\n", nbins);
+    printf("total number of atom slots = %d\n", nbins * BIN_DEPTH);
+    printf("%% overhead space = %g\n",
+        (natoms / (double) (nbins * BIN_DEPTH)) * 100);
+    printf("number of bytes for bin data = %u\n",
+        (unsigned int)(nbins * BIN_DEPTH * sizeof(cl_float4)));
+    printf("\n");
+    printf("bin histogram with padding:\n");
+    sum = 0;
+    for (n = 0;  n <= BIN_DEPTH;  n++) {
+      printf("     number of bins with %d atoms:  %d\n", n, binHistoFull[n]);
+      sum += binHistoFull[n];
+    }
+    printf("     total number of bins:  %d\n", sum);
+    printf("     %% average fill:  %g\n", avgFillFull * 100);
+    printf("\n");
+    printf("bin histogram excluding padding:\n");
+    sum = 0;
+    for (n = 0;  n <= BIN_DEPTH;  n++) {
+      printf("     number of bins with %d atoms:  %d\n", n, binHistoCover[n]);
+      sum += binHistoCover[n];
+    }
+    printf("     total number of bins:  %d\n", sum);
+    printf("     %% average fill:  %g\n", avgFillCover * 100);
+    printf("\n");
+    printf("number of extra atoms = %d\n", extra->size);
+    printf("%% atoms that are extra = %g\n", (extra->size / (double) natoms) * 100);
+    printf("\n");
+
+    /* sanity check on bins */
+    sum = 0;
+    for (n = 0;  n <= BIN_DEPTH;  n++) {
+      sum += n * binHistoFull[n];
+    }
+    sum += extra->size + num_excluded;
+    printf("sanity check on bin histogram with edges:  "
+        "sum + others = %d\n", sum);
+    sum = 0;
+    for (n = 0;  n <= BIN_DEPTH;  n++) {
+      sum += n * binHistoCover[n];
+    }
+    sum += extra->size + num_excluded;
+    printf("sanity check on bin histogram excluding edges:  "
+        "sum + others = %d\n", sum);
+    printf("\n");
+
+    /* neighbor list */
+    printf("neighbor list length = %d\n", nbrlistlen);
+    printf("\n");
+  }
+
+  printf("Ok!\n");
+
+  pb_Context* pb_context;
+  pb_context = pb_InitOpenCLContext(parameters);
+  if (pb_context == NULL) {
+    fprintf (stderr, "Error: No OpenCL platform/device can be found."); 
+    return -1;
+  }
+
+  printf("Ok!\n");
+
+  cl_int clStatus;
+  cl_device_id clDevice = (cl_device_id) pb_context->clDeviceId;
+  cl_platform_id clPlatform = (cl_platform_id) pb_context->clPlatformId;
+  cl_context clContext = (cl_context) pb_context->clContext;
+
+  cl_command_queue clCommandQueue = clCreateCommandQueue(clContext,clDevice,CL_QUEUE_PROFILING_ENABLE,&clStatus);
+  CHECK_ERROR("clCreateCommandQueue")
+
+  pb_SetOpenCL(&clContext, &clCommandQueue);
+  
+  //const char* clSource[] = {readFile("src/opencl_base/kernel.cl")};
+  //cl_program clProgram = clCreateProgramWithSource(clContext,1,clSource,NULL,&clStatus);
+  cl_program clProgram = clCreateProgramWithBuiltInKernels(
+      clContext, 1, &clDevice, "opencl_cutoff_potential_lattice", &clStatus);
+  CHECK_ERROR("clCreateProgramWithSource")
+
+  char clOptions[50];
+  sprintf(clOptions,"-I src/opencl_base");  //-cl-nv-verbose
+
+  clStatus = clBuildProgram(clProgram,1,&clDevice,clOptions,NULL,NULL);
+  if (clStatus != CL_SUCCESS) {
+    size_t string_size = 0;
+    clGetProgramBuildInfo(clProgram, clDevice, CL_PROGRAM_BUILD_LOG, 
+                          0, NULL, &string_size);
+    char* string = (char*)malloc(string_size*sizeof(char));
+    clGetProgramBuildInfo(clProgram, clDevice, CL_PROGRAM_BUILD_LOG, 
+                          string_size, string, NULL);
+    puts(string);
+  }
+
+  CHECK_ERROR("clBuildProgram")
+
+  cl_kernel clKernel = clCreateKernel(clProgram,"opencl_cutoff_potential_lattice",&clStatus);
+  CHECK_ERROR("clCreateKernel")
+
+  /* setup OpenCL kernel parameters */
+  blockDim[0] = 8;
+  blockDim[1] = 8;
+  blockDim[2] = 2;
+  gridDim[0] = 4 * xRegionDim * blockDim[0];
+  gridDim[1] = yRegionDim * blockDim[1];
+  gridDim[2] = 1 * blockDim[2];
+
+  /* allocate and initialize memory on OpenCL device */
+  pb_SwitchToTimer(timers, pb_TimerID_COPY);
+  if (verbose) {
+    printf("Allocating %.2fMB on OpenCL device for potentials\n",
+           lnall * sizeof(float) / (double) (1024*1024));
+  }
+
+  regionZeroCl = clCreateBuffer(clContext,CL_MEM_WRITE_ONLY,lnall*sizeof(float),NULL,&clStatus);
+  CHECK_ERROR("clCreateBuffer")
+
+  // clMemSet(clCommandQueue,regionZeroCl,0,lnall*sizeof(float));
+
+  if (verbose) {
+    printf("Allocating %.2fMB on OpenCL device for atom bins\n",
+           nbins * BIN_DEPTH * sizeof(cl_float4) / (double) (1024*1024));
+  }
+
+  binBaseCl = clCreateBuffer(clContext,CL_MEM_READ_ONLY,nbins*BIN_DEPTH*sizeof(cl_float4),NULL,&clStatus);
+  CHECK_ERROR("clCreateBuffer")
+ 
+  clStatus = clEnqueueWriteBuffer(clCommandQueue,binBaseCl,CL_TRUE,0,nbins*BIN_DEPTH*sizeof(cl_float4),binBaseAddr,0,NULL,NULL);
+  CHECK_ERROR("clEnqueueWriteBuffer")
+
+  //Sub buffers are not supported in OpenCL v1.0
+  int offset = ((c * binDim.y + c) * binDim.x + c) * BIN_DEPTH;  
+
+  NbrListLen = clCreateBuffer(clContext,CL_MEM_READ_ONLY,sizeof(int),NULL,&clStatus);
+  CHECK_ERROR("clCreateBuffer")
+  clStatus = clEnqueueWriteBuffer(clCommandQueue,NbrListLen,CL_TRUE,0,sizeof(int),&nbrlistlen,0,NULL,NULL);
+  CHECK_ERROR("clEnqueueWriteBuffer")
+
+  NbrList = clCreateBuffer(clContext,CL_MEM_READ_ONLY,NBRLIST_MAXLEN*sizeof(xyz),NULL,&clStatus);
+  CHECK_ERROR("clCreateBuffer")
+  clStatus = clEnqueueWriteBuffer(clCommandQueue,NbrList,CL_TRUE,0,nbrlistlen*sizeof(xyz),nbrlist,0,NULL,NULL);
+  CHECK_ERROR("clEnqueueWriteBuffer")
+
+  if (verbose) 
+    printf("\n");
+
+  clStatus = clSetKernelArg(clKernel,0,sizeof(int),&(binDim.x));
+  clStatus = clSetKernelArg(clKernel,1,sizeof(int),&(binDim.y));
+  clStatus = clSetKernelArg(clKernel,2,sizeof(cl_mem),&binBaseCl);
+  clStatus = clSetKernelArg(clKernel,3,sizeof(int),&offset);
+  clStatus = clSetKernelArg(clKernel,4,sizeof(float),&h);
+  clStatus = clSetKernelArg(clKernel,5,sizeof(float),&cutoff2);
+  clStatus = clSetKernelArg(clKernel,6,sizeof(float),&inv_cutoff2);
+  clStatus = clSetKernelArg(clKernel,7,sizeof(cl_mem),&regionZeroCl);
+  clStatus = clSetKernelArg(clKernel,9,sizeof(cl_mem),&NbrListLen);
+  clStatus = clSetKernelArg(clKernel,10,sizeof(cl_mem),&NbrList);
+  CHECK_ERROR("clSetKernelArg")
+
+  printf("Ok!!\n");
+
+
+  /* loop over z-dimension, invoke OpenCL kernel for each x-y plane */
+  pb_SwitchToTimer(timers, pb_TimerID_KERNEL);
+  printf("Invoking OpenCL kernel on %d region planes...\n", zRegionDim);
+  for (zRegionIndex = 0;  zRegionIndex < zRegionDim;  zRegionIndex++) {
+    printf("  computing plane %d\r", zRegionIndex);
+    fflush(stdout);
+
+    clStatus = clSetKernelArg(clKernel,8,sizeof(int),&zRegionIndex);
+    CHECK_ERROR("clSetKernelArg")
+
+    printf("Ok**!2\n");
+
+    clStatus = clEnqueueNDRangeKernel(clCommandQueue,clKernel,3,NULL,gridDim,blockDim,0,NULL,NULL);
+
+    printf("Ok**!2\n");
+
+    CHECK_ERROR("clEnqueueNDRangeKernel")
+
+    printf("Ok**!2\n");
+
+    clStatus = clFinish(clCommandQueue);
+
+    printf("Ok**!2\n");
+
+    CHECK_ERROR("clFinish")
+  }
+
+  printf("Ok++!\n");
+
+  printf("Finished OpenCL kernel calls                        \n");
+
+  /* copy result regions from OpenCL device */
+  pb_SwitchToTimer(timers, pb_TimerID_COPY);
+  clStatus = clEnqueueReadBuffer(clCommandQueue,regionZeroCl,CL_TRUE,0,lnall*sizeof(float),regionZeroAddr,0,NULL,NULL);
+  CHECK_ERROR("clEnqueueReadBuffer")
+
+  /* free OpenCL memory allocations */
+  clStatus = clReleaseMemObject(regionZeroCl);
+  clStatus = clReleaseMemObject(binBaseCl);
+  clStatus = clReleaseMemObject(NbrListLen);
+  clStatus = clReleaseMemObject(NbrList);
+  CHECK_ERROR("clReleaseMemObject")
+
+  clStatus = clReleaseKernel(clKernel);
+  clStatus = clReleaseProgram(clProgram);
+  clStatus = clReleaseCommandQueue(clCommandQueue);
+  clStatus = clReleaseContext(clContext);
+
+  //free((void*)clSource[0]);
+
+  /* transpose regions back into lattice */
+  pb_SwitchToTimer(timers, pb_TimerID_COMPUTE);
+  for (k = 0;  k < nz;  k++) {
+    zRegionIndex = (k >> 3);
+    zOffset = (k & 7);
+
+    for (j = 0;  j < ny;  j++) {
+      yRegionIndex = (j >> 3);
+      yOffset = (j & 7);
+
+      for (i = 0;  i < nx;  i++) {
+        xRegionIndex = (i >> 3);
+        xOffset = (i & 7);
+
+        thisRegion = regionZeroAddr
+          + ((zRegionIndex * yRegionDim + yRegionIndex) * xRegionDim
+              + xRegionIndex) * REGION_SIZE;
+
+        indexRegion = (zOffset * 8 + yOffset) * 8 + xOffset;
+        index = (k * ny + j) * nx + i;
+
+        lattice->lattice[index] = thisRegion[indexRegion];
+      }
+    }
+  }
+
+  /* handle extra atoms */
+  if (extra->size > 0) {
+    printf("computing extra atoms on CPU\n");
+    if (cpu_compute_cutoff_potential_lattice(lattice, cutoff, extra)) {
+      fprintf(stderr, "cpu_compute_cutoff_potential_lattice() failed "
+          "for extra atoms\n");
+      return -1;
+    }
+    printf("\n");
+  }
+
+  /* cleanup memory allocations */
+  free(regionZeroAddr);
+  free(binBaseAddr);
+  free(bincntBaseAddr);
+  free_atom(extra);
+
+  return 0;
+}

benchmarks/opencl/cutcp/cutoff.h

@@ -0,0 +1,72 @@
+/***************************************************************************
+ *cr
+ *cr            (C) Copyright 2008-2010 The Board of Trustees of the
+ *cr                        University of Illinois
+ *cr                         All Rights Reserved
+ *cr
+ ***************************************************************************/
+
+#ifndef CUTOFF_H
+#define CUTOFF_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define SHIFTED
+
+  /* A structure to record how points in 3D space map to array
+     elements.  Array element (z, y, x)
+     where 0 <= x < nx, 0 <= y < ny, 0 <= z < nz
+     maps to coordinate (xlo, ylo, zlo) + h * (x, y, z).
+  */
+  typedef struct LatticeDim_t {
+    /* Number of lattice points in x, y, z dimensions */
+    int nx, ny, nz;
+
+    /* Lowest corner of lattice */
+    Vec3 lo;
+
+    /* Lattice spacing */
+    float h;
+  } LatticeDim;
+
+  /* An electric potential field sampled on a regular grid.  The
+     lattice size and grid point positions are specified by 'dim'.
+  */
+  typedef struct Lattice_t {
+    LatticeDim dim;
+    float *lattice;
+  } Lattice;
+
+  LatticeDim lattice_from_bounding_box(Vec3 lo, Vec3 hi, float h);
+
+  Lattice *create_lattice(LatticeDim dim);
+  void destroy_lattice(Lattice *);
+
+  int gpu_compute_cutoff_potential_lattice(
+      struct pb_TimerSet *timers,
+      Lattice *lattice,
+      float cutoff,                      /* cutoff distance */
+      Atoms *atom,                       /* array of atoms */
+      int verbose,                        /* print info/debug messages */
+      struct pb_Parameters *parameters
+    );
+
+  int cpu_compute_cutoff_potential_lattice(
+      Lattice *lattice,                  /* the lattice */
+      float cutoff,                      /* cutoff distance */
+      Atoms *atoms                       /* array of atoms */
+    );
+
+  int remove_exclusions(
+      Lattice *lattice,                  /* the lattice */
+      float exclcutoff,                  /* exclusion cutoff distance */
+      Atoms *atom                        /* array of atoms */
+    );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* CUTOFF_H */

benchmarks/opencl/cutcp/excl.c

@@ -0,0 +1,157 @@
+/***************************************************************************
+ *cr
+ *cr            (C) Copyright 2008-2010 The Board of Trustees of the
+ *cr                        University of Illinois
+ *cr                         All Rights Reserved
+ *cr
+ ***************************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <parboil.h>
+
+#include "atom.h"
+#include "cutoff.h"
+
+#define CELLEN      4.f
+#define INV_CELLEN  (1.f/CELLEN)
+
+extern int remove_exclusions(
+    Lattice *lattice,                  /* the lattice */
+    float cutoff,                      /* exclusion cutoff distance */
+    Atoms *atoms                       /* array of atoms */
+    )
+{
+  int nx = lattice->dim.nx;
+  int ny = lattice->dim.ny;
+  int nz = lattice->dim.nz;
+  float xlo = lattice->dim.lo.x;
+  float ylo = lattice->dim.lo.y;
+  float zlo = lattice->dim.lo.z;
+  float gridspacing = lattice->dim.h;
+  Atom *atom = atoms->atoms;
+
+  const float a2 = cutoff * cutoff;
+  const float inv_gridspacing = 1.f / gridspacing;
+  const int radius = (int) ceilf(cutoff * inv_gridspacing) - 1;
+    /* lattice point radius about each atom */
+
+  int n;
+  int i, j, k;
+  int ia, ib, ic;
+  int ja, jb, jc;
+  int ka, kb, kc;
+  int index;
+  int koff, jkoff;
+
+  float x, y, z, q;
+  float dx, dy, dz;
+  float dz2, dydz2, r2;
+  float e;
+  float xstart, ystart;
+
+  float *pg;
+
+  int gindex;
+  int ncell, nxcell, nycell, nzcell;
+  int *first, *next;
+  float inv_cellen = INV_CELLEN;
+  Vec3 minext, maxext;
+
+  /* find min and max extent */
+  get_atom_extent(&minext, &maxext, atoms);
+
+  /* number of cells in each dimension */
+  nxcell = (int) floorf((maxext.x-minext.x) * inv_cellen) + 1;
+  nycell = (int) floorf((maxext.y-minext.y) * inv_cellen) + 1;
+  nzcell = (int) floorf((maxext.z-minext.z) * inv_cellen) + 1;
+  ncell = nxcell * nycell * nzcell;
+
+  /* allocate for cursor link list implementation */
+  first = (int *) malloc(ncell * sizeof(int));
+  for (gindex = 0;  gindex < ncell;  gindex++) {
+    first[gindex] = -1;
+  }
+  next = (int *) malloc(atoms->size * sizeof(int));
+  for (n = 0;  n < atoms->size;  n++) {
+    next[n] = -1;
+  }
+
+  /* geometric hashing */
+  for (n = 0;  n < atoms->size;  n++) {
+    if (0==atom[n].q) continue;  /* skip any non-contributing atoms */
+    i = (int) floorf((atom[n].x - minext.x) * inv_cellen);
+    j = (int) floorf((atom[n].y - minext.y) * inv_cellen);
+    k = (int) floorf((atom[n].z - minext.z) * inv_cellen);
+    gindex = (k*nycell + j)*nxcell + i;
+    next[n] = first[gindex];
+    first[gindex] = n;
+  }
+
+  /* traverse the grid cells */
+  for (gindex = 0;  gindex < ncell;  gindex++) {
+    for (n = first[gindex];  n != -1;  n = next[n]) {
+      x = atom[n].x - xlo;
+      y = atom[n].y - ylo;
+      z = atom[n].z - zlo;
+      q = atom[n].q;
+
+      /* find closest grid point with position less than or equal to atom */
+      ic = (int) (x * inv_gridspacing);
+      jc = (int) (y * inv_gridspacing);
+      kc = (int) (z * inv_gridspacing);
+
+      /* find extent of surrounding box of grid points */
+      ia = ic - radius;
+      ib = ic + radius + 1;
+      ja = jc - radius;
+      jb = jc + radius + 1;
+      ka = kc - radius;
+      kb = kc + radius + 1;
+
+      /* trim box edges so that they are within grid point lattice */
+      if (ia < 0)   ia = 0;
+      if (ib >= nx) ib = nx-1;
+      if (ja < 0)   ja = 0;
+      if (jb >= ny) jb = ny-1;
+      if (ka < 0)   ka = 0;
+      if (kb >= nz) kb = nz-1;
+
+      /* loop over surrounding grid points */
+      xstart = ia*gridspacing - x;
+      ystart = ja*gridspacing - y;
+      dz = ka*gridspacing - z;
+      for (k = ka;  k <= kb;  k++, dz += gridspacing) {
+        koff = k*ny;
+        dz2 = dz*dz;
+
+        dy = ystart;
+        for (j = ja;  j <= jb;  j++, dy += gridspacing) {
+          jkoff = (koff + j)*nx;
+          dydz2 = dy*dy + dz2;
+
+          dx = xstart;
+          index = jkoff + ia;
+          pg = lattice->lattice + index;
+
+          for (i = ia;  i <= ib;  i++, pg++, dx += gridspacing) {
+            r2 = dx*dx + dydz2;
+
+	    /* If atom and lattice point are too close, set the lattice value
+	     * to zero */
+            if (r2 < a2) *pg = 0;
+          }
+        }
+      } /* end loop over surrounding grid points */
+
+    } /* end loop over atoms in a gridcell */
+  } /* end loop over gridcells */
+
+  /* free memory */
+  free(next);
+  free(first);
+
+  return 0;
+}

benchmarks/opencl/cutcp/gpu_info.c

@@ -0,0 +1,55 @@
+/***************************************************************************
+ *cr
+ *cr            (C) Copyright 2010 The Board of Trustees of the
+ *cr                        University of Illinois
+ *cr                         All Rights Reserved
+ *cr
+ ***************************************************************************/
+//#include <endian.h>
+#include <stdlib.h>
+#include <malloc.h>
+#include <stdio.h>
+#include <inttypes.h>
+
+#include "gpu_info.h"
+
+void compute_active_thread(size_t *thread,
+			   size_t *grid,
+			   int task,
+			   int pad,
+			   int major,
+			   int minor,
+			   int sm)
+{
+	int max_thread;
+	int max_block=8;
+	if(major==1)
+	{
+		if(minor>=2)
+			max_thread=1024;
+		else
+			max_thread=768;
+	}
+	else if(major==2)
+		max_thread=1536;
+	else
+		//newer GPU  //keep using 2.0
+		max_thread=1536;
+	
+	int _grid;
+	int _thread;
+	
+	if(task*pad>sm*max_thread)
+	{
+		_thread=max_thread/max_block;
+		_grid = ((task*pad+_thread-1)/_thread)*_thread;
+	}
+	else
+	{
+		_thread=pad;
+		_grid=task*pad;
+	}
+
+	thread[0]=_thread;
+	grid[0]=_grid;
+}

benchmarks/opencl/cutcp/gpu_info.h

@@ -0,0 +1,20 @@
+/***************************************************************************
+ *cr
+ *cr            (C) Copyright 2010 The Board of Trustees of the
+ *cr                        University of Illinois
+ *cr                         All Rights Reserved
+ *cr
+ ***************************************************************************/
+
+#ifndef __GPUINFOH__
+#define __GPUINFOH__
+
+void compute_active_thread(size_t *thread,
+			   size_t *grid,
+			   int task,
+			   int pad,
+			   int major,
+			   int minor,
+			   int sm);
+
+#endif

benchmarks/opencl/cutcp/kernel.cl

@@ -0,0 +1,104 @@
+/*
+ * potential lattice is decomposed into size 8^3 lattice point "regions"
+ *
+ * THIS IMPLEMENTATION:  one thread per lattice point
+ * thread block size 128 gives 4 thread blocks per region
+ * kernel is invoked for each x-y plane of regions,
+ * where gridDim.x is 4*(x region dimension) so that blockIdx.x 
+ * can absorb the z sub-region index in its 2 lowest order bits
+ *
+ * Regions are stored contiguously in memory in row-major order
+ *
+ * The bins have to not only cover the region, but they need to surround
+ * the outer edges so that region sides and corners can still use
+ * neighbor list stencil.  The binZeroAddr is actually a shifted pointer into
+ * the bin array (binZeroAddr = binBaseAddr + (c*binDim_y + c)*binDim_x + c)
+ * where c = ceil(cutoff / binsize).  This allows for negative offsets to
+ * be added to myBinIndex.
+ *
+ * The (0,0,0) spatial origin corresponds to lower left corner of both
+ * regionZeroAddr and binZeroAddr.  The atom coordinates are translated
+ * during binning to enforce this assumption.
+ */
+
+#include "macros.h"
+
+// OpenCL 1.1 support for int3 is not uniform on all implementations, so
+// we use int4 instead.  Only the 'x', 'y', and 'z' fields of xyz are used.
+typedef int4 xyz;
+
+__kernel void opencl_cutoff_potential_lattice(
+    int binDim_x,
+    int binDim_y,
+    __global float4 *binBaseAddr,
+    int offset,
+    float h,                /* lattice spacing */
+    float cutoff2,          /* square of cutoff distance */
+    float inv_cutoff2,
+    __global float *regionZeroAddr,  /* address of lattice regions starting at origin */
+    int zRegionIndex,
+    __constant int *NbrListLen,
+    __constant xyz *NbrList
+    )
+{
+  __global float4* binZeroAddr = binBaseAddr + offset;
+
+  __global float *myRegionAddr;
+  int Bx, By, Bz;
+
+  /* thread id */
+  const int tid = (get_local_id(2)*get_local_size(1) + 
+                      get_local_id(1))*get_local_size(0) + get_local_id(0);
+
+  /* this is the start of the sub-region indexed by tid */
+  myRegionAddr = regionZeroAddr + ((zRegionIndex*get_num_groups(1)
+	+ get_group_id(1))*(get_num_groups(0)>>2) + (get_group_id(0)>>2))*REGION_SIZE
+	+ (get_group_id(0)&3)*SUB_REGION_SIZE;
+
+  /* spatial coordinate of this lattice point */
+  float x = (8 * (get_group_id(0) >> 2) + get_local_id(0)) * h;
+  float y = (8 * get_group_id(1) + get_local_id(1)) * h;
+  float z = (8 * zRegionIndex + 2*(get_group_id(0)&3) + get_local_id(2)) * h;
+
+  float dx;
+  float dy;
+  float dz;
+  float r2;
+  float s;
+
+  int totalbins = 0;
+
+  /* bin number determined by center of region */
+  Bx = (int) floor((8 * (get_group_id(0) >> 2) + 4) * h * BIN_INVLEN);
+  By = (int) floor((8 * get_group_id(1) + 4) * h * BIN_INVLEN);
+  Bz = (int) floor((8 * zRegionIndex + 4) * h * BIN_INVLEN);
+
+  float energy = 0.f;
+  int bincnt;
+  for (bincnt = 0; bincnt < *NbrListLen;  bincnt++) {
+    int i = Bx + NbrList[bincnt].x;
+    int j = By + NbrList[bincnt].y;
+    int k = Bz + NbrList[bincnt].z;
+
+  	__global float4* p_global = binZeroAddr + 
+  	                       (((k*binDim_y + j)*binDim_x + i) * BIN_DEPTH);
+
+    int m;
+    for (m = 0;  m < BIN_DEPTH;  m++) {
+    	float aq = p_global[m].w;
+      if (0.f != aq) {
+        dx = p_global[m].x - x;
+        dy = p_global[m].y - y;
+        dz = p_global[m].z - z;
+        r2 = dx*dx + dy*dy + dz*dz;
+        if (r2 < cutoff2) {
+          s = (1.f - r2 * inv_cutoff2);
+          energy += aq * rsqrt(r2) * s * s;
+        }
+      }
+    } /* end loop over atoms in bin */
+  } /* end loop over neighbor list */
+
+  /* store into global memory */
+  myRegionAddr[tid+0] = energy;
+}

benchmarks/opencl/cutcp/macros.h

@@ -0,0 +1,69 @@
+#ifndef __MACROSH__
+#define __MACROSH__
+
+#ifdef __DEVICE_EMULATION__
+#define DEBUG
+/* define which grid block and which thread to examine */
+#define BX  0
+#define BY  0
+#define TX  0
+#define TY  0
+#define TZ  0
+#define EMU(code) do { \
+  if (blockIdx.x==BX && blockIdx.y==BY && \
+      threadIdx.x==TX && threadIdx.y==TY && threadIdx.z==TZ) { \
+    code; \
+  } \
+} while (0)
+#define INT(n)    printf("%s = %d\n", #n, n)
+#define FLOAT(f)  printf("%s = %g\n", #f, (double)(f))
+#define INT3(n)   printf("%s = %d %d %d\n", #n, (n).x, (n).y, (n).z)
+#define FLOAT4(f) printf("%s = %g %g %g %g\n", #f, (double)(f).x, \
+    (double)(f).y, (double)(f).z, (double)(f).w)
+#else
+#define EMU(code)
+#define INT(n)
+#define FLOAT(f)
+#define INT3(n)
+#define FLOAT4(f)
+#endif
+
+/* report error from OpenCL */
+#define CHECK_ERROR(errorMessage)           \
+  if(clStatus != CL_SUCCESS)                \
+  {                                         \
+     printf("Error: %s!\n",errorMessage);   \
+     printf("Line: %d\n",__LINE__);         \
+     exit(1);                               \
+  }
+
+/*
+ * neighbor list:
+ * stored in constant memory as table of offsets
+ * flat index addressing is computed by kernel
+ *
+ * reserve enough memory for 11^3 stencil of grid cells
+ * this fits within 16K of memory
+ */
+#define NBRLIST_DIM  11
+#define NBRLIST_MAXLEN (NBRLIST_DIM * NBRLIST_DIM * NBRLIST_DIM)
+
+/*
+ * atom bins cached into shared memory for processing
+ *
+ * this reserves 4K of shared memory for 32 atom bins each containing 8 atoms,
+ * should permit scheduling of up to 3 thread blocks per SM
+ */
+#define BIN_DEPTH         8  /* max number of atoms per bin */
+#define BIN_SIZE         32  /* size of bin in floats */
+#define BIN_CACHE_MAXLEN 32  /* max number of atom bins to cache */
+
+#define BIN_LENGTH      4.f  /* spatial length in Angstroms */
+#define BIN_INVLEN  (1.f / BIN_LENGTH)
+/* assuming density of 1 atom / 10 A^3, expectation is 6.4 atoms per bin
+ * so that bin fill should be 80% (for non-empty regions of space) */
+
+#define REGION_SIZE     512  /* number of floats in lattice region */
+#define SUB_REGION_SIZE 128  /* number of floats in lattice sub-region */
+
+#endif

benchmarks/opencl/cutcp/main.cc

@@ -0,0 +1,194 @@
+/***************************************************************************
+ *cr
+ *cr            (C) Copyright 2008-2010 The Board of Trustees of the
+ *cr                        University of Illinois
+ *cr                         All Rights Reserved
+ *cr
+ ***************************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <parboil.h>
+
+#include "atom.h"
+#include "cutoff.h"
+#include "output.h"
+
+#define ERRTOL 1e-4f
+
+#define NOKERNELS             0
+#define CUTOFF1               1
+#define CUTOFF6              32
+#define CUTOFF6OVERLAP       64
+#define CUTOFFCPU         16384
+
+
+int appenddata(const char *filename, int size, double time) {
+  FILE *fp;
+  fp=fopen(filename, "a");
+  if (fp == NULL) {
+    printf("error appending to file %s..\n", filename);
+    return -1;
+  }
+  fprintf(fp, "%d  %.3f\n", size, time);
+  fclose(fp);
+  return 0;
+}
+
+LatticeDim
+lattice_from_bounding_box(Vec3 lo, Vec3 hi, float h)
+{
+  LatticeDim ret;
+
+  ret.nx = (int) floorf((hi.x-lo.x)/h) + 1;
+  ret.ny = (int) floorf((hi.y-lo.y)/h) + 1;
+  ret.nz = (int) floorf((hi.z-lo.z)/h) + 1;
+  ret.lo = lo;
+  ret.h = h;
+
+  return ret;
+}
+
+Lattice *
+create_lattice(LatticeDim dim)
+{
+  int size;
+  Lattice *lat = (Lattice *)malloc(sizeof(Lattice));
+
+  if (lat == NULL) {
+    fprintf(stderr, "Out of memory\n");
+    exit(1);
+  }
+
+  lat->dim = dim;
+
+  /* Round up the allocated size to a multiple of 8 */
+  size = ((dim.nx * dim.ny * dim.nz) + 7) & ~7;
+  lat->lattice = (float *)calloc(size, sizeof(float));
+
+  if (lat->lattice == NULL) {
+    fprintf(stderr, "Out of memory\n");
+    exit(1);
+  }
+
+  return lat;
+}
+
+
+void
+destroy_lattice(Lattice *lat)
+{
+  if (lat) {
+    free(lat->lattice);
+    free(lat);
+  }
+}
+
+int main(int argc, char *argv[]) {
+  Atoms *atom;
+
+  LatticeDim lattice_dim;
+  Lattice *gpu_lattice;
+  Vec3 min_ext, max_ext;	/* Bounding box of atoms */
+  Vec3 lo, hi;			/* Bounding box with padding  */
+
+  float h = 0.5f;		/* Lattice spacing */
+  float cutoff = 12.f;		/* Cutoff radius */
+  float exclcutoff = 1.f;	/* Radius for exclusion */
+  float padding = 0.5f;		/* Bounding box padding distance */
+
+  int n;
+
+  struct pb_Parameters *parameters;
+  struct pb_TimerSet timers;
+
+  /* Read input parameters */
+  parameters = pb_ReadParameters(&argc, argv);
+  if (parameters == NULL) {
+    exit(1);
+  }
+
+  parameters->inpFiles = (char **)malloc(sizeof(char *) * 2);
+  parameters->inpFiles[0] = (char *)malloc(100);
+  parameters->inpFiles[1] = NULL;
+  strncpy(parameters->inpFiles[0], "watbox.sl40.pqr", 100);
+
+  /* Expect one input file */
+  if (pb_Parameters_CountInputs(parameters) != 1) {
+    fprintf(stderr, "Expecting one input file\n");
+    exit(1);
+  }
+
+  pb_InitializeTimerSet(&timers);
+  pb_SwitchToTimer(&timers, pb_TimerID_IO);
+
+  printf("OK\n");
+
+  {
+    const char *pqrfilename = parameters->inpFiles[0];
+
+    if (!(atom = read_atom_file(pqrfilename))) {
+      fprintf(stderr, "read_atom_file() failed\n");
+      exit(1);
+    }
+    printf("read %d atoms from file '%s'\n", atom->size, pqrfilename);
+  }
+
+  printf("OK\n");
+
+  /* find extent of domain */
+  pb_SwitchToTimer(&timers, pb_TimerID_COMPUTE);
+  get_atom_extent(&min_ext, &max_ext, atom);
+  printf("extent of domain is:\n");
+  printf("  minimum %g %g %g\n", min_ext.x, min_ext.y, min_ext.z);
+  printf("  maximum %g %g %g\n", max_ext.x, max_ext.y, max_ext.z);
+
+  printf("padding domain by %g Angstroms\n", padding);
+  lo = (Vec3) {min_ext.x - padding, min_ext.y - padding, min_ext.z - padding};
+  hi = (Vec3) {max_ext.x + padding, max_ext.y + padding, max_ext.z + padding};
+  printf("domain lengths are %g by %g by %g\n", hi.x-lo.x, hi.y-lo.y, hi.z-lo.z);
+
+  lattice_dim = lattice_from_bounding_box(lo, hi, h);
+  gpu_lattice = create_lattice(lattice_dim);
+  printf("\n");
+
+  /*
+   *  Run OpenCL kernel
+   *  (Begin and end with COMPUTE timer active)
+   */
+  if (gpu_compute_cutoff_potential_lattice(&timers, gpu_lattice, cutoff, atom, 0, parameters)) {
+    fprintf(stderr, "Computation failed\n");
+    exit(1);
+  }
+
+  /*
+   * Zero the lattice points that are too close to an atom.  This is
+   * necessary for numerical stability.
+   */
+  if (remove_exclusions(gpu_lattice, exclcutoff, atom)) {
+    fprintf(stderr, "remove_exclusions() failed for gpu lattice\n");
+    exit(1);
+  }
+
+  printf("\n");
+
+  pb_SwitchToTimer(&timers, pb_TimerID_IO);
+
+  /* Print output */
+  if (parameters->outFile) {
+    //write_lattice_summary(parameters->outFile, gpu_lattice);
+  }
+  pb_SwitchToTimer(&timers, pb_TimerID_COMPUTE);
+
+  /* Cleanup */
+  destroy_lattice(gpu_lattice);
+  free_atom(atom);
+
+  pb_SwitchToTimer(&timers, pb_TimerID_NONE);
+  pb_PrintTimerSet(&timers);
+  pb_FreeParameters(parameters);
+
+  return 0;
+}

benchmarks/opencl/cutcp/ocl.c

@@ -0,0 +1,49 @@
+#include <CL/cl.h>
+#include <stdio.h>
+#include <string.h>
+#include "ocl.h"
+
+char* readFile(const char* fileName)
+{
+        FILE* fp;
+        fp = fopen(fileName,"r");
+        if(fp == NULL)
+        {
+                printf("Error 1!\n");
+                exit(1);
+        }
+
+        fseek(fp,0,SEEK_END);
+        long size = ftell(fp);
+        rewind(fp);
+
+        char* buffer = (char*)malloc(sizeof(char)*(size+1));
+        if(buffer  == NULL)
+        {
+                printf("Error 2!\n");
+                fclose(fp);
+                exit(1);
+        }
+
+        size_t res = fread(buffer,1,size,fp);
+        if(res != size)
+        {
+                printf("Error 3!\n");
+                fclose(fp);
+                exit(1);
+        }
+
+	buffer[size] = 0;
+        fclose(fp);
+        return buffer;
+}
+
+void clMemSet(cl_command_queue clCommandQueue, cl_mem buf, int val, size_t size)
+{
+	cl_int clStatus;
+	char* temp = (char*)malloc(size);
+	memset(temp,val,size);
+	clStatus = clEnqueueWriteBuffer(clCommandQueue,buf,CL_TRUE,0,size,temp,0,NULL,NULL);
+	CHECK_ERROR("clEnqueueWriteBuffer")
+	free(temp);
+}

benchmarks/opencl/cutcp/ocl.h

@@ -0,0 +1,17 @@
+#ifndef __OCLH__
+#define __OCLH__
+
+#include <stdlib.h>
+
+void clMemSet(cl_command_queue, cl_mem, int, size_t);
+char* readFile(const char*);
+
+#define CHECK_ERROR(errorMessage)           \
+  if(clStatus != CL_SUCCESS)                \
+  {                                         \
+     printf("Error: %s!\n",errorMessage);   \
+     printf("Line: %d\n",__LINE__);         \
+     exit(1);                               \
+  }
+
+#endif

benchmarks/opencl/cutcp/output.c

@@ -0,0 +1,67 @@
+/***************************************************************************
+ *cr
+ *cr            (C) Copyright 2008-2010 The Board of Trustees of the
+ *cr                        University of Illinois
+ *cr                         All Rights Reserved
+ *cr
+ ***************************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <inttypes.h>
+#include <math.h>
+#include <parboil.h>
+
+#include "atom.h"
+#include "cutoff.h"
+
+void
+write_lattice_summary(const char *filename, Lattice *lattice)
+{
+  float *lattice_data = lattice->lattice;
+  int nx = lattice->dim.nx;
+  int ny = lattice->dim.ny;
+  int nz = lattice->dim.nz;
+
+  /* Open output file */
+  FILE *outfile = fopen(filename, "w");
+
+  if (outfile == NULL) {
+    fprintf(stderr, "Cannot open output file\n");
+    exit(1);
+  }
+
+  /* Write the sum of the the absolute values of all lattice potentials */
+  {
+    double abspotential = 0.0;
+    float tmp;
+    int i;
+
+    for (i = 0; i < nx * ny * nz; i++)
+      abspotential += fabs((double) lattice_data[i]);
+
+    tmp = (float) abspotential;
+
+    fwrite(&tmp, 1, sizeof(float), outfile);
+  }
+
+  /* Write the size of a lattice plane */
+  {
+    uint32_t tmp;
+
+    tmp = (uint32_t) (lattice->dim.nx * lattice->dim.ny);
+    fwrite(&tmp, 1, sizeof(uint32_t), outfile);
+  }
+
+  /* Write the plane of lattice data at z=0 and z = nz-1 */
+  {
+    int plane_size = nx * ny;
+
+    fwrite(lattice_data, plane_size, sizeof(float), outfile);
+    fwrite(lattice_data + (nz-1) * plane_size, plane_size, sizeof(float),
+	   outfile);
+  }
+
+  /* Cleanup */
+  fclose(outfile);
+}

benchmarks/opencl/cutcp/output.h

@@ -0,0 +1,25 @@
+/***************************************************************************
+ *cr
+ *cr            (C) Copyright 2008-2010 The Board of Trustees of the
+ *cr                        University of Illinois
+ *cr                         All Rights Reserved
+ *cr
+ ***************************************************************************/
+
+#ifndef OUTPUT_H
+#define OUTPUT_H
+
+#include "cutoff.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void
+write_lattice_summary(const char *filename, Lattice *lattice);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

benchmarks/opencl/cutcp/parboil.h

@@ -0,0 +1,348 @@
+/*
+ * (c) 2010 The Board of Trustees of the University of Illinois.
+ */
+#ifndef PARBOIL_HEADER
+#define PARBOIL_HEADER
+
+#include <stdio.h>
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <unistd.h>
+
+/* A platform as specified by the user on the command line */
+struct pb_PlatformParam {
+  char *name;                   /* The platform name.  This string is owned. */
+  char *version;                /* The platform version; may be NULL.
+                                 * This string is owned. */
+};
+
+/* Create a PlatformParam from the given strings.
+ * 'name' must not be NULL.  'version' may be NULL.
+ * If not NULL, the strings should have been allocated by malloc(),
+ * and they will be owned by the returned object.
+ */
+struct pb_PlatformParam *
+pb_PlatformParam(char *name, char *version);
+
+void
+pb_FreePlatformParam(struct pb_PlatformParam *);
+
+/* A criterion for how to select a device */
+enum pb_DeviceSelectionCriterion {
+  pb_Device_INDEX,             /* Enumerate the devices and select one
+                                * by its number */
+  pb_Device_CPU,                /* Select a CPU device */
+  pb_Device_GPU,                /* Select a GPU device  */
+  pb_Device_ACCELERATOR,        /* Select an accelerator device */
+  pb_Device_NAME                /* Select a device by name */
+};
+
+/* A device as specified by the user on the command line */
+struct pb_DeviceParam {
+  enum pb_DeviceSelectionCriterion criterion;
+  union {
+    int index;                  /* If criterion == pb_Device_INDEX,
+                                 * the index of the device */
+    char *name;                 /* If criterion == pb_Device_NAME,
+                                 * the name of the device.
+                                 * This string is owned. */
+  };
+};
+
+struct pb_DeviceParam *
+pb_DeviceParam_index(int index);
+
+struct pb_DeviceParam *
+pb_DeviceParam_cpu(void);
+
+struct pb_DeviceParam *
+pb_DeviceParam_gpu(void);
+
+struct pb_DeviceParam *
+pb_DeviceParam_accelerator(void);
+
+/* Create a by-name device selection criterion.
+ * The string should have been allocated by malloc(), and it will will be
+ * owned by the returned object.
+ */
+struct pb_DeviceParam *
+pb_DeviceParam_name(char *name);
+
+void
+pb_FreeDeviceParam(struct pb_DeviceParam *);
+
+/* Command line parameters for benchmarks */
+struct pb_Parameters {
+  char *outFile;		/* If not NULL, the raw output of the
+				 * computation should be saved to this
+				 * file. The string is owned. */
+  char **inpFiles;		/* A NULL-terminated array of strings
+				 * holding the input file(s) for the
+				 * computation.  The array and strings
+				 * are owned. */
+  struct pb_PlatformParam *platform; /* If not NULL, the platform
+                                      * specified on the command line. */
+  struct pb_DeviceParam *device; /* If not NULL, the device
+                                      * specified on the command line. */
+};
+
+/* Read command-line parameters.
+ *
+ * The argc and argv parameters to main are read, and any parameters
+ * interpreted by this function are removed from the argument list.
+ *
+ * A new instance of struct pb_Parameters is returned.
+ * If there is an error, then an error message is printed on stderr
+ * and NULL is returned.
+ */
+struct pb_Parameters *
+pb_ReadParameters(int *_argc, char **argv);
+
+/* Free an instance of struct pb_Parameters.
+ */
+void
+pb_FreeParameters(struct pb_Parameters *p);
+
+void
+pb_FreeStringArray(char **);
+
+/* Count the number of input files in a pb_Parameters instance.
+ */
+int
+pb_Parameters_CountInputs(struct pb_Parameters *p);
+
+/* A time or duration. */
+//#if _POSIX_VERSION >= 200112L
+typedef unsigned long long pb_Timestamp; /* time in microseconds */
+//#else
+//# error "Timestamps not implemented"
+//#endif
+
+enum pb_TimerState {
+  pb_Timer_STOPPED,
+  pb_Timer_RUNNING,
+};
+
+struct pb_Timer {
+  enum pb_TimerState state;
+  pb_Timestamp elapsed;		/* Amount of time elapsed so far */
+  pb_Timestamp init;		/* Beginning of the current time interval,
+				 * if state is RUNNING.  End of the last 
+				 * recorded time interfal otherwise.  */
+};
+
+/* Reset a timer.
+ * Use this to initialize a timer or to clear
+ * its elapsed time.  The reset timer is stopped.
+ */
+void
+pb_ResetTimer(struct pb_Timer *timer);
+
+/* Start a timer.  The timer is set to RUNNING mode and
+ * time elapsed while the timer is running is added to
+ * the timer.
+ * The timer should not already be running.
+ */
+void
+pb_StartTimer(struct pb_Timer *timer);
+
+/* Stop a timer.
+ * This stops adding elapsed time to the timer.
+ * The timer should not already be stopped.
+ */
+void
+pb_StopTimer(struct pb_Timer *timer);
+
+/* Get the elapsed time in seconds. */
+double
+pb_GetElapsedTime(struct pb_Timer *timer);
+
+/* Execution time is assigned to one of these categories. */
+enum pb_TimerID {
+  pb_TimerID_NONE = 0,
+  pb_TimerID_IO,		/* Time spent in input/output */
+  pb_TimerID_KERNEL,		/* Time spent computing on the device, 
+				 * recorded asynchronously */
+  pb_TimerID_COPY,		/* Time spent synchronously moving data 
+				 * to/from device and allocating/freeing 
+				 * memory on the device */
+  pb_TimerID_DRIVER,		/* Time spent in the host interacting with the 
+				 * driver, primarily for recording the time 
+                                 * spent queueing asynchronous operations */
+  pb_TimerID_COPY_ASYNC,	/* Time spent in asynchronous transfers */
+  pb_TimerID_COMPUTE,		/* Time for all program execution other
+				 * than parsing command line arguments,
+				 * I/O, kernel, and copy */
+  pb_TimerID_OVERLAP,		/* Time double-counted in asynchronous and 
+				 * host activity: automatically filled in, 
+				 * not intended for direct usage */
+  pb_TimerID_LAST		/* Number of timer IDs */
+};
+
+/* Dynamic list of asynchronously tracked times between events */
+struct pb_async_time_marker_list {
+  char *label; // actually just a pointer to a string
+  enum pb_TimerID timerID;	/* The ID to which the interval beginning 
+                                 * with this marker should be attributed */
+  void * marker; 
+  //cudaEvent_t marker; 		/* The driver event for this marker */
+  struct pb_async_time_marker_list *next; 
+};
+
+struct pb_SubTimer {
+  char *label;
+  struct pb_Timer timer;
+  struct pb_SubTimer *next;
+};
+
+struct pb_SubTimerList {
+  struct pb_SubTimer *current;
+  struct pb_SubTimer *subtimer_list;
+};
+
+/* A set of timers for recording execution times. */
+struct pb_TimerSet {
+  enum pb_TimerID current;
+  struct pb_async_time_marker_list* async_markers;
+  pb_Timestamp async_begin;
+  pb_Timestamp wall_begin;
+  struct pb_Timer timers[pb_TimerID_LAST];
+  struct pb_SubTimerList *sub_timer_list[pb_TimerID_LAST];
+};
+
+/* Reset all timers in the set. */
+void
+pb_InitializeTimerSet(struct pb_TimerSet *timers);
+
+void
+pb_AddSubTimer(struct pb_TimerSet *timers, char *label, enum pb_TimerID pb_Category);
+
+/* Select which timer the next interval of time should be accounted
+ * to. The selected timer is started and other timers are stopped.
+ * Using pb_TimerID_NONE stops all timers. */
+void
+pb_SwitchToTimer(struct pb_TimerSet *timers, enum pb_TimerID timer);
+
+void
+pb_SwitchToSubTimer(struct pb_TimerSet *timers, char *label, enum pb_TimerID category);
+
+/* Print timer values to standard output. */
+void
+pb_PrintTimerSet(struct pb_TimerSet *timers);
+
+/* Release timer resources */
+void
+pb_DestroyTimerSet(struct pb_TimerSet * timers);
+
+void
+pb_SetOpenCL(void *clContextPtr, void *clCommandQueuePtr);
+
+
+typedef struct pb_Device_tag {
+  char* name;
+  void* clDevice;
+  int id;
+  unsigned int in_use;
+  unsigned int available;
+} pb_Device;
+
+struct pb_Context_tag;
+typedef struct pb_Context_tag pb_Context;
+
+typedef struct pb_Platform_tag {
+  char* name;
+  char* version;
+  void* clPlatform;
+  unsigned int in_use;
+  pb_Context** contexts;
+  pb_Device** devices;
+} pb_Platform;
+
+struct pb_Context_tag {
+  void* clPlatformId;
+  void* clContext;
+  void* clDeviceId;
+  pb_Platform* pb_platform;
+  pb_Device* pb_device;
+};
+
+// verbosely print out list of platforms and their devices to the console.
+pb_Platform**
+pb_GetPlatforms();
+
+// Choose a platform according to the given platform specification
+pb_Platform*
+pb_GetPlatform(struct pb_PlatformParam *platform);
+
+// choose a platform: by name, name & version
+pb_Platform*
+pb_GetPlatformByName(const char* name);
+
+pb_Platform*
+pb_GetPlatformByNameAndVersion(const char* name, const char* version);
+
+// Choose a device according to the given device specification
+pb_Device*
+pb_GetDevice(pb_Platform* pb_platform, struct pb_DeviceParam *device);
+
+pb_Device**
+pb_GetDevices(pb_Platform* pb_platform);
+
+// choose a device by name.
+pb_Device*
+pb_GetDeviceByName(pb_Platform* pb_platform, const char* name);
+
+pb_Platform*
+pb_GetPlatformByEnvVars();
+
+pb_Context*
+pb_InitOpenCLContext(struct pb_Parameters* parameters);
+
+void
+pb_ReleasePlatforms();
+
+void
+pb_ReleaseContext(pb_Context* c);
+
+void
+pb_PrintPlatformInfo(pb_Context* c);
+
+void
+perf_init();
+
+//#define MEASURE_KERNEL_TIME
+
+#include <CL/cl.h>
+
+#ifdef MEASURE_KERNEL_TIME
+#define clEnqueueNDRangeKernel(q,k,d,o,dg,db,a,b,c) pb_clEnqueueNDRangeKernel((q), (k), (d), (o), (dg), (db), (a), (b), (c))
+cl_int
+pb_clEnqueueNDRangeKernel(cl_command_queue /* command_queue */,
+                       cl_kernel        /* kernel */,
+                       cl_uint          /* work_dim */,
+                       const size_t *   /* global_work_offset */,
+                       const size_t *   /* global_work_size */,
+                       const size_t *   /* local_work_size */,
+                       cl_uint          /* num_events_in_wait_list */,
+                       const cl_event * /* event_wait_list */,
+                       cl_event *       /* event */);
+#endif
+
+enum { T_FLOAT, T_DOUBLE, T_SHORT, T_INT, T_UCHAR };
+void pb_sig_float(char*, float*, int);
+void pb_sig_double(char*, double*, int);
+void pb_sig_short(char*, short*, int);
+void pb_sig_int(char*, int*, int);
+void pb_sig_uchar(char*, unsigned char*, unsigned int);
+void pb_sig_clmem(char*, cl_command_queue, cl_mem, int);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //PARBOIL_HEADER
+

benchmarks/opencl/cutcp/readatom.c

@@ -0,0 +1,139 @@
+/***************************************************************************
+ *cr
+ *cr            (C) Copyright 2008-2010 The Board of Trustees of the
+ *cr                        University of Illinois
+ *cr                         All Rights Reserved
+ *cr
+ ***************************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include "atom.h"
+
+
+#define LINELEN 96
+#define INITLEN 20
+
+
+Atoms *read_atom_file(const char *fname)
+{
+  FILE *file;
+  char line[LINELEN];
+
+  Atom *atom;			/* Atom array */
+  int len = INITLEN;		/* Size of atom array */
+  int cnt = 0;			/* Number of atoms read */
+
+  /* allocate initial atom array */
+  atom = (Atom *) malloc(len * sizeof(Atom));
+  if (NULL==atom) {
+    fprintf(stderr, "can't allocate memory\n");
+    return NULL;
+  }
+
+  int i;
+  for (i = 0; i < len; ++i) {
+    atom[i].x = i+0;
+    atom[i].y = i+1;
+    atom[i].z = i+2;
+    atom[i].q = 1;
+  }
+
+#if 0
+  /* open atom "pqr" file */
+  file = fopen(fname, "r");
+  if (NULL==file) {
+    fprintf(stderr, "can't open file \"%s\" for reading\n", fname);
+    return NULL;
+  }
+
+  /* loop to read pqr file line by line */
+  while (fgets(line, LINELEN, file) != NULL) {
+
+    if (strncmp(line, "ATOM  ", 6) != 0 && strncmp(line, "HETATM", 6) != 0) {
+      continue;  /* skip anything that isn't an atom record */
+    }
+
+    if (cnt==len) {  /* extend atom array */
+      void *tmp = realloc(atom, 2*len*sizeof(Atom));
+      if (NULL==tmp) {
+        fprintf(stderr, "can't allocate more memory\n");
+        return NULL;
+      }
+      atom = (Atom *) tmp;
+      len *= 2;
+    }
+
+    /* read position coordinates and charge from atom record */
+    if (sscanf(line, "%*s %*d %*s %*s %*d %f %f %f %f", &(atom[cnt].x),
+          &(atom[cnt].y), &(atom[cnt].z), &(atom[cnt].q)) != 4) {
+      fprintf(stderr, "atom record %d does not have expected format\n", cnt+1);
+      return NULL;
+    }
+
+    cnt++;  /* count atoms as we store them */
+  }
+
+  /* verify EOF and close file */
+  if ( !feof(file) ) {
+    fprintf(stderr, "did not find EOF\n");
+    return NULL;
+  }
+  if (fclose(file)) {
+    fprintf(stderr, "can't close file\n");
+    return NULL;
+  }
+#endif
+
+  /* Build the output data structure */
+  {
+    Atoms *out = (Atoms *)malloc(sizeof(Atoms));
+
+    if (NULL == out) {
+      fprintf(stderr, "can't allocate memory\n");
+      return NULL;
+    }
+
+    out->size = cnt;
+    out->atoms = atom;
+
+    return out;
+  }
+}
+
+
+void free_atom(Atoms *atom)
+{
+  if (atom) {
+    free(atom->atoms);
+    free(atom);
+  }
+}
+
+void
+get_atom_extent(Vec3 *out_lo, Vec3 *out_hi, Atoms *atom)
+{
+  Atom *atoms = atom->atoms;
+  int natoms = atom->size;
+  Vec3 lo;
+  Vec3 hi;
+  int n;
+
+  hi.x = lo.x = atoms[0].x;
+  hi.y = lo.y = atoms[0].y;
+  hi.z = lo.z = atoms[0].z;
+
+  for (n = 1; n < natoms; n++) {
+    lo.x = fminf(lo.x, atoms[n].x);
+    hi.x = fmaxf(hi.x, atoms[n].x);
+    lo.y = fminf(lo.y, atoms[n].y);
+    hi.y = fmaxf(hi.y, atoms[n].y);
+    lo.z = fminf(lo.z, atoms[n].z);
+    hi.z = fmaxf(hi.z, atoms[n].z);
+  }
+
+  *out_lo = lo;
+  *out_hi = hi;
+}

benchmarks/opencl/lbm/Makefile

@@ -0,0 +1,67 @@
+RISCV_TOOL_PATH ?= $(wildcard ../../../../riscv-gnu-toolchain/drops)
+POCL_CC_PATH ?= $(wildcard ../../../../pocl/drops_riscv_cc)
+POCL_INC_PATH ?= $(wildcard ../include)
+POCL_LIB_PATH ?= $(wildcard ../lib)
+VX_RT_PATH ?= $(wildcard ../../../runtime)
+VX_SIMX_PATH ?= $(wildcard ../../../simX/obj_dir)
+
+CC  = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-gcc
+CXX = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-g++
+DMP = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-objdump
+HEX = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-objcopy
+GDB = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-gdb
+
+VX_SRCS =  $(VX_RT_PATH)/newlib/newlib.c
+VX_SRCS += $(VX_RT_PATH)/startup/vx_start.S
+VX_SRCS += $(VX_RT_PATH)/intrinsics/vx_intrinsics.S
+VX_SRCS += $(VX_RT_PATH)/io/vx_io.S $(VX_RT_PATH)/io/vx_io.c
+VX_SRCS += $(VX_RT_PATH)/fileio/fileio.S
+VX_SRCS += $(VX_RT_PATH)/tests/tests.c
+VX_SRCS += $(VX_RT_PATH)/vx_api/vx_api.c
+
+VX_CFLAGS = -nostartfiles -Wl,-Bstatic,-T,$(VX_RT_PATH)/startup/vx_link.ld
+
+CXXFLAGS =  -g -O0 -march=rv32im -mabi=ilp32 
+CXXFLAGS += -ffreestanding # program may not begin at main()
+CXXFLAGS += -Wl,--gc-sections # enable garbage collection of unused input sections
+CXXFLAGS += -fno-rtti -fno-non-call-exceptions # disable RTTI and exceptions
+CXXFLAGS += -I$(POCL_INC_PATH) -I.
+
+VX_LIBS = -Wl,--whole-archive lib$(PROJECT).a -Wl,--no-whole-archive $(POCL_LIB_PATH)/libOpenCL.a
+QEMU_LIBS = $(VX_RT_PATH)/qemu/vx_api.c -Wl,--whole-archive lib$(PROJECT).a -Wl,--no-whole-archive $(POCL_LIB_PATH)/libOpenCL.a
+
+PROJECT = lbm
+ 
+SRCS = main.cc args.c parboil_opencl.c gpu_info.c lbm.c ocl.c
+
+all: $(PROJECT).dump $(PROJECT).hex
+
+lib$(PROJECT).a: kernel.cl
+	POCL_DEBUG=all POCL_DEBUG_LLVM_PASSES=1 LD_LIBRARY_PATH=$(RISCV_TOOL_PATH)/lib:$(POCL_CC_PATH)/lib $(POCL_CC_PATH)/bin/poclcc -o lib$(PROJECT).a kernel.cl
+
+$(PROJECT).elf: $(SRCS) lib$(PROJECT).a
+	$(CXX) $(CXXFLAGS) $(VX_CFLAGS) $(VX_SRCS) $(SRCS) $(VX_LIBS) -o $(PROJECT).elf
+
+$(PROJECT).qemu: $(SRCS) lib$(PROJECT).a
+	$(CXX) $(CXXFLAGS) $(SRCS) $(QEMU_LIBS) -o $(PROJECT).qemu
+
+$(PROJECT).hex: $(PROJECT).elf
+	$(HEX) -O ihex $(PROJECT).elf $(PROJECT).hex
+
+$(PROJECT).dump: $(PROJECT).elf
+	$(DMP) -D $(PROJECT).elf > $(PROJECT).dump
+
+run: $(PROJECT).hex
+	POCL_DEBUG=all $(VX_SIMX_PATH)/Vcache_simX -E -a rv32i --core $(PROJECT).hex -s -b 1> emulator.debug
+
+qemu: $(PROJECT).qemu
+	POCL_DEBUG=all $(RISCV_TOOL_PATH)/bin/qemu-riscv32 -d in_asm -D debug.log $(PROJECT).qemu
+
+gdb-s: $(PROJECT).qemu
+	POCL_DEBUG=all $(RISCV_TOOL_PATH)/bin/qemu-riscv32 -g 1234 -d in_asm -D debug.log $(PROJECT).qemu
+
+gdb-c: $(PROJECT).qemu
+	$(GDB) $(PROJECT).qemu
+
+clean:
+	rm -rf *.o *.elf *.dump *.hex *.qemu *.log *.debug

benchmarks/opencl/lbm/args.c

@@ -0,0 +1,617 @@
+
+#include <parboil.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+/*****************************************************************************/
+/* Memory management routines */
+
+/* Free an array of owned strings. */
+void
+pb_FreeStringArray(char **string_array)
+{
+  char **p;
+
+  if (!string_array) return;
+  for (p = string_array; *p; p++) free(*p);
+  free(string_array);
+}
+
+struct pb_PlatformParam *
+pb_PlatformParam(char *name, char *version)
+{
+  if (name == NULL) {
+    fprintf(stderr, "pb_PlatformParam: Invalid argument\n");
+    exit(-1);
+  }
+
+  struct pb_PlatformParam *ret =
+    (struct pb_PlatformParam *)malloc(sizeof (struct pb_PlatformParam));
+
+  ret->name = name;
+  ret->version = version;
+  return ret;
+}
+
+void
+pb_FreePlatformParam(struct pb_PlatformParam *p)
+{
+  if (p == NULL) return;
+
+  free(p->name);
+  free(p->version);
+  free(p);
+}
+
+struct pb_DeviceParam *
+pb_DeviceParam_index(int index)
+{
+  struct pb_DeviceParam *ret =
+    (struct pb_DeviceParam *)malloc(sizeof (struct pb_DeviceParam));
+  ret->criterion = pb_Device_INDEX;
+  ret->index = index;
+  return ret;
+}
+
+struct pb_DeviceParam *
+pb_DeviceParam_cpu(void)
+{
+  struct pb_DeviceParam *ret =
+    (struct pb_DeviceParam *)malloc(sizeof (struct pb_DeviceParam));
+  ret->criterion = pb_Device_CPU;
+  return ret;
+}
+
+struct pb_DeviceParam *
+pb_DeviceParam_gpu(void)
+{
+  struct pb_DeviceParam *ret =
+    (struct pb_DeviceParam *)malloc(sizeof (struct pb_DeviceParam));
+  ret->criterion = pb_Device_GPU;
+  return ret;
+}
+
+struct pb_DeviceParam *
+pb_DeviceParam_accelerator(void)
+{
+  struct pb_DeviceParam *ret =
+    (struct pb_DeviceParam *)malloc(sizeof (struct pb_DeviceParam));
+  ret->criterion = pb_Device_ACCELERATOR;
+  return ret;
+}
+
+struct pb_DeviceParam *
+pb_DeviceParam_name(char *name)
+{
+  struct pb_DeviceParam *ret =
+    (struct pb_DeviceParam *)malloc(sizeof (struct pb_DeviceParam));
+  ret->criterion = pb_Device_NAME;
+  ret->name = name;
+  return ret;
+}
+
+void
+pb_FreeDeviceParam(struct pb_DeviceParam *p)
+{
+  if (p == NULL) return;
+
+  switch(p->criterion) {
+  case pb_Device_NAME:
+    free(p->name);
+    break;
+  case pb_Device_INDEX:
+  case pb_Device_CPU:
+  case pb_Device_ACCELERATOR:
+    break;
+  default:
+    fprintf(stderr, "pb_FreeDeviceParam: Invalid argument\n");
+    exit(-1);
+  }
+}
+
+void
+pb_FreeParameters(struct pb_Parameters *p)
+{
+  free(p->outFile);
+  pb_FreeStringArray(p->inpFiles);
+  pb_FreePlatformParam(p->platform);
+  pb_FreeDeviceParam(p->device);
+  free(p);
+}
+
+/*****************************************************************************/
+
+/* Parse a comma-delimited list of strings into an
+ * array of strings. */
+static char ** 
+read_string_array(char *in)
+{
+  char **ret;
+  int i;
+  int count;			/* Number of items in the input */
+  char *substring;		/* Current substring within 'in' */
+
+  /* Count the number of items in the string */
+  count = 1;
+  for (i = 0; in[i]; i++) if (in[i] == ',') count++;
+
+  /* Allocate storage */
+  ret = (char **)malloc((count + 1) * sizeof(char *));
+
+  /* Create copies of the strings from the list */
+  substring = in;
+  for (i = 0; i < count; i++) {
+    char *substring_end;
+    int substring_length;
+
+    /* Find length of substring */
+    for (substring_end = substring;
+	 (*substring_end != ',') && (*substring_end != 0);
+	 substring_end++);
+
+    substring_length = substring_end - substring;
+
+    /* Allocate memory and copy the substring */
+    ret[i] = (char *)malloc(substring_length + 1);
+    memcpy(ret[i], substring, substring_length);
+    ret[i][substring_length] = 0;
+
+    /* go to next substring */
+    substring = substring_end + 1;
+  }
+  ret[i] = NULL;		/* Write the sentinel value */
+
+  return ret;
+}
+
+static void
+report_parse_error(const char *str)
+{
+  fputs(str, stderr);
+}
+
+/* Interpret a string as a 'pb_DeviceParam' value.
+ * Return a pointer to a new value, or NULL on failure.
+ */
+static struct pb_DeviceParam *
+read_device_param(char *str)
+{  
+  /* Try different ways of interpreting 'device_string' until one works */
+
+  /* If argument is an integer, then interpret it as a device index */
+  errno = 0;
+  char *end;
+  long device_int = strtol(str, &end, 10);
+  if (!errno) {
+    /* Negative numbers are not valid */
+    if (device_int < 0 || device_int > INT_MAX) return NULL;
+
+    return pb_DeviceParam_index(device_int);
+  }
+
+  /* Match against predefined strings */
+  if (strcmp(str, "CPU") == 0)
+    return pb_DeviceParam_cpu();
+  if (strcmp(str, "GPU") == 0)
+    return pb_DeviceParam_gpu();
+  if (strcmp(str, "ACCELERATOR") == 0)
+    return pb_DeviceParam_accelerator();
+
+  /* Assume any other string is a device name */
+  return pb_DeviceParam_name(strdup(str));
+}
+
+/* Interpret a string as a 'pb_PlatformParam' value.
+ * Return a pointer to a new value, or NULL on failure.
+ */
+static struct pb_PlatformParam *
+read_platform_param(char *str)
+{
+  int separator_index;          /* Index of the '-' character separating
+                                 * name and version number.  It's -1 if
+                                 * there's no '-' character. */
+
+  /* Find the last occurrence of '-' in 'str' */
+  {
+    char *cur;
+    separator_index = -1;
+    for (cur = str; *cur; cur++) {
+      if (*cur == '-') separator_index = cur - str;
+    }
+  }
+
+  /* The platform name is either the entire string, or all characters before
+   * the separator */
+  int name_length = separator_index == -1 ? strlen(str) : separator_index;
+  char *name_str = (char *)malloc(name_length + 1);
+  memcpy(name_str, str, name_length);
+  name_str[name_length] = 0;
+
+  /* The version is either NULL, or all characters after the separator */
+  char *version_str;
+  if (separator_index == -1) {
+    version_str = NULL;
+  }
+  else {
+    const char *version_input_str = str + separator_index + 1;
+    int version_length = strlen(version_input_str);
+
+    version_str = (char *)malloc(version_length + 1);
+    memcpy(version_str, version_input_str, version_length);
+    version_str[version_length] = 0;
+  }
+
+  /* Create output structure */
+  return pb_PlatformParam(name_str, version_str);
+}
+
+/****************************************************************************/
+/* Argument parsing state */
+
+/* Argument parsing state.
+ *
+ * Arguments that are interpreted by the argument parser are removed from
+ * the list.  Variables 'argc' and 'argn' do not count arguments that have
+ * been removed.
+ *
+ * During argument parsing, the array of arguments is compacted, overwriting
+ * the erased arguments.  Variable 'argv_put' points to the array element
+ * where the next argument will be written.  Variable 'argv_get' points to
+ * the array element where the next argument will be read from.
+ */
+struct argparse {
+  int argc;			/* Number of arguments.  Mutable. */
+  int argn;			/* Current argument index. */
+  char **argv_get;		/* Argument value being read. */
+  char **argv_put;		/* Argument value being written.
+				 * argv_put <= argv_get. */
+};
+
+static void
+initialize_argparse(struct argparse *ap, int argc, char **argv)
+{
+  ap->argc = argc;
+  ap->argn = 0;
+  ap->argv_get = ap->argv_put = argv;
+}
+
+/* Finish argument parsing, without processing the remaining arguments.
+ * Write new argument count into _argc. */
+static void
+finalize_argparse(struct argparse *ap, int *_argc, char **argv)
+{
+  /* Move the remaining arguments */
+  for(; ap->argn < ap->argc; ap->argn++)
+    *ap->argv_put++ = *ap->argv_get++;
+
+  /* Update the argument count */
+  *_argc = ap->argc;
+
+  /* Insert a terminating NULL */
+  argv[ap->argc] = NULL;
+}
+
+/* Delete the current argument.  The argument will not be visible
+ * when argument parsing is done. */
+static void
+delete_argument(struct argparse *ap)
+{
+  if (ap->argn >= ap->argc) {
+    fprintf(stderr, "delete_argument\n");
+  }
+  ap->argc--;
+  ap->argv_get++;
+}
+
+/* Go to the next argument.  Also, move the current argument to its
+ * final location in argv. */
+static void
+next_argument(struct argparse *ap)
+{
+  if (ap->argn >= ap->argc) {
+    fprintf(stderr, "next_argument\n");
+  }
+  /* Move argument to its new location. */
+  *ap->argv_put++ = *ap->argv_get++;
+  ap->argn++;
+}
+
+static int
+is_end_of_arguments(struct argparse *ap)
+{
+  return ap->argn == ap->argc;
+}
+
+/* Get the current argument */
+static char *
+get_argument(struct argparse *ap)
+{
+  return *ap->argv_get;
+}
+
+/* Get the current argument, and also delete it */
+static char *
+consume_argument(struct argparse *ap)
+{
+  char *ret = get_argument(ap);
+  delete_argument(ap);
+  return ret;
+}
+
+/****************************************************************************/
+
+/* The result of parsing a command-line argument */
+typedef enum {
+  ARGPARSE_OK,                  /* Success */
+  ARGPARSE_ERROR,               /* Error */
+  ARGPARSE_DONE                 /* Success, and do not continue parsing */
+} result;
+
+typedef result parse_action(struct argparse *ap, struct pb_Parameters *params);
+
+
+/* A command-line option */
+struct option {
+  char short_name;              /* If not 0, the one-character
+                                 * name of this option */
+  const char *long_name;        /* If not NULL, the long name of this option */
+  parse_action *action;       /* What to do when this option occurs.
+                               * Sentinel value is NULL.
+                               */
+};
+
+/* Output file
+ *
+ * -o FILE
+ */
+static result
+parse_output_file(struct argparse *ap, struct pb_Parameters *params)
+{
+  if (is_end_of_arguments(ap))
+    {
+      report_parse_error("Expecting file name after '-o'\n");
+      return ARGPARSE_ERROR;
+    }
+
+  /* Replace the output file name */
+  free(params->outFile);
+  params->outFile = strdup(consume_argument(ap));
+
+  return ARGPARSE_OK;
+}
+
+/* Input files
+ *
+ * -i FILE,FILE,...
+ */
+static result
+parse_input_files(struct argparse *ap, struct pb_Parameters *params)
+{
+  if (is_end_of_arguments(ap))
+    {
+      report_parse_error("Expecting file name after '-i'\n");
+      return ARGPARSE_ERROR;
+    }
+
+  /* Replace the input file list */
+  pb_FreeStringArray(params->inpFiles);
+  params->inpFiles = read_string_array(consume_argument(ap));
+  return ARGPARSE_OK;
+}
+
+/* End of options
+ *
+ * --
+ */
+
+static result
+parse_end_options(struct argparse *ap, struct pb_Parameters *params)
+{
+  return ARGPARSE_DONE;
+}
+
+/* OpenCL device
+ *
+ * --device X
+ */
+
+static result
+parse_device(struct argparse *ap, struct pb_Parameters *params)
+{
+  /* Read the next argument, which specifies a device */
+
+  if (is_end_of_arguments(ap))
+    {
+      report_parse_error("Expecting device specification after '--device'\n");
+      return ARGPARSE_ERROR;
+    }
+
+  char *device_string = consume_argument(ap);
+  struct pb_DeviceParam *device_param = read_device_param(device_string);
+
+  if (!device_param) {
+    report_parse_error("Unrecognized device specification format on command line\n");
+    return ARGPARSE_ERROR;
+  }
+
+  /* Save the result */
+  pb_FreeDeviceParam(params->device);
+  params->device = device_param;
+
+  return ARGPARSE_OK;
+}
+
+static result
+parse_platform(struct argparse *ap, struct pb_Parameters *params)
+{
+  /* Read the next argument, which specifies a platform */
+
+  if (is_end_of_arguments(ap))
+    {
+      report_parse_error("Expecting device specification after '--platform'\n");
+      return ARGPARSE_ERROR;
+    }
+
+  char *platform_string = consume_argument(ap);
+  struct pb_PlatformParam *platform_param = read_platform_param(platform_string);
+
+  if (!platform_param) {
+    report_parse_error("Unrecognized platform specification format on command line\n");
+    return ARGPARSE_ERROR;
+  }
+
+  /* Save the result */
+  pb_FreePlatformParam(params->platform);
+  params->platform = platform_param;
+
+  return ARGPARSE_OK;
+}
+  
+
+static struct option options[] = {
+  { 'o', NULL, &parse_output_file },
+  { 'i', NULL, &parse_input_files },
+  { '-', NULL, &parse_end_options },
+  { 0, "device", &parse_device },
+  { 0, "platform", &parse_platform },
+  { 0, NULL, NULL }
+};
+
+static int
+is_last_option(struct option *op)
+{
+  return op->action == NULL;
+}
+
+/****************************************************************************/
+
+/* Parse command-line parameters.
+ * Return zero on error, nonzero otherwise.
+ * On error, the other outputs may be invalid.
+ *
+ * The information collected from parameters is used to update
+ * 'ret'.  'ret' should be initialized.
+ *
+ * '_argc' and 'argv' are updated to contain only the unprocessed arguments.
+ */
+static int
+pb_ParseParameters (struct pb_Parameters *ret, int *_argc, char **argv)
+{
+  char *err_message;
+  struct argparse ap;
+
+  /* Each argument */
+  initialize_argparse(&ap, *_argc, argv);
+  while(!is_end_of_arguments(&ap)) {
+    result arg_result;          /* Result of parsing this option */
+    char *arg = get_argument(&ap);
+
+    /* Process this argument */
+    if (arg[0] == '-') {
+      /* Single-character flag */
+      if ((arg[1] != 0) && (arg[2] == 0)) {
+        delete_argument(&ap);	/* This argument is consumed here */
+
+        /* Find a matching short option */
+        struct option *op;
+        for (op = options; !is_last_option(op); op++) {
+          if (op->short_name == arg[1]) {
+            arg_result = (*op->action)(&ap, ret);
+            goto option_was_processed;
+          }
+        }
+
+        /* No option matches */
+        report_parse_error("Unexpected command-line parameter\n");
+        arg_result = ARGPARSE_ERROR;
+        goto option_was_processed;
+      }
+
+      /* Long flag */
+      if (arg[1] == '-') {
+        delete_argument(&ap);	/* This argument is consumed here */
+
+        /* Find a matching long option */
+        struct option *op;
+        for (op = options; !is_last_option(op); op++) {
+          if (op->long_name && strcmp(&arg[2], op->long_name) == 0) {
+            arg_result = (*op->action)(&ap, ret);
+            goto option_was_processed;
+          }
+        }
+
+        /* No option matches */
+        report_parse_error("Unexpected command-line parameter\n");
+        arg_result = ARGPARSE_ERROR;
+        goto option_was_processed;
+      }
+    }
+    else {
+      /* Other arguments are ignored */
+      next_argument(&ap);
+      arg_result = ARGPARSE_OK;
+      goto option_was_processed;
+    }
+
+  option_was_processed:
+    /* Decide what to do next based on 'arg_result' */
+    switch(arg_result) {
+    case ARGPARSE_OK:
+      /* Continue processing */
+      break;
+
+    case ARGPARSE_ERROR:
+      /* Error exit from the function */
+      return 0;
+
+    case ARGPARSE_DONE:
+      /* Normal exit from the argument parsing loop */
+      goto end_of_options;
+    }
+  } /* end for each argument */
+
+  /* If all arguments were processed, then normal exit from the loop */
+
+ end_of_options:
+  finalize_argparse(&ap, _argc, argv);
+  return 1;
+}
+
+/*****************************************************************************/
+/* Other exported functions */
+
+struct pb_Parameters *
+pb_ReadParameters(int *_argc, char **argv)
+{
+  struct pb_Parameters *ret =
+    (struct pb_Parameters *)malloc(sizeof(struct pb_Parameters));
+
+  /* Initialize the parameters structure */
+  ret->outFile = NULL;
+  ret->inpFiles = (char **)malloc(sizeof(char *));
+  ret->inpFiles[0] = NULL;
+  ret->platform = NULL;
+  ret->device = NULL;
+
+  /* Read parameters and update _argc, argv */
+  if (!pb_ParseParameters(ret, _argc, argv)) {
+    /* Parse error */
+    pb_FreeParameters(ret);
+    return NULL;
+  }
+
+  return ret;
+}
+
+int
+pb_Parameters_CountInputs(struct pb_Parameters *p)
+{
+  int n;
+
+  for (n = 0; p->inpFiles[n]; n++);
+  return n;
+}
+

benchmarks/opencl/lbm/gpu_info.c

@@ -0,0 +1,55 @@
+/***************************************************************************
+ *cr
+ *cr            (C) Copyright 2010 The Board of Trustees of the
+ *cr                        University of Illinois
+ *cr                         All Rights Reserved
+ *cr
+ ***************************************************************************/
+//#include <endian.h>
+#include <stdlib.h>
+#include <malloc.h>
+#include <stdio.h>
+#include <inttypes.h>
+
+#include "gpu_info.h"
+
+void compute_active_thread(size_t *thread,
+			   size_t *grid,
+			   int task,
+			   int pad,
+			   int major,
+			   int minor,
+			   int sm)
+{
+	int max_thread;
+	int max_block=8;
+	if(major==1)
+	{
+		if(minor>=2)
+			max_thread=1024;
+		else
+			max_thread=768;
+	}
+	else if(major==2)
+		max_thread=1536;
+	else
+		//newer GPU  //keep using 2.0
+		max_thread=1536;
+	
+	int _grid;
+	int _thread;
+	
+	if(task*pad>sm*max_thread)
+	{
+		_thread=max_thread/max_block;
+		_grid = ((task*pad+_thread-1)/_thread)*_thread;
+	}
+	else
+	{
+		_thread=pad;
+		_grid=task*pad;
+	}
+
+	thread[0]=_thread;
+	grid[0]=_grid;
+}

benchmarks/opencl/lbm/gpu_info.h

@@ -0,0 +1,20 @@
+/***************************************************************************
+ *cr
+ *cr            (C) Copyright 2010 The Board of Trustees of the
+ *cr                        University of Illinois
+ *cr                         All Rights Reserved
+ *cr
+ ***************************************************************************/
+
+#ifndef __GPUINFOH__
+#define __GPUINFOH__
+
+void compute_active_thread(size_t *thread,
+			   size_t *grid,
+			   int task,
+			   int pad,
+			   int major,
+			   int minor,
+			   int sm);
+
+#endif

benchmarks/opencl/lbm/kernel.cl

@@ -0,0 +1,424 @@
+/***************************************************************************
+ *cr
+ *cr            (C) Copyright 2010 The Board of Trustees of the
+ *cr                        University of Illinois
+ *cr                         All Rights Reserved
+ *cr
+ ***************************************************************************/
+
+#ifndef LBM_KERNEL_CL
+#define LBM_KERNEL_CL
+
+
+/***************************************************************************
+ *cr
+ *cr            (C) Copyright 2010 The Board of Trustees of the
+ *cr                        University of Illinois
+ *cr                         All Rights Reserved
+ *cr
+ ***************************************************************************/
+/***************************************************************************
+ *cr
+ *cr            (C) Copyright 2010 The Board of Trustees of the
+ *cr                        University of Illinois
+ *cr                         All Rights Reserved
+ *cr
+ ***************************************************************************/
+
+/*############################################################################*/
+
+#ifndef _LAYOUT_CONFIG_H_
+#define _LAYOUT_CONFIG_H_
+
+/*############################################################################*/
+
+//Unchangeable settings: volume simulation size for the given example
+#define SIZE_X (32)
+#define SIZE_Y (32)
+#define SIZE_Z (32)
+
+//Changeable settings
+//Padding in each dimension
+#define PADDING_X (8)
+#define PADDING_Y (0)
+#define PADDING_Z (4)
+
+//Pitch in each dimension
+#define PADDED_X (SIZE_X+PADDING_X)
+#define PADDED_Y (SIZE_Y+PADDING_Y)
+#define PADDED_Z (SIZE_Z+PADDING_Z)
+
+#define TOTAL_CELLS (SIZE_X*SIZE_Y*SIZE_Z)
+#define TOTAL_PADDED_CELLS (PADDED_X*PADDED_Y*PADDED_Z)
+
+//Flattening function
+//  This macro will be used to map a 3-D index and element to a value
+//  The macro below implements the equivalent of a 3-D array of 
+//  20-element structures in C standard layout.
+#define CALC_INDEX(x,y,z,e) ( e + N_CELL_ENTRIES*\
+                               ((x)+(y)*PADDED_X+(z)*PADDED_X*PADDED_Y) )
+
+#define MARGIN (CALC_INDEX(0, 0, 2, 0) - CALC_INDEX(0,0,0,0))
+
+// Set this value to 1 for GATHER, or 0 for SCATTER
+#if 1
+#define GATHER
+#else
+#define SCATTER
+#endif
+
+//OpenCL block size (not trivially changeable here)
+#define BLOCK_SIZE SIZE_X
+
+/*############################################################################*/
+
+typedef enum {C = 0,
+              N, S, E, W, T, B,
+              NE, NW, SE, SW,
+              NT, NB, ST, SB,
+              ET, EB, WT, WB,
+              FLAGS, N_CELL_ENTRIES} CELL_ENTRIES;
+
+#define N_DISTR_FUNCS FLAGS
+
+typedef enum {OBSTACLE    = 1 << 0,
+              ACCEL       = 1 << 1,
+              IN_OUT_FLOW = 1 << 2} CELL_FLAGS;
+
+#endif /* _CONFIG_H_ */
+
+
+#ifndef _LBM_MARCOS_H
+#define _LBM_MACROS_H_
+
+#define OMEGA (1.95f)
+
+#define OUTPUT_PRECISION float
+
+#define BOOL int
+#define TRUE (-1)
+#define FALSE (0)
+
+#define DFL1 (1.0f/ 3.0f)
+#define DFL2 (1.0f/18.0f)
+#define DFL3 (1.0f/36.0f)
+
+/*############################################################################*/
+
+typedef float* LBM_Grid;//float LBM_Grid[PADDED_Z*PADDED_Y*PADDED_X*N_CELL_ENTRIES];
+typedef LBM_Grid* LBM_GridPtr;
+
+/*############################################################################*/
+
+
+#define SWEEP_X  __temp_x__
+#define SWEEP_Y  __temp_y__
+#define SWEEP_Z  __temp_z__
+#define SWEEP_VAR int __temp_x__, __temp_y__, __temp_z__;
+
+#define SWEEP_START(x1,y1,z1,x2,y2,z2) \
+	for( __temp_z__ = z1; \
+	     __temp_z__ < z2; \
+		__temp_z__++) { \
+            for( __temp_y__ = 0; \
+                 __temp_y__ < SIZE_Y; \
+                 __temp_y__++) { \
+		for(__temp_x__ = 0; \
+	            __temp_x__ < SIZE_X; \
+                    __temp_x__++) { \
+
+#define SWEEP_END }}}
+
+
+#define GRID_ENTRY(g,x,y,z,e)          ((g)[CALC_INDEX( x,  y,  z, e)])
+#define GRID_ENTRY_SWEEP(g,dx,dy,dz,e) ((g)[CALC_INDEX((dx)+SWEEP_X, (dy)+SWEEP_Y, (dz)+SWEEP_Z, e)])
+
+#define LOCAL(g,e)       (GRID_ENTRY_SWEEP( g,  0,  0,  0, e ))
+#define NEIGHBOR_C(g,e)  (GRID_ENTRY_SWEEP( g,  0,  0,  0, e ))
+#define NEIGHBOR_N(g,e)  (GRID_ENTRY_SWEEP( g,  0, +1,  0, e ))
+#define NEIGHBOR_S(g,e)  (GRID_ENTRY_SWEEP( g,  0, -1,  0, e ))
+#define NEIGHBOR_E(g,e)  (GRID_ENTRY_SWEEP( g, +1,  0,  0, e ))
+#define NEIGHBOR_W(g,e)  (GRID_ENTRY_SWEEP( g, -1,  0,  0, e ))
+#define NEIGHBOR_T(g,e)  (GRID_ENTRY_SWEEP( g,  0,  0, +1, e ))
+#define NEIGHBOR_B(g,e)  (GRID_ENTRY_SWEEP( g,  0,  0, -1, e ))
+#define NEIGHBOR_NE(g,e) (GRID_ENTRY_SWEEP( g, +1, +1,  0, e ))
+#define NEIGHBOR_NW(g,e) (GRID_ENTRY_SWEEP( g, -1, +1,  0, e ))
+#define NEIGHBOR_SE(g,e) (GRID_ENTRY_SWEEP( g, +1, -1,  0, e ))
+#define NEIGHBOR_SW(g,e) (GRID_ENTRY_SWEEP( g, -1, -1,  0, e ))
+#define NEIGHBOR_NT(g,e) (GRID_ENTRY_SWEEP( g,  0, +1, +1, e ))
+#define NEIGHBOR_NB(g,e) (GRID_ENTRY_SWEEP( g,  0, +1, -1, e ))
+#define NEIGHBOR_ST(g,e) (GRID_ENTRY_SWEEP( g,  0, -1, +1, e ))
+#define NEIGHBOR_SB(g,e) (GRID_ENTRY_SWEEP( g,  0, -1, -1, e ))
+#define NEIGHBOR_ET(g,e) (GRID_ENTRY_SWEEP( g, +1,  0, +1, e ))
+#define NEIGHBOR_EB(g,e) (GRID_ENTRY_SWEEP( g, +1,  0, -1, e ))
+#define NEIGHBOR_WT(g,e) (GRID_ENTRY_SWEEP( g, -1,  0, +1, e ))
+#define NEIGHBOR_WB(g,e) (GRID_ENTRY_SWEEP( g, -1,  0, -1, e ))
+
+
+#ifdef SCATTER
+
+#define SRC_C(g)  (LOCAL( g, C  ))
+#define SRC_N(g)  (LOCAL( g, N  ))
+#define SRC_S(g)  (LOCAL( g, S  ))
+#define SRC_E(g)  (LOCAL( g, E  ))
+#define SRC_W(g)  (LOCAL( g, W  ))
+#define SRC_T(g)  (LOCAL( g, T  ))
+#define SRC_B(g)  (LOCAL( g, B  ))
+#define SRC_NE(g) (LOCAL( g, NE ))
+#define SRC_NW(g) (LOCAL( g, NW ))
+#define SRC_SE(g) (LOCAL( g, SE ))
+#define SRC_SW(g) (LOCAL( g, SW ))
+#define SRC_NT(g) (LOCAL( g, NT ))
+#define SRC_NB(g) (LOCAL( g, NB ))
+#define SRC_ST(g) (LOCAL( g, ST ))
+#define SRC_SB(g) (LOCAL( g, SB ))
+#define SRC_ET(g) (LOCAL( g, ET ))
+#define SRC_EB(g) (LOCAL( g, EB ))
+#define SRC_WT(g) (LOCAL( g, WT ))
+#define SRC_WB(g) (LOCAL( g, WB ))
+
+#define DST_C(g)  (NEIGHBOR_C ( g, C  ))
+#define DST_N(g)  (NEIGHBOR_N ( g, N  ))
+#define DST_S(g)  (NEIGHBOR_S ( g, S  ))
+#define DST_E(g)  (NEIGHBOR_E ( g, E  ))
+#define DST_W(g)  (NEIGHBOR_W ( g, W  ))
+#define DST_T(g)  (NEIGHBOR_T ( g, T  ))
+#define DST_B(g)  (NEIGHBOR_B ( g, B  ))
+#define DST_NE(g) (NEIGHBOR_NE( g, NE ))
+#define DST_NW(g) (NEIGHBOR_NW( g, NW ))
+#define DST_SE(g) (NEIGHBOR_SE( g, SE ))
+#define DST_SW(g) (NEIGHBOR_SW( g, SW ))
+#define DST_NT(g) (NEIGHBOR_NT( g, NT ))
+#define DST_NB(g) (NEIGHBOR_NB( g, NB ))
+#define DST_ST(g) (NEIGHBOR_ST( g, ST ))
+#define DST_SB(g) (NEIGHBOR_SB( g, SB ))
+#define DST_ET(g) (NEIGHBOR_ET( g, ET ))
+#define DST_EB(g) (NEIGHBOR_EB( g, EB ))
+#define DST_WT(g) (NEIGHBOR_WT( g, WT ))
+#define DST_WB(g) (NEIGHBOR_WB( g, WB ))
+
+#else /* GATHER */
+
+#define SRC_C(g)  (NEIGHBOR_C ( g, C  ))
+#define SRC_N(g)  (NEIGHBOR_S ( g, N  ))
+#define SRC_S(g)  (NEIGHBOR_N ( g, S  ))
+#define SRC_E(g)  (NEIGHBOR_W ( g, E  ))
+#define SRC_W(g)  (NEIGHBOR_E ( g, W  ))
+#define SRC_T(g)  (NEIGHBOR_B ( g, T  ))
+#define SRC_B(g)  (NEIGHBOR_T ( g, B  ))
+#define SRC_NE(g) (NEIGHBOR_SW( g, NE ))
+#define SRC_NW(g) (NEIGHBOR_SE( g, NW ))
+#define SRC_SE(g) (NEIGHBOR_NW( g, SE ))
+#define SRC_SW(g) (NEIGHBOR_NE( g, SW ))
+#define SRC_NT(g) (NEIGHBOR_SB( g, NT ))
+#define SRC_NB(g) (NEIGHBOR_ST( g, NB ))
+#define SRC_ST(g) (NEIGHBOR_NB( g, ST ))
+#define SRC_SB(g) (NEIGHBOR_NT( g, SB ))
+#define SRC_ET(g) (NEIGHBOR_WB( g, ET ))
+#define SRC_EB(g) (NEIGHBOR_WT( g, EB ))
+#define SRC_WT(g) (NEIGHBOR_EB( g, WT ))
+#define SRC_WB(g) (NEIGHBOR_ET( g, WB ))
+
+#define DST_C(g)  (LOCAL( g, C  ))
+#define DST_N(g)  (LOCAL( g, N  ))
+#define DST_S(g)  (LOCAL( g, S  ))
+#define DST_E(g)  (LOCAL( g, E  ))
+#define DST_W(g)  (LOCAL( g, W  ))
+#define DST_T(g)  (LOCAL( g, T  ))
+#define DST_B(g)  (LOCAL( g, B  ))
+#define DST_NE(g) (LOCAL( g, NE ))
+#define DST_NW(g) (LOCAL( g, NW ))
+#define DST_SE(g) (LOCAL( g, SE ))
+#define DST_SW(g) (LOCAL( g, SW ))
+#define DST_NT(g) (LOCAL( g, NT ))
+#define DST_NB(g) (LOCAL( g, NB ))
+#define DST_ST(g) (LOCAL( g, ST ))
+#define DST_SB(g) (LOCAL( g, SB ))
+#define DST_ET(g) (LOCAL( g, ET ))
+#define DST_EB(g) (LOCAL( g, EB ))
+#define DST_WT(g) (LOCAL( g, WT ))
+#define DST_WB(g) (LOCAL( g, WB ))
+
+#endif /* GATHER */
+
+#define MAGIC_CAST(v) ((unsigned int*) ((void*) (&(v))))
+#define FLAG_VAR(v) unsigned int* _aux_ = MAGIC_CAST(v)
+
+#define TEST_FLAG_SWEEP(g,f)     ((*MAGIC_CAST(LOCAL(g, FLAGS))) & (f))
+#define SET_FLAG_SWEEP(g,f)      {FLAG_VAR(LOCAL(g, FLAGS)); (*_aux_) |=  (f);}
+#define CLEAR_FLAG_SWEEP(g,f)    {FLAG_VAR(LOCAL(g, FLAGS)); (*_aux_) &= ~(f);}
+#define CLEAR_ALL_FLAGS_SWEEP(g) {FLAG_VAR(LOCAL(g, FLAGS)); (*_aux_)  =    0;}
+
+#define TEST_FLAG(g,x,y,z,f)     ((*MAGIC_CAST(GRID_ENTRY(g, x, y, z, FLAGS))) & (f))
+#define SET_FLAG(g,x,y,z,f)      {FLAG_VAR(GRID_ENTRY(g, x, y, z, FLAGS)); (*_aux_) |=  (f);}
+#define CLEAR_FLAG(g,x,y,z,f)    {FLAG_VAR(GRID_ENTRY(g, x, y, z, FLAGS)); (*_aux_) &= ~(f);}
+#define CLEAR_ALL_FLAGS(g,x,y,z) {FLAG_VAR(GRID_ENTRY(g, x, y, z, FLAGS)); (*_aux_)  =    0;}
+
+/*############################################################################*/
+
+#endif /* _CONFIG_H_ */
+
+
+/******************************************************************************/
+
+__kernel void performStreamCollide_kernel( __global float* srcGrid, __global float* dstGrid )
+{
+	srcGrid += MARGIN;
+	dstGrid += MARGIN;
+
+
+	//Using some predefined macros here.  Consider this the declaration 
+        //  and initialization of the variables SWEEP_X, SWEEP_Y and SWEEP_Z
+
+        SWEEP_VAR
+	SWEEP_X = get_local_id(0);
+	SWEEP_Y = get_group_id(0);
+	SWEEP_Z = get_group_id(1);
+	
+	float temp_swp, tempC, tempN, tempS, tempE, tempW, tempT, tempB;
+	float tempNE, tempNW, tempSE, tempSW, tempNT, tempNB, tempST ;
+	float tempSB, tempET, tempEB, tempWT, tempWB ;
+
+	//Load all of the input fields
+	//This is a gather operation of the SCATTER preprocessor variable
+        // is undefined in layout_config.h, or a "local" read otherwise
+	tempC = SRC_C(srcGrid);
+
+	tempN = SRC_N(srcGrid);
+	tempS = SRC_S(srcGrid);
+	tempE = SRC_E(srcGrid);
+	tempW = SRC_W(srcGrid);
+	tempT = SRC_T(srcGrid);
+	tempB = SRC_B(srcGrid);
+
+	tempNE = SRC_NE(srcGrid);
+	tempNW = SRC_NW(srcGrid);
+	tempSE = SRC_SE(srcGrid);
+	tempSW = SRC_SW(srcGrid);
+	tempNT = SRC_NT(srcGrid);
+	tempNB = SRC_NB(srcGrid);
+	tempST = SRC_ST(srcGrid);
+	tempSB = SRC_SB(srcGrid);
+	tempET = SRC_ET(srcGrid);
+	tempEB = SRC_EB(srcGrid);
+	tempWT = SRC_WT(srcGrid);
+	tempWB = SRC_WB(srcGrid);
+
+	//Test whether the cell is fluid or obstacle
+	if(as_uint(LOCAL(srcGrid,FLAGS)) & (OBSTACLE)) {
+		
+		//Swizzle the inputs: reflect any fluid coming into this cell 
+		// back to where it came from
+		temp_swp = tempN ; tempN = tempS ; tempS = temp_swp ;
+		temp_swp = tempE ; tempE = tempW ; tempW = temp_swp;
+		temp_swp = tempT ; tempT = tempB ; tempB = temp_swp;
+		temp_swp = tempNE; tempNE = tempSW ; tempSW = temp_swp;
+		temp_swp = tempNW; tempNW = tempSE ; tempSE = temp_swp;
+		temp_swp = tempNT ; tempNT = tempSB ; tempSB = temp_swp; 
+		temp_swp = tempNB ; tempNB = tempST ; tempST = temp_swp;
+		temp_swp = tempET ; tempET= tempWB ; tempWB = temp_swp;
+		temp_swp = tempEB ; tempEB = tempWT ; tempWT = temp_swp;
+	}
+	else {
+ 
+                //The math meat of LBM: ignore for optimization
+	        float ux, uy, uz, rho, u2;
+		float temp1, temp2, temp_base;
+		rho = tempC + tempN
+			+ tempS + tempE
+			+ tempW + tempT
+			+ tempB + tempNE
+			+ tempNW + tempSE
+			+ tempSW + tempNT
+			+ tempNB + tempST
+			+ tempSB + tempET
+			+ tempEB + tempWT
+			+ tempWB;
+
+		ux = + tempE - tempW
+			+ tempNE - tempNW
+			+ tempSE - tempSW
+			+ tempET + tempEB
+			- tempWT - tempWB;
+
+		uy = + tempN - tempS
+			+ tempNE + tempNW
+			- tempSE - tempSW
+			+ tempNT + tempNB
+			- tempST - tempSB;
+
+		uz = + tempT - tempB
+			+ tempNT - tempNB
+			+ tempST - tempSB
+			+ tempET - tempEB
+			+ tempWT - tempWB;		
+		
+		ux /= rho;
+		uy /= rho;
+		uz /= rho;
+
+		if(as_uint(LOCAL(srcGrid,FLAGS)) & (ACCEL)) {
+
+			ux = 0.005f;
+			uy = 0.002f;
+			uz = 0.000f;
+		}
+
+		u2 = 1.5f * (ux*ux + uy*uy + uz*uz) - 1.0f;
+		temp_base = OMEGA*rho;
+		temp1 = DFL1*temp_base;
+
+		//Put the output values for this cell in the shared memory
+		temp_base = OMEGA*rho;
+		temp1 = DFL1*temp_base;
+		temp2 = 1.0f-OMEGA;
+		tempC = temp2*tempC + temp1*(                                 - u2);
+	        temp1 = DFL2*temp_base;	
+		tempN = temp2*tempN + temp1*(       uy*(4.5f*uy       + 3.0f) - u2);
+		tempS = temp2*tempS + temp1*(       uy*(4.5f*uy       - 3.0f) - u2);
+		tempT = temp2*tempT + temp1*(       uz*(4.5f*uz       + 3.0f) - u2);
+		tempB = temp2*tempB + temp1*(       uz*(4.5f*uz       - 3.0f) - u2);
+		tempE = temp2*tempE + temp1*(       ux*(4.5f*ux       + 3.0f) - u2);
+		tempW = temp2*tempW + temp1*(       ux*(4.5f*ux       - 3.0f) - u2);
+		temp1 = DFL3*temp_base;
+		tempNT= temp2*tempNT + temp1 *( (+uy+uz)*(4.5f*(+uy+uz) + 3.0f) - u2);
+		tempNB= temp2*tempNB + temp1 *( (+uy-uz)*(4.5f*(+uy-uz) + 3.0f) - u2);
+		tempST= temp2*tempST + temp1 *( (-uy+uz)*(4.5f*(-uy+uz) + 3.0f) - u2);
+		tempSB= temp2*tempSB + temp1 *( (-uy-uz)*(4.5f*(-uy-uz) + 3.0f) - u2);
+		tempNE = temp2*tempNE + temp1 *( (+ux+uy)*(4.5f*(+ux+uy) + 3.0f) - u2);
+		tempSE = temp2*tempSE + temp1 *((+ux-uy)*(4.5f*(+ux-uy) + 3.0f) - u2);
+		tempET = temp2*tempET + temp1 *( (+ux+uz)*(4.5f*(+ux+uz) + 3.0f) - u2);
+		tempEB = temp2*tempEB + temp1 *( (+ux-uz)*(4.5f*(+ux-uz) + 3.0f) - u2);
+		tempNW = temp2*tempNW + temp1 *( (-ux+uy)*(4.5f*(-ux+uy) + 3.0f) - u2);
+		tempSW = temp2*tempSW + temp1 *( (-ux-uy)*(4.5f*(-ux-uy) + 3.0f) - u2);
+		tempWT = temp2*tempWT + temp1 *( (-ux+uz)*(4.5f*(-ux+uz) + 3.0f) - u2);
+		tempWB = temp2*tempWB + temp1 *( (-ux-uz)*(4.5f*(-ux-uz) + 3.0f) - u2);
+	}
+
+	//Write the results computed above
+	//This is a scatter operation of the SCATTER preprocessor variable
+        // is defined in layout_config.h, or a "local" write otherwise
+	DST_C ( dstGrid ) = tempC;
+
+	DST_N ( dstGrid ) = tempN; 
+	DST_S ( dstGrid ) = tempS;
+	DST_E ( dstGrid ) = tempE;
+	DST_W ( dstGrid ) = tempW;
+	DST_T ( dstGrid ) = tempT;
+	DST_B ( dstGrid ) = tempB;
+
+	DST_NE( dstGrid ) = tempNE;
+	DST_NW( dstGrid ) = tempNW;
+	DST_SE( dstGrid ) = tempSE;
+	DST_SW( dstGrid ) = tempSW;
+	DST_NT( dstGrid ) = tempNT;
+	DST_NB( dstGrid ) = tempNB;
+	DST_ST( dstGrid ) = tempST;
+	DST_SB( dstGrid ) = tempSB;
+	DST_ET( dstGrid ) = tempET;
+	DST_EB( dstGrid ) = tempEB;
+	DST_WT( dstGrid ) = tempWT;
+	DST_WB( dstGrid ) = tempWB;
+}
+
+#endif // LBM_KERNEL_CL

benchmarks/opencl/lbm/layout_config.h

@@ -0,0 +1,69 @@
+/***************************************************************************
+ *cr
+ *cr            (C) Copyright 2010 The Board of Trustees of the
+ *cr                        University of Illinois
+ *cr                         All Rights Reserved
+ *cr
+ ***************************************************************************/
+
+/*############################################################################*/
+
+#ifndef _LAYOUT_CONFIG_H_
+#define _LAYOUT_CONFIG_H_
+
+/*############################################################################*/
+
+//Unchangeable settings: volume simulation size for the given example
+#define SIZE_X (32)
+#define SIZE_Y (16)
+#define SIZE_Z (8)
+
+//Changeable settings
+//Padding in each dimension
+#define PADDING_X (8)
+#define PADDING_Y (0)
+#define PADDING_Z (4)
+
+//Pitch in each dimension
+#define PADDED_X (SIZE_X+PADDING_X)
+#define PADDED_Y (SIZE_Y+PADDING_Y)
+#define PADDED_Z (SIZE_Z+PADDING_Z)
+
+#define TOTAL_CELLS (SIZE_X*SIZE_Y*SIZE_Z)
+#define TOTAL_PADDED_CELLS (PADDED_X*PADDED_Y*PADDED_Z)
+
+//Flattening function
+//  This macro will be used to map a 3-D index and element to a value
+//  The macro below implements the equivalent of a 3-D array of 
+//  20-element structures in C standard layout.
+#define CALC_INDEX(x,y,z,e) ( e + N_CELL_ENTRIES*\
+                               ((x)+(y)*PADDED_X+(z)*PADDED_X*PADDED_Y) )
+
+#define MARGIN (CALC_INDEX(0, 0, 2, 0) - CALC_INDEX(0,0,0,0))
+
+// Set this value to 1 for GATHER, or 0 for SCATTER
+#if 1
+#define GATHER
+#else
+#define SCATTER
+#endif
+
+//OpenCL block size (not trivially changeable here)
+#define BLOCK_SIZE SIZE_X
+
+/*############################################################################*/
+
+typedef enum {C = 0,
+              N, S, E, W, T, B,
+              NE, NW, SE, SW,
+              NT, NB, ST, SB,
+              ET, EB, WT, WB,
+              FLAGS, N_CELL_ENTRIES} CELL_ENTRIES;
+
+#define N_DISTR_FUNCS FLAGS
+
+typedef enum {OBSTACLE    = 1 << 0,
+              ACCEL       = 1 << 1,
+              IN_OUT_FLOW = 1 << 2} CELL_FLAGS;
+
+#endif /* _CONFIG_H_ */

benchmarks/opencl/lbm/lbm.c

@@ -0,0 +1,356 @@
+/***************************************************************************
+ *cr
+ *cr            (C) Copyright 2010 The Board of Trustees of the
+ *cr                        University of Illinois
+ *cr                         All Rights Reserved
+ *cr
+ ***************************************************************************/
+
+/*############################################################################*/
+
+// includes, system
+#include <CL/cl.h>
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <float.h>
+
+// includes, project
+#include "layout_config.h"
+#include "lbm_macros.h"
+#include "ocl.h"
+#include "lbm.h"
+
+#include "parboil.h"
+
+/******************************************************************************/
+
+void OpenCL_LBM_performStreamCollide( const OpenCL_Param* prm, cl_mem srcGrid, cl_mem dstGrid ) {
+	 
+	cl_int clStatus;
+
+	clStatus = clSetKernelArg(prm->clKernel,0,sizeof(cl_mem),(void*)&srcGrid);
+	CHECK_ERROR("clSetKernelArg")
+
+	clStatus = clSetKernelArg(prm->clKernel,1,sizeof(cl_mem),(void*)&dstGrid);
+	CHECK_ERROR("clSetKernelArg")
+
+	size_t dimBlock[3] = {SIZE_X,1,1};
+	size_t dimGrid[3] = {SIZE_X*SIZE_Y,SIZE_Z,1};
+	clStatus = clEnqueueNDRangeKernel(prm->clCommandQueue,prm->clKernel,3,NULL,dimGrid,dimBlock,0,NULL,NULL); 
+	CHECK_ERROR("clEnqueueNDRangeKernel") 	
+	
+	clStatus = clFinish(prm->clCommandQueue);
+	CHECK_ERROR("clFinish")
+}
+/*############################################################################*/
+
+void LBM_allocateGrid( float** ptr ) {
+	const size_t size   = TOTAL_PADDED_CELLS * N_CELL_ENTRIES * sizeof(float);
+	*ptr = (float*)malloc( size );
+	if( !ptr ) {
+		printf( "LBM_allocateGrid: could not allocate %.1f MByte\n",
+				size / (1024.0*1024.0) );
+		exit( 1 );
+	}
+
+	memset( *ptr, 0, size );
+
+	printf( "LBM_allocateGrid: allocated %.1f MByte\n",
+			size / (1024.0*1024.0) );
+	
+	*ptr += MARGIN;
+}
+
+/******************************************************************************/
+
+void OpenCL_LBM_allocateGrid( const OpenCL_Param* prm, cl_mem* ptr ) {
+	const size_t size = TOTAL_PADDED_CELLS*N_CELL_ENTRIES*sizeof( float );
+	cl_int clStatus;
+/*size_t max_alloc_size = 0;
+	clGetDeviceInfo(prm->clDevice, CL_DEVICE_MAX_MEM_ALLOC_SIZE, 
+                  sizeof(max_alloc_size), &max_alloc_size, NULL);
+  if (max_alloc_size < size) {
+    fprintf(stderr, "Can't allocate buffer: max alloc size is %dMB\n",
+            (int) (max_alloc_size >> 20));
+    exit(-1);
+  }*/
+	*ptr = clCreateBuffer(prm->clContext,CL_MEM_READ_WRITE,size,NULL,&clStatus);
+	CHECK_ERROR("clCreateBuffer")
+}
+
+/*############################################################################*/
+
+void LBM_freeGrid( float** ptr ) {
+	free( *ptr-MARGIN );
+	*ptr = NULL;
+}
+
+/******************************************************************************/
+
+void OpenCL_LBM_freeGrid(cl_mem ptr) {
+	clReleaseMemObject(ptr);
+}
+
+/*############################################################################*/
+
+void LBM_initializeGrid( LBM_Grid grid ) {
+	SWEEP_VAR
+
+	SWEEP_START( 0, 0, 0, 0, 0, SIZE_Z )
+	SRC_C( grid  ) = DFL1;
+	SRC_N( grid  ) = DFL2;
+	SRC_S( grid  ) = DFL2;
+	SRC_E( grid  ) = DFL2;
+	SRC_W( grid  ) = DFL2;
+	SRC_T( grid  ) = DFL2;
+	SRC_B( grid  ) = DFL2;
+	SRC_NE( grid ) = DFL3;
+	SRC_NW( grid ) = DFL3;
+	SRC_SE( grid ) = DFL3;
+	SRC_SW( grid ) = DFL3;
+	SRC_NT( grid ) = DFL3;
+	SRC_NB( grid ) = DFL3;
+	SRC_ST( grid ) = DFL3;
+	SRC_SB( grid ) = DFL3;
+	SRC_ET( grid ) = DFL3;
+	SRC_EB( grid ) = DFL3;
+	SRC_WT( grid ) = DFL3;
+	SRC_WB( grid ) = DFL3;
+	
+	CLEAR_ALL_FLAGS_SWEEP( grid );
+	SWEEP_END
+}
+
+/******************************************************************************/
+
+void OpenCL_LBM_initializeGrid( const OpenCL_Param* prm, cl_mem d_grid, LBM_Grid h_grid ) {
+	const size_t size = TOTAL_PADDED_CELLS*N_CELL_ENTRIES*sizeof( float ); 
+	cl_int clStatus;
+	clStatus = clEnqueueWriteBuffer(prm->clCommandQueue,d_grid,CL_TRUE,0,size,h_grid-MARGIN,0,NULL,NULL);
+	CHECK_ERROR("clEnqueueWriteBuffer")
+}
+
+void OpenCL_LBM_getDeviceGrid( const OpenCL_Param* prm, cl_mem d_grid, LBM_Grid h_grid ) {
+	const size_t size = TOTAL_PADDED_CELLS*N_CELL_ENTRIES*sizeof( float );
+        cl_int clStatus;
+        clStatus = clEnqueueReadBuffer(prm->clCommandQueue,d_grid,CL_TRUE,0,size,h_grid-MARGIN,0,NULL,NULL);
+	CHECK_ERROR("clEnqueueReadBuffer")
+}
+
+/*############################################################################*/
+
+void LBM_swapGrids( cl_mem* grid1, cl_mem* grid2 ) {
+	cl_mem aux = *grid1;
+	*grid1 = *grid2;
+	*grid2 = aux;
+}
+
+/*############################################################################*/
+
+void LBM_loadObstacleFile( LBM_Grid grid, const char* filename ) {
+	int x,  y,  z;
+
+	FILE* file = fopen( filename, "rb" );
+
+	for( z = 0; z < SIZE_Z; z++ ) {
+		for( y = 0; y < SIZE_Y; y++ ) {
+			for( x = 0; x < SIZE_X; x++ ) {
+				if( fgetc( file ) != '.' ) SET_FLAG( grid, x, y, z, OBSTACLE );
+			}
+			fgetc( file );
+		}
+		fgetc( file );
+	}
+
+	fclose( file );
+}
+
+/*############################################################################*/
+
+void LBM_initializeSpecialCellsForLDC( LBM_Grid grid ) {
+	int x,  y,  z;
+
+	for( z = -2; z < SIZE_Z+2; z++ ) {
+		for( y = 0; y < SIZE_Y; y++ ) {
+			for( x = 0; x < SIZE_X; x++ ) {
+				if( x == 0 || x == SIZE_X-1 ||
+						y == 0 || y == SIZE_Y-1 ||
+						z == 0 || z == SIZE_Z-1 ) {
+					SET_FLAG( grid, x, y, z, OBSTACLE );
+				}
+				else {
+					if( (z == 1 || z == SIZE_Z-2) &&
+							x > 1 && x < SIZE_X-2 &&
+							y > 1 && y < SIZE_Y-2 ) {
+						SET_FLAG( grid, x, y, z, ACCEL );
+					}
+				}
+			}
+		}
+	}
+}
+
+/*############################################################################*/
+
+void LBM_showGridStatistics( LBM_Grid grid ) {
+	int nObstacleCells = 0,
+	    nAccelCells    = 0,
+	    nFluidCells    = 0;
+	float ux, uy, uz;
+	float minU2  = 1e+30, maxU2  = -1e+30, u2;
+	float minRho = 1e+30, maxRho = -1e+30, rho;
+	float mass = 0;
+
+	SWEEP_VAR
+
+		SWEEP_START( 0, 0, 0, 0, 0, SIZE_Z )
+		rho = LOCAL( grid, C  ) + LOCAL( grid, N  )
+		+ LOCAL( grid, S  ) + LOCAL( grid, E  )
+		+ LOCAL( grid, W  ) + LOCAL( grid, T  )
+		+ LOCAL( grid, B  ) + LOCAL( grid, NE )
+		+ LOCAL( grid, NW ) + LOCAL( grid, SE )
+		+ LOCAL( grid, SW ) + LOCAL( grid, NT )
+		+ LOCAL( grid, NB ) + LOCAL( grid, ST )
+		+ LOCAL( grid, SB ) + LOCAL( grid, ET )
+		+ LOCAL( grid, EB ) + LOCAL( grid, WT )
+		+ LOCAL( grid, WB );
+
+	if( rho < minRho ) minRho = rho;
+	if( rho > maxRho ) maxRho = rho;
+	mass += rho;
+
+	if( TEST_FLAG_SWEEP( grid, OBSTACLE )) {
+		nObstacleCells++;
+	}
+	else {
+		if( TEST_FLAG_SWEEP( grid, ACCEL ))
+			nAccelCells++;
+		else
+			nFluidCells++;
+
+		ux = + LOCAL( grid, E  ) - LOCAL( grid, W  )
+			+ LOCAL( grid, NE ) - LOCAL( grid, NW )
+			+ LOCAL( grid, SE ) - LOCAL( grid, SW )
+			+ LOCAL( grid, ET ) + LOCAL( grid, EB )
+			- LOCAL( grid, WT ) - LOCAL( grid, WB );
+		uy = + LOCAL( grid, N  ) - LOCAL( grid, S  )
+			+ LOCAL( grid, NE ) + LOCAL( grid, NW )
+			- LOCAL( grid, SE ) - LOCAL( grid, SW )
+			+ LOCAL( grid, NT ) + LOCAL( grid, NB )
+			- LOCAL( grid, ST ) - LOCAL( grid, SB );
+		uz = + LOCAL( grid, T  ) - LOCAL( grid, B  )
+			+ LOCAL( grid, NT ) - LOCAL( grid, NB )
+			+ LOCAL( grid, ST ) - LOCAL( grid, SB )
+			+ LOCAL( grid, ET ) - LOCAL( grid, EB )
+			+ LOCAL( grid, WT ) - LOCAL( grid, WB );
+		u2 = (ux*ux + uy*uy + uz*uz) / (rho*rho);
+		if( u2 < minU2 ) minU2 = u2;
+		if( u2 > maxU2 ) maxU2 = u2;
+	}
+	SWEEP_END
+
+		printf( "LBM_showGridStatistics:\n"
+				"\tnObstacleCells: %7i nAccelCells: %7i nFluidCells: %7i\n"
+				"\tminRho: %8.4f maxRho: %8.4f mass: %e\n"
+				"\tminU: %e maxU: %e\n\n",
+				nObstacleCells, nAccelCells, nFluidCells,
+				minRho, maxRho, mass,
+				sqrt( minU2 ), sqrt( maxU2 ) );
+
+}
+
+/*############################################################################*/
+
+static void storeValue( FILE* file, OUTPUT_PRECISION* v ) {
+	const int litteBigEndianTest = 1;
+	if( (*((unsigned char*) &litteBigEndianTest)) == 0 ) {         /* big endian */
+		const char* vPtr = (char*) v;
+		char buffer[sizeof( OUTPUT_PRECISION )];
+		int i;
+
+		for (i = 0; i < sizeof( OUTPUT_PRECISION ); i++)
+			buffer[i] = vPtr[sizeof( OUTPUT_PRECISION ) - i - 1];
+
+		fwrite( buffer, sizeof( OUTPUT_PRECISION ), 1, file );
+	}
+	else {                                                     /* little endian */
+		fwrite( v, sizeof( OUTPUT_PRECISION ), 1, file );
+	}
+}
+
+/*############################################################################*/
+
+static void loadValue( FILE* file, OUTPUT_PRECISION* v ) {
+	const int litteBigEndianTest = 1;
+	if( (*((unsigned char*) &litteBigEndianTest)) == 0 ) {         /* big endian */
+		char* vPtr = (char*) v;
+		char buffer[sizeof( OUTPUT_PRECISION )];
+		int i;
+
+		fread( buffer, sizeof( OUTPUT_PRECISION ), 1, file );
+
+		for (i = 0; i < sizeof( OUTPUT_PRECISION ); i++)
+			vPtr[i] = buffer[sizeof( OUTPUT_PRECISION ) - i - 1];
+	}
+	else {                                                     /* little endian */
+		fread( v, sizeof( OUTPUT_PRECISION ), 1, file );
+	}
+}
+
+/*############################################################################*/
+
+void LBM_storeVelocityField( LBM_Grid grid, const char* filename,
+		const int binary ) {
+	OUTPUT_PRECISION rho, ux, uy, uz;
+
+	FILE* file = fopen( filename, (binary ? "wb" : "w") );
+
+	SWEEP_VAR
+	SWEEP_START(0,0,0,SIZE_X,SIZE_Y,SIZE_Z)
+				rho = + SRC_C( grid ) + SRC_N( grid )
+					+ SRC_S( grid ) + SRC_E( grid )
+					+ SRC_W( grid ) + SRC_T( grid )
+					+ SRC_B( grid ) + SRC_NE( grid )
+					+ SRC_NW( grid ) + SRC_SE( grid )
+					+ SRC_SW( grid ) + SRC_NT( grid )
+					+ SRC_NB( grid ) + SRC_ST( grid )
+					+ SRC_SB( grid ) + SRC_ET( grid )
+					+ SRC_EB( grid ) + SRC_WT( grid )
+					+ SRC_WB( grid );
+				ux = + SRC_E( grid ) - SRC_W( grid ) 
+					+ SRC_NE( grid ) - SRC_NW( grid ) 
+					+ SRC_SE( grid ) - SRC_SW( grid ) 
+					+ SRC_ET( grid ) + SRC_EB( grid ) 
+					- SRC_WT( grid ) - SRC_WB( grid );
+				uy = + SRC_N( grid ) - SRC_S( grid ) 
+					+ SRC_NE( grid ) + SRC_NW( grid ) 
+					- SRC_SE( grid ) - SRC_SW( grid ) 
+					+ SRC_NT( grid ) + SRC_NB( grid ) 
+					- SRC_ST( grid ) - SRC_SB( grid );
+				uz = + SRC_T( grid ) - SRC_B( grid ) 
+					+ SRC_NT( grid ) - SRC_NB( grid ) 
+					+ SRC_ST( grid ) - SRC_SB( grid ) 
+					+ SRC_ET( grid ) - SRC_EB( grid ) 
+					+ SRC_WT( grid ) - SRC_WB( grid );
+				ux /= rho;
+				uy /= rho;
+				uz /= rho;
+
+				if( binary ) {
+					/*
+					   fwrite( &ux, sizeof( ux ), 1, file );
+					   fwrite( &uy, sizeof( uy ), 1, file );
+					   fwrite( &uz, sizeof( uz ), 1, file );
+					   */
+					storeValue( file, &ux );
+					storeValue( file, &uy );
+					storeValue( file, &uz );
+				} else
+					fprintf( file, "%e %e %e\n", ux, uy, uz );
+
+	SWEEP_END;
+
+	fclose( file );
+}

benchmarks/opencl/lbm/lbm.h

@@ -0,0 +1,39 @@
+/***************************************************************************
+ *cr
+ *cr            (C) Copyright 2010 The Board of Trustees of the
+ *cr                        University of Illinois
+ *cr                         All Rights Reserved
+ *cr
+ ***************************************************************************/
+
+/*############################################################################*/
+
+#ifndef _LBM_H_
+#define _LBM_H_
+
+/*############################################################################*/
+
+#include "ocl.h"
+#include "lbm_macros.h"
+
+void LBM_allocateGrid( float** ptr );
+void LBM_freeGrid( float** ptr );
+void LBM_initializeGrid( LBM_Grid grid );
+void LBM_initializeSpecialCellsForLDC( LBM_Grid grid );
+void LBM_loadObstacleFile( LBM_Grid grid, const char* filename );
+void LBM_swapGrids( cl_mem* grid1, cl_mem* grid2 );
+void LBM_showGridStatistics( LBM_Grid Grid );
+void LBM_storeVelocityField( LBM_Grid grid, const char* filename,
+                           const BOOL binary );
+
+/* OpenCL *********************************************************************/
+
+void OpenCL_LBM_allocateGrid( const OpenCL_Param* prm, cl_mem* ptr );
+void OpenCL_LBM_freeGrid( cl_mem ptr );
+void OpenCL_LBM_initializeGrid( const OpenCL_Param* prm, cl_mem d_grid, LBM_Grid h_grid );
+void OpenCL_LBM_getDeviceGrid( const OpenCL_Param* prm, cl_mem d_grid, LBM_Grid h_grid );
+void OpenCL_LBM_performStreamCollide( const OpenCL_Param* prm, cl_mem srcGrid, cl_mem dstGrid );
+
+/*############################################################################*/
+
+#endif /* _LBM_H_ */

benchmarks/opencl/lbm/lbm_macros.h

@@ -0,0 +1,177 @@
+/***************************************************************************
+ *cr
+ *cr            (C) Copyright 2010 The Board of Trustees of the
+ *cr                        University of Illinois
+ *cr                         All Rights Reserved
+ *cr
+ ***************************************************************************/
+
+#ifndef _LBM_MARCOS_H
+#define _LBM_MACROS_H_
+
+#define OMEGA (1.95f)
+
+#define OUTPUT_PRECISION float
+
+#define BOOL int
+#define TRUE (-1)
+#define FALSE (0)
+
+#define DFL1 (1.0f/ 3.0f)
+#define DFL2 (1.0f/18.0f)
+#define DFL3 (1.0f/36.0f)
+
+/*############################################################################*/
+
+typedef float* LBM_Grid;//float LBM_Grid[PADDED_Z*PADDED_Y*PADDED_X*N_CELL_ENTRIES];
+typedef LBM_Grid* LBM_GridPtr;
+
+/*############################################################################*/
+
+
+#define SWEEP_X  __temp_x__
+#define SWEEP_Y  __temp_y__
+#define SWEEP_Z  __temp_z__
+#define SWEEP_VAR int __temp_x__, __temp_y__, __temp_z__;
+
+#define SWEEP_START(x1,y1,z1,x2,y2,z2) \
+	for( __temp_z__ = z1; \
+	     __temp_z__ < z2; \
+		__temp_z__++) { \
+            for( __temp_y__ = 0; \
+                 __temp_y__ < SIZE_Y; \
+                 __temp_y__++) { \
+		for(__temp_x__ = 0; \
+	            __temp_x__ < SIZE_X; \
+                    __temp_x__++) { \
+
+#define SWEEP_END }}}
+
+
+#define GRID_ENTRY(g,x,y,z,e)          ((g)[CALC_INDEX( x,  y,  z, e)])
+#define GRID_ENTRY_SWEEP(g,dx,dy,dz,e) ((g)[CALC_INDEX((dx)+SWEEP_X, (dy)+SWEEP_Y, (dz)+SWEEP_Z, e)])
+
+#define LOCAL(g,e)       (GRID_ENTRY_SWEEP( g,  0,  0,  0, e ))
+#define NEIGHBOR_C(g,e)  (GRID_ENTRY_SWEEP( g,  0,  0,  0, e ))
+#define NEIGHBOR_N(g,e)  (GRID_ENTRY_SWEEP( g,  0, +1,  0, e ))
+#define NEIGHBOR_S(g,e)  (GRID_ENTRY_SWEEP( g,  0, -1,  0, e ))
+#define NEIGHBOR_E(g,e)  (GRID_ENTRY_SWEEP( g, +1,  0,  0, e ))
+#define NEIGHBOR_W(g,e)  (GRID_ENTRY_SWEEP( g, -1,  0,  0, e ))
+#define NEIGHBOR_T(g,e)  (GRID_ENTRY_SWEEP( g,  0,  0, +1, e ))
+#define NEIGHBOR_B(g,e)  (GRID_ENTRY_SWEEP( g,  0,  0, -1, e ))
+#define NEIGHBOR_NE(g,e) (GRID_ENTRY_SWEEP( g, +1, +1,  0, e ))
+#define NEIGHBOR_NW(g,e) (GRID_ENTRY_SWEEP( g, -1, +1,  0, e ))
+#define NEIGHBOR_SE(g,e) (GRID_ENTRY_SWEEP( g, +1, -1,  0, e ))
+#define NEIGHBOR_SW(g,e) (GRID_ENTRY_SWEEP( g, -1, -1,  0, e ))
+#define NEIGHBOR_NT(g,e) (GRID_ENTRY_SWEEP( g,  0, +1, +1, e ))
+#define NEIGHBOR_NB(g,e) (GRID_ENTRY_SWEEP( g,  0, +1, -1, e ))
+#define NEIGHBOR_ST(g,e) (GRID_ENTRY_SWEEP( g,  0, -1, +1, e ))
+#define NEIGHBOR_SB(g,e) (GRID_ENTRY_SWEEP( g,  0, -1, -1, e ))
+#define NEIGHBOR_ET(g,e) (GRID_ENTRY_SWEEP( g, +1,  0, +1, e ))
+#define NEIGHBOR_EB(g,e) (GRID_ENTRY_SWEEP( g, +1,  0, -1, e ))
+#define NEIGHBOR_WT(g,e) (GRID_ENTRY_SWEEP( g, -1,  0, +1, e ))
+#define NEIGHBOR_WB(g,e) (GRID_ENTRY_SWEEP( g, -1,  0, -1, e ))
+
+
+#ifdef SCATTER
+
+#define SRC_C(g)  (LOCAL( g, C  ))
+#define SRC_N(g)  (LOCAL( g, N  ))
+#define SRC_S(g)  (LOCAL( g, S  ))
+#define SRC_E(g)  (LOCAL( g, E  ))
+#define SRC_W(g)  (LOCAL( g, W  ))
+#define SRC_T(g)  (LOCAL( g, T  ))
+#define SRC_B(g)  (LOCAL( g, B  ))
+#define SRC_NE(g) (LOCAL( g, NE ))
+#define SRC_NW(g) (LOCAL( g, NW ))
+#define SRC_SE(g) (LOCAL( g, SE ))
+#define SRC_SW(g) (LOCAL( g, SW ))
+#define SRC_NT(g) (LOCAL( g, NT ))
+#define SRC_NB(g) (LOCAL( g, NB ))
+#define SRC_ST(g) (LOCAL( g, ST ))
+#define SRC_SB(g) (LOCAL( g, SB ))
+#define SRC_ET(g) (LOCAL( g, ET ))
+#define SRC_EB(g) (LOCAL( g, EB ))
+#define SRC_WT(g) (LOCAL( g, WT ))
+#define SRC_WB(g) (LOCAL( g, WB ))
+
+#define DST_C(g)  (NEIGHBOR_C ( g, C  ))
+#define DST_N(g)  (NEIGHBOR_N ( g, N  ))
+#define DST_S(g)  (NEIGHBOR_S ( g, S  ))
+#define DST_E(g)  (NEIGHBOR_E ( g, E  ))
+#define DST_W(g)  (NEIGHBOR_W ( g, W  ))
+#define DST_T(g)  (NEIGHBOR_T ( g, T  ))
+#define DST_B(g)  (NEIGHBOR_B ( g, B  ))
+#define DST_NE(g) (NEIGHBOR_NE( g, NE ))
+#define DST_NW(g) (NEIGHBOR_NW( g, NW ))
+#define DST_SE(g) (NEIGHBOR_SE( g, SE ))
+#define DST_SW(g) (NEIGHBOR_SW( g, SW ))
+#define DST_NT(g) (NEIGHBOR_NT( g, NT ))
+#define DST_NB(g) (NEIGHBOR_NB( g, NB ))
+#define DST_ST(g) (NEIGHBOR_ST( g, ST ))
+#define DST_SB(g) (NEIGHBOR_SB( g, SB ))
+#define DST_ET(g) (NEIGHBOR_ET( g, ET ))
+#define DST_EB(g) (NEIGHBOR_EB( g, EB ))
+#define DST_WT(g) (NEIGHBOR_WT( g, WT ))
+#define DST_WB(g) (NEIGHBOR_WB( g, WB ))
+
+#else /* GATHER */
+
+#define SRC_C(g)  (NEIGHBOR_C ( g, C  ))
+#define SRC_N(g)  (NEIGHBOR_S ( g, N  ))
+#define SRC_S(g)  (NEIGHBOR_N ( g, S  ))
+#define SRC_E(g)  (NEIGHBOR_W ( g, E  ))
+#define SRC_W(g)  (NEIGHBOR_E ( g, W  ))
+#define SRC_T(g)  (NEIGHBOR_B ( g, T  ))
+#define SRC_B(g)  (NEIGHBOR_T ( g, B  ))
+#define SRC_NE(g) (NEIGHBOR_SW( g, NE ))
+#define SRC_NW(g) (NEIGHBOR_SE( g, NW ))
+#define SRC_SE(g) (NEIGHBOR_NW( g, SE ))
+#define SRC_SW(g) (NEIGHBOR_NE( g, SW ))
+#define SRC_NT(g) (NEIGHBOR_SB( g, NT ))
+#define SRC_NB(g) (NEIGHBOR_ST( g, NB ))
+#define SRC_ST(g) (NEIGHBOR_NB( g, ST ))
+#define SRC_SB(g) (NEIGHBOR_NT( g, SB ))
+#define SRC_ET(g) (NEIGHBOR_WB( g, ET ))
+#define SRC_EB(g) (NEIGHBOR_WT( g, EB ))
+#define SRC_WT(g) (NEIGHBOR_EB( g, WT ))
+#define SRC_WB(g) (NEIGHBOR_ET( g, WB ))
+
+#define DST_C(g)  (LOCAL( g, C  ))
+#define DST_N(g)  (LOCAL( g, N  ))
+#define DST_S(g)  (LOCAL( g, S  ))
+#define DST_E(g)  (LOCAL( g, E  ))
+#define DST_W(g)  (LOCAL( g, W  ))
+#define DST_T(g)  (LOCAL( g, T  ))
+#define DST_B(g)  (LOCAL( g, B  ))
+#define DST_NE(g) (LOCAL( g, NE ))
+#define DST_NW(g) (LOCAL( g, NW ))
+#define DST_SE(g) (LOCAL( g, SE ))
+#define DST_SW(g) (LOCAL( g, SW ))
+#define DST_NT(g) (LOCAL( g, NT ))
+#define DST_NB(g) (LOCAL( g, NB ))
+#define DST_ST(g) (LOCAL( g, ST ))
+#define DST_SB(g) (LOCAL( g, SB ))
+#define DST_ET(g) (LOCAL( g, ET ))
+#define DST_EB(g) (LOCAL( g, EB ))
+#define DST_WT(g) (LOCAL( g, WT ))
+#define DST_WB(g) (LOCAL( g, WB ))
+
+#endif /* GATHER */
+
+#define MAGIC_CAST(v) ((unsigned int*) ((void*) (&(v))))
+#define FLAG_VAR(v) unsigned int* _aux_ = MAGIC_CAST(v)
+
+#define TEST_FLAG_SWEEP(g,f)     ((*MAGIC_CAST(LOCAL(g, FLAGS))) & (f))
+#define SET_FLAG_SWEEP(g,f)      {FLAG_VAR(LOCAL(g, FLAGS)); (*_aux_) |=  (f);}
+#define CLEAR_FLAG_SWEEP(g,f)    {FLAG_VAR(LOCAL(g, FLAGS)); (*_aux_) &= ~(f);}
+#define CLEAR_ALL_FLAGS_SWEEP(g) {FLAG_VAR(LOCAL(g, FLAGS)); (*_aux_)  =    0;}
+
+#define TEST_FLAG(g,x,y,z,f)     ((*MAGIC_CAST(GRID_ENTRY(g, x, y, z, FLAGS))) & (f))
+#define SET_FLAG(g,x,y,z,f)      {FLAG_VAR(GRID_ENTRY(g, x, y, z, FLAGS)); (*_aux_) |=  (f);}
+#define CLEAR_FLAG(g,x,y,z,f)    {FLAG_VAR(GRID_ENTRY(g, x, y, z, FLAGS)); (*_aux_) &= ~(f);}
+#define CLEAR_ALL_FLAGS(g,x,y,z) {FLAG_VAR(GRID_ENTRY(g, x, y, z, FLAGS)); (*_aux_)  =    0;}
+
+/*############################################################################*/
+
+#endif /* _CONFIG_H_ */

benchmarks/opencl/lbm/main.cc

@@ -0,0 +1,238 @@
+/***************************************************************************
+ *cr
+ *cr            (C) Copyright 2010 The Board of Trustees of the
+ *cr                        University of Illinois
+ *cr                         All Rights Reserved
+ *cr
+ ***************************************************************************/
+
+/*############################################################################*/
+
+#include <CL/cl.h>
+#include <parboil.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+
+
+#include "layout_config.h"
+#include "lbm.h"
+#include "lbm_macros.h"
+#include "main.h"
+#include "ocl.h"
+
+
+/*############################################################################*/
+
+static cl_mem OpenCL_srcGrid, OpenCL_dstGrid;
+
+/*############################################################################*/
+
+struct pb_TimerSet timers;
+int main(int nArgs, char *arg[]) {
+  MAIN_Param param;
+  int t;
+
+  OpenCL_Param prm;
+
+  pb_InitializeTimerSet(&timers);
+  struct pb_Parameters *params;
+  params = pb_ReadParameters(&nArgs, arg);
+
+	params->inpFiles = (char **)malloc(sizeof(char *) * 2);
+  params->inpFiles[0] = (char *)malloc(100);
+  params->inpFiles[1] = NULL;
+  strncpy(params->inpFiles[0], "120_120_150_ldc.of", 100);
+
+  static LBM_GridPtr TEMP_srcGrid;
+  // Setup TEMP datastructures
+  LBM_allocateGrid((float **)&TEMP_srcGrid);
+  MAIN_parseCommandLine(nArgs, arg, &param, params);
+  MAIN_printInfo(&param);
+
+  OpenCL_initialize(params, &prm);
+  MAIN_initialize(&param, &prm);
+
+  for (t = 1; t <= param.nTimeSteps; t++) {
+    pb_SwitchToTimer(&timers, pb_TimerID_KERNEL);
+    OpenCL_LBM_performStreamCollide(&prm, OpenCL_srcGrid, OpenCL_dstGrid);
+    pb_SwitchToTimer(&timers, pb_TimerID_COMPUTE);
+    LBM_swapGrids(&OpenCL_srcGrid, &OpenCL_dstGrid);
+
+    if ((t & 63) == 0) {
+      printf("timestep: %i\n", t);
+#if 0
+			CUDA_LBM_getDeviceGrid((float**)&CUDA_srcGrid, (float**)&TEMP_srcGrid);
+			LBM_showGridStatistics( *TEMP_srcGrid );
+#endif
+    }
+  }
+
+  MAIN_finalize(&param, &prm);
+
+  LBM_freeGrid((float **)&TEMP_srcGrid);
+
+  pb_SwitchToTimer(&timers, pb_TimerID_NONE);
+  pb_PrintTimerSet(&timers);
+  pb_FreeParameters(params);
+  return 0;
+}
+
+/*############################################################################*/
+
+void MAIN_parseCommandLine(int nArgs, char *arg[], MAIN_Param *param,
+                           struct pb_Parameters *params) {
+  struct stat fileStat;
+
+  /*if (nArgs < 2) {
+    printf("syntax: lbm <time steps>\n");
+    exit(1);
+  }*/
+
+  param->nTimeSteps = 4; //atoi(arg[1]);
+
+  if (params->inpFiles[0] != NULL) {
+    param->obstacleFilename = params->inpFiles[0];
+
+    /*if (stat(param->obstacleFilename, &fileStat) != 0) {
+      printf("MAIN_parseCommandLine: cannot stat obstacle file '%s'\n",
+             param->obstacleFilename);
+      exit(1);
+    }
+    if (fileStat.st_size != SIZE_X * SIZE_Y * SIZE_Z + (SIZE_Y + 1) * SIZE_Z) {
+      printf("MAIN_parseCommandLine:\n"
+             "\tsize of file '%s' is %i bytes\n"
+             "\texpected size is %i bytes\n",
+             param->obstacleFilename, (int)fileStat.st_size,
+             SIZE_X * SIZE_Y * SIZE_Z + (SIZE_Y + 1) * SIZE_Z);
+      exit(1);
+    }*/
+  } else
+    param->obstacleFilename = NULL;
+
+  param->resultFilename = params->outFile;
+}
+
+/*############################################################################*/
+
+void MAIN_printInfo(const MAIN_Param *param) {
+  printf("MAIN_printInfo:\n"
+         "\tgrid size      : %i x %i x %i = %.2f * 10^6 Cells\n"
+         "\tnTimeSteps     : %i\n"
+         "\tresult file    : %s\n"
+         "\taction         : %s\n"
+         "\tsimulation type: %s\n"
+         "\tobstacle file  : %s\n\n",
+         SIZE_X, SIZE_Y, SIZE_Z, 1e-6 * SIZE_X * SIZE_Y * SIZE_Z,
+         param->nTimeSteps, param->resultFilename, "store", "lid-driven cavity",
+         (param->obstacleFilename == NULL) ? "<none>"
+                                           : param->obstacleFilename);
+}
+
+/*############################################################################*/
+
+void MAIN_initialize(const MAIN_Param *param, const OpenCL_Param *prm) {
+  static LBM_Grid TEMP_srcGrid, TEMP_dstGrid;
+
+  pb_SwitchToTimer(&timers, pb_TimerID_COMPUTE);
+  // Setup TEMP datastructures
+  LBM_allocateGrid((float **)&TEMP_srcGrid);
+  LBM_allocateGrid((float **)&TEMP_dstGrid);
+  LBM_initializeGrid(TEMP_srcGrid);
+  LBM_initializeGrid(TEMP_dstGrid);
+
+  pb_SwitchToTimer(&timers, pb_TimerID_IO);
+  if (param->obstacleFilename != NULL) {
+    LBM_loadObstacleFile(TEMP_srcGrid, param->obstacleFilename);
+    LBM_loadObstacleFile(TEMP_dstGrid, param->obstacleFilename);
+  }
+
+  pb_SwitchToTimer(&timers, pb_TimerID_COMPUTE);
+  LBM_initializeSpecialCellsForLDC(TEMP_srcGrid);
+  LBM_initializeSpecialCellsForLDC(TEMP_dstGrid);
+
+	pb_SwitchToTimer(&timers, pb_TimerID_COPY);
+
+	printf("OK+\n");
+
+  // Setup DEVICE datastructures
+  OpenCL_LBM_allocateGrid(prm, &OpenCL_srcGrid);
+  OpenCL_LBM_allocateGrid(prm, &OpenCL_dstGrid);
+
+	printf("OK-\n");
+
+  // Initialize DEVICE datastructures
+  OpenCL_LBM_initializeGrid(prm, OpenCL_srcGrid, TEMP_srcGrid);
+  OpenCL_LBM_initializeGrid(prm, OpenCL_dstGrid, TEMP_dstGrid);
+
+  pb_SwitchToTimer(&timers, pb_TimerID_COMPUTE);
+  LBM_showGridStatistics(TEMP_srcGrid);
+
+  LBM_freeGrid((float **)&TEMP_srcGrid);
+  LBM_freeGrid((float **)&TEMP_dstGrid);
+
+	printf("OK\n");
+}
+
+/*############################################################################*/
+
+void MAIN_finalize(const MAIN_Param *param, const OpenCL_Param *prm) {
+  LBM_Grid TEMP_srcGrid;
+
+  // Setup TEMP datastructures
+  LBM_allocateGrid((float **)&TEMP_srcGrid);
+
+  pb_SwitchToTimer(&timers, pb_TimerID_COPY);
+  OpenCL_LBM_getDeviceGrid(prm, OpenCL_srcGrid, TEMP_srcGrid);
+
+  pb_SwitchToTimer(&timers, pb_TimerID_COMPUTE);
+  LBM_showGridStatistics(TEMP_srcGrid);
+
+  LBM_storeVelocityField(TEMP_srcGrid, param->resultFilename, TRUE);
+
+  LBM_freeGrid((float **)&TEMP_srcGrid);
+  OpenCL_LBM_freeGrid(OpenCL_srcGrid);
+  OpenCL_LBM_freeGrid(OpenCL_dstGrid);
+
+  clReleaseProgram(prm->clProgram);
+  clReleaseKernel(prm->clKernel);
+  clReleaseCommandQueue(prm->clCommandQueue);
+  clReleaseContext(prm->clContext);
+}
+
+void OpenCL_initialize(struct pb_Parameters *p, OpenCL_Param *prm) {
+  cl_int clStatus;
+  pb_Context *pb_context;
+  pb_context = pb_InitOpenCLContext(p);
+  if (pb_context == NULL) {
+    fprintf(stderr, "Error: No OpenCL platform/device can be found.");
+    return;
+  }
+  prm->clDevice = (cl_device_id)pb_context->clDeviceId;
+  prm->clPlatform = (cl_platform_id)pb_context->clPlatformId;
+  prm->clContext = (cl_context)pb_context->clContext;
+
+  prm->clCommandQueue = clCreateCommandQueue(
+      prm->clContext, prm->clDevice, CL_QUEUE_PROFILING_ENABLE, &clStatus);
+  CHECK_ERROR("clCreateCommandQueue")
+
+  pb_SetOpenCL(&(prm->clContext), &(prm->clCommandQueue));
+
+  //const char *clSource[] = {readFile("src/opencl_base/kernel.cl")};
+  //prm->clProgram = clCreateProgramWithSource(prm->clContext, 1, clSource, NULL, &clStatus);
+	prm->clProgram = clCreateProgramWithBuiltInKernels(
+      prm->clContext, 1, &prm->clDevice, "performStreamCollide_kernel", &clStatus);
+  CHECK_ERROR("clCreateProgramWithSource")
+
+  //char clOptions[100];
+  //sprintf(clOptions, "-I src/opencl_base");
+	//clStatus = clBuildProgram(prm->clProgram, 1, &(prm->clDevice), clOptions, NULL, NULL);
+	clStatus = clBuildProgram(prm->clProgram, 1, &prm->clDevice, NULL, NULL, NULL);  
+  CHECK_ERROR("clBuildProgram")
+
+  prm->clKernel =
+      clCreateKernel(prm->clProgram, "performStreamCollide_kernel", &clStatus);
+  CHECK_ERROR("clCreateKernel")
+
+  //free((void *)clSource[0]);
+}

benchmarks/opencl/lbm/main.h

@@ -0,0 +1,31 @@
+/***************************************************************************
+ *cr
+ *cr            (C) Copyright 2010 The Board of Trustees of the
+ *cr                        University of Illinois
+ *cr                         All Rights Reserved
+ *cr
+ ***************************************************************************/
+
+#ifndef _MAIN_H_
+#define _MAIN_H_
+
+/*############################################################################*/
+
+typedef struct {
+	int nTimeSteps;
+	char* resultFilename;
+	char* obstacleFilename;
+} MAIN_Param;
+
+/*############################################################################*/
+
+void MAIN_parseCommandLine( int nArgs, char* arg[], MAIN_Param* param, struct pb_Parameters* );
+void MAIN_printInfo( const MAIN_Param* param );
+void MAIN_initialize( const MAIN_Param* param, const OpenCL_Param* prm );
+void MAIN_finalize( const MAIN_Param* param, const OpenCL_Param* prm );
+
+void OpenCL_initialize(struct pb_Parameters*, OpenCL_Param* prm);
+
+/*############################################################################*/
+
+#endif /* _MAIN_H_ */

benchmarks/opencl/lbm/ocl.c

@@ -0,0 +1,40 @@
+#include <CL/cl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "ocl.h"
+
+char* readFile(char* fileName)
+{
+	FILE* fp;
+	fp = fopen(fileName,"r");
+
+	if(fp == NULL)
+	{
+		printf("Error 1!\n");
+		return NULL;
+	}
+
+	fseek(fp,0,SEEK_END);
+	long size = ftell(fp);
+	rewind(fp);
+
+	char* buffer = (char*)malloc(sizeof(char)*(size+1));
+	if(buffer == NULL)
+	{
+		printf("Error 2!\n");
+		fclose(fp);
+		return NULL;
+	}
+
+	size_t res = fread(buffer,1,size,fp);
+	if(res != size)
+	{
+		printf("Error 3!\n");
+		fclose(fp);
+		return NULL;
+	}
+
+	buffer[size] = 0;
+	fclose(fp);
+	return buffer;
+}

benchmarks/opencl/lbm/ocl.h

@@ -0,0 +1,25 @@
+#ifndef __OCLH__
+#define __OCLH__
+
+typedef struct {
+	cl_platform_id clPlatform;
+	cl_context_properties clCps[3];
+	cl_device_id clDevice;
+	cl_context clContext;
+	cl_command_queue clCommandQueue;
+	cl_program clProgram;
+	cl_kernel clKernel;
+} OpenCL_Param;
+
+
+#define CHECK_ERROR(errorMessage)           \
+  if(clStatus != CL_SUCCESS)                \
+  {                                         \
+     printf("Error: %s!\n",errorMessage);   \
+     printf("Line: %d\n",__LINE__);         \
+     exit(1);                               \
+  }
+
+char* readFile(char*);
+
+#endif

benchmarks/opencl/lbm/parboil.h

@@ -0,0 +1,348 @@
+/*
+ * (c) 2010 The Board of Trustees of the University of Illinois.
+ */
+#ifndef PARBOIL_HEADER
+#define PARBOIL_HEADER
+
+#include <stdio.h>
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <unistd.h>
+
+/* A platform as specified by the user on the command line */
+struct pb_PlatformParam {
+  char *name;                   /* The platform name.  This string is owned. */
+  char *version;                /* The platform version; may be NULL.
+                                 * This string is owned. */
+};
+
+/* Create a PlatformParam from the given strings.
+ * 'name' must not be NULL.  'version' may be NULL.
+ * If not NULL, the strings should have been allocated by malloc(),
+ * and they will be owned by the returned object.
+ */
+struct pb_PlatformParam *
+pb_PlatformParam(char *name, char *version);
+
+void
+pb_FreePlatformParam(struct pb_PlatformParam *);
+
+/* A criterion for how to select a device */
+enum pb_DeviceSelectionCriterion {
+  pb_Device_INDEX,             /* Enumerate the devices and select one
+                                * by its number */
+  pb_Device_CPU,                /* Select a CPU device */
+  pb_Device_GPU,                /* Select a GPU device  */
+  pb_Device_ACCELERATOR,        /* Select an accelerator device */
+  pb_Device_NAME                /* Select a device by name */
+};
+
+/* A device as specified by the user on the command line */
+struct pb_DeviceParam {
+  enum pb_DeviceSelectionCriterion criterion;
+  union {
+    int index;                  /* If criterion == pb_Device_INDEX,
+                                 * the index of the device */
+    char *name;                 /* If criterion == pb_Device_NAME,
+                                 * the name of the device.
+                                 * This string is owned. */
+  };
+};
+
+struct pb_DeviceParam *
+pb_DeviceParam_index(int index);
+
+struct pb_DeviceParam *
+pb_DeviceParam_cpu(void);
+
+struct pb_DeviceParam *
+pb_DeviceParam_gpu(void);
+
+struct pb_DeviceParam *
+pb_DeviceParam_accelerator(void);
+
+/* Create a by-name device selection criterion.
+ * The string should have been allocated by malloc(), and it will will be
+ * owned by the returned object.
+ */
+struct pb_DeviceParam *
+pb_DeviceParam_name(char *name);
+
+void
+pb_FreeDeviceParam(struct pb_DeviceParam *);
+
+/* Command line parameters for benchmarks */
+struct pb_Parameters {
+  char *outFile;		/* If not NULL, the raw output of the
+				 * computation should be saved to this
+				 * file. The string is owned. */
+  char **inpFiles;		/* A NULL-terminated array of strings
+				 * holding the input file(s) for the
+				 * computation.  The array and strings
+				 * are owned. */
+  struct pb_PlatformParam *platform; /* If not NULL, the platform
+                                      * specified on the command line. */
+  struct pb_DeviceParam *device; /* If not NULL, the device
+                                      * specified on the command line. */
+};
+
+/* Read command-line parameters.
+ *
+ * The argc and argv parameters to main are read, and any parameters
+ * interpreted by this function are removed from the argument list.
+ *
+ * A new instance of struct pb_Parameters is returned.
+ * If there is an error, then an error message is printed on stderr
+ * and NULL is returned.
+ */
+struct pb_Parameters *
+pb_ReadParameters(int *_argc, char **argv);
+
+/* Free an instance of struct pb_Parameters.
+ */
+void
+pb_FreeParameters(struct pb_Parameters *p);
+
+void
+pb_FreeStringArray(char **);
+
+/* Count the number of input files in a pb_Parameters instance.
+ */
+int
+pb_Parameters_CountInputs(struct pb_Parameters *p);
+
+/* A time or duration. */
+//#if _POSIX_VERSION >= 200112L
+typedef unsigned long long pb_Timestamp; /* time in microseconds */
+//#else
+//# error "Timestamps not implemented"
+//#endif
+
+enum pb_TimerState {
+  pb_Timer_STOPPED,
+  pb_Timer_RUNNING,
+};
+
+struct pb_Timer {
+  enum pb_TimerState state;
+  pb_Timestamp elapsed;		/* Amount of time elapsed so far */
+  pb_Timestamp init;		/* Beginning of the current time interval,
+				 * if state is RUNNING.  End of the last 
+				 * recorded time interfal otherwise.  */
+};
+
+/* Reset a timer.
+ * Use this to initialize a timer or to clear
+ * its elapsed time.  The reset timer is stopped.
+ */
+void
+pb_ResetTimer(struct pb_Timer *timer);
+
+/* Start a timer.  The timer is set to RUNNING mode and
+ * time elapsed while the timer is running is added to
+ * the timer.
+ * The timer should not already be running.
+ */
+void
+pb_StartTimer(struct pb_Timer *timer);
+
+/* Stop a timer.
+ * This stops adding elapsed time to the timer.
+ * The timer should not already be stopped.
+ */
+void
+pb_StopTimer(struct pb_Timer *timer);
+
+/* Get the elapsed time in seconds. */
+double
+pb_GetElapsedTime(struct pb_Timer *timer);
+
+/* Execution time is assigned to one of these categories. */
+enum pb_TimerID {
+  pb_TimerID_NONE = 0,
+  pb_TimerID_IO,		/* Time spent in input/output */
+  pb_TimerID_KERNEL,		/* Time spent computing on the device, 
+				 * recorded asynchronously */
+  pb_TimerID_COPY,		/* Time spent synchronously moving data 
+				 * to/from device and allocating/freeing 
+				 * memory on the device */
+  pb_TimerID_DRIVER,		/* Time spent in the host interacting with the 
+				 * driver, primarily for recording the time 
+                                 * spent queueing asynchronous operations */
+  pb_TimerID_COPY_ASYNC,	/* Time spent in asynchronous transfers */
+  pb_TimerID_COMPUTE,		/* Time for all program execution other
+				 * than parsing command line arguments,
+				 * I/O, kernel, and copy */
+  pb_TimerID_OVERLAP,		/* Time double-counted in asynchronous and 
+				 * host activity: automatically filled in, 
+				 * not intended for direct usage */
+  pb_TimerID_LAST		/* Number of timer IDs */
+};
+
+/* Dynamic list of asynchronously tracked times between events */
+struct pb_async_time_marker_list {
+  char *label; // actually just a pointer to a string
+  enum pb_TimerID timerID;	/* The ID to which the interval beginning 
+                                 * with this marker should be attributed */
+  void * marker; 
+  //cudaEvent_t marker; 		/* The driver event for this marker */
+  struct pb_async_time_marker_list *next; 
+};
+
+struct pb_SubTimer {
+  char *label;
+  struct pb_Timer timer;
+  struct pb_SubTimer *next;
+};
+
+struct pb_SubTimerList {
+  struct pb_SubTimer *current;
+  struct pb_SubTimer *subtimer_list;
+};
+
+/* A set of timers for recording execution times. */
+struct pb_TimerSet {
+  enum pb_TimerID current;
+  struct pb_async_time_marker_list* async_markers;
+  pb_Timestamp async_begin;
+  pb_Timestamp wall_begin;
+  struct pb_Timer timers[pb_TimerID_LAST];
+  struct pb_SubTimerList *sub_timer_list[pb_TimerID_LAST];
+};
+
+/* Reset all timers in the set. */
+void
+pb_InitializeTimerSet(struct pb_TimerSet *timers);
+
+void
+pb_AddSubTimer(struct pb_TimerSet *timers, char *label, enum pb_TimerID pb_Category);
+
+/* Select which timer the next interval of time should be accounted
+ * to. The selected timer is started and other timers are stopped.
+ * Using pb_TimerID_NONE stops all timers. */
+void
+pb_SwitchToTimer(struct pb_TimerSet *timers, enum pb_TimerID timer);
+
+void
+pb_SwitchToSubTimer(struct pb_TimerSet *timers, char *label, enum pb_TimerID category);
+
+/* Print timer values to standard output. */
+void
+pb_PrintTimerSet(struct pb_TimerSet *timers);
+
+/* Release timer resources */
+void
+pb_DestroyTimerSet(struct pb_TimerSet * timers);
+
+void
+pb_SetOpenCL(void *clContextPtr, void *clCommandQueuePtr);
+
+
+typedef struct pb_Device_tag {
+  char* name;
+  void* clDevice;
+  int id;
+  unsigned int in_use;
+  unsigned int available;
+} pb_Device;
+
+struct pb_Context_tag;
+typedef struct pb_Context_tag pb_Context;
+
+typedef struct pb_Platform_tag {
+  char* name;
+  char* version;
+  void* clPlatform;
+  unsigned int in_use;
+  pb_Context** contexts;
+  pb_Device** devices;
+} pb_Platform;
+
+struct pb_Context_tag {
+  void* clPlatformId;
+  void* clContext;
+  void* clDeviceId;
+  pb_Platform* pb_platform;
+  pb_Device* pb_device;
+};
+
+// verbosely print out list of platforms and their devices to the console.
+pb_Platform**
+pb_GetPlatforms();
+
+// Choose a platform according to the given platform specification
+pb_Platform*
+pb_GetPlatform(struct pb_PlatformParam *platform);
+
+// choose a platform: by name, name & version
+pb_Platform*
+pb_GetPlatformByName(const char* name);
+
+pb_Platform*
+pb_GetPlatformByNameAndVersion(const char* name, const char* version);
+
+// Choose a device according to the given device specification
+pb_Device*
+pb_GetDevice(pb_Platform* pb_platform, struct pb_DeviceParam *device);
+
+pb_Device**
+pb_GetDevices(pb_Platform* pb_platform);
+
+// choose a device by name.
+pb_Device*
+pb_GetDeviceByName(pb_Platform* pb_platform, const char* name);
+
+pb_Platform*
+pb_GetPlatformByEnvVars();
+
+pb_Context*
+pb_InitOpenCLContext(struct pb_Parameters* parameters);
+
+void
+pb_ReleasePlatforms();
+
+void
+pb_ReleaseContext(pb_Context* c);
+
+void
+pb_PrintPlatformInfo(pb_Context* c);
+
+void
+perf_init();
+
+//#define MEASURE_KERNEL_TIME
+
+#include <CL/cl.h>
+
+#ifdef MEASURE_KERNEL_TIME
+#define clEnqueueNDRangeKernel(q,k,d,o,dg,db,a,b,c) pb_clEnqueueNDRangeKernel((q), (k), (d), (o), (dg), (db), (a), (b), (c))
+cl_int
+pb_clEnqueueNDRangeKernel(cl_command_queue /* command_queue */,
+                       cl_kernel        /* kernel */,
+                       cl_uint          /* work_dim */,
+                       const size_t *   /* global_work_offset */,
+                       const size_t *   /* global_work_size */,
+                       const size_t *   /* local_work_size */,
+                       cl_uint          /* num_events_in_wait_list */,
+                       const cl_event * /* event_wait_list */,
+                       cl_event *       /* event */);
+#endif
+
+enum { T_FLOAT, T_DOUBLE, T_SHORT, T_INT, T_UCHAR };
+void pb_sig_float(char*, float*, int);
+void pb_sig_double(char*, double*, int);
+void pb_sig_short(char*, short*, int);
+void pb_sig_int(char*, int*, int);
+void pb_sig_uchar(char*, unsigned char*, unsigned int);
+void pb_sig_clmem(char*, cl_command_queue, cl_mem, int);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //PARBOIL_HEADER
+

benchmarks/opencl/mri-q/Makefile

@@ -0,0 +1,67 @@
+RISCV_TOOL_PATH ?= $(wildcard ../../../../riscv-gnu-toolchain/drops)
+POCL_CC_PATH ?= $(wildcard ../../../../pocl/drops_riscv_cc)
+POCL_INC_PATH ?= $(wildcard ../include)
+POCL_LIB_PATH ?= $(wildcard ../lib)
+VX_RT_PATH ?= $(wildcard ../../../runtime)
+VX_SIMX_PATH ?= $(wildcard ../../../simX/obj_dir)
+
+CC  = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-gcc
+CXX = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-g++
+DMP = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-objdump
+HEX = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-objcopy
+GDB = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-gdb
+
+VX_SRCS =  $(VX_RT_PATH)/newlib/newlib.c
+VX_SRCS += $(VX_RT_PATH)/startup/vx_start.S
+VX_SRCS += $(VX_RT_PATH)/intrinsics/vx_intrinsics.S
+VX_SRCS += $(VX_RT_PATH)/io/vx_io.S $(VX_RT_PATH)/io/vx_io.c
+VX_SRCS += $(VX_RT_PATH)/fileio/fileio.S
+VX_SRCS += $(VX_RT_PATH)/tests/tests.c
+VX_SRCS += $(VX_RT_PATH)/vx_api/vx_api.c
+
+VX_CFLAGS = -nostartfiles -Wl,-Bstatic,-T,$(VX_RT_PATH)/startup/vx_link.ld
+
+CXXFLAGS =  -g -O0 -march=rv32im -mabi=ilp32 
+CXXFLAGS += -ffreestanding # program may not begin at main()
+CXXFLAGS += -Wl,--gc-sections # enable garbage collection of unused input sections
+CXXFLAGS += -fno-rtti -fno-non-call-exceptions # disable RTTI and exceptions
+CXXFLAGS += -I$(POCL_INC_PATH) -I.
+
+VX_LIBS = -Wl,--whole-archive lib$(PROJECT).a -Wl,--no-whole-archive $(POCL_LIB_PATH)/libOpenCL.a
+QEMU_LIBS = $(VX_RT_PATH)/qemu/vx_api.c -Wl,--whole-archive lib$(PROJECT).a -Wl,--no-whole-archive $(POCL_LIB_PATH)/libOpenCL.a
+
+PROJECT = mri-q
+
+SRCS = main.cc args.c parboil_opencl.c ocl.c gpu_info.c file.cc computeQ.c
+
+all: $(PROJECT).dump $(PROJECT).hex
+
+lib$(PROJECT).a: kernel.cl
+	POCL_DEBUG=all POCL_DEBUG_LLVM_PASSES=1 LD_LIBRARY_PATH=$(RISCV_TOOL_PATH)/lib:$(POCL_CC_PATH)/lib $(POCL_CC_PATH)/bin/poclcc -o lib$(PROJECT).a kernel.cl
+
+$(PROJECT).elf: $(SRCS) lib$(PROJECT).a
+	$(CXX) $(CXXFLAGS) $(VX_CFLAGS) $(VX_SRCS) $(SRCS) $(VX_LIBS) -o $(PROJECT).elf
+
+$(PROJECT).qemu: $(SRCS) lib$(PROJECT).a
+	$(CXX) $(CXXFLAGS) $(SRCS) $(QEMU_LIBS) -o $(PROJECT).qemu
+
+$(PROJECT).hex: $(PROJECT).elf
+	$(HEX) -O ihex $(PROJECT).elf $(PROJECT).hex
+
+$(PROJECT).dump: $(PROJECT).elf
+	$(DMP) -D $(PROJECT).elf > $(PROJECT).dump
+
+run: $(PROJECT).hex
+	POCL_DEBUG=all $(VX_SIMX_PATH)/Vcache_simX -E -a rv32i --core $(PROJECT).hex -s -b 1> emulator.debug
+
+qemu: $(PROJECT).qemu
+	POCL_DEBUG=all $(RISCV_TOOL_PATH)/bin/qemu-riscv32 -d in_asm -D debug.log $(PROJECT).qemu
+
+gdb-s: $(PROJECT).qemu
+	POCL_DEBUG=all $(RISCV_TOOL_PATH)/bin/qemu-riscv32 -g 1234 -d in_asm -D debug.log $(PROJECT).qemu
+
+gdb-c: $(PROJECT).qemu
+	$(GDB) $(PROJECT).qemu
+
+clean:
+	rm -rf *.o *.elf *.dump *.hex *.qemu *.log *.debug

benchmarks/opencl/mri-q/args.c

@@ -0,0 +1,617 @@
+
+#include <parboil.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+/*****************************************************************************/
+/* Memory management routines */
+
+/* Free an array of owned strings. */
+void
+pb_FreeStringArray(char **string_array)
+{
+  char **p;
+
+  if (!string_array) return;
+  for (p = string_array; *p; p++) free(*p);
+  free(string_array);
+}
+
+struct pb_PlatformParam *
+pb_PlatformParam(char *name, char *version)
+{
+  if (name == NULL) {
+    fprintf(stderr, "pb_PlatformParam: Invalid argument\n");
+    exit(-1);
+  }
+
+  struct pb_PlatformParam *ret =
+    (struct pb_PlatformParam *)malloc(sizeof (struct pb_PlatformParam));
+
+  ret->name = name;
+  ret->version = version;
+  return ret;
+}
+
+void
+pb_FreePlatformParam(struct pb_PlatformParam *p)
+{
+  if (p == NULL) return;
+
+  free(p->name);
+  free(p->version);
+  free(p);
+}
+
+struct pb_DeviceParam *
+pb_DeviceParam_index(int index)
+{
+  struct pb_DeviceParam *ret =
+    (struct pb_DeviceParam *)malloc(sizeof (struct pb_DeviceParam));
+  ret->criterion = pb_Device_INDEX;
+  ret->index = index;
+  return ret;
+}
+
+struct pb_DeviceParam *
+pb_DeviceParam_cpu(void)
+{
+  struct pb_DeviceParam *ret =
+    (struct pb_DeviceParam *)malloc(sizeof (struct pb_DeviceParam));
+  ret->criterion = pb_Device_CPU;
+  return ret;
+}
+
+struct pb_DeviceParam *
+pb_DeviceParam_gpu(void)
+{
+  struct pb_DeviceParam *ret =
+    (struct pb_DeviceParam *)malloc(sizeof (struct pb_DeviceParam));
+  ret->criterion = pb_Device_GPU;
+  return ret;
+}
+
+struct pb_DeviceParam *
+pb_DeviceParam_accelerator(void)
+{
+  struct pb_DeviceParam *ret =
+    (struct pb_DeviceParam *)malloc(sizeof (struct pb_DeviceParam));
+  ret->criterion = pb_Device_ACCELERATOR;
+  return ret;
+}
+
+struct pb_DeviceParam *
+pb_DeviceParam_name(char *name)
+{
+  struct pb_DeviceParam *ret =
+    (struct pb_DeviceParam *)malloc(sizeof (struct pb_DeviceParam));
+  ret->criterion = pb_Device_NAME;
+  ret->name = name;
+  return ret;
+}
+
+void
+pb_FreeDeviceParam(struct pb_DeviceParam *p)
+{
+  if (p == NULL) return;
+
+  switch(p->criterion) {
+  case pb_Device_NAME:
+    free(p->name);
+    break;
+  case pb_Device_INDEX:
+  case pb_Device_CPU:
+  case pb_Device_ACCELERATOR:
+    break;
+  default:
+    fprintf(stderr, "pb_FreeDeviceParam: Invalid argument\n");
+    exit(-1);
+  }
+}
+
+void
+pb_FreeParameters(struct pb_Parameters *p)
+{
+  free(p->outFile);
+  pb_FreeStringArray(p->inpFiles);
+  pb_FreePlatformParam(p->platform);
+  pb_FreeDeviceParam(p->device);
+  free(p);
+}
+
+/*****************************************************************************/
+
+/* Parse a comma-delimited list of strings into an
+ * array of strings. */
+static char ** 
+read_string_array(char *in)
+{
+  char **ret;
+  int i;
+  int count;			/* Number of items in the input */
+  char *substring;		/* Current substring within 'in' */
+
+  /* Count the number of items in the string */
+  count = 1;
+  for (i = 0; in[i]; i++) if (in[i] == ',') count++;
+
+  /* Allocate storage */
+  ret = (char **)malloc((count + 1) * sizeof(char *));
+
+  /* Create copies of the strings from the list */
+  substring = in;
+  for (i = 0; i < count; i++) {
+    char *substring_end;
+    int substring_length;
+
+    /* Find length of substring */
+    for (substring_end = substring;
+	 (*substring_end != ',') && (*substring_end != 0);
+	 substring_end++);
+
+    substring_length = substring_end - substring;
+
+    /* Allocate memory and copy the substring */
+    ret[i] = (char *)malloc(substring_length + 1);
+    memcpy(ret[i], substring, substring_length);
+    ret[i][substring_length] = 0;
+
+    /* go to next substring */
+    substring = substring_end + 1;
+  }
+  ret[i] = NULL;		/* Write the sentinel value */
+
+  return ret;
+}
+
+static void
+report_parse_error(const char *str)
+{
+  fputs(str, stderr);
+}
+
+/* Interpret a string as a 'pb_DeviceParam' value.
+ * Return a pointer to a new value, or NULL on failure.
+ */
+static struct pb_DeviceParam *
+read_device_param(char *str)
+{  
+  /* Try different ways of interpreting 'device_string' until one works */
+
+  /* If argument is an integer, then interpret it as a device index */
+  errno = 0;
+  char *end;
+  long device_int = strtol(str, &end, 10);
+  if (!errno) {
+    /* Negative numbers are not valid */
+    if (device_int < 0 || device_int > INT_MAX) return NULL;
+
+    return pb_DeviceParam_index(device_int);
+  }
+
+  /* Match against predefined strings */
+  if (strcmp(str, "CPU") == 0)
+    return pb_DeviceParam_cpu();
+  if (strcmp(str, "GPU") == 0)
+    return pb_DeviceParam_gpu();
+  if (strcmp(str, "ACCELERATOR") == 0)
+    return pb_DeviceParam_accelerator();
+
+  /* Assume any other string is a device name */
+  return pb_DeviceParam_name(strdup(str));
+}
+
+/* Interpret a string as a 'pb_PlatformParam' value.
+ * Return a pointer to a new value, or NULL on failure.
+ */
+static struct pb_PlatformParam *
+read_platform_param(char *str)
+{
+  int separator_index;          /* Index of the '-' character separating
+                                 * name and version number.  It's -1 if
+                                 * there's no '-' character. */
+
+  /* Find the last occurrence of '-' in 'str' */
+  {
+    char *cur;
+    separator_index = -1;
+    for (cur = str; *cur; cur++) {
+      if (*cur == '-') separator_index = cur - str;
+    }
+  }
+
+  /* The platform name is either the entire string, or all characters before
+   * the separator */
+  int name_length = separator_index == -1 ? strlen(str) : separator_index;
+  char *name_str = (char *)malloc(name_length + 1);
+  memcpy(name_str, str, name_length);
+  name_str[name_length] = 0;
+
+  /* The version is either NULL, or all characters after the separator */
+  char *version_str;
+  if (separator_index == -1) {
+    version_str = NULL;
+  }
+  else {
+    const char *version_input_str = str + separator_index + 1;
+    int version_length = strlen(version_input_str);
+
+    version_str = (char *)malloc(version_length + 1);
+    memcpy(version_str, version_input_str, version_length);
+    version_str[version_length] = 0;
+  }
+
+  /* Create output structure */
+  return pb_PlatformParam(name_str, version_str);
+}
+
+/****************************************************************************/
+/* Argument parsing state */
+
+/* Argument parsing state.
+ *
+ * Arguments that are interpreted by the argument parser are removed from
+ * the list.  Variables 'argc' and 'argn' do not count arguments that have
+ * been removed.
+ *
+ * During argument parsing, the array of arguments is compacted, overwriting
+ * the erased arguments.  Variable 'argv_put' points to the array element
+ * where the next argument will be written.  Variable 'argv_get' points to
+ * the array element where the next argument will be read from.
+ */
+struct argparse {
+  int argc;			/* Number of arguments.  Mutable. */
+  int argn;			/* Current argument index. */
+  char **argv_get;		/* Argument value being read. */
+  char **argv_put;		/* Argument value being written.
+				 * argv_put <= argv_get. */
+};
+
+static void
+initialize_argparse(struct argparse *ap, int argc, char **argv)
+{
+  ap->argc = argc;
+  ap->argn = 0;
+  ap->argv_get = ap->argv_put = argv;
+}
+
+/* Finish argument parsing, without processing the remaining arguments.
+ * Write new argument count into _argc. */
+static void
+finalize_argparse(struct argparse *ap, int *_argc, char **argv)
+{
+  /* Move the remaining arguments */
+  for(; ap->argn < ap->argc; ap->argn++)
+    *ap->argv_put++ = *ap->argv_get++;
+
+  /* Update the argument count */
+  *_argc = ap->argc;
+
+  /* Insert a terminating NULL */
+  argv[ap->argc] = NULL;
+}
+
+/* Delete the current argument.  The argument will not be visible
+ * when argument parsing is done. */
+static void
+delete_argument(struct argparse *ap)
+{
+  if (ap->argn >= ap->argc) {
+    fprintf(stderr, "delete_argument\n");
+  }
+  ap->argc--;
+  ap->argv_get++;
+}
+
+/* Go to the next argument.  Also, move the current argument to its
+ * final location in argv. */
+static void
+next_argument(struct argparse *ap)
+{
+  if (ap->argn >= ap->argc) {
+    fprintf(stderr, "next_argument\n");
+  }
+  /* Move argument to its new location. */
+  *ap->argv_put++ = *ap->argv_get++;
+  ap->argn++;
+}
+
+static int
+is_end_of_arguments(struct argparse *ap)
+{
+  return ap->argn == ap->argc;
+}
+
+/* Get the current argument */
+static char *
+get_argument(struct argparse *ap)
+{
+  return *ap->argv_get;
+}
+
+/* Get the current argument, and also delete it */
+static char *
+consume_argument(struct argparse *ap)
+{
+  char *ret = get_argument(ap);
+  delete_argument(ap);
+  return ret;
+}
+
+/****************************************************************************/
+
+/* The result of parsing a command-line argument */
+typedef enum {
+  ARGPARSE_OK,                  /* Success */
+  ARGPARSE_ERROR,               /* Error */
+  ARGPARSE_DONE                 /* Success, and do not continue parsing */
+} result;
+
+typedef result parse_action(struct argparse *ap, struct pb_Parameters *params);
+
+
+/* A command-line option */
+struct option {
+  char short_name;              /* If not 0, the one-character
+                                 * name of this option */
+  const char *long_name;        /* If not NULL, the long name of this option */
+  parse_action *action;       /* What to do when this option occurs.
+                               * Sentinel value is NULL.
+                               */
+};
+
+/* Output file
+ *
+ * -o FILE
+ */
+static result
+parse_output_file(struct argparse *ap, struct pb_Parameters *params)
+{
+  if (is_end_of_arguments(ap))
+    {
+      report_parse_error("Expecting file name after '-o'\n");
+      return ARGPARSE_ERROR;
+    }
+
+  /* Replace the output file name */
+  free(params->outFile);
+  params->outFile = strdup(consume_argument(ap));
+
+  return ARGPARSE_OK;
+}
+
+/* Input files
+ *
+ * -i FILE,FILE,...
+ */
+static result
+parse_input_files(struct argparse *ap, struct pb_Parameters *params)
+{
+  if (is_end_of_arguments(ap))
+    {
+      report_parse_error("Expecting file name after '-i'\n");
+      return ARGPARSE_ERROR;
+    }
+
+  /* Replace the input file list */
+  pb_FreeStringArray(params->inpFiles);
+  params->inpFiles = read_string_array(consume_argument(ap));
+  return ARGPARSE_OK;
+}
+
+/* End of options
+ *
+ * --
+ */
+
+static result
+parse_end_options(struct argparse *ap, struct pb_Parameters *params)
+{
+  return ARGPARSE_DONE;
+}
+
+/* OpenCL device
+ *
+ * --device X
+ */
+
+static result
+parse_device(struct argparse *ap, struct pb_Parameters *params)
+{
+  /* Read the next argument, which specifies a device */
+
+  if (is_end_of_arguments(ap))
+    {
+      report_parse_error("Expecting device specification after '--device'\n");
+      return ARGPARSE_ERROR;
+    }
+
+  char *device_string = consume_argument(ap);
+  struct pb_DeviceParam *device_param = read_device_param(device_string);
+
+  if (!device_param) {
+    report_parse_error("Unrecognized device specification format on command line\n");
+    return ARGPARSE_ERROR;
+  }
+
+  /* Save the result */
+  pb_FreeDeviceParam(params->device);
+  params->device = device_param;
+
+  return ARGPARSE_OK;
+}
+
+static result
+parse_platform(struct argparse *ap, struct pb_Parameters *params)
+{
+  /* Read the next argument, which specifies a platform */
+
+  if (is_end_of_arguments(ap))
+    {
+      report_parse_error("Expecting device specification after '--platform'\n");
+      return ARGPARSE_ERROR;
+    }
+
+  char *platform_string = consume_argument(ap);
+  struct pb_PlatformParam *platform_param = read_platform_param(platform_string);
+
+  if (!platform_param) {
+    report_parse_error("Unrecognized platform specification format on command line\n");
+    return ARGPARSE_ERROR;
+  }
+
+  /* Save the result */
+  pb_FreePlatformParam(params->platform);
+  params->platform = platform_param;
+
+  return ARGPARSE_OK;
+}
+  
+
+static struct option options[] = {
+  { 'o', NULL, &parse_output_file },
+  { 'i', NULL, &parse_input_files },
+  { '-', NULL, &parse_end_options },
+  { 0, "device", &parse_device },
+  { 0, "platform", &parse_platform },
+  { 0, NULL, NULL }
+};
+
+static int
+is_last_option(struct option *op)
+{
+  return op->action == NULL;
+}
+
+/****************************************************************************/
+
+/* Parse command-line parameters.
+ * Return zero on error, nonzero otherwise.
+ * On error, the other outputs may be invalid.
+ *
+ * The information collected from parameters is used to update
+ * 'ret'.  'ret' should be initialized.
+ *
+ * '_argc' and 'argv' are updated to contain only the unprocessed arguments.
+ */
+static int
+pb_ParseParameters (struct pb_Parameters *ret, int *_argc, char **argv)
+{
+  char *err_message;
+  struct argparse ap;
+
+  /* Each argument */
+  initialize_argparse(&ap, *_argc, argv);
+  while(!is_end_of_arguments(&ap)) {
+    result arg_result;          /* Result of parsing this option */
+    char *arg = get_argument(&ap);
+
+    /* Process this argument */
+    if (arg[0] == '-') {
+      /* Single-character flag */
+      if ((arg[1] != 0) && (arg[2] == 0)) {
+        delete_argument(&ap);	/* This argument is consumed here */
+
+        /* Find a matching short option */
+        struct option *op;
+        for (op = options; !is_last_option(op); op++) {
+          if (op->short_name == arg[1]) {
+            arg_result = (*op->action)(&ap, ret);
+            goto option_was_processed;
+          }
+        }
+
+        /* No option matches */
+        report_parse_error("Unexpected command-line parameter\n");
+        arg_result = ARGPARSE_ERROR;
+        goto option_was_processed;
+      }
+
+      /* Long flag */
+      if (arg[1] == '-') {
+        delete_argument(&ap);	/* This argument is consumed here */
+
+        /* Find a matching long option */
+        struct option *op;
+        for (op = options; !is_last_option(op); op++) {
+          if (op->long_name && strcmp(&arg[2], op->long_name) == 0) {
+            arg_result = (*op->action)(&ap, ret);
+            goto option_was_processed;
+          }
+        }
+
+        /* No option matches */
+        report_parse_error("Unexpected command-line parameter\n");
+        arg_result = ARGPARSE_ERROR;
+        goto option_was_processed;
+      }
+    }
+    else {
+      /* Other arguments are ignored */
+      next_argument(&ap);
+      arg_result = ARGPARSE_OK;
+      goto option_was_processed;
+    }
+
+  option_was_processed:
+    /* Decide what to do next based on 'arg_result' */
+    switch(arg_result) {
+    case ARGPARSE_OK:
+      /* Continue processing */
+      break;
+
+    case ARGPARSE_ERROR:
+      /* Error exit from the function */
+      return 0;
+
+    case ARGPARSE_DONE:
+      /* Normal exit from the argument parsing loop */
+      goto end_of_options;
+    }
+  } /* end for each argument */
+
+  /* If all arguments were processed, then normal exit from the loop */
+
+ end_of_options:
+  finalize_argparse(&ap, _argc, argv);
+  return 1;
+}
+
+/*****************************************************************************/
+/* Other exported functions */
+
+struct pb_Parameters *
+pb_ReadParameters(int *_argc, char **argv)
+{
+  struct pb_Parameters *ret =
+    (struct pb_Parameters *)malloc(sizeof(struct pb_Parameters));
+
+  /* Initialize the parameters structure */
+  ret->outFile = NULL;
+  ret->inpFiles = (char **)malloc(sizeof(char *));
+  ret->inpFiles[0] = NULL;
+  ret->platform = NULL;
+  ret->device = NULL;
+
+  /* Read parameters and update _argc, argv */
+  if (!pb_ParseParameters(ret, _argc, argv)) {
+    /* Parse error */
+    pb_FreeParameters(ret);
+    return NULL;
+  }
+
+  return ret;
+}
+
+int
+pb_Parameters_CountInputs(struct pb_Parameters *p)
+{
+  int n;
+
+  for (n = 0; p->inpFiles[n]; n++);
+  return n;
+}
+

benchmarks/opencl/mri-q/computeQ.c

@@ -0,0 +1,118 @@
+/***************************************************************************
+ *cr
+ *cr            (C) Copyright 2007 The Board of Trustees of the
+ *cr                        University of Illinois
+ *cr                         All Rights Reserved
+ *cr
+ ***************************************************************************/
+
+#include <stdio.h>
+#include <malloc.h>
+#include <CL/cl.h>
+#include "ocl.h"
+#include "macros.h"
+#include "computeQ.h"
+#include "parboil.h"
+
+#define NC 1
+
+void computePhiMag_GPU(int numK,cl_mem phiR_d,cl_mem phiI_d,cl_mem phiMag_d,clPrmtr* clPrm)
+{
+  int phiMagBlocks = numK / KERNEL_PHI_MAG_THREADS_PER_BLOCK;
+  if (numK % KERNEL_PHI_MAG_THREADS_PER_BLOCK)
+    phiMagBlocks++;
+  
+  size_t DimPhiMagBlock = KERNEL_PHI_MAG_THREADS_PER_BLOCK;
+  size_t DimPhiMagGrid = phiMagBlocks*KERNEL_PHI_MAG_THREADS_PER_BLOCK;
+
+  cl_int clStatus;
+  clStatus = clSetKernelArg(clPrm->clKernel,0,sizeof(cl_mem),&phiR_d);
+  clStatus = clSetKernelArg(clPrm->clKernel,1,sizeof(cl_mem),&phiI_d);
+  clStatus = clSetKernelArg(clPrm->clKernel,2,sizeof(cl_mem),&phiMag_d);
+  clStatus = clSetKernelArg(clPrm->clKernel,3,sizeof(int),&numK);
+  CHECK_ERROR("clSetKernelArg")
+
+  clStatus = clEnqueueNDRangeKernel(clPrm->clCommandQueue,clPrm->clKernel,1,NULL,&DimPhiMagGrid,&DimPhiMagBlock,0,NULL,NULL);
+  CHECK_ERROR("clEnqueueNDRangeKernel")
+}
+
+static
+unsigned long long int
+readElapsedTime(cl_event internal)
+{
+  cl_int status;
+  cl_ulong t_begin, t_end;
+  status = clGetEventProfilingInfo(internal, CL_PROFILING_COMMAND_START,
+    sizeof(cl_ulong), &t_begin, NULL);
+  if (status != CL_SUCCESS) return 0;
+  status = clGetEventProfilingInfo(internal, CL_PROFILING_COMMAND_END,
+  sizeof(cl_ulong), &t_end, NULL);
+  if (status != CL_SUCCESS) return 0;
+  return (unsigned long long int)(t_end - t_begin);
+}
+
+
+void computeQ_GPU (int numK,int numX,
+		   cl_mem x_d, cl_mem y_d, cl_mem z_d,
+		   struct kValues* kVals,
+		   cl_mem Qr_d, cl_mem Qi_d,
+		   clPrmtr* clPrm)
+{
+  int QGrids = numK / KERNEL_Q_K_ELEMS_PER_GRID;
+  if (numK % KERNEL_Q_K_ELEMS_PER_GRID)
+    QGrids++;
+  int QBlocks = numX / KERNEL_Q_THREADS_PER_BLOCK;
+  if (numX % KERNEL_Q_THREADS_PER_BLOCK)
+    QBlocks++;
+
+  size_t DimQBlock = KERNEL_Q_THREADS_PER_BLOCK/NC;
+  size_t DimQGrid = QBlocks*KERNEL_Q_THREADS_PER_BLOCK/NC;
+
+  cl_int clStatus;
+  cl_mem ck;
+  ck = clCreateBuffer(clPrm->clContext,CL_MEM_READ_WRITE,KERNEL_Q_K_ELEMS_PER_GRID*sizeof(struct kValues),NULL,&clStatus);
+
+  int QGrid;
+  for (QGrid = 0; QGrid < QGrids; QGrid++) {
+    // Put the tile of K values into constant mem
+    int QGridBase = QGrid * KERNEL_Q_K_ELEMS_PER_GRID;
+    struct kValues* kValsTile = kVals + QGridBase;
+    int numElems = MIN(KERNEL_Q_K_ELEMS_PER_GRID, numK - QGridBase);
+
+    clStatus = clEnqueueWriteBuffer(clPrm->clCommandQueue,ck,CL_TRUE,0,numElems*sizeof(struct kValues),kValsTile,0,NULL,NULL);
+    CHECK_ERROR("clEnqueueWriteBuffer")
+    
+    clStatus = clSetKernelArg(clPrm->clKernel,0,sizeof(int),&numK);
+    clStatus = clSetKernelArg(clPrm->clKernel,1,sizeof(int),&QGridBase);
+    clStatus = clSetKernelArg(clPrm->clKernel,2,sizeof(cl_mem),&x_d);
+    clStatus = clSetKernelArg(clPrm->clKernel,3,sizeof(cl_mem),&y_d);
+    clStatus = clSetKernelArg(clPrm->clKernel,4,sizeof(cl_mem),&z_d);
+    clStatus = clSetKernelArg(clPrm->clKernel,5,sizeof(cl_mem),&Qr_d);
+    clStatus = clSetKernelArg(clPrm->clKernel,6,sizeof(cl_mem),&Qi_d);
+    clStatus = clSetKernelArg(clPrm->clKernel,7,sizeof(cl_mem),&ck);
+    CHECK_ERROR("clSetKernelArg")
+
+    printf ("Grid: %d, Block: %d\n", DimQGrid, DimQBlock);
+
+    #define TIMED_EXECUTION
+    #ifdef TIMED_EXECUTION
+    cl_event e;
+    clStatus = clEnqueueNDRangeKernel(clPrm->clCommandQueue,clPrm->clKernel,1,NULL,&DimQGrid,&DimQBlock,0,NULL,&e);
+    CHECK_ERROR("clEnqueueNDRangeKernel")
+    clWaitForEvents(1, &e);
+    printf ("%llu\n", readElapsedTime(e));
+    #else
+    clStatus = clEnqueueNDRangeKernel(clPrm->clCommandQueue,clPrm->clKernel,1,NULL,&DimQGrid,&DimQBlock,0,NULL,NULL);
+    CHECK_ERROR("clEnqueueNDRangeKernel")
+    #endif
+  }
+}
+
+void createDataStructsCPU(int numK, int numX, float** phiMag,
+	 float** Qr, float** Qi)
+{
+  *phiMag = (float* ) memalign(16, numK * sizeof(float));
+  *Qr = (float*) memalign(16, numX * sizeof (float));
+  *Qi = (float*) memalign(16, numX * sizeof (float));
+}
+

benchmarks/opencl/mri-q/computeQ.h

@@ -0,0 +1,14 @@
+#ifndef __COMPUTEQ__
+#define __COMPUTEQ__
+
+void computePhiMag_GPU(int numK,cl_mem phiR_d,cl_mem phiI_d,cl_mem phiMag_d,clPrmtr* clPrm);
+void computeQ_GPU (int numK,int numX,
+		   cl_mem x_d, cl_mem y_d, cl_mem z_d,
+		   struct kValues* kVals,
+		   cl_mem Qr_d, cl_mem Qi_d,
+		   clPrmtr* clPrm);
+
+void createDataStructsCPU(int numK, int numX, float** phiMag,
+	 		  float** Qr, float** Qi);
+
+#endif

benchmarks/opencl/mri-q/file.cc

@@ -0,0 +1,78 @@
+/***************************************************************************
+ *cr
+ *cr            (C) Copyright 2007 The Board of Trustees of the
+ *cr                        University of Illinois
+ *cr                         All Rights Reserved
+ *cr
+ ***************************************************************************/
+
+//#include <endian.h>
+#include <stdlib.h>
+#include <malloc.h>
+#include <stdio.h>
+#include <inttypes.h>
+
+#include "file.h"
+
+#if __BYTE_ORDER != __LITTLE_ENDIAN
+# error "File I/O is not implemented for this system: wrong endianness."
+#endif
+
+extern "C"
+void inputData(char* fName, int* _numK, int* _numX,
+               float** kx, float** ky, float** kz,
+               float** x, float** y, float** z,
+               float** phiR, float** phiI)
+{
+  int numK, numX;
+  FILE* fid = fopen(fName, "r");
+
+  if (fid == NULL)
+    {
+      fprintf(stderr, "Cannot open input file\n");
+      exit(-1);
+    }
+  fread (&numK, sizeof (int), 1, fid);
+  *_numK = numK;
+  fread (&numX, sizeof (int), 1, fid);
+  *_numX = numX;
+  *kx = (float *) memalign(16, numK * sizeof (float));
+  fread (*kx, sizeof (float), numK, fid);
+  *ky = (float *) memalign(16, numK * sizeof (float));
+  fread (*ky, sizeof (float), numK, fid);
+  *kz = (float *) memalign(16, numK * sizeof (float));
+  fread (*kz, sizeof (float), numK, fid);
+  *x = (float *) memalign(16, numX * sizeof (float));
+  fread (*x, sizeof (float), numX, fid);
+  *y = (float *) memalign(16, numX * sizeof (float));
+  fread (*y, sizeof (float), numX, fid);
+  *z = (float *) memalign(16, numX * sizeof (float));
+  fread (*z, sizeof (float), numX, fid);
+  *phiR = (float *) memalign(16, numK * sizeof (float));
+  fread (*phiR, sizeof (float), numK, fid);
+  *phiI = (float *) memalign(16, numK * sizeof (float));
+  fread (*phiI, sizeof (float), numK, fid);
+  fclose (fid); 
+}
+
+extern "C"
+void outputData(char* fName, float* outR, float* outI, int numX)
+{
+  FILE* fid = fopen(fName, "w");
+  uint32_t tmp32;
+
+  if (fid == NULL)
+    {
+      fprintf(stderr, "Cannot open output file\n");
+      exit(-1);
+    }
+
+  /* Write the data size */
+  tmp32 = numX;
+  fwrite(&tmp32, sizeof(uint32_t), 1, fid);
+
+  /* Write the reconstructed data */
+  fwrite (outR, sizeof (float), numX, fid);
+  fwrite (outI, sizeof (float), numX, fid);
+  fclose (fid);
+}

benchmarks/opencl/mri-q/file.h

@@ -0,0 +1,22 @@
+/***************************************************************************
+ *cr
+ *cr            (C) Copyright 2007 The Board of Trustees of the
+ *cr                        University of Illinois
+ *cr                         All Rights Reserved
+ *cr
+ ***************************************************************************/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void inputData(char* fName, int* _numK, int* _numX,
+               float** kx, float** ky, float** kz,
+               float** x, float** y, float** z,
+               float** phiR, float** phiI);
+
+void outputData(char* fName, float* outR, float* outI, int numX);
+
+#ifdef __cplusplus
+}
+#endif

benchmarks/opencl/mri-q/gpu_info.c

@@ -0,0 +1,55 @@
+/***************************************************************************
+ *cr
+ *cr            (C) Copyright 2010 The Board of Trustees of the
+ *cr                        University of Illinois
+ *cr                         All Rights Reserved
+ *cr
+ ***************************************************************************/
+//#include <endian.h>
+#include <stdlib.h>
+#include <malloc.h>
+#include <stdio.h>
+#include <inttypes.h>
+
+#include "gpu_info.h"
+
+void compute_active_thread(size_t *thread,
+			   size_t *grid,
+			   int task,
+			   int pad,
+			   int major,
+			   int minor,
+			   int sm)
+{
+	int max_thread;
+	int max_block=8;
+	if(major==1)
+	{
+		if(minor>=2)
+			max_thread=1024;
+		else
+			max_thread=768;
+	}
+	else if(major==2)
+		max_thread=1536;
+	else
+		//newer GPU  //keep using 2.0
+		max_thread=1536;
+	
+	int _grid;
+	int _thread;
+	
+	if(task*pad>sm*max_thread)
+	{
+		_thread=max_thread/max_block;
+		_grid = ((task*pad+_thread-1)/_thread)*_thread;
+	}
+	else
+	{
+		_thread=pad;
+		_grid=task*pad;
+	}
+
+	thread[0]=_thread;
+	grid[0]=_grid;
+}

benchmarks/opencl/mri-q/gpu_info.h

@@ -0,0 +1,20 @@
+/***************************************************************************
+ *cr
+ *cr            (C) Copyright 2010 The Board of Trustees of the
+ *cr                        University of Illinois
+ *cr                         All Rights Reserved
+ *cr
+ ***************************************************************************/
+
+#ifndef __GPUINFOH__
+#define __GPUINFOH__
+
+void compute_active_thread(size_t *thread,
+			   size_t *grid,
+			   int task,
+			   int pad,
+			   int major,
+			   int minor,
+			   int sm);
+
+#endif

benchmarks/opencl/mri-q/kernel.cl

@@ -0,0 +1,51 @@
+#include "macros.h"
+
+__kernel void
+ComputePhiMag_GPU(__global float* phiR, __global float* phiI, __global float* phiMag, int numK) {
+  int indexK = get_global_id(0);
+  float real = indexK;
+  float imag = indexK;
+  if (indexK < numK) {
+    /*float*/ real = phiR[indexK];
+    /*float*/ imag = phiI[indexK];
+    phiMag[indexK] = real*real + imag*imag;
+  }
+}
+
+__kernel void
+ComputeQ_GPU(int numK, int kGlobalIndex,
+	     __global float* x, __global float* y, __global float* z,
+	     __global float* Qr, __global float* Qi, __global struct kValues* ck) 
+{
+  float sX;
+  float sY;
+  float sZ;
+  float sQr;
+  float sQi;
+
+  // Determine the element of the X arrays computed by this thread
+  int xIndex = get_group_id(0)*KERNEL_Q_THREADS_PER_BLOCK + get_local_id(0);
+
+  // Read block's X values from global mem to shared mem
+  sX = x[xIndex];
+  sY = y[xIndex];
+  sZ = z[xIndex];
+  sQr = Qr[xIndex];
+  sQi = Qi[xIndex];
+
+  int kIndex = 0;
+  for (; (kIndex < KERNEL_Q_K_ELEMS_PER_GRID); kIndex++) {
+    if (kGlobalIndex < numK) {
+      float expArg;
+      expArg = PIx2 * (ck[kIndex].Kx * sX +
+			   ck[kIndex].Ky * sY +
+			   ck[kIndex].Kz * sZ);
+      sQr = sQr + ck[kIndex].PhiMag * cos(expArg); // native_cos(expArg);
+      sQi = sQi + ck[kIndex].PhiMag * sin(expArg); // native_sin(expArg);
+    }
+    kGlobalIndex++;
+  }
+
+  Qr[xIndex] = sQr;
+  Qi[xIndex] = sQi;
+}

benchmarks/opencl/mri-q/macros.h

@@ -0,0 +1,21 @@
+#ifndef __MACROS__
+#define __MACROS__
+
+#define PI   3.1415926535897932384626433832795029f
+#define PIx2 6.2831853071795864769252867665590058f
+
+#define MIN(X,Y) ((X) < (Y) ? (X) : (Y))
+#define K_ELEMS_PER_GRID 2048
+
+#define KERNEL_PHI_MAG_THREADS_PER_BLOCK 256
+#define KERNEL_Q_THREADS_PER_BLOCK 256
+#define KERNEL_Q_K_ELEMS_PER_GRID 1024
+
+struct kValues {
+  float Kx;
+  float Ky;
+  float Kz;
+  float PhiMag;
+};
+
+#endif

benchmarks/opencl/mri-q/main.cc

@@ -0,0 +1,295 @@
+/***************************************************************************
+ *cr
+ *cr            (C) Copyright 2007 The Board of Trustees of the
+ *cr                        University of Illinois
+ *cr                         All Rights Reserved
+ *cr
+ ***************************************************************************/
+
+/* 
+ * C code for creating the Q data structure for fast convolution-based 
+ * Hessian multiplication for arbitrary k-space trajectories.
+ *
+ * Inputs:
+ * kx - VECTOR of kx values, same length as ky and kz
+ * ky - VECTOR of ky values, same length as kx and kz
+ * kz - VECTOR of kz values, same length as kx and ky
+ * x  - VECTOR of x values, same length as y and z
+ * y  - VECTOR of y values, same length as x and z
+ * z  - VECTOR of z values, same length as x and y
+ * phi - VECTOR of the Fourier transform of the spatial basis 
+ *      function, evaluated at [kx, ky, kz].  Same length as kx, ky, and kz.
+ *
+ * recommended g++ options:
+ *  -O3 -lm -ffast-math -funroll-all-loops
+ */
+
+#include <stdio.h>
+#include <sys/time.h>
+#include <parboil.h>
+#include <CL/cl.h>
+
+#include "ocl.h"
+#include "file.h"
+#include "macros.h"
+#include "computeQ.h"
+
+static void
+setupMemoryGPU(int num, int size, cl_mem* dev_ptr, float* host_ptr,clPrmtr* clPrm)
+{
+  cl_int clStatus;
+  *dev_ptr = clCreateBuffer(clPrm->clContext,CL_MEM_READ_ONLY,num*size,NULL,&clStatus);
+  CHECK_ERROR("clCreateBuffer");
+  clStatus = clEnqueueWriteBuffer(clPrm->clCommandQueue,*dev_ptr,CL_TRUE,0,num*size,host_ptr,0,NULL,NULL);
+  CHECK_ERROR("clEnequeueWriteBuffer");
+}
+
+static void
+cleanupMemoryGPU(int num, int size, cl_mem* dev_ptr, float* host_ptr, clPrmtr* clPrm)
+{
+  cl_int clStatus;
+  clStatus = clEnqueueReadBuffer(clPrm->clCommandQueue,*dev_ptr,CL_TRUE,0,num*size,host_ptr,0,NULL,NULL);
+  CHECK_ERROR("clEnqueueReadBuffer")
+  clStatus = clReleaseMemObject(*dev_ptr);
+  CHECK_ERROR("clReleaseMemObject")
+}
+
+int
+main (int argc, char *argv[]) {
+  int numX, numK;		/* Number of X and K values */
+  int original_numK;		/* Number of K values in input file */
+  float *kx, *ky, *kz;		/* K trajectory (3D vectors) */
+  float *x, *y, *z;		/* X coordinates (3D vectors) */
+  float *phiR, *phiI;		/* Phi values (complex) */
+  float *phiMag;		/* Magnitude of Phi */
+  float *Qr, *Qi;		/* Q signal (complex) */
+
+  struct kValues* kVals;
+
+  struct pb_Parameters *params;
+  struct pb_TimerSet timers;
+
+  pb_InitializeTimerSet(&timers);
+
+  /* Read command line */
+  params = pb_ReadParameters(&argc, argv);
+  
+  params->inpFiles = (char **)malloc(sizeof(char *) * 2);
+  params->inpFiles[0] = (char *)malloc(100);
+  params->inpFiles[1] = NULL;
+  strncpy(params->inpFiles[0], "32_32_32_dataset.bin", 100);
+
+  if ((params->inpFiles[0] == NULL) || (params->inpFiles[1] != NULL))
+    {
+      fprintf(stderr, "Expecting one input filename\n");
+      exit(-1);
+    }
+    
+  /* Read in data */
+  pb_SwitchToTimer(&timers, pb_TimerID_IO);
+  inputData(params->inpFiles[0],
+	    &original_numK, &numX,
+	    &kx, &ky, &kz,
+	    &x, &y, &z,
+	    &phiR, &phiI);
+
+  printf("OK\n");
+
+  /* Reduce the number of k-space samples if a number is given
+   * on the command line */
+  if (argc < 2)
+    numK = original_numK;
+  else
+    {
+      int inputK;
+      char *end;
+      inputK = strtol(argv[1], &end, 10);
+      if (end == argv[1])
+	{
+	  fprintf(stderr, "Expecting an integer parameter\n");
+	  exit(-1);
+	}
+
+      numK = MIN(inputK, original_numK);
+    }
+
+  printf("%d pixels in output; %d samples in trajectory; using %d samples\n",
+         numX, original_numK, numK);
+
+  pb_SwitchToTimer(&timers, pb_TimerID_COMPUTE);
+
+  clPrmtr clPrm;
+
+  pb_Context* pb_context;
+  pb_context = pb_InitOpenCLContext(params);
+  if (pb_context == NULL) {
+    fprintf (stderr, "Error: No OpenCL platform/device can be found.");
+    return -1;
+  }
+
+  cl_int clStatus;
+  cl_device_id clDevice = (cl_device_id) pb_context->clDeviceId;
+  cl_platform_id clPlatform = (cl_platform_id) pb_context->clPlatformId;
+  clPrm.clContext = (cl_context) pb_context->clContext;
+
+  clPrm.clCommandQueue = clCreateCommandQueue(clPrm.clContext,clDevice,CL_QUEUE_PROFILING_ENABLE,&clStatus);
+  CHECK_ERROR("clCreateCommandQueue")
+
+  pb_SetOpenCL(&(clPrm.clContext), &(clPrm.clCommandQueue));
+
+  printf("OK\n");
+
+  //const char* clSource[] = {readFile("src/opencl_base/kernels.cl")};
+  //cl_program clProgram = clCreateProgramWithSource(clPrm.clContext,1,clSource,NULL,&clStatus);
+  cl_program clProgram = clCreateProgramWithBuiltInKernels(
+      clPrm.clContext, 1, &clDevice, "ComputePhiMag_GPU;ComputeQ_GPU", &clStatus);
+  CHECK_ERROR("clCreateProgramWithSource")
+
+  char options[50];
+  sprintf(options,"-I src/opencl_nvidia");
+  clStatus = clBuildProgram(clProgram,0,NULL,options,NULL,NULL);
+  if (clStatus != CL_SUCCESS) {
+    char buf[4096];
+    clGetProgramBuildInfo(clProgram, clDevice, CL_PROGRAM_BUILD_LOG, 4096, buf, NULL);
+    printf ("%s\n", buf);
+    CHECK_ERROR("clBuildProgram")
+  }
+
+  /* Create CPU data structures */
+  createDataStructsCPU(numK, numX, &phiMag, &Qr, &Qi);
+
+  /* GPU section 1 (precompute PhiMag) */
+  {
+    clPrm.clKernel = clCreateKernel(clProgram,"ComputePhiMag_GPU",&clStatus);
+    CHECK_ERROR("clCreateKernel")    
+
+    /* Mirror several data structures on the device */
+    cl_mem phiR_d;
+    cl_mem phiI_d;
+    cl_mem phiMag_d;
+
+    pb_SwitchToTimer(&timers, pb_TimerID_COPY);
+    
+    setupMemoryGPU(numK,sizeof(float),&phiR_d,phiR,&clPrm);
+    setupMemoryGPU(numK,sizeof(float),&phiI_d,phiI,&clPrm);
+    phiMag_d = clCreateBuffer(clPrm.clContext,CL_MEM_WRITE_ONLY,numK*sizeof(float),NULL,&clStatus);
+    CHECK_ERROR("clCreateBuffer")
+
+    clStatus = clFinish(clPrm.clCommandQueue);
+    CHECK_ERROR("clFinish")
+
+    pb_SwitchToTimer(&timers, pb_TimerID_KERNEL);
+
+    computePhiMag_GPU(numK, phiR_d, phiI_d, phiMag_d, &clPrm);
+
+    clStatus = clFinish(clPrm.clCommandQueue);
+    CHECK_ERROR("clFinish")
+
+    pb_SwitchToTimer(&timers, pb_TimerID_COPY);
+
+    cleanupMemoryGPU(numK,sizeof(float),&phiMag_d,phiMag,&clPrm);
+
+    clStatus = clReleaseMemObject(phiR_d);
+    CHECK_ERROR("clReleaseMemObject")
+    clStatus = clReleaseMemObject(phiI_d);
+    CHECK_ERROR("clReleaseMemObject")
+  }
+
+  pb_SwitchToTimer(&timers, pb_TimerID_COMPUTE);
+
+  kVals = (struct kValues*)calloc(numK, sizeof (struct kValues));
+
+  int k;
+  for (k = 0; k < numK; k++) {
+    kVals[k].Kx = kx[k];
+    kVals[k].Ky = ky[k];
+    kVals[k].Kz = kz[k];
+    kVals[k].PhiMag = phiMag[k];
+  }
+
+  free(phiMag);
+  
+  clStatus = clReleaseKernel(clPrm.clKernel);
+
+  /* GPU section 2 */
+  {
+    clPrm.clKernel = clCreateKernel(clProgram,"ComputeQ_GPU",&clStatus);
+    CHECK_ERROR("clCreateKernel")
+
+    cl_mem x_d;
+    cl_mem y_d;
+    cl_mem z_d;
+    cl_mem Qr_d;
+    cl_mem Qi_d;
+
+    pb_SwitchToTimer(&timers, pb_TimerID_COPY);
+
+    setupMemoryGPU(numX,sizeof(float),&x_d,x,&clPrm);
+    setupMemoryGPU(numX,sizeof(float),&y_d,y,&clPrm);
+    setupMemoryGPU(numX,sizeof(float),&z_d,z,&clPrm);
+
+    Qr_d = clCreateBuffer(clPrm.clContext,CL_MEM_READ_WRITE,numX*sizeof(float),NULL,&clStatus);
+    CHECK_ERROR("clCreateBuffer")
+    clMemSet(&clPrm,Qr_d,0,numX*sizeof(float));
+    Qi_d = clCreateBuffer(clPrm.clContext,CL_MEM_READ_WRITE,numX*sizeof(float),NULL,&clStatus);
+    CHECK_ERROR("clCreateBuffer")
+    clMemSet(&clPrm,Qi_d,0,numX*sizeof(float));
+
+    clStatus = clFinish(clPrm.clCommandQueue);
+    CHECK_ERROR("clFinish")
+
+    pb_SwitchToTimer(&timers, pb_TimerID_KERNEL);
+
+    computeQ_GPU(numK, numX, x_d, y_d, z_d, kVals, Qr_d, Qi_d, &clPrm);
+
+    clStatus = clFinish(clPrm.clCommandQueue);
+    CHECK_ERROR("clFinish")
+
+    pb_SwitchToTimer(&timers, pb_TimerID_COPY);
+
+    clStatus = clReleaseMemObject(x_d);
+    CHECK_ERROR("clReleaseMemObject")
+    clStatus = clReleaseMemObject(y_d);
+    CHECK_ERROR("clReleaseMemObject")
+    clStatus = clReleaseMemObject(z_d);
+    CHECK_ERROR("clReleaseMemObject")
+    cleanupMemoryGPU(numX,sizeof(float),&Qr_d,Qr,&clPrm);
+    cleanupMemoryGPU(numX,sizeof(float),&Qi_d,Qi,&clPrm);
+  }
+
+  pb_SwitchToTimer(&timers, pb_TimerID_COMPUTE);
+
+  if (params->outFile)
+    {
+      /* Write Q to file */
+      pb_SwitchToTimer(&timers, pb_TimerID_IO);
+      outputData(params->outFile, Qr, Qi, numX);
+      pb_SwitchToTimer(&timers, pb_TimerID_COMPUTE);
+    }
+
+  free (kx);
+  free (ky);
+  free (kz);
+  free (x);
+  free (y);
+  free (z);
+  free (phiR);
+  free (phiI);
+  free (kVals);
+  free (Qr);
+  free (Qi);
+
+  //free((void*)clSource[0]);
+
+  clStatus = clReleaseKernel(clPrm.clKernel);
+  clStatus = clReleaseProgram(clProgram);
+  clStatus = clReleaseCommandQueue(clPrm.clCommandQueue);
+  clStatus = clReleaseContext(clPrm.clContext);
+
+  pb_SwitchToTimer(&timers, pb_TimerID_NONE);
+  pb_PrintTimerSet(&timers);
+
+  pb_FreeParameters(params);
+
+  return 0;
+}

benchmarks/opencl/mri-q/ocl copy.c

@@ -0,0 +1,50 @@
+#include <CL/cl.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include "ocl.h"
+
+char* readFile(const char* fileName)
+{
+        FILE* fp;
+        fp = fopen(fileName,"r");
+        if(fp == NULL)
+        {
+                printf("Error 1!\n");
+                exit(1);
+        }
+
+        fseek(fp,0,SEEK_END);
+        long size = ftell(fp);
+        rewind(fp);
+
+        char* buffer = (char*)malloc(sizeof(char)*(size+1));
+        if(buffer  == NULL)
+        {
+                printf("Error 2!\n");
+                fclose(fp);
+                exit(1);
+        }
+
+        size_t res = fread(buffer,1,size,fp);
+        if(res != size)
+        {
+                printf("Error 3!\n");
+                fclose(fp);
+                exit(1);
+        }
+
+	buffer[size] = 0;
+        fclose(fp);
+        return buffer;
+}
+
+void clMemSet(cl_command_queue clCommandQueue, cl_mem buf, int val, size_t size)
+{
+	cl_int clStatus;
+	char* temp = (char*)malloc(size);
+	memset(temp,val,size);
+	clStatus = clEnqueueWriteBuffer(clCommandQueue,buf,CL_TRUE,0,size,temp,0,NULL,NULL);
+	CHECK_ERROR("clEnqueueWriteBuffer")
+	free(temp);
+}

benchmarks/opencl/mri-q/ocl copy.h

@@ -0,0 +1,21 @@
+#ifndef __OCLH__
+#define __OCLH__
+
+typedef struct {
+	cl_uint major;
+	cl_uint minor;
+	cl_uint multiProcessorCount;
+} OpenCLDeviceProp;
+
+void clMemSet(cl_command_queue, cl_mem, int, size_t);
+char* readFile(const char*);
+
+#define CHECK_ERROR(errorMessage)           \
+  if(clStatus != CL_SUCCESS)                \
+  {                                         \
+     printf("Error: %s!\n",errorMessage);   \
+     printf("Line: %d\n",__LINE__);         \
+     exit(1);                               \
+  }
+
+#endif

benchmarks/opencl/mri-q/ocl.c

@@ -0,0 +1,50 @@
+#include <CL/cl.h>
+#include <stdio.h>
+#include <string.h>
+#include "ocl.h"
+#include <parboil.h>
+
+char* readFile(const char* fileName)
+{
+        FILE* fp;
+        fp = fopen(fileName,"r");
+        if(fp == NULL)
+        {
+                printf("Error 1!\n");
+                exit(1);
+        }
+
+        fseek(fp,0,SEEK_END);
+        long size = ftell(fp);
+        rewind(fp);
+
+        char* buffer = (char*)malloc(sizeof(char)*(size+1));
+        if(buffer  == NULL)
+        {
+                printf("Error 2!\n");
+                fclose(fp);
+                exit(1);
+        }
+
+        size_t res = fread(buffer,1,size,fp);
+        if(res != size)
+        {
+                printf("Error 3!\n");
+                fclose(fp);
+                exit(1);
+        }
+
+	buffer[size] = 0;
+        fclose(fp);
+        return buffer;
+}
+
+void clMemSet(clPrmtr* clPrm, cl_mem buf, int val, size_t size)
+{
+	cl_int clStatus;
+	char* temp = (char*)malloc(size);
+	memset(temp,val,size);
+	clStatus = clEnqueueWriteBuffer(clPrm->clCommandQueue,buf,CL_TRUE,0,size,temp,0,NULL,NULL);
+	CHECK_ERROR("clEnqueueWriteBuffer")
+	free(temp);
+}

benchmarks/opencl/mri-q/ocl.h

@@ -0,0 +1,23 @@
+#ifndef __OCLH__
+#define __OCLH__
+
+#include <stdlib.h>
+
+typedef struct {
+	cl_context clContext;
+	cl_command_queue clCommandQueue;
+	cl_kernel clKernel;
+} clPrmtr;
+
+void clMemSet(clPrmtr*, cl_mem, int, size_t);
+char* readFile(const char*);
+
+#define CHECK_ERROR(errorMessage)           \
+  if(clStatus != CL_SUCCESS)                \
+  {                                         \
+     printf("Error: %s!\n",errorMessage);   \
+     printf("Line: %d\n",__LINE__);         \
+     exit(1);                               \
+  }
+
+#endif

benchmarks/opencl/mri-q/parboil.h

@@ -0,0 +1,348 @@
+/*
+ * (c) 2010 The Board of Trustees of the University of Illinois.
+ */
+#ifndef PARBOIL_HEADER
+#define PARBOIL_HEADER
+
+#include <stdio.h>
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <unistd.h>
+
+/* A platform as specified by the user on the command line */
+struct pb_PlatformParam {
+  char *name;                   /* The platform name.  This string is owned. */
+  char *version;                /* The platform version; may be NULL.
+                                 * This string is owned. */
+};
+
+/* Create a PlatformParam from the given strings.
+ * 'name' must not be NULL.  'version' may be NULL.
+ * If not NULL, the strings should have been allocated by malloc(),
+ * and they will be owned by the returned object.
+ */
+struct pb_PlatformParam *
+pb_PlatformParam(char *name, char *version);
+
+void
+pb_FreePlatformParam(struct pb_PlatformParam *);
+
+/* A criterion for how to select a device */
+enum pb_DeviceSelectionCriterion {
+  pb_Device_INDEX,             /* Enumerate the devices and select one
+                                * by its number */
+  pb_Device_CPU,                /* Select a CPU device */
+  pb_Device_GPU,                /* Select a GPU device  */
+  pb_Device_ACCELERATOR,        /* Select an accelerator device */
+  pb_Device_NAME                /* Select a device by name */
+};
+
+/* A device as specified by the user on the command line */
+struct pb_DeviceParam {
+  enum pb_DeviceSelectionCriterion criterion;
+  union {
+    int index;                  /* If criterion == pb_Device_INDEX,
+                                 * the index of the device */
+    char *name;                 /* If criterion == pb_Device_NAME,
+                                 * the name of the device.
+                                 * This string is owned. */
+  };
+};
+
+struct pb_DeviceParam *
+pb_DeviceParam_index(int index);
+
+struct pb_DeviceParam *
+pb_DeviceParam_cpu(void);
+
+struct pb_DeviceParam *
+pb_DeviceParam_gpu(void);
+
+struct pb_DeviceParam *
+pb_DeviceParam_accelerator(void);
+
+/* Create a by-name device selection criterion.
+ * The string should have been allocated by malloc(), and it will will be
+ * owned by the returned object.
+ */
+struct pb_DeviceParam *
+pb_DeviceParam_name(char *name);
+
+void
+pb_FreeDeviceParam(struct pb_DeviceParam *);
+
+/* Command line parameters for benchmarks */
+struct pb_Parameters {
+  char *outFile;		/* If not NULL, the raw output of the
+				 * computation should be saved to this
+				 * file. The string is owned. */
+  char **inpFiles;		/* A NULL-terminated array of strings
+				 * holding the input file(s) for the
+				 * computation.  The array and strings
+				 * are owned. */
+  struct pb_PlatformParam *platform; /* If not NULL, the platform
+                                      * specified on the command line. */
+  struct pb_DeviceParam *device; /* If not NULL, the device
+                                      * specified on the command line. */
+};
+
+/* Read command-line parameters.
+ *
+ * The argc and argv parameters to main are read, and any parameters
+ * interpreted by this function are removed from the argument list.
+ *
+ * A new instance of struct pb_Parameters is returned.
+ * If there is an error, then an error message is printed on stderr
+ * and NULL is returned.
+ */
+struct pb_Parameters *
+pb_ReadParameters(int *_argc, char **argv);
+
+/* Free an instance of struct pb_Parameters.
+ */
+void
+pb_FreeParameters(struct pb_Parameters *p);
+
+void
+pb_FreeStringArray(char **);
+
+/* Count the number of input files in a pb_Parameters instance.
+ */
+int
+pb_Parameters_CountInputs(struct pb_Parameters *p);
+
+/* A time or duration. */
+//#if _POSIX_VERSION >= 200112L
+typedef unsigned long long pb_Timestamp; /* time in microseconds */
+//#else
+//# error "Timestamps not implemented"
+//#endif
+
+enum pb_TimerState {
+  pb_Timer_STOPPED,
+  pb_Timer_RUNNING,
+};
+
+struct pb_Timer {
+  enum pb_TimerState state;
+  pb_Timestamp elapsed;		/* Amount of time elapsed so far */
+  pb_Timestamp init;		/* Beginning of the current time interval,
+				 * if state is RUNNING.  End of the last 
+				 * recorded time interfal otherwise.  */
+};
+
+/* Reset a timer.
+ * Use this to initialize a timer or to clear
+ * its elapsed time.  The reset timer is stopped.
+ */
+void
+pb_ResetTimer(struct pb_Timer *timer);
+
+/* Start a timer.  The timer is set to RUNNING mode and
+ * time elapsed while the timer is running is added to
+ * the timer.
+ * The timer should not already be running.
+ */
+void
+pb_StartTimer(struct pb_Timer *timer);
+
+/* Stop a timer.
+ * This stops adding elapsed time to the timer.
+ * The timer should not already be stopped.
+ */
+void
+pb_StopTimer(struct pb_Timer *timer);
+
+/* Get the elapsed time in seconds. */
+double
+pb_GetElapsedTime(struct pb_Timer *timer);
+
+/* Execution time is assigned to one of these categories. */
+enum pb_TimerID {
+  pb_TimerID_NONE = 0,
+  pb_TimerID_IO,		/* Time spent in input/output */
+  pb_TimerID_KERNEL,		/* Time spent computing on the device, 
+				 * recorded asynchronously */
+  pb_TimerID_COPY,		/* Time spent synchronously moving data 
+				 * to/from device and allocating/freeing 
+				 * memory on the device */
+  pb_TimerID_DRIVER,		/* Time spent in the host interacting with the 
+				 * driver, primarily for recording the time 
+                                 * spent queueing asynchronous operations */
+  pb_TimerID_COPY_ASYNC,	/* Time spent in asynchronous transfers */
+  pb_TimerID_COMPUTE,		/* Time for all program execution other
+				 * than parsing command line arguments,
+				 * I/O, kernel, and copy */
+  pb_TimerID_OVERLAP,		/* Time double-counted in asynchronous and 
+				 * host activity: automatically filled in, 
+				 * not intended for direct usage */
+  pb_TimerID_LAST		/* Number of timer IDs */
+};
+
+/* Dynamic list of asynchronously tracked times between events */
+struct pb_async_time_marker_list {
+  char *label; // actually just a pointer to a string
+  enum pb_TimerID timerID;	/* The ID to which the interval beginning 
+                                 * with this marker should be attributed */
+  void * marker; 
+  //cudaEvent_t marker; 		/* The driver event for this marker */
+  struct pb_async_time_marker_list *next; 
+};
+
+struct pb_SubTimer {
+  char *label;
+  struct pb_Timer timer;
+  struct pb_SubTimer *next;
+};
+
+struct pb_SubTimerList {
+  struct pb_SubTimer *current;
+  struct pb_SubTimer *subtimer_list;
+};
+
+/* A set of timers for recording execution times. */
+struct pb_TimerSet {
+  enum pb_TimerID current;
+  struct pb_async_time_marker_list* async_markers;
+  pb_Timestamp async_begin;
+  pb_Timestamp wall_begin;
+  struct pb_Timer timers[pb_TimerID_LAST];
+  struct pb_SubTimerList *sub_timer_list[pb_TimerID_LAST];
+};
+
+/* Reset all timers in the set. */
+void
+pb_InitializeTimerSet(struct pb_TimerSet *timers);
+
+void
+pb_AddSubTimer(struct pb_TimerSet *timers, char *label, enum pb_TimerID pb_Category);
+
+/* Select which timer the next interval of time should be accounted
+ * to. The selected timer is started and other timers are stopped.
+ * Using pb_TimerID_NONE stops all timers. */
+void
+pb_SwitchToTimer(struct pb_TimerSet *timers, enum pb_TimerID timer);
+
+void
+pb_SwitchToSubTimer(struct pb_TimerSet *timers, char *label, enum pb_TimerID category);
+
+/* Print timer values to standard output. */
+void
+pb_PrintTimerSet(struct pb_TimerSet *timers);
+
+/* Release timer resources */
+void
+pb_DestroyTimerSet(struct pb_TimerSet * timers);
+
+void
+pb_SetOpenCL(void *clContextPtr, void *clCommandQueuePtr);
+
+
+typedef struct pb_Device_tag {
+  char* name;
+  void* clDevice;
+  int id;
+  unsigned int in_use;
+  unsigned int available;
+} pb_Device;
+
+struct pb_Context_tag;
+typedef struct pb_Context_tag pb_Context;
+
+typedef struct pb_Platform_tag {
+  char* name;
+  char* version;
+  void* clPlatform;
+  unsigned int in_use;
+  pb_Context** contexts;
+  pb_Device** devices;
+} pb_Platform;
+
+struct pb_Context_tag {
+  void* clPlatformId;
+  void* clContext;
+  void* clDeviceId;
+  pb_Platform* pb_platform;
+  pb_Device* pb_device;
+};
+
+// verbosely print out list of platforms and their devices to the console.
+pb_Platform**
+pb_GetPlatforms();
+
+// Choose a platform according to the given platform specification
+pb_Platform*
+pb_GetPlatform(struct pb_PlatformParam *platform);
+
+// choose a platform: by name, name & version
+pb_Platform*
+pb_GetPlatformByName(const char* name);
+
+pb_Platform*
+pb_GetPlatformByNameAndVersion(const char* name, const char* version);
+
+// Choose a device according to the given device specification
+pb_Device*
+pb_GetDevice(pb_Platform* pb_platform, struct pb_DeviceParam *device);
+
+pb_Device**
+pb_GetDevices(pb_Platform* pb_platform);
+
+// choose a device by name.
+pb_Device*
+pb_GetDeviceByName(pb_Platform* pb_platform, const char* name);
+
+pb_Platform*
+pb_GetPlatformByEnvVars();
+
+pb_Context*
+pb_InitOpenCLContext(struct pb_Parameters* parameters);
+
+void
+pb_ReleasePlatforms();
+
+void
+pb_ReleaseContext(pb_Context* c);
+
+void
+pb_PrintPlatformInfo(pb_Context* c);
+
+void
+perf_init();
+
+//#define MEASURE_KERNEL_TIME
+
+#include <CL/cl.h>
+
+#ifdef MEASURE_KERNEL_TIME
+#define clEnqueueNDRangeKernel(q,k,d,o,dg,db,a,b,c) pb_clEnqueueNDRangeKernel((q), (k), (d), (o), (dg), (db), (a), (b), (c))
+cl_int
+pb_clEnqueueNDRangeKernel(cl_command_queue /* command_queue */,
+                       cl_kernel        /* kernel */,
+                       cl_uint          /* work_dim */,
+                       const size_t *   /* global_work_offset */,
+                       const size_t *   /* global_work_size */,
+                       const size_t *   /* local_work_size */,
+                       cl_uint          /* num_events_in_wait_list */,
+                       const cl_event * /* event_wait_list */,
+                       cl_event *       /* event */);
+#endif
+
+enum { T_FLOAT, T_DOUBLE, T_SHORT, T_INT, T_UCHAR };
+void pb_sig_float(char*, float*, int);
+void pb_sig_double(char*, double*, int);
+void pb_sig_short(char*, short*, int);
+void pb_sig_int(char*, int*, int);
+void pb_sig_uchar(char*, unsigned char*, unsigned int);
+void pb_sig_clmem(char*, cl_command_queue, cl_mem, int);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //PARBOIL_HEADER
+

benchmarks/opencl/reduce0/Makefile

@@ -0,0 +1,65 @@
+RISCV_TOOL_PATH ?= $(wildcard ../../../../riscv-gnu-toolchain/drops)
+POCL_CC_PATH ?= $(wildcard ../../../../pocl/drops_riscv_cc)
+POCL_INC_PATH ?= $(wildcard ../include)
+POCL_LIB_PATH ?= $(wildcard ../lib)
+VX_RT_PATH ?= $(wildcard ../../../runtime)
+VX_SIMX_PATH ?= $(wildcard ../../../simX/obj_dir)
+
+CC  = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-gcc
+CXX = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-g++
+DMP = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-objdump
+HEX = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-objcopy
+GDB = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-gdb
+
+VX_SRCS =  $(VX_RT_PATH)/newlib/newlib.c
+VX_SRCS += $(VX_RT_PATH)/startup/vx_start.S
+VX_SRCS += $(VX_RT_PATH)/intrinsics/vx_intrinsics.S
+VX_SRCS += $(VX_RT_PATH)/io/vx_io.S $(VX_RT_PATH)/io/vx_io.c
+VX_SRCS += $(VX_RT_PATH)/fileio/fileio.S
+VX_SRCS += $(VX_RT_PATH)/tests/tests.c
+VX_SRCS += $(VX_RT_PATH)/vx_api/vx_api.c
+
+VX_CFLAGS = -nostartfiles -Wl,-Bstatic,-T,$(VX_RT_PATH)/startup/vx_link.ld
+
+CXXFLAGS =  -g -O0 -march=rv32im -mabi=ilp32
+CXXFLAGS += -ffreestanding # program may not begin at main()
+CXXFLAGS += -Wl,--gc-sections # enable garbage collection of unused input sections
+CXXFLAGS += -fno-rtti -fno-non-call-exceptions # disable RTTI and exceptions
+CXXFLAGS += -I$(POCL_INC_PATH) -I.
+
+VX_LIBS = -Wl,--whole-archive lib$(PROJECT).a -Wl,--no-whole-archive $(POCL_LIB_PATH)/libOpenCL.a
+QEMU_LIBS = $(VX_RT_PATH)/qemu/vx_api.c -Wl,--whole-archive lib$(PROJECT).a -Wl,--no-whole-archive $(POCL_LIB_PATH)/libOpenCL.a
+
+PROJECT=reduce0
+
+all: $(PROJECT).dump $(PROJECT).hex
+
+lib$(PROJECT).a: oclReduction_kernel.cl
+	POCL_DEBUG=all POCL_DEBUG_LLVM_PASSES=1 LD_LIBRARY_PATH=$(RISCV_TOOL_PATH)/lib:$(POCL_CC_PATH)/lib $(POCL_CC_PATH)/bin/poclcc -o lib$(PROJECT).a kernel.cl
+
+$(PROJECT).elf: main.cc lib$(PROJECT).a
+	$(CXX) $(CXXFLAGS) $(VX_CFLAGS) $(VX_SRCS) main.cc $(VX_LIBS) -o $(PROJECT).elf
+
+$(PROJECT).qemu: main.cc lib$(PROJECT).a
+	$(CXX) $(CXXFLAGS) main.cc $(QEMU_LIBS) -o $(PROJECT).qemu
+
+$(PROJECT).hex: $(PROJECT).elf
+	$(HEX) -O ihex $(PROJECT).elf $(PROJECT).hex
+
+$(PROJECT).dump: $(PROJECT).elf
+	$(DMP) -D $(PROJECT).elf > $(PROJECT).dump
+
+run: $(PROJECT).hex
+	POCL_DEBUG=all $(VX_SIMX_PATH)/Vcache_simX -E -a rv32i --core $(PROJECT).hex -s -b 1> emulator.debug
+
+qemu: $(PROJECT).qemu
+	POCL_DEBUG=all $(RISCV_TOOL_PATH)/bin/qemu-riscv32 -d in_asm -D debug.log $(PROJECT).qemu
+
+gdb-s: $(PROJECT).qemu
+	POCL_DEBUG=all $(RISCV_TOOL_PATH)/bin/qemu-riscv32 -g 1234 -d in_asm -D debug.log $(PROJECT).qemu
+
+gdb-c: $(PROJECT).qemu
+	$(GDB) $(PROJECT).qemu
+
+clean:
+	rm -rf *.elf *.dump *.hex

benchmarks/opencl/reduce0/main.cc

@@ -0,0 +1,638 @@
+/*
+* 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.
+*
+*/
+
+/*
+    Parallel reduction
+
+    This sample shows how to perform a reduction operation on an array of values
+    to produce a single value.
+
+    Reductions are a very common computation in parallel algorithms.  Any time
+    an array of values needs to be reduced to a single value using a binary 
+    associative operator, a reduction can be used.  Example applications include
+    statistics computaions such as mean and standard deviation, and image 
+    processing applications such as finding the total luminance of an
+    image.
+
+    This code performs sum reductions, but any associative operator such as
+    min() or max() could also be used.
+
+    It assumes the input size is a power of 2.
+
+    COMMAND LINE ARGUMENTS
+
+    "--shmoo":         Test performance for 1 to 32M elements with each of the 7 different kernels
+    "--n=<N>":         Specify the number of elements to reduce (default 1048576)
+    "--threads=<N>":   Specify the number of threads per block (default 128)
+    "--kernel=<N>":    Specify which kernel to run (0-6, default 6)
+    "--maxblocks=<N>": Specify the maximum number of thread blocks to launch (kernel 6 only, default 64)
+    "--cpufinal":      Read back the per-block results and do final sum of block sums on CPU (default false)
+    "--cputhresh=<N>": The threshold of number of blocks sums below which to perform a CPU final reduction (default 1)
+    
+*/
+
+// Common system and utility includes 
+#include <oclUtils.h>
+#include <shrQATest.h>
+
+// additional includes
+#include <sstream>
+#include <oclReduction.h>
+
+// Forward declarations and sample-specific defines
+// *********************************************************************
+enum ReduceType
+{
+    REDUCE_INT,
+    REDUCE_FLOAT,
+    REDUCE_DOUBLE
+};
+
+template <class T>
+bool runTest( int argc, const char** argv, ReduceType datatype);
+
+#define MAX_BLOCK_DIM_SIZE 65535
+
+extern "C"
+bool isPow2(unsigned int x)
+{
+    return ((x&(x-1))==0);
+}
+
+cl_kernel getReductionKernel(ReduceType datatype, int whichKernel, int blockSize, int isPowOf2);
+
+// Main function 
+// *********************************************************************
+int main( int argc, const char** argv) 
+{
+    shrQAStart(argc, (char **)argv);
+
+    // start logs 
+    shrSetLogFileName ("oclReduction.txt");
+    shrLog("%s Starting...\n\n", argv[0]); 
+
+    char *typeChoice;
+    shrGetCmdLineArgumentstr(argc, argv, "type", &typeChoice);
+
+    // determine type of array from command line args
+    if (0 == typeChoice)
+    {
+        typeChoice = (char*)malloc(7 * sizeof(char));
+        #ifdef WIN32
+            strcpy_s(typeChoice, 7 * sizeof(char) + 1, "int");
+        #else
+            strcpy(typeChoice, "int");
+        #endif
+    }
+    ReduceType datatype = REDUCE_INT;
+
+    #ifdef WIN32
+        if (!_strcmpi(typeChoice, "float"))
+            datatype = REDUCE_FLOAT;
+        else if (!_strcmpi(typeChoice, "double"))
+            datatype = REDUCE_DOUBLE;
+        else
+            datatype = REDUCE_INT;
+    #else
+        if (!strcmp(typeChoice, "float"))
+            datatype = REDUCE_FLOAT;
+        else if (!strcmp(typeChoice, "double"))
+            datatype = REDUCE_DOUBLE;
+        else
+            datatype = REDUCE_INT;
+    #endif
+
+    shrLog("Reducing array of type %s.\n", typeChoice);
+
+    //Get the NVIDIA platform
+    ciErrNum = oclGetPlatformID(&cpPlatform);
+    //oclCheckError(ciErrNum, CL_SUCCESS);
+
+    //Get the devices
+    ciErrNum = clGetDeviceIDs(cpPlatform, CL_DEVICE_TYPE_DEFAULT, 0, NULL, &uiNumDevices);
+    //oclCheckError(ciErrNum, CL_SUCCESS);
+    cl_device_id *cdDevices = (cl_device_id *)malloc(uiNumDevices * sizeof(cl_device_id) );
+    ciErrNum = clGetDeviceIDs(cpPlatform, CL_DEVICE_TYPE_DEFAULT, uiNumDevices, cdDevices, NULL);
+    //oclCheckError(ciErrNum, CL_SUCCESS);
+
+    //Create the context
+    cxGPUContext = clCreateContext(0, uiNumDevices, cdDevices, NULL, NULL, &ciErrNum);
+    //oclCheckError(ciErrNum, CL_SUCCESS);
+
+    // get and log the device info
+    if( shrCheckCmdLineFlag(argc, (const char**)argv, "device") ) {
+      int device_nr = 0;
+      shrGetCmdLineArgumenti(argc, (const char**)argv, "device", &device_nr);
+	  if( device_nr < uiNumDevices ) {
+		device = oclGetDev(cxGPUContext, device_nr);
+	  } else {
+		shrLog("Invalid Device %d Requested.\n", device_nr);
+		shrExitEX(argc, argv, EXIT_FAILURE);
+	  }
+    } else {
+      device = oclGetMaxFlopsDev(cxGPUContext);
+    }
+    oclPrintDevName(LOGBOTH, device);
+    shrLog("\n");
+
+    // create a command-queue
+    cqCommandQueue = clCreateCommandQueue(cxGPUContext, device, 0, &ciErrNum);
+    //oclCheckError(ciErrNum, CL_SUCCESS);
+
+    source_path = shrFindFilePath("oclReduction_kernel.cl", argv[0]);
+
+    bool bSuccess = false;
+    switch (datatype)
+    {
+    default:
+    case REDUCE_INT:
+        bSuccess = runTest<int>( argc, argv, datatype);
+        break;
+    case REDUCE_FLOAT:
+        bSuccess = runTest<float>( argc, argv, datatype);
+        break;
+    }
+    
+    // finish
+    shrQAFinishExit(argc, (const char **)argv, bSuccess ? QA_PASSED : QA_FAILED);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//! Compute sum reduction on CPU
+//! We use Kahan summation for an accurate sum of large arrays.
+//! http://en.wikipedia.org/wiki/Kahan_summation_algorithm
+//! 
+//! @param data       pointer to input data
+//! @param size       number of input data elements
+////////////////////////////////////////////////////////////////////////////////
+template<class T>
+T reduceCPU(T *data, int size)
+{
+    T sum = data[0];
+    T c = (T)0.0;              
+    for (int i = 1; i < size; i++)
+    {
+        T y = data[i] - c;  
+        T t = sum + y;      
+        c = (t - sum) - y;  
+        sum = t;            
+    }
+    return sum;
+}
+
+unsigned int nextPow2( unsigned int x ) {
+    --x;
+    x |= x >> 1;
+    x |= x >> 2;
+    x |= x >> 4;
+    x |= x >> 8;
+    x |= x >> 16;
+    return ++x;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Compute the number of threads and blocks to use for the given reduction kernel
+// For the kernels >= 3, we set threads / block to the minimum of maxThreads and
+// n/2. For kernels < 3, we set to the minimum of maxThreads and n.  For kernel 
+// 6, we observe the maximum specified number of blocks, because each thread in 
+// that kernel can process a variable number of elements.
+////////////////////////////////////////////////////////////////////////////////
+void getNumBlocksAndThreads(int whichKernel, int n, int maxBlocks, int maxThreads, int &blocks, int &threads)
+{
+    if (whichKernel < 3)
+    {
+        threads = (n < maxThreads) ? nextPow2(n) : maxThreads;
+        blocks = (n + threads - 1) / threads;
+    }
+    else
+    {
+        threads = (n < maxThreads*2) ? nextPow2((n + 1)/ 2) : maxThreads;
+        blocks = (n + (threads * 2 - 1)) / (threads * 2);
+    }
+        
+
+    if (whichKernel == 6)
+        blocks = MIN(maxBlocks, blocks);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// This function performs a reduction of the input data multiple times and 
+// measures the average reduction time.
+////////////////////////////////////////////////////////////////////////////////
+template <class T>
+T profileReduce(ReduceType datatype,
+                  cl_int  n, 
+                  int  numThreads,
+                  int  numBlocks,
+                  int  maxThreads,
+                  int  maxBlocks,
+                  int  whichKernel, 
+                  int  testIterations,
+                  bool cpuFinalReduction,
+                  int  cpuFinalThreshold,
+                  double* dTotalTime,
+                  T* h_odata,
+                  cl_mem d_idata, 
+                  cl_mem d_odata)
+{
+
+
+    T gpu_result = 0;
+    bool needReadBack = true;
+    cl_kernel finalReductionKernel[10];
+    int finalReductionIterations=0;
+
+    //shrLog("Profile Kernel %d\n", whichKernel);
+
+    cl_kernel reductionKernel = getReductionKernel(datatype, whichKernel, numThreads, isPow2(n) );
+    clSetKernelArg(reductionKernel, 0, sizeof(cl_mem), (void *) &d_idata);
+    clSetKernelArg(reductionKernel, 1, sizeof(cl_mem), (void *) &d_odata);
+    clSetKernelArg(reductionKernel, 2, sizeof(cl_int), &n);
+    clSetKernelArg(reductionKernel, 3, sizeof(T) * numThreads, NULL);
+
+    if( !cpuFinalReduction ) {
+        int s=numBlocks;
+        int threads = 0, blocks = 0;
+        int kernel = (whichKernel == 6) ? 5 : whichKernel;
+        
+        while(s > cpuFinalThreshold) 
+        {
+            getNumBlocksAndThreads(kernel, s, maxBlocks, maxThreads, blocks, threads);
+
+            finalReductionKernel[finalReductionIterations] = getReductionKernel(datatype, kernel, threads, isPow2(s) );
+            clSetKernelArg(finalReductionKernel[finalReductionIterations], 0, sizeof(cl_mem), (void *) &d_odata);
+            clSetKernelArg(finalReductionKernel[finalReductionIterations], 1, sizeof(cl_mem), (void *) &d_odata);
+            clSetKernelArg(finalReductionKernel[finalReductionIterations], 2, sizeof(cl_int), &n);
+            clSetKernelArg(finalReductionKernel[finalReductionIterations], 3, sizeof(T) * numThreads, NULL);
+            
+            if (kernel < 3)
+                s = (s + threads - 1) / threads;
+            else
+                s = (s + (threads*2-1)) / (threads*2);
+
+            finalReductionIterations++;
+        }
+    }
+    
+    size_t globalWorkSize[1];
+    size_t localWorkSize[1];
+
+    for (int i = 0; i < testIterations; ++i)
+    {
+        gpu_result = 0;
+
+        clFinish(cqCommandQueue);
+        if(i>0) shrDeltaT(1);
+
+        // execute the kernel
+        globalWorkSize[0] = numBlocks * numThreads;
+        localWorkSize[0] = numThreads;
+	
+        ciErrNum = clEnqueueNDRangeKernel(cqCommandQueue,reductionKernel, 1, 0, globalWorkSize, localWorkSize,
+                                          0, NULL, NULL);               
+
+        // check if kernel execution generated an error        
+        //oclCheckError(ciErrNum, CL_SUCCESS);
+
+        if (cpuFinalReduction)
+        {
+            // sum partial sums from each block on CPU        
+            // copy result from device to host
+            clEnqueueReadBuffer(cqCommandQueue, d_odata, CL_TRUE, 0, numBlocks * sizeof(T), 
+                                h_odata, 0, NULL, NULL);
+
+            for(int i=0; i<numBlocks; i++) 
+            {
+                gpu_result += h_odata[i];
+            }
+
+            needReadBack = false;
+        }
+        else
+        {
+            // sum partial block sums on GPU
+            int s=numBlocks;
+            int kernel = (whichKernel == 6) ? 5 : whichKernel;
+            int it = 0;
+            
+
+            while(s > cpuFinalThreshold) 
+            {
+                int threads = 0, blocks = 0;
+                getNumBlocksAndThreads(kernel, s, maxBlocks, maxThreads, blocks, threads);
+
+                globalWorkSize[0] = threads * blocks;
+                localWorkSize[0] = threads;
+                
+                ciErrNum = clEnqueueNDRangeKernel(cqCommandQueue, finalReductionKernel[it], 1, 0,
+                                                  globalWorkSize, localWorkSize, 0, NULL, NULL);               
+                //oclCheckError(ciErrNum, CL_SUCCESS);
+                
+                if (kernel < 3)
+                    s = (s + threads - 1) / threads;
+                else
+                    s = (s + (threads*2-1)) / (threads*2);
+
+                it++;
+            }
+
+            if (s > 1)
+            {
+                // copy result from device to host
+                clEnqueueReadBuffer(cqCommandQueue, d_odata, CL_TRUE, 0, s * sizeof(T), 
+                                    h_odata, 0, NULL, NULL);
+
+                for(int i=0; i < s; i++) 
+                {
+                    gpu_result += h_odata[i];
+                }
+
+                needReadBack = false;
+            }
+        }
+
+        clFinish(cqCommandQueue);
+        if(i>0) *dTotalTime += shrDeltaT(1); 
+    }
+
+    if (needReadBack)
+    {
+        // copy final sum from device to host
+        clEnqueueReadBuffer(cqCommandQueue, d_odata, CL_TRUE, 0, sizeof(T), 
+                            &gpu_result, 0, NULL, NULL);
+    }
+
+    // Release the kernels
+    clReleaseKernel(reductionKernel);
+    if( !cpuFinalReduction ) {
+        for(int it=0; it<finalReductionIterations; ++it) {
+            clReleaseKernel(finalReductionKernel[it]);
+        }
+        
+    }
+
+    return gpu_result;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// This function calls profileReduce multple times for a range of array sizes
+// and prints a report in CSV (comma-separated value) format that can be used for
+// generating a "shmoo" plot showing the performance for each kernel variation
+// over a wide range of input sizes.
+////////////////////////////////////////////////////////////////////////////////
+template <class T>
+void shmoo(int minN, int maxN, int maxThreads, int maxBlocks, ReduceType datatype)
+{ 
+    // create random input data on CPU
+    unsigned int bytes = maxN * sizeof(T);
+
+    T* h_idata = (T*)malloc(bytes);
+
+    for(int i = 0; i < maxN; i++) {
+        // Keep the numbers small so we don't get truncation error in the sum
+        if (datatype == REDUCE_INT)
+            h_idata[i] = (T)(rand() & 0xFF);
+        else
+            h_idata[i] = (rand() & 0xFF) / (T)RAND_MAX;
+    }
+
+    int maxNumBlocks = MIN( maxN / maxThreads, MAX_BLOCK_DIM_SIZE);
+
+    // allocate mem for the result on host side
+    T* h_odata = (T*) malloc(maxNumBlocks*sizeof(T));
+
+    // allocate device memory and data
+    cl_mem d_idata = clCreateBuffer(cxGPUContext, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, bytes, h_idata, NULL);
+    cl_mem d_odata = clCreateBuffer(cxGPUContext, CL_MEM_READ_WRITE, maxNumBlocks * sizeof(T), NULL, NULL);
+
+    int testIterations = 100;
+    double dTotalTime = 0.0;
+    
+    // print headers
+    shrLog("Time in seconds for various numbers of elements for each kernel\n");
+    shrLog("\n\n");
+    shrLog("Kernel");
+    for (int i = minN; i <= maxN; i *= 2)
+    {
+        shrLog(", %d", i);
+    }
+   
+    for (int kernel = 0; kernel < 7; kernel++)
+    {
+        shrLog("\n");
+        shrLog("%d", kernel);
+        for (int i = minN; i <= maxN; i *= 2)
+        {
+            int numBlocks = 0;
+            int numThreads = 0;
+            getNumBlocksAndThreads(kernel, i, maxBlocks, maxThreads, numBlocks, numThreads);
+            
+            double reduceTime;
+            if( numBlocks <= MAX_BLOCK_DIM_SIZE ) {
+                profileReduce(datatype, i, numThreads, numBlocks, maxThreads, maxBlocks, kernel, 
+                                testIterations, false, 1, &dTotalTime, h_odata, d_idata, d_odata);
+                reduceTime = dTotalTime/(double)testIterations;
+            } else {                
+                reduceTime = -1.0;
+            }
+            shrLog(", %.4f m", reduceTime);
+        }
+    }
+
+    // cleanup
+    free(h_idata);
+    free(h_odata);
+    clReleaseMemObject(d_idata);
+    clReleaseMemObject(d_odata);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// The main function whihc runs the reduction test.
+////////////////////////////////////////////////////////////////////////////////
+template <class T>
+bool
+runTest( int argc, const char** argv, ReduceType datatype) 
+{
+    int size = 1<<24;    // number of elements to reduce
+    int maxThreads;
+
+    cl_kernel reductionKernel = getReductionKernel(datatype, 0, 64, 1);        
+    clReleaseKernel(reductionKernel);
+
+    if (smallBlock) 
+      maxThreads = 64;  // number of threads per block
+    else
+      maxThreads = 128;
+
+    int whichKernel = 6;
+    int maxBlocks = 64;
+    bool cpuFinalReduction = false;
+    int cpuFinalThreshold = 1;
+
+    shrGetCmdLineArgumenti( argc, (const char**) argv, "n", &size);
+    shrGetCmdLineArgumenti( argc, (const char**) argv, "threads", &maxThreads);
+    shrGetCmdLineArgumenti( argc, (const char**) argv, "kernel", &whichKernel);
+    shrGetCmdLineArgumenti( argc, (const char**) argv, "maxblocks", &maxBlocks);
+    
+    shrLog(" %d elements\n", size);
+    shrLog(" %d threads (max)\n", maxThreads);
+
+    cpuFinalReduction = (shrCheckCmdLineFlag( argc, (const char**) argv, "cpufinal") == shrTRUE);
+    shrGetCmdLineArgumenti( argc, (const char**) argv, "cputhresh", &cpuFinalThreshold);
+
+    bool runShmoo = (shrCheckCmdLineFlag(argc, (const char**) argv, "shmoo") == shrTRUE);
+
+#ifdef GPU_PROFILING
+    if (runShmoo)
+    {
+        shmoo<T>(1, 33554432, maxThreads, maxBlocks, datatype);
+        return true;
+    }
+    else
+#endif
+    {
+        // create random input data on CPU
+        unsigned int bytes = size * sizeof(T);
+        T* h_idata = (T*)malloc(bytes);
+
+        for(int i=0; i<size; i++) 
+        {
+            // Keep the numbers small so we don't get truncation error in the sum
+            if (datatype == REDUCE_INT)
+                h_idata[i] = (T)(rand() & 0xFF);
+            else
+                h_idata[i] = (rand() & 0xFF) / (T)RAND_MAX;
+        }
+
+        int numBlocks = 0;
+        int numThreads = 0;
+        getNumBlocksAndThreads(whichKernel, size, maxBlocks, maxThreads, numBlocks, numThreads);
+        if (numBlocks == 1) cpuFinalThreshold = 1;
+        shrLog(" %d blocks\n\n", numBlocks);
+
+        // allocate mem for the result on host side
+        T* h_odata = (T*)malloc(numBlocks * sizeof(T));
+
+        // allocate device memory and data
+        cl_mem d_idata = clCreateBuffer(cxGPUContext, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, bytes, h_idata, NULL);
+        cl_mem d_odata = clCreateBuffer(cxGPUContext, CL_MEM_READ_WRITE, numBlocks * sizeof(T), NULL, NULL);
+      
+        int testIterations = 100;
+        double dTotalTime = 0.0;
+        T gpu_result = 0;
+        gpu_result = profileReduce<T>(datatype, size, numThreads, numBlocks, maxThreads, maxBlocks,
+                                        whichKernel, testIterations, cpuFinalReduction, 
+                                        cpuFinalThreshold, &dTotalTime,
+                                        h_odata, d_idata, d_odata);
+
+#ifdef GPU_PROFILING
+        double reduceTime = dTotalTime/(double)testIterations;
+        shrLogEx(LOGBOTH | MASTER, 0, "oclReduction, Throughput = %.4f GB/s, Time = %.5f s, Size = %u Elements, NumDevsUsed = %d, Workgroup = %u\n", 
+               1.0e-9 * ((double)bytes)/reduceTime, reduceTime, size, 1, numThreads);
+#endif
+
+        // compute reference solution
+        shrLog("\nComparing against Host/C++ computation...\n"); 
+        T cpu_result = reduceCPU<T>(h_idata, size);
+        if (datatype == REDUCE_INT)
+        {
+            shrLog(" GPU result = %d\n", gpu_result);
+            shrLog(" CPU result = %d\n\n", cpu_result);
+            shrLog("%s\n\n", (gpu_result == cpu_result) ? "PASSED" : "FAILED");
+        }
+        else
+        {
+            shrLog(" GPU result = %.9f\n", gpu_result);
+            shrLog(" CPU result = %.9f\n\n", cpu_result);
+
+            double threshold = (datatype == REDUCE_FLOAT) ? 1e-8 * size : 1e-12;
+            double diff = abs((double)gpu_result - (double)cpu_result);
+            shrLog("%s\n\n", (diff < threshold) ? "PASSED" : "FAILED");
+        }
+      
+        // cleanup
+        free(h_idata);
+        free(h_odata);
+        clReleaseMemObject(d_idata);
+        clReleaseMemObject(d_odata);
+
+        return (gpu_result == cpu_result);
+    }
+}
+
+// Helper function to create and build program and kernel
+// *********************************************************************
+cl_kernel getReductionKernel(ReduceType datatype, int whichKernel, int blockSize, int isPowOf2)
+{
+    // compile cl program
+    size_t program_length;
+    char *source; 
+
+    std::ostringstream preamble;   
+
+    // create the program
+    // with type specification depending on datatype argument
+    switch (datatype)
+    {
+    default:
+    case REDUCE_INT:
+        preamble << "#define T int" << std::endl;
+        break;
+    case REDUCE_FLOAT:
+        preamble << "#define T float" << std::endl;
+        break;
+    }
+    
+    // set blockSize at compile time
+    preamble << "#define blockSize " << blockSize << std::endl;
+    
+    // set isPow2 at compile time
+    preamble << "#define nIsPow2 " << isPowOf2 << std::endl;
+    
+    // Load the source code and prepend the preamble
+    source = oclLoadProgSource(source_path, preamble.str().c_str(), &program_length);
+    //oclCheckError(source != NULL, shrTRUE);
+    
+    program =
+      clCreateProgramWithBuiltInKernels(context, 1, &device_id, "reduce0", NULL);
+    //cl_program rv_program = clCreateProgramWithSource(cxGPUContext, 1,(const char **) &source, 
+     //                                                &program_length, &ciErrNum);
+    //oclCheckError(ciErrNum, CL_SUCCESS);
+    free(source);
+
+    // build the program
+    ciErrNum = clBuildProgram(rv_program, 0, NULL, "-cl-fast-relaxed-math", NULL, NULL);
+    if (ciErrNum != CL_SUCCESS)
+    {
+        // write out standard error, Build Log and PTX, then cleanup and exit
+        shrLogEx(LOGBOTH | ERRORMSG, ciErrNum, STDERROR);
+        oclLogBuildInfo(rv_program, oclGetFirstDev(cxGPUContext));
+        oclLogPtx(rv_program, oclGetFirstDev(cxGPUContext), "oclReduction.ptx");
+        //oclCheckError(ciErrNum, CL_SUCCESS); 
+    }
+    
+    // create Kernel    
+    std::ostringstream kernelName;
+    kernelName << "reduce" << whichKernel;    
+    cl_kernel ckKernel = clCreateKernel(rv_program, kernelName.str().c_str(), &ciErrNum);
+    //oclCheckError(ciErrNum, CL_SUCCESS);
+
+    size_t wgSize;
+    ciErrNum = clGetKernelWorkGroupInfo(ckKernel, device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &wgSize, NULL);
+    if (wgSize == 64) 
+      smallBlock = true;
+    else smallBlock = false;
+
+    // NOTE: the program will get deleted when the kernel is also released
+    clReleaseProgram(rv_program);
+    
+    return ckKernel;
+}

benchmarks/opencl/reduce0/oclReduction.h

@@ -0,0 +1,34 @@
+/*
+ * 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 __REDUCTION_H__
+#define __REDUCTION_H__
+
+template <class T>
+void reduce_sm10(int size, int threads, int blocks, 
+                 int whichKernel, T *d_idata, T *d_odata);
+
+template <class T>
+void reduce_sm13(int size, int threads, int blocks, 
+                 int whichKernel, T *d_idata, T *d_odata);
+
+// CL objects
+cl_platform_id cpPlatform;
+cl_uint uiNumDevices;
+cl_device_id* cdDevices; 
+cl_context cxGPUContext;
+cl_command_queue cqCommandQueue;
+cl_device_id device;
+cl_int ciErrNum;
+const char* source_path;
+bool smallBlock = true;
+
+#endif

benchmarks/opencl/reduce0/oclReduction_kernel.cl

@@ -0,0 +1,273 @@
+/*
+ * 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.
+ *
+ */
+
+/*
+    Parallel reduction kernels
+*/
+
+// The following defines are set during runtime compilation, see reduction.cpp
+// #define T float
+// #define blockSize 128
+// #define nIsPow2 1
+
+#ifndef _REDUCE_KERNEL_H_
+#define _REDUCE_KERNEL_H_
+
+/*
+    Parallel sum reduction using shared memory
+    - takes log(n) steps for n input elements
+    - uses n threads
+    - only works for power-of-2 arrays
+*/
+
+/* This reduction interleaves which threads are active by using the modulo
+   operator.  This operator is very expensive on GPUs, and the interleaved 
+   inactivity means that no whole warps are active, which is also very 
+   inefficient */
+__kernel void reduce0(__global T *g_idata, __global T *g_odata, unsigned int n, __local T* sdata)
+{
+    // load shared mem
+    unsigned int tid = get_local_id(0);
+    unsigned int i = get_global_id(0);
+    
+    sdata[tid] = (i < n) ? g_idata[i] : 0;
+    
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    // do reduction in shared mem
+    for(unsigned int s=1; s < get_local_size(0); s *= 2) {
+        // modulo arithmetic is slow!
+        if ((tid % (2*s)) == 0) {
+            sdata[tid] += sdata[tid + s];
+        }
+        barrier(CLK_LOCAL_MEM_FENCE);
+    }
+
+    // write result for this block to global mem
+    if (tid == 0) g_odata[get_group_id(0)] = sdata[0];
+}
+
+
+/* This version uses contiguous threads, but its interleaved 
+   addressing results in many shared memory bank conflicts. */
+__kernel void reduce1(__global T *g_idata, __global T *g_odata, unsigned int n, __local T* sdata)
+{
+    // load shared mem
+    unsigned int tid = get_local_id(0);
+    unsigned int i = get_global_id(0);
+    
+    sdata[tid] = (i < n) ? g_idata[i] : 0;
+    
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    // do reduction in shared mem
+    for(unsigned int s=1; s < get_local_size(0); s *= 2) 
+    {
+        int index = 2 * s * tid;
+
+        if (index < get_local_size(0)) 
+        {
+            sdata[index] += sdata[index + s];
+        }
+
+        barrier(CLK_LOCAL_MEM_FENCE);
+    }
+
+    // write result for this block to global mem
+    if (tid == 0) g_odata[get_group_id(0)] = sdata[0];
+}
+
+/*
+    This version uses sequential addressing -- no divergence or bank conflicts.
+*/
+__kernel void reduce2(__global T *g_idata, __global T *g_odata, unsigned int n, __local T* sdata)
+{
+    // load shared mem
+    unsigned int tid = get_local_id(0);
+    unsigned int i = get_global_id(0);
+    
+    sdata[tid] = (i < n) ? g_idata[i] : 0;
+    
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    // do reduction in shared mem
+    for(unsigned int s=get_local_size(0)/2; s>0; s>>=1) 
+    {
+        if (tid < s) 
+        {
+            sdata[tid] += sdata[tid + s];
+        }
+        barrier(CLK_LOCAL_MEM_FENCE);
+    }
+
+    // write result for this block to global mem
+    if (tid == 0) g_odata[get_group_id(0)] = sdata[0];
+}
+
+/*
+    This version uses n/2 threads --
+    it performs the first level of reduction when reading from global memory
+*/
+__kernel void reduce3(__global T *g_idata, __global T *g_odata, unsigned int n, __local T* sdata)
+{
+    // perform first level of reduction,
+    // reading from global memory, writing to shared memory
+    unsigned int tid = get_local_id(0);
+    unsigned int i = get_group_id(0)*(get_local_size(0)*2) + get_local_id(0);
+
+    sdata[tid] = (i < n) ? g_idata[i] : 0;
+    if (i + get_local_size(0) < n) 
+        sdata[tid] += g_idata[i+get_local_size(0)];  
+
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    // do reduction in shared mem
+    for(unsigned int s=get_local_size(0)/2; s>0; s>>=1) 
+    {
+        if (tid < s) 
+        {
+            sdata[tid] += sdata[tid + s];
+        }
+        barrier(CLK_LOCAL_MEM_FENCE);
+    }
+
+    // write result for this block to global mem 
+    if (tid == 0) g_odata[get_group_id(0)] = sdata[0];
+}
+
+/*
+    This version unrolls the last warp to avoid synchronization where it 
+    isn't needed
+*/
+__kernel void reduce4(__global T *g_idata, __global T *g_odata, unsigned int n, __local volatile T* sdata)
+{
+    // perform first level of reduction,
+    // reading from global memory, writing to shared memory
+    unsigned int tid = get_local_id(0);
+    unsigned int i = get_group_id(0)*(get_local_size(0)*2) + get_local_id(0);
+
+    sdata[tid] = (i < n) ? g_idata[i] : 0;
+    if (i + get_local_size(0) < n) 
+        sdata[tid] += g_idata[i+get_local_size(0)];  
+
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    // do reduction in shared mem
+    #pragma unroll 1
+    for(unsigned int s=get_local_size(0)/2; s>32; s>>=1) 
+    {
+        if (tid < s) 
+        {
+            sdata[tid] += sdata[tid + s];
+        }
+        barrier(CLK_LOCAL_MEM_FENCE);
+    }
+
+    if (tid < 32)
+    {
+        if (blockSize >=  64) { sdata[tid] += sdata[tid + 32]; }
+        if (blockSize >=  32) { sdata[tid] += sdata[tid + 16]; }
+        if (blockSize >=  16) { sdata[tid] += sdata[tid +  8]; }
+        if (blockSize >=   8) { sdata[tid] += sdata[tid +  4]; }
+        if (blockSize >=   4) { sdata[tid] += sdata[tid +  2]; }
+        if (blockSize >=   2) { sdata[tid] += sdata[tid +  1]; }
+    }
+
+    // write result for this block to global mem 
+    if (tid == 0) g_odata[get_group_id(0)] = sdata[0];
+}
+
+/*
+    This version is completely unrolled.  It uses a template parameter to achieve 
+    optimal code for any (power of 2) number of threads.  This requires a switch 
+    statement in the host code to handle all the different thread block sizes at 
+    compile time.
+*/
+__kernel void reduce5(__global T *g_idata, __global T *g_odata, unsigned int n, __local volatile T* sdata)
+{
+    // perform first level of reduction,
+    // reading from global memory, writing to shared memory
+    unsigned int tid = get_local_id(0);
+    unsigned int i = get_group_id(0)*(get_local_size(0)*2) + get_local_id(0);
+
+    sdata[tid] = (i < n) ? g_idata[i] : 0;
+    if (i + blockSize < n) 
+        sdata[tid] += g_idata[i+blockSize];  
+
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    // do reduction in shared mem
+    if (blockSize >= 512) { if (tid < 256) { sdata[tid] += sdata[tid + 256]; } barrier(CLK_LOCAL_MEM_FENCE); }
+    if (blockSize >= 256) { if (tid < 128) { sdata[tid] += sdata[tid + 128]; } barrier(CLK_LOCAL_MEM_FENCE); }
+    if (blockSize >= 128) { if (tid <  64) { sdata[tid] += sdata[tid +  64]; } barrier(CLK_LOCAL_MEM_FENCE); }
+    
+    if (tid < 32)
+    {
+        if (blockSize >=  64) { sdata[tid] += sdata[tid + 32]; }
+        if (blockSize >=  32) { sdata[tid] += sdata[tid + 16]; }
+        if (blockSize >=  16) { sdata[tid] += sdata[tid +  8]; }
+        if (blockSize >=   8) { sdata[tid] += sdata[tid +  4]; }
+        if (blockSize >=   4) { sdata[tid] += sdata[tid +  2]; }
+        if (blockSize >=   2) { sdata[tid] += sdata[tid +  1]; }
+    }
+    
+    // write result for this block to global mem 
+    if (tid == 0) g_odata[get_group_id(0)] = sdata[0];
+}
+
+/*
+    This version adds multiple elements per thread sequentially.  This reduces the overall
+    cost of the algorithm while keeping the work complexity O(n) and the step complexity O(log n).
+    (Brent's Theorem optimization)
+*/
+__kernel void reduce6(__global T *g_idata, __global T *g_odata, unsigned int n, __local volatile T* sdata)
+{
+    // perform first level of reduction,
+    // reading from global memory, writing to shared memory
+    unsigned int tid = get_local_id(0);
+    unsigned int i = get_group_id(0)*(get_local_size(0)*2) + get_local_id(0);
+    unsigned int gridSize = blockSize*2*get_num_groups(0);
+    sdata[tid] = 0;
+
+    // we reduce multiple elements per thread.  The number is determined by the 
+    // number of active thread blocks (via gridDim).  More blocks will result
+    // in a larger gridSize and therefore fewer elements per thread
+    while (i < n)
+    {         
+        sdata[tid] += g_idata[i];
+        // ensure we don't read out of bounds -- this is optimized away for powerOf2 sized arrays
+        if (nIsPow2 || i + blockSize < n) 
+            sdata[tid] += g_idata[i+blockSize];  
+        i += gridSize;
+    } 
+
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    // do reduction in shared mem
+    if (blockSize >= 512) { if (tid < 256) { sdata[tid] += sdata[tid + 256]; } barrier(CLK_LOCAL_MEM_FENCE); }
+    if (blockSize >= 256) { if (tid < 128) { sdata[tid] += sdata[tid + 128]; } barrier(CLK_LOCAL_MEM_FENCE); }
+    if (blockSize >= 128) { if (tid <  64) { sdata[tid] += sdata[tid +  64]; } barrier(CLK_LOCAL_MEM_FENCE); }
+    
+    if (tid < 32)
+    {
+        if (blockSize >=  64) { sdata[tid] += sdata[tid + 32]; }
+        if (blockSize >=  32) { sdata[tid] += sdata[tid + 16]; }
+        if (blockSize >=  16) { sdata[tid] += sdata[tid +  8]; }
+        if (blockSize >=   8) { sdata[tid] += sdata[tid +  4]; }
+        if (blockSize >=   4) { sdata[tid] += sdata[tid +  2]; }
+        if (blockSize >=   2) { sdata[tid] += sdata[tid +  1]; }
+    }
+    
+    // write result for this block to global mem 
+    if (tid == 0) g_odata[get_group_id(0)] = sdata[0];
+}
+
+#endif // #ifndef _REDUCE_KERNEL_H_

benchmarks/opencl/reduce0/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 <shrUtils.h>
+
+// All OpenCL headers
+#if defined (__APPLE__) || defined(MACOSX)
+    #include <OpenCL/opencl.h>
+#else
+    #include <CL/opencl.h>
+#endif 
+
+// Includes
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+// For systems with CL_EXT that are not updated with these extensions, we copied these
+// extensions from <CL/cl_ext.h>
+#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

benchmarks/opencl/reduce0/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 <windows.h>
+	#include <time.h>
+#else
+    // Headers needed for Linux
+    #include <sys/stat.h>
+    #include <sys/types.h>
+    #include <sys/time.h>
+    #include <stdio.h>
+    #include <stdlib.h>
+    #include <string.h>
+    #include <stdarg.h>
+    #include <unistd.h>
+    #include <time.h>
+#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 <Enter> 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

benchmarks/opencl/reduce0/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 <windows.h>
+#else
+    // Headers needed for Linux
+    #include <sys/stat.h>
+    #include <sys/types.h>
+    #include <sys/time.h>
+    #include <stdio.h>
+    #include <stdlib.h>
+    #include <string.h>
+    #include <stdarg.h>
+#endif
+
+// Other headers needed for both Windows and Linux
+#include <math.h>
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+// 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 <Enter> to Quit...\n");                  
+        getchar();                                                           
+    }       
+    else 
+    {
+        shrLogEx(LOGBOTH | CLOSELOG, 0, "%s Exiting...\n", argv[0]); 
+    }
+    fflush(stderr);                                                         
+    exit(iExitCode);
+}
+
+#endif

benchmarks/opencl/sad/DESCRIPTION

@@ -0,0 +1 @@
+Inputs: reference.bin frame.bin

benchmarks/opencl/sad/Makefile

@@ -0,0 +1,67 @@
+RISCV_TOOL_PATH ?= $(wildcard ../../../../riscv-gnu-toolchain/drops)
+POCL_CC_PATH ?= $(wildcard ../../../../pocl/drops_riscv_cc)
+POCL_INC_PATH ?= $(wildcard ../include)
+POCL_LIB_PATH ?= $(wildcard ../lib)
+VX_RT_PATH ?= $(wildcard ../../../runtime)
+VX_SIMX_PATH ?= $(wildcard ../../../simX/obj_dir)
+
+CC  = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-gcc
+CXX = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-g++
+DMP = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-objdump
+HEX = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-objcopy
+GDB = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-gdb
+
+VX_SRCS =  $(VX_RT_PATH)/newlib/newlib.c
+VX_SRCS += $(VX_RT_PATH)/startup/vx_start.S
+VX_SRCS += $(VX_RT_PATH)/intrinsics/vx_intrinsics.S
+VX_SRCS += $(VX_RT_PATH)/io/vx_io.S $(VX_RT_PATH)/io/vx_io.c
+VX_SRCS += $(VX_RT_PATH)/fileio/fileio.S
+VX_SRCS += $(VX_RT_PATH)/tests/tests.c
+VX_SRCS += $(VX_RT_PATH)/vx_api/vx_api.c
+
+VX_CFLAGS = -nostartfiles -Wl,-Bstatic,-T,$(VX_RT_PATH)/startup/vx_link.ld
+
+CXXFLAGS =  -g -O0 -march=rv32im -mabi=ilp32 
+CXXFLAGS += -ffreestanding # program may not begin at main()
+CXXFLAGS += -Wl,--gc-sections # enable garbage collection of unused input sections
+CXXFLAGS += -fno-rtti -fno-non-call-exceptions # disable RTTI and exceptions
+CXXFLAGS += -I$(POCL_INC_PATH) -I.
+
+VX_LIBS = -Wl,--whole-archive lib$(PROJECT).a -Wl,--no-whole-archive $(POCL_LIB_PATH)/libOpenCL.a
+QEMU_LIBS = $(VX_RT_PATH)/qemu/vx_api.c -Wl,--whole-archive lib$(PROJECT).a -Wl,--no-whole-archive $(POCL_LIB_PATH)/libOpenCL.a
+
+PROJECT = sad
+
+SRCS = main.cc args.c parboil_opencl.c ocl.c gpu_info.c file.c image.c OpenCL_common.cpp
+
+all: $(PROJECT).dump $(PROJECT).hex
+
+lib$(PROJECT).a: kernel.cl
+	POCL_DEBUG=all POCL_DEBUG_LLVM_PASSES=1 LD_LIBRARY_PATH=$(RISCV_TOOL_PATH)/lib:$(POCL_CC_PATH)/lib $(POCL_CC_PATH)/bin/poclcc -o lib$(PROJECT).a kernel.cl
+
+$(PROJECT).elf: $(SRCS) lib$(PROJECT).a
+	$(CXX) $(CXXFLAGS) $(VX_CFLAGS) $(VX_SRCS) $(SRCS) $(VX_LIBS) -o $(PROJECT).elf
+
+$(PROJECT).qemu: $(SRCS) lib$(PROJECT).a
+	$(CXX) $(CXXFLAGS) $(SRCS) $(QEMU_LIBS) -o $(PROJECT).qemu
+
+$(PROJECT).hex: $(PROJECT).elf
+	$(HEX) -O ihex $(PROJECT).elf $(PROJECT).hex
+
+$(PROJECT).dump: $(PROJECT).elf
+	$(DMP) -D $(PROJECT).elf > $(PROJECT).dump
+
+run: $(PROJECT).hex
+	POCL_DEBUG=all $(VX_SIMX_PATH)/Vcache_simX -E -a rv32i --core $(PROJECT).hex -s -b 1> emulator.debug
+
+qemu: $(PROJECT).qemu
+	POCL_DEBUG=all $(RISCV_TOOL_PATH)/bin/qemu-riscv32 -d in_asm -D debug.log $(PROJECT).qemu
+
+gdb-s: $(PROJECT).qemu
+	POCL_DEBUG=all $(RISCV_TOOL_PATH)/bin/qemu-riscv32 -g 1234 -d in_asm -D debug.log $(PROJECT).qemu
+
+gdb-c: $(PROJECT).qemu
+	$(GDB) $(PROJECT).qemu
+
+clean:
+	rm -rf *.o *.elf *.dump *.hex *.qemu *.log *.debug

benchmarks/opencl/sad/OpenCL_common.cpp

@@ -0,0 +1,298 @@
+
+
+#include "OpenCL_common.h"
+#include <stdlib.h>
+#include <string.h>
+
+// -1 for NO suitable device found, 0 if an appropriate device was found
+int getOpenCLDevice(cl_platform_id *platform, cl_device_id *device, cl_device_type *reqDeviceType, int numRequests, ...) {
+      
+        // Supported Device Requests (anything that returns cl_bool)
+        //   CL_DEVICE_IMAGE_SUPPORT
+        //   CL_DEVICE_HOST_UNIFIED_MEMORY
+        //   CL_DEVICE_ERROR_CORRECTION_SUPPORT
+        //   CL_DEVICE_AVAILABLE
+        //   CL_DEVICE_COMPILER_AVAILABLE
+  
+  cl_uint numEntries = 16;
+  cl_platform_id clPlatforms[numEntries];
+  cl_uint numPlatforms;
+  
+  cl_device_id clDevices[numEntries];
+  cl_uint numDevices;
+
+  OCL_ERRCK_RETVAL ( clGetPlatformIDs(numEntries, clPlatforms, &numPlatforms) );
+  //fprintf(stderr, "Number of Platforms found: %d\n", numPlatforms);
+  bool needDevice = true;
+  
+  for (int ip = 0; ip < numPlatforms && needDevice; ++ip) {
+
+    cl_platform_id clPlatform = clPlatforms[ip];
+    
+    OCL_ERRCK_RETVAL ( clGetDeviceIDs(clPlatform, CL_DEVICE_TYPE_ALL, numEntries, clDevices, &numDevices) );
+    //fprintf(stderr, "  Number of Devices found for Platform %d: %d\n", ip, numDevices);
+    
+    for (int id = 0; (id < numDevices) && needDevice ; ++id) {
+      cl_device_id clDevice = clDevices[id];
+      cl_device_type clDeviceType;
+
+      bool canSatisfy = true;
+      
+      if (reqDeviceType != NULL) {
+        OCL_ERRCK_RETVAL( clGetDeviceInfo(clDevice, CL_DEVICE_TYPE, sizeof(cl_device_type), &clDeviceType, NULL));
+        if (*reqDeviceType != CL_DEVICE_TYPE_ALL) {
+          if (*reqDeviceType != clDeviceType) {
+            canSatisfy = false;
+          }
+        }
+      }
+
+      va_list paramList;
+      va_start(paramList, numRequests);
+      for (int i = 0; (i < numRequests) && canSatisfy ; ++i) {
+      
+        cl_device_info devReq = va_arg( paramList, cl_device_info );  
+        cl_bool clInfoBool;
+        size_t infoRetSize = sizeof(cl_bool);
+        
+        OCL_ERRCK_RETVAL( clGetDeviceInfo(clDevice, devReq, infoRetSize, &clInfoBool, NULL));
+        if (clInfoBool != true) {
+          canSatisfy = false;
+        }
+      }
+      
+      va_end(paramList);
+      if (canSatisfy) {
+        *device = clDevice;
+        *platform = clPlatform;
+        needDevice = false;
+        if (reqDeviceType != NULL && (*reqDeviceType == CL_DEVICE_TYPE_ALL)) {
+          *reqDeviceType = clDeviceType;
+        }
+      }
+    } // End checking all devices for a platform
+  } // End checking all platforms
+
+  int retVal = -1;
+  if (needDevice) {
+    retVal = -1;
+  } else {
+    retVal = 0;
+  }
+  
+  return retVal;
+
+}
+
+const char* oclErrorString(cl_int error)
+{
+// From NVIDIA SDK
+	static const char* errorString[] = {
+		"CL_SUCCESS",
+		"CL_DEVICE_NOT_FOUND",
+		"CL_DEVICE_NOT_AVAILABLE",
+		"CL_COMPILER_NOT_AVAILABLE",
+		"CL_MEM_OBJECT_ALLOCATION_FAILURE",
+		"CL_OUT_OF_RESOURCES",
+		"CL_OUT_OF_HOST_MEMORY",
+		"CL_PROFILING_INFO_NOT_AVAILABLE",
+		"CL_MEM_COPY_OVERLAP",
+		"CL_IMAGE_FORMAT_MISMATCH",
+		"CL_IMAGE_FORMAT_NOT_SUPPORTED",
+		"CL_BUILD_PROGRAM_FAILURE",
+		"CL_MAP_FAILURE",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"CL_INVALID_VALUE",
+		"CL_INVALID_DEVICE_TYPE",
+		"CL_INVALID_PLATFORM",
+		"CL_INVALID_DEVICE",
+		"CL_INVALID_CONTEXT",
+		"CL_INVALID_QUEUE_PROPERTIES",
+		"CL_INVALID_COMMAND_QUEUE",
+		"CL_INVALID_HOST_PTR",
+		"CL_INVALID_MEM_OBJECT",
+		"CL_INVALID_IMAGE_FORMAT_DESCRIPTOR",
+		"CL_INVALID_IMAGE_SIZE",
+		"CL_INVALID_SAMPLER",
+		"CL_INVALID_BINARY",
+		"CL_INVALID_BUILD_OPTIONS",
+		"CL_INVALID_PROGRAM",
+		"CL_INVALID_PROGRAM_EXECUTABLE",
+		"CL_INVALID_KERNEL_NAME",
+		"CL_INVALID_KERNEL_DEFINITION",
+		"CL_INVALID_KERNEL",
+		"CL_INVALID_ARG_INDEX",
+		"CL_INVALID_ARG_VALUE",
+		"CL_INVALID_ARG_SIZE",
+		"CL_INVALID_KERNEL_ARGS",
+		"CL_INVALID_WORK_DIMENSION",
+		"CL_INVALID_WORK_GROUP_SIZE",
+		"CL_INVALID_WORK_ITEM_SIZE",
+		"CL_INVALID_GLOBAL_OFFSET",
+		"CL_INVALID_EVENT_WAIT_LIST",
+		"CL_INVALID_EVENT",
+		"CL_INVALID_OPERATION",
+		"CL_INVALID_GL_OBJECT",
+		"CL_INVALID_BUFFER_SIZE",
+		"CL_INVALID_MIP_LEVEL",
+		"CL_INVALID_GLOBAL_WORK_SIZE",
+	};
+
+	const int errorCount = sizeof(errorString) / sizeof(errorString[0]);
+
+	const int index = -error;
+
+	return (index >= 0 && index < errorCount) ? errorString[index] : "";
+}
+
+
+const char* oclDebugErrString(cl_int error, cl_device_id device)
+{
+// From NVIDIA SDK
+	static const char* errorString[] = {
+		"CL_SUCCESS",
+		"CL_DEVICE_NOT_FOUND",
+		"CL_DEVICE_NOT_AVAILABLE",
+		"CL_COMPILER_NOT_AVAILABLE",
+		"CL_MEM_OBJECT_ALLOCATION_FAILURE",
+		"CL_OUT_OF_RESOURCES",
+		"CL_OUT_OF_HOST_MEMORY",
+		"CL_PROFILING_INFO_NOT_AVAILABLE",
+		"CL_MEM_COPY_OVERLAP",
+		"CL_IMAGE_FORMAT_MISMATCH",
+		"CL_IMAGE_FORMAT_NOT_SUPPORTED",
+		"CL_BUILD_PROGRAM_FAILURE",
+		"CL_MAP_FAILURE",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"CL_INVALID_VALUE",
+		"CL_INVALID_DEVICE_TYPE",
+		"CL_INVALID_PLATFORM",
+		"CL_INVALID_DEVICE",
+		"CL_INVALID_CONTEXT",
+		"CL_INVALID_QUEUE_PROPERTIES",
+		"CL_INVALID_COMMAND_QUEUE",
+		"CL_INVALID_HOST_PTR",
+		"CL_INVALID_MEM_OBJECT",
+		"CL_INVALID_IMAGE_FORMAT_DESCRIPTOR",
+		"CL_INVALID_IMAGE_SIZE",
+		"CL_INVALID_SAMPLER",
+		"CL_INVALID_BINARY",
+		"CL_INVALID_BUILD_OPTIONS",
+		"CL_INVALID_PROGRAM",
+		"CL_INVALID_PROGRAM_EXECUTABLE",
+		"CL_INVALID_KERNEL_NAME",
+		"CL_INVALID_KERNEL_DEFINITION",
+		"CL_INVALID_KERNEL",
+		"CL_INVALID_ARG_INDEX",
+		"CL_INVALID_ARG_VALUE",
+		"CL_INVALID_ARG_SIZE",
+		"CL_INVALID_KERNEL_ARGS",
+		"CL_INVALID_WORK_DIMENSION",
+		"CL_INVALID_WORK_GROUP_SIZE",
+		"CL_INVALID_WORK_ITEM_SIZE",
+		"CL_INVALID_GLOBAL_OFFSET",
+		"CL_INVALID_EVENT_WAIT_LIST",
+		"CL_INVALID_EVENT",
+		"CL_INVALID_OPERATION",
+		"CL_INVALID_GL_OBJECT",
+		"CL_INVALID_BUFFER_SIZE",
+		"CL_INVALID_MIP_LEVEL",
+		"CL_INVALID_GLOBAL_WORK_SIZE",
+	};
+
+	const int errorCount = sizeof(errorString) / sizeof(errorString[0]);
+
+	const int index = -error;
+	
+	if (index == 4) {
+	cl_uint maxMemAlloc = 0;
+	
+	OCL_ERRCK_RETVAL ( clGetDeviceInfo(	device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof(cl_ulong), &maxMemAlloc, NULL) );
+
+	
+	  fprintf(stderr, "  Device Maximum block allocation size: %lu\n", maxMemAlloc);
+	}
+
+	return (index >= 0 && index < errorCount) ? errorString[index] : "";
+}
+
+char* oclLoadProgSource(const char* cFilename, const char* cPreamble, size_t* szFinalLength)
+{
+    // locals 
+    FILE* pFileStream = NULL;
+    size_t szSourceLength;
+
+    // open the OpenCL source code file
+    #ifdef _WIN32   // Windows version
+        if(fopen_s(&pFileStream, cFilename, "rb") != 0) 
+        {       
+            return NULL;
+        }
+    #else           // Linux version
+        pFileStream = fopen(cFilename, "rb");
+        if(pFileStream == 0) 
+        {       
+            return NULL;
+        }
+    #endif
+
+    size_t szPreambleLength = strlen(cPreamble);
+    szPreambleLength = 0;
+
+    // get the length of the source code
+    fseek(pFileStream, 0, SEEK_END); 
+    szSourceLength = ftell(pFileStream);
+    fseek(pFileStream, 0, SEEK_SET); 
+
+    // allocate a buffer for the source code string and read it in
+    char* cSourceString = (char *)malloc(szSourceLength + szPreambleLength + 1); 
+    memcpy(cSourceString, cPreamble, szPreambleLength);
+    if (fread((cSourceString) + szPreambleLength, szSourceLength, 1, pFileStream) != 1)
+    {
+        fclose(pFileStream);
+        free(cSourceString);
+        return 0;
+    }
+
+    // close the file and return the total length of the combined (preamble + source) string
+    fclose(pFileStream);
+    if(szFinalLength != 0)
+    {
+        *szFinalLength = szSourceLength + szPreambleLength;
+    }
+    cSourceString[szSourceLength + szPreambleLength] = '\0';
+
+    return cSourceString;
+}

benchmarks/opencl/sad/OpenCL_common.h

@@ -0,0 +1,22 @@
+
+#ifndef __OPENCL_COMMON_H_
+#define __OPENCL_COMMON_H_
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <CL/cl.h>
+
+int getOpenCLDevice(cl_platform_id *platform, cl_device_id *device, cl_device_type *reqDeviceType, int numRequests, ...);
+const char* oclErrorString(cl_int error);
+const char* oclDebugErrString(cl_int error, cl_device_id device);
+
+#define OCL_ERRCK_VAR(var) \
+  { if (var != CL_SUCCESS) fprintf(stderr, "OpenCL Error (%s: %d): %s\n", __FILE__, __LINE__, oclErrorString(var)); }  
+  
+#define OCL_ERRCK_RETVAL(s) \
+  { cl_int clerr = (s);\
+    if (clerr != CL_SUCCESS) fprintf(stderr, "OpenCL Error (%s: %d): %s\n", __FILE__, __LINE__, oclErrorString(clerr)); }
+
+char* oclLoadProgSource(const char* cFilename, const char* cPreamble, size_t* szFinalLength);
+
+#endif

benchmarks/opencl/sad/args.c

@@ -0,0 +1,617 @@
+
+#include <parboil.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+/*****************************************************************************/
+/* Memory management routines */
+
+/* Free an array of owned strings. */
+void
+pb_FreeStringArray(char **string_array)
+{
+  char **p;
+
+  if (!string_array) return;
+  for (p = string_array; *p; p++) free(*p);
+  free(string_array);
+}
+
+struct pb_PlatformParam *
+pb_PlatformParam(char *name, char *version)
+{
+  if (name == NULL) {
+    fprintf(stderr, "pb_PlatformParam: Invalid argument\n");
+    exit(-1);
+  }
+
+  struct pb_PlatformParam *ret =
+    (struct pb_PlatformParam *)malloc(sizeof (struct pb_PlatformParam));
+
+  ret->name = name;
+  ret->version = version;
+  return ret;
+}
+
+void
+pb_FreePlatformParam(struct pb_PlatformParam *p)
+{
+  if (p == NULL) return;
+
+  free(p->name);
+  free(p->version);
+  free(p);
+}
+
+struct pb_DeviceParam *
+pb_DeviceParam_index(int index)
+{
+  struct pb_DeviceParam *ret =
+    (struct pb_DeviceParam *)malloc(sizeof (struct pb_DeviceParam));
+  ret->criterion = pb_Device_INDEX;
+  ret->index = index;
+  return ret;
+}
+
+struct pb_DeviceParam *
+pb_DeviceParam_cpu(void)
+{
+  struct pb_DeviceParam *ret =
+    (struct pb_DeviceParam *)malloc(sizeof (struct pb_DeviceParam));
+  ret->criterion = pb_Device_CPU;
+  return ret;
+}
+
+struct pb_DeviceParam *
+pb_DeviceParam_gpu(void)
+{
+  struct pb_DeviceParam *ret =
+    (struct pb_DeviceParam *)malloc(sizeof (struct pb_DeviceParam));
+  ret->criterion = pb_Device_GPU;
+  return ret;
+}
+
+struct pb_DeviceParam *
+pb_DeviceParam_accelerator(void)
+{
+  struct pb_DeviceParam *ret =
+    (struct pb_DeviceParam *)malloc(sizeof (struct pb_DeviceParam));
+  ret->criterion = pb_Device_ACCELERATOR;
+  return ret;
+}
+
+struct pb_DeviceParam *
+pb_DeviceParam_name(char *name)
+{
+  struct pb_DeviceParam *ret =
+    (struct pb_DeviceParam *)malloc(sizeof (struct pb_DeviceParam));
+  ret->criterion = pb_Device_NAME;
+  ret->name = name;
+  return ret;
+}
+
+void
+pb_FreeDeviceParam(struct pb_DeviceParam *p)
+{
+  if (p == NULL) return;
+
+  switch(p->criterion) {
+  case pb_Device_NAME:
+    free(p->name);
+    break;
+  case pb_Device_INDEX:
+  case pb_Device_CPU:
+  case pb_Device_ACCELERATOR:
+    break;
+  default:
+    fprintf(stderr, "pb_FreeDeviceParam: Invalid argument\n");
+    exit(-1);
+  }
+}
+
+void
+pb_FreeParameters(struct pb_Parameters *p)
+{
+  free(p->outFile);
+  pb_FreeStringArray(p->inpFiles);
+  pb_FreePlatformParam(p->platform);
+  pb_FreeDeviceParam(p->device);
+  free(p);
+}
+
+/*****************************************************************************/
+
+/* Parse a comma-delimited list of strings into an
+ * array of strings. */
+static char ** 
+read_string_array(char *in)
+{
+  char **ret;
+  int i;
+  int count;			/* Number of items in the input */
+  char *substring;		/* Current substring within 'in' */
+
+  /* Count the number of items in the string */
+  count = 1;
+  for (i = 0; in[i]; i++) if (in[i] == ',') count++;
+
+  /* Allocate storage */
+  ret = (char **)malloc((count + 1) * sizeof(char *));
+
+  /* Create copies of the strings from the list */
+  substring = in;
+  for (i = 0; i < count; i++) {
+    char *substring_end;
+    int substring_length;
+
+    /* Find length of substring */
+    for (substring_end = substring;
+	 (*substring_end != ',') && (*substring_end != 0);
+	 substring_end++);
+
+    substring_length = substring_end - substring;
+
+    /* Allocate memory and copy the substring */
+    ret[i] = (char *)malloc(substring_length + 1);
+    memcpy(ret[i], substring, substring_length);
+    ret[i][substring_length] = 0;
+
+    /* go to next substring */
+    substring = substring_end + 1;
+  }
+  ret[i] = NULL;		/* Write the sentinel value */
+
+  return ret;
+}
+
+static void
+report_parse_error(const char *str)
+{
+  fputs(str, stderr);
+}
+
+/* Interpret a string as a 'pb_DeviceParam' value.
+ * Return a pointer to a new value, or NULL on failure.
+ */
+static struct pb_DeviceParam *
+read_device_param(char *str)
+{  
+  /* Try different ways of interpreting 'device_string' until one works */
+
+  /* If argument is an integer, then interpret it as a device index */
+  errno = 0;
+  char *end;
+  long device_int = strtol(str, &end, 10);
+  if (!errno) {
+    /* Negative numbers are not valid */
+    if (device_int < 0 || device_int > INT_MAX) return NULL;
+
+    return pb_DeviceParam_index(device_int);
+  }
+
+  /* Match against predefined strings */
+  if (strcmp(str, "CPU") == 0)
+    return pb_DeviceParam_cpu();
+  if (strcmp(str, "GPU") == 0)
+    return pb_DeviceParam_gpu();
+  if (strcmp(str, "ACCELERATOR") == 0)
+    return pb_DeviceParam_accelerator();
+
+  /* Assume any other string is a device name */
+  return pb_DeviceParam_name(strdup(str));
+}
+
+/* Interpret a string as a 'pb_PlatformParam' value.
+ * Return a pointer to a new value, or NULL on failure.
+ */
+static struct pb_PlatformParam *
+read_platform_param(char *str)
+{
+  int separator_index;          /* Index of the '-' character separating
+                                 * name and version number.  It's -1 if
+                                 * there's no '-' character. */
+
+  /* Find the last occurrence of '-' in 'str' */
+  {
+    char *cur;
+    separator_index = -1;
+    for (cur = str; *cur; cur++) {
+      if (*cur == '-') separator_index = cur - str;
+    }
+  }
+
+  /* The platform name is either the entire string, or all characters before
+   * the separator */
+  int name_length = separator_index == -1 ? strlen(str) : separator_index;
+  char *name_str = (char *)malloc(name_length + 1);
+  memcpy(name_str, str, name_length);
+  name_str[name_length] = 0;
+
+  /* The version is either NULL, or all characters after the separator */
+  char *version_str;
+  if (separator_index == -1) {
+    version_str = NULL;
+  }
+  else {
+    const char *version_input_str = str + separator_index + 1;
+    int version_length = strlen(version_input_str);
+
+    version_str = (char *)malloc(version_length + 1);
+    memcpy(version_str, version_input_str, version_length);
+    version_str[version_length] = 0;
+  }
+
+  /* Create output structure */
+  return pb_PlatformParam(name_str, version_str);
+}
+
+/****************************************************************************/
+/* Argument parsing state */
+
+/* Argument parsing state.
+ *
+ * Arguments that are interpreted by the argument parser are removed from
+ * the list.  Variables 'argc' and 'argn' do not count arguments that have
+ * been removed.
+ *
+ * During argument parsing, the array of arguments is compacted, overwriting
+ * the erased arguments.  Variable 'argv_put' points to the array element
+ * where the next argument will be written.  Variable 'argv_get' points to
+ * the array element where the next argument will be read from.
+ */
+struct argparse {
+  int argc;			/* Number of arguments.  Mutable. */
+  int argn;			/* Current argument index. */
+  char **argv_get;		/* Argument value being read. */
+  char **argv_put;		/* Argument value being written.
+				 * argv_put <= argv_get. */
+};
+
+static void
+initialize_argparse(struct argparse *ap, int argc, char **argv)
+{
+  ap->argc = argc;
+  ap->argn = 0;
+  ap->argv_get = ap->argv_put = argv;
+}
+
+/* Finish argument parsing, without processing the remaining arguments.
+ * Write new argument count into _argc. */
+static void
+finalize_argparse(struct argparse *ap, int *_argc, char **argv)
+{
+  /* Move the remaining arguments */
+  for(; ap->argn < ap->argc; ap->argn++)
+    *ap->argv_put++ = *ap->argv_get++;
+
+  /* Update the argument count */
+  *_argc = ap->argc;
+
+  /* Insert a terminating NULL */
+  argv[ap->argc] = NULL;
+}
+
+/* Delete the current argument.  The argument will not be visible
+ * when argument parsing is done. */
+static void
+delete_argument(struct argparse *ap)
+{
+  if (ap->argn >= ap->argc) {
+    fprintf(stderr, "delete_argument\n");
+  }
+  ap->argc--;
+  ap->argv_get++;
+}
+
+/* Go to the next argument.  Also, move the current argument to its
+ * final location in argv. */
+static void
+next_argument(struct argparse *ap)
+{
+  if (ap->argn >= ap->argc) {
+    fprintf(stderr, "next_argument\n");
+  }
+  /* Move argument to its new location. */
+  *ap->argv_put++ = *ap->argv_get++;
+  ap->argn++;
+}
+
+static int
+is_end_of_arguments(struct argparse *ap)
+{
+  return ap->argn == ap->argc;
+}
+
+/* Get the current argument */
+static char *
+get_argument(struct argparse *ap)
+{
+  return *ap->argv_get;
+}
+
+/* Get the current argument, and also delete it */
+static char *
+consume_argument(struct argparse *ap)
+{
+  char *ret = get_argument(ap);
+  delete_argument(ap);
+  return ret;
+}
+
+/****************************************************************************/
+
+/* The result of parsing a command-line argument */
+typedef enum {
+  ARGPARSE_OK,                  /* Success */
+  ARGPARSE_ERROR,               /* Error */
+  ARGPARSE_DONE                 /* Success, and do not continue parsing */
+} result;
+
+typedef result parse_action(struct argparse *ap, struct pb_Parameters *params);
+
+
+/* A command-line option */
+struct option {
+  char short_name;              /* If not 0, the one-character
+                                 * name of this option */
+  const char *long_name;        /* If not NULL, the long name of this option */
+  parse_action *action;       /* What to do when this option occurs.
+                               * Sentinel value is NULL.
+                               */
+};
+
+/* Output file
+ *
+ * -o FILE
+ */
+static result
+parse_output_file(struct argparse *ap, struct pb_Parameters *params)
+{
+  if (is_end_of_arguments(ap))
+    {
+      report_parse_error("Expecting file name after '-o'\n");
+      return ARGPARSE_ERROR;
+    }
+
+  /* Replace the output file name */
+  free(params->outFile);
+  params->outFile = strdup(consume_argument(ap));
+
+  return ARGPARSE_OK;
+}
+
+/* Input files
+ *
+ * -i FILE,FILE,...
+ */
+static result
+parse_input_files(struct argparse *ap, struct pb_Parameters *params)
+{
+  if (is_end_of_arguments(ap))
+    {
+      report_parse_error("Expecting file name after '-i'\n");
+      return ARGPARSE_ERROR;
+    }
+
+  /* Replace the input file list */
+  pb_FreeStringArray(params->inpFiles);
+  params->inpFiles = read_string_array(consume_argument(ap));
+  return ARGPARSE_OK;
+}
+
+/* End of options
+ *
+ * --
+ */
+
+static result
+parse_end_options(struct argparse *ap, struct pb_Parameters *params)
+{
+  return ARGPARSE_DONE;
+}
+
+/* OpenCL device
+ *
+ * --device X
+ */
+
+static result
+parse_device(struct argparse *ap, struct pb_Parameters *params)
+{
+  /* Read the next argument, which specifies a device */
+
+  if (is_end_of_arguments(ap))
+    {
+      report_parse_error("Expecting device specification after '--device'\n");
+      return ARGPARSE_ERROR;
+    }
+
+  char *device_string = consume_argument(ap);
+  struct pb_DeviceParam *device_param = read_device_param(device_string);
+
+  if (!device_param) {
+    report_parse_error("Unrecognized device specification format on command line\n");
+    return ARGPARSE_ERROR;
+  }
+
+  /* Save the result */
+  pb_FreeDeviceParam(params->device);
+  params->device = device_param;
+
+  return ARGPARSE_OK;
+}
+
+static result
+parse_platform(struct argparse *ap, struct pb_Parameters *params)
+{
+  /* Read the next argument, which specifies a platform */
+
+  if (is_end_of_arguments(ap))
+    {
+      report_parse_error("Expecting device specification after '--platform'\n");
+      return ARGPARSE_ERROR;
+    }
+
+  char *platform_string = consume_argument(ap);
+  struct pb_PlatformParam *platform_param = read_platform_param(platform_string);
+
+  if (!platform_param) {
+    report_parse_error("Unrecognized platform specification format on command line\n");
+    return ARGPARSE_ERROR;
+  }
+
+  /* Save the result */
+  pb_FreePlatformParam(params->platform);
+  params->platform = platform_param;
+
+  return ARGPARSE_OK;
+}
+  
+
+static struct option options[] = {
+  { 'o', NULL, &parse_output_file },
+  { 'i', NULL, &parse_input_files },
+  { '-', NULL, &parse_end_options },
+  { 0, "device", &parse_device },
+  { 0, "platform", &parse_platform },
+  { 0, NULL, NULL }
+};
+
+static int
+is_last_option(struct option *op)
+{
+  return op->action == NULL;
+}
+
+/****************************************************************************/
+
+/* Parse command-line parameters.
+ * Return zero on error, nonzero otherwise.
+ * On error, the other outputs may be invalid.
+ *
+ * The information collected from parameters is used to update
+ * 'ret'.  'ret' should be initialized.
+ *
+ * '_argc' and 'argv' are updated to contain only the unprocessed arguments.
+ */
+static int
+pb_ParseParameters (struct pb_Parameters *ret, int *_argc, char **argv)
+{
+  char *err_message;
+  struct argparse ap;
+
+  /* Each argument */
+  initialize_argparse(&ap, *_argc, argv);
+  while(!is_end_of_arguments(&ap)) {
+    result arg_result;          /* Result of parsing this option */
+    char *arg = get_argument(&ap);
+
+    /* Process this argument */
+    if (arg[0] == '-') {
+      /* Single-character flag */
+      if ((arg[1] != 0) && (arg[2] == 0)) {
+        delete_argument(&ap);	/* This argument is consumed here */
+
+        /* Find a matching short option */
+        struct option *op;
+        for (op = options; !is_last_option(op); op++) {
+          if (op->short_name == arg[1]) {
+            arg_result = (*op->action)(&ap, ret);
+            goto option_was_processed;
+          }
+        }
+
+        /* No option matches */
+        report_parse_error("Unexpected command-line parameter\n");
+        arg_result = ARGPARSE_ERROR;
+        goto option_was_processed;
+      }
+
+      /* Long flag */
+      if (arg[1] == '-') {
+        delete_argument(&ap);	/* This argument is consumed here */
+
+        /* Find a matching long option */
+        struct option *op;
+        for (op = options; !is_last_option(op); op++) {
+          if (op->long_name && strcmp(&arg[2], op->long_name) == 0) {
+            arg_result = (*op->action)(&ap, ret);
+            goto option_was_processed;
+          }
+        }
+
+        /* No option matches */
+        report_parse_error("Unexpected command-line parameter\n");
+        arg_result = ARGPARSE_ERROR;
+        goto option_was_processed;
+      }
+    }
+    else {
+      /* Other arguments are ignored */
+      next_argument(&ap);
+      arg_result = ARGPARSE_OK;
+      goto option_was_processed;
+    }
+
+  option_was_processed:
+    /* Decide what to do next based on 'arg_result' */
+    switch(arg_result) {
+    case ARGPARSE_OK:
+      /* Continue processing */
+      break;
+
+    case ARGPARSE_ERROR:
+      /* Error exit from the function */
+      return 0;
+
+    case ARGPARSE_DONE:
+      /* Normal exit from the argument parsing loop */
+      goto end_of_options;
+    }
+  } /* end for each argument */
+
+  /* If all arguments were processed, then normal exit from the loop */
+
+ end_of_options:
+  finalize_argparse(&ap, _argc, argv);
+  return 1;
+}
+
+/*****************************************************************************/
+/* Other exported functions */
+
+struct pb_Parameters *
+pb_ReadParameters(int *_argc, char **argv)
+{
+  struct pb_Parameters *ret =
+    (struct pb_Parameters *)malloc(sizeof(struct pb_Parameters));
+
+  /* Initialize the parameters structure */
+  ret->outFile = NULL;
+  ret->inpFiles = (char **)malloc(sizeof(char *));
+  ret->inpFiles[0] = NULL;
+  ret->platform = NULL;
+  ret->device = NULL;
+
+  /* Read parameters and update _argc, argv */
+  if (!pb_ParseParameters(ret, _argc, argv)) {
+    /* Parse error */
+    pb_FreeParameters(ret);
+    return NULL;
+  }
+
+  return ret;
+}
+
+int
+pb_Parameters_CountInputs(struct pb_Parameters *p)
+{
+  int n;
+
+  for (n = 0; p->inpFiles[n]; n++);
+  return n;
+}
+

benchmarks/opencl/sad/file.c

@@ -0,0 +1,55 @@
+/***************************************************************************
+ *cr
+ *cr            (C) Copyright 2007 The Board of Trustees of the
+ *cr                        University of Illinois
+ *cr                         All Rights Reserved
+ *cr
+ ***************************************************************************/
+
+#include <stdio.h>
+#include "file.h"
+
+unsigned short
+read16u(FILE *f)
+{
+  int n;
+
+  n = fgetc(f);
+  n += fgetc(f) << 8;
+
+  return n;
+}
+
+short
+read16i(FILE *f)
+{
+  int n;
+
+  n = fgetc(f);
+  n += fgetc(f) << 8;
+
+  return n;
+}
+
+void
+write32u(FILE *f, unsigned int i)
+{
+  putc(i, f);
+  putc(i >> 8, f);
+  putc(i >> 16, f);
+  putc(i >> 24, f);
+}
+
+void
+write16u(FILE *f, unsigned short h)
+{
+  putc(h, f);
+  putc(h >> 8, f);
+}
+
+void
+write16i(FILE *f, short h)
+{
+  putc(h, f);
+  putc(h >> 8, f);
+}

benchmarks/opencl/sad/file.h

@@ -0,0 +1,22 @@
+/***************************************************************************
+ *cr
+ *cr            (C) Copyright 2007 The Board of Trustees of the
+ *cr                        University of Illinois
+ *cr                         All Rights Reserved
+ *cr
+ ***************************************************************************/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+unsigned short read16u(FILE *f);
+short read16i(FILE *f);
+
+void write32u(FILE *f, unsigned int i);
+void write16u(FILE *f, unsigned short h);
+void write16i(FILE *f, short h);
+
+#ifdef __cplusplus
+}
+#endif

benchmarks/opencl/sad/gpu_info.c

@@ -0,0 +1,55 @@
+/***************************************************************************
+ *cr
+ *cr            (C) Copyright 2010 The Board of Trustees of the
+ *cr                        University of Illinois
+ *cr                         All Rights Reserved
+ *cr
+ ***************************************************************************/
+//#include <endian.h>
+#include <stdlib.h>
+#include <malloc.h>
+#include <stdio.h>
+#include <inttypes.h>
+
+#include "gpu_info.h"
+
+void compute_active_thread(size_t *thread,
+			   size_t *grid,
+			   int task,
+			   int pad,
+			   int major,
+			   int minor,
+			   int sm)
+{
+	int max_thread;
+	int max_block=8;
+	if(major==1)
+	{
+		if(minor>=2)
+			max_thread=1024;
+		else
+			max_thread=768;
+	}
+	else if(major==2)
+		max_thread=1536;
+	else
+		//newer GPU  //keep using 2.0
+		max_thread=1536;
+	
+	int _grid;
+	int _thread;
+	
+	if(task*pad>sm*max_thread)
+	{
+		_thread=max_thread/max_block;
+		_grid = ((task*pad+_thread-1)/_thread)*_thread;
+	}
+	else
+	{
+		_thread=pad;
+		_grid=task*pad;
+	}
+
+	thread[0]=_thread;
+	grid[0]=_grid;
+}

benchmarks/opencl/sad/gpu_info.h

@@ -0,0 +1,20 @@
+/***************************************************************************
+ *cr
+ *cr            (C) Copyright 2010 The Board of Trustees of the
+ *cr                        University of Illinois
+ *cr                         All Rights Reserved
+ *cr
+ ***************************************************************************/
+
+#ifndef __GPUINFOH__
+#define __GPUINFOH__
+
+void compute_active_thread(size_t *thread,
+			   size_t *grid,
+			   int task,
+			   int pad,
+			   int major,
+			   int minor,
+			   int sm);
+
+#endif

benchmarks/opencl/sad/image.c

@@ -0,0 +1,56 @@
+/***************************************************************************
+ *cr
+ *cr            (C) Copyright 2007 The Board of Trustees of the
+ *cr                        University of Illinois
+ *cr                         All Rights Reserved
+ *cr
+ ***************************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "file.h"
+#include "image.h"
+
+struct image_i16 *
+load_image(char *filename)
+{
+  FILE *infile;
+  short *data;
+  int w;
+  int h;
+
+  infile = fopen(filename, "r");
+
+  if (!infile)
+    {
+      fprintf(stderr, "Cannot find file '%s'\n", filename);
+      exit(-1);
+    }
+
+  /* Read image dimensions */
+  w = read16u(infile);
+  h = read16u(infile);
+
+  /* Read image contents */
+  data = (short *)malloc(w * h * sizeof(short));
+  fread(data, sizeof(short), w * h, infile);
+
+  fclose(infile);
+
+  /* Create the return data structure */
+  {
+    struct image_i16 *ret =
+      (struct image_i16 *)malloc(sizeof(struct image_i16));
+    ret->width = w;
+    ret->height = h;
+    ret->data = data;
+    return ret;
+  }
+}
+
+void
+free_image(struct image_i16 *img)
+{
+  free(img->data);
+  free(img);
+}

benchmarks/opencl/sad/image.h

@@ -0,0 +1,25 @@
+/***************************************************************************
+ *cr
+ *cr            (C) Copyright 2007 The Board of Trustees of the
+ *cr                        University of Illinois
+ *cr                         All Rights Reserved
+ *cr
+ ***************************************************************************/
+
+struct image_i16
+{
+  int width;
+  int height;
+  short *data;
+};
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct image_i16 * load_image(char *filename);
+void free_image(struct image_i16 *);
+
+#ifdef __cplusplus
+}
+#endif

benchmarks/opencl/sad/kernel.cl

@@ -0,0 +1,326 @@
+/***************************************************************************
+ *cr
+ *cr            (C) Copyright 2007 The Board of Trustees of the
+ *cr                        University of Illinois
+ *cr                         All Rights Reserved
+ *cr
+ ***************************************************************************/
+
+#ifndef MAX_POS
+#define MAX_POS 1089
+#define CEIL_POS 61
+#define POS_PER_THREAD 18
+#define MAX_POS_PADDED 1096
+#define THREADS_W 1
+#define THREADS_H 1
+#define SEARCH_RANGE 16
+#define SEARCH_DIMENSION 33
+#endif
+
+/* The compute kernel. */
+/* The macros THREADS_W and THREADS_H specify the width and height of the
+ * area to be processed by one thread, measured in 4-by-4 pixel blocks.
+ * Larger numbers mean more computation per thread block.
+ *
+ * The macro POS_PER_THREAD specifies the number of search positions for which
+ * an SAD is computed.  A larger value indicates more computation per thread,
+ * and fewer threads per thread block.  It must be a multiple of 3 and also
+ * must be at most 33 because the loop to copy from shared memory uses
+ * 32 threads per 4-by-4 pixel block.
+ *
+ */
+ 
+// AMD OpenCL fails UINT_CUDA_V
+#define SHORT2_V 0
+#define UINT_CUDA_V 0
+
+// Either works
+#define VEC_LOAD 0
+
+// CAST_STORE is only method that works for all implementations of OpenCL tested
+#define VEC_STORE 0
+#define CAST_STORE 0
+#define SCALAR_STORE 1
+
+__kernel void mb_sad_calc(__global unsigned short *blk_sad,
+                            __global unsigned short *frame,
+                            int mb_width,
+                            int mb_height,
+                            __global unsigned short* img_ref) // __read_only image2d_t img_ref)
+{   
+  int tx = (get_local_id(0) / CEIL_POS) % THREADS_W;
+  int ty = (get_local_id(0) / CEIL_POS) / THREADS_W;
+  int bx = get_group_id(0);
+  int by = get_group_id(1);
+  int img_width = mb_width*16;
+  int lidx = get_local_id(0);
+
+  // Macroblock and sub-block coordinates
+  int mb_x = (tx + bx * THREADS_W) >> 2;
+  int mb_y = (ty + by * THREADS_H) >> 2;
+  int block_x = (tx + bx * THREADS_W) & 0x03;
+  int block_y = (ty + by * THREADS_H) & 0x03;
+
+  // If this thread is assigned to an invalid 4x4 block, do nothing 
+  if ((mb_x < mb_width) && (mb_y < mb_height))
+    {
+      // Pixel offset of the origin of the current 4x4 block
+      int frame_x = ((mb_x << 2) + block_x) << 2;
+      int frame_y = ((mb_y << 2) + block_y) << 2;
+
+      // Origin of the search area for this 4x4 block
+      int ref_x = frame_x - SEARCH_RANGE;
+      int ref_y = frame_y - SEARCH_RANGE;
+
+      // Origin in the current frame for this 4x4 block
+      int cur_o = frame_y * img_width + frame_x;
+
+      int search_pos;
+      int search_pos_base =
+        (lidx % CEIL_POS) * POS_PER_THREAD;
+      int search_pos_end = search_pos_base + POS_PER_THREAD;
+
+      // Don't go past bounds
+      if (search_pos_end > MAX_POS) {
+        search_pos_end = MAX_POS;
+      }
+
+      // For each search position, within the range allocated to this thread
+      for (search_pos = search_pos_base;
+           search_pos < search_pos_end;
+           search_pos++) {
+        unsigned short sad4x4 = 0;
+        int search_off_x = ref_x + (search_pos % SEARCH_DIMENSION);
+        int search_off_y = ref_y + (search_pos / SEARCH_DIMENSION);
+
+        // 4x4 SAD computation
+        for(int y=0; y<4; y++) {
+          for (int x=0; x<4; x++) {
+          
+          // ([unsigned] short)read_imageui or
+          //                   read_imagei  is required for correct calculation.
+          // Though read_imagei() is shorter, its results are undefined by specification since the input
+          // is an unsigned type, CL_UNSIGNED_INT16
+          
+            int sx = search_off_x + x;
+            sx = (sx < 0) ? 0 : sx;
+            sx = (sx >= img_width) ? img_width - 1 : sx;
+            int sy = search_off_y + y;
+            sy = (sy < 0) ? 0 : sy;
+            sy = (sy >= mb_height * 16) ? mb_height * 16 - 1 : sy;
+            sad4x4 += abs((unsigned short) img_ref[(sx) + (sy) * img_width]  - 
+                  frame[cur_o + y * img_width + x]);
+          }
+        }
+
+        // Save this value into the local SAD array 
+        blk_sad[mb_width * mb_height * MAX_POS_PADDED * (9 + 16) +
+        (mb_y * mb_width + mb_x) * MAX_POS_PADDED * 16 +
+        (4 * block_y + block_x) * MAX_POS_PADDED+search_pos] = sad4x4;
+      }
+    }
+
+}
+
+
+//typedef unsigned int uint;
+
+__kernel void larger_sad_calc_8(__global unsigned short *blk_sad,
+				  int mb_width,
+				  int mb_height)
+{
+  int tx = get_local_id(1) & 1;
+  int ty = get_local_id(1) >> 1;
+
+  // Macroblock and sub-block coordinates
+  int mb_x = get_group_id(0);
+  int mb_y = get_group_id(1);
+  int lidx = get_local_id(0);
+
+  // Number of macroblocks in a frame
+  int macroblocks = mul24(mb_width, mb_height);
+  int macroblock_index = (mul24(mb_y, mb_width) + mb_x) * MAX_POS_PADDED;
+
+  __global unsigned short *bi;
+  __global unsigned short *bo_6, *bo_5, *bo_4;
+
+  // MXPA
+  bo_4 = (__global unsigned short *) tx;
+  bo_5 = (__global unsigned short *) tx;
+
+
+  bi = blk_sad    
+    + (mul24(macroblocks, 25) + (ty * 8 + tx * 2)) * MAX_POS_PADDED
+    + macroblock_index * 16;
+
+  // Block type 6: 4x8
+  bo_6 = blk_sad
+    + ((macroblocks << 4) + macroblocks + (ty * 4 + tx * 2)) * MAX_POS_PADDED
+    + macroblock_index * 8;
+
+  if (ty < 100) // always true, but improves register allocation
+    {
+      // Block type 5: 8x4
+      bo_5 = blk_sad
+	+ ((macroblocks << 3) + macroblocks + (ty * 4 + tx)) * MAX_POS_PADDED
+	+ macroblock_index * 8;
+
+      // Block type 4: 8x8
+      bo_4 = blk_sad
+	+ ((macroblocks << 2) + macroblocks + (ty * 2 + tx)) * MAX_POS_PADDED
+	+ macroblock_index * 4;
+    }
+
+  for (int search_pos = lidx; search_pos < (MAX_POS+1)/2; search_pos += 32)
+    {
+#if SHORT2_V
+  #if VEC_LOAD
+      ushort2 s00 = vload2(search_pos,                    bi);
+      ushort2 s01 = vload2(search_pos+  MAX_POS_PADDED/2, bi);
+      ushort2 s10 = vload2(search_pos+4*MAX_POS_PADDED/2, bi);
+      ushort2 s11 = vload2(search_pos+5*MAX_POS_PADDED/2, bi);
+  #else
+      ushort2 s00 = (ushort2) (bi[search_pos*2], bi[search_pos*2+1]);
+      ushort2 s01 = (ushort2) (bi[(search_pos + MAX_POS_PADDED/2)*2], bi[(search_pos + MAX_POS_PADDED/2)*2+1]);
+      ushort2 s10 = (ushort2) (bi[(search_pos + 4*MAX_POS_PADDED/2)*2], bi[(search_pos + 4*MAX_POS_PADDED/2)*2+1]);
+      ushort2 s11 = (ushort2) (bi[(search_pos + 5*MAX_POS_PADDED/2)*2], bi[(search_pos + 5*MAX_POS_PADDED/2)*2+1]);
+  #endif
+
+  #if VEC_STORE
+      ushort2 s0010 = s00 + s10;
+      ushort2 s0111 = s01 + s11;
+      ushort2 s0001 = s00 + s01;
+      ushort2 s1011 = s10 + s11;
+      ushort2 s00011011 = s0001 + s1011;
+      
+      vstore2(s0010, search_pos, bo_6);
+      vstore2(s0111, search_pos+MAX_POS_PADDED/2, bo_6);
+      vstore2(s0001, search_pos, bo_5);
+      vstore2(s1011, search_pos+2*MAX_POS_PADDED/2, bo_5);
+      vstore2(s00011011, search_pos, bo_4);
+  #elif CAST_STORE
+      ((__global ushort2 *)bo_6)[search_pos]                  = s00 + s10;
+      ((__global ushort2 *)bo_6)[search_pos+MAX_POS_PADDED/2] = s01 + s11;
+      ((__global ushort2 *)bo_5)[search_pos]                  = s00 + s01;
+      ((__global ushort2 *)bo_5)[search_pos+2*MAX_POS_PADDED/2] = s10 + s11;
+      ((__global ushort2 *)bo_4)[search_pos]                  = (s00 + s01) + (s10 + s11);
+  #else // SCALAR_STORE
+      bo_6[search_pos*2] = s00.x + s10.x;
+      bo_6[search_pos*2+1] = s00.y + s10.y;
+      bo_6[(search_pos+MAX_POS_PADDED/2)*2] = s01.x + s11.x;
+      bo_6[(search_pos+MAX_POS_PADDED/2)*2+1] = s01.y + s11.y;
+      bo_5[search_pos*2] = s00.x + s01.x;
+      bo_5[search_pos*2+1] = s00.y + s01.y;
+      bo_5[(search_pos+2*MAX_POS_PADDED/2)*2] = s10.x + s11.x;
+      bo_5[(search_pos+2*MAX_POS_PADDED/2)*2+1] = s10.y + s11.y;
+      bo_4[search_pos*2] = (s00.x + s01.x) + (s10.x + s11.x);
+      bo_4[search_pos*2+1] = (s00.y + s01.y) + (s10.y + s11.y);
+  #endif
+#else // UINT_CUDA_V
+      uint i00 = ((__global uint *)bi)[search_pos];
+      uint i01 = ((__global uint *)bi)[search_pos + MAX_POS_PADDED/2];
+      uint i10 = ((__global uint *)bi)[search_pos + 4*MAX_POS_PADDED/2];
+      uint i11 = ((__global uint *)bi)[search_pos + 5*MAX_POS_PADDED/2];
+
+      ((__global uint *)bo_6)[search_pos]                  = i00 + i10;
+      ((__global uint *)bo_6)[search_pos+MAX_POS_PADDED/2] = i01 + i11;
+      ((__global uint *)bo_5)[search_pos]                  = i00 + i01;
+      ((__global uint *)bo_5)[search_pos+2*MAX_POS_PADDED/2] = i10 + i11;
+      ((__global uint *)bo_4)[search_pos]                  = (i00 + i01) + (i10 + i11);
+#endif
+    }
+    
+}
+
+
+
+__kernel void larger_sad_calc_16(__global unsigned short *blk_sad,
+				   int mb_width,
+				   int mb_height)
+{
+  // Macroblock coordinates 
+  int mb_x = get_group_id(0);
+  int mb_y = get_group_id(1);
+  int search_pos = get_local_id(0);
+
+  // Number of macroblocks in a frame
+  int macroblocks = mul24(mb_width, mb_height) * MAX_POS_PADDED;
+  int macroblock_index = (mul24(mb_y, mb_width) + mb_x) * MAX_POS_PADDED;
+
+  __global unsigned short *bi;
+  __global unsigned short *bo_3, *bo_2, *bo_1;
+
+  //bi = blk_sad + macroblocks * 5 + macroblock_index * 4;
+  bi = blk_sad + ((macroblocks + macroblock_index) << 2) + macroblocks;
+
+  // Block type 3: 8x16
+  //bo_3 = blk_sad + macroblocks * 3 + macroblock_index * 2;
+  bo_3 = blk_sad + ((macroblocks + macroblock_index) << 1) + macroblocks;
+
+  // Block type 5: 8x4
+  bo_2 = blk_sad + macroblocks + macroblock_index * 2;
+
+  // Block type 4: 8x8
+  bo_1 = blk_sad + macroblock_index;
+
+  for ( ; search_pos < (MAX_POS+1)/2; search_pos += 32)
+    {
+#if SHORT2_V
+  #if VEC_LOAD
+      ushort2 s00 = vload2(search_pos,                    bi);
+      ushort2 s01 = vload2(search_pos+  MAX_POS_PADDED/2, bi);
+      ushort2 s10 = vload2(search_pos+2*MAX_POS_PADDED/2, bi);
+      ushort2 s11 = vload2(search_pos+3*MAX_POS_PADDED/2, bi);
+  #else
+      ushort2 s00 = (ushort2) (bi[search_pos*2], bi[search_pos*2+1]);
+      ushort2 s01 = (ushort2) (bi[(search_pos + MAX_POS_PADDED/2)*2], bi[(search_pos + MAX_POS_PADDED/2)*2+1]);
+      ushort2 s10 = (ushort2) (bi[(search_pos + 2*MAX_POS_PADDED/2)*2], bi[(search_pos + 2*MAX_POS_PADDED/2)*2+1]);
+      ushort2 s11 = (ushort2) (bi[(search_pos + 3*MAX_POS_PADDED/2)*2], bi[(search_pos + 3*MAX_POS_PADDED/2)*2+1]);
+  #endif
+
+  #if VEC_STORE
+      ushort2 s0010 = s00 + s10;
+      ushort2 s0111 = s01 + s11;
+      ushort2 s0001 = s00 + s01;
+      ushort2 s1011 = s10 + s11;
+      ushort2 s00011011 = s0001 + s1011;
+      
+      vstore2(s0010, search_pos, bo_3);
+      vstore2(s0111, search_pos+MAX_POS_PADDED/2, bo_3);
+      vstore2(s0001, search_pos, bo_2);
+      vstore2(s1011, search_pos+MAX_POS_PADDED/2, bo_2);
+      vstore2(s00011011, search_pos, bo_1);
+  #elif CAST_STORE
+      ((__global ushort2 *)bo_3)[search_pos]                  = s00 + s10;
+      ((__global ushort2 *)bo_3)[search_pos+MAX_POS_PADDED/2] = s01 + s11;
+      ((__global ushort2 *)bo_2)[search_pos]                  = s00 + s01;
+      ((__global ushort2 *)bo_2)[search_pos+MAX_POS_PADDED/2] = s10 + s11;
+      ((__global ushort2 *)bo_1)[search_pos]                  = (s00 + s01) + (s10 + s11);
+  #else // SCALAR_STORE
+      bo_3[search_pos*2] = s00.x + s10.x;
+      bo_3[search_pos*2+1] = s00.y + s10.y;
+      bo_3[(search_pos+MAX_POS_PADDED/2)*2] = s01.x + s11.x;
+      bo_3[(search_pos+MAX_POS_PADDED/2)*2+1] = s01.y + s11.y;
+      bo_2[search_pos*2] = s00.x + s01.x;
+      bo_2[search_pos*2+1] = s00.y + s01.y;
+      bo_2[(search_pos+MAX_POS_PADDED/2)*2] = s10.x + s11.x;
+      bo_2[(search_pos+MAX_POS_PADDED/2)*2+1] = s10.y + s11.y;
+      bo_1[search_pos*2] = (s00.x + s01.x) + (s10.x + s11.x);
+      bo_1[search_pos*2+1] = (s00.y + s01.y) + (s10.y + s11.y);
+  #endif
+#else // UINT_CUDA_V
+      uint i00 = ((__global uint *)bi)[search_pos];
+      uint i01 = ((__global uint *)bi)[search_pos + MAX_POS_PADDED/2];
+      uint i10 = ((__global uint *)bi)[search_pos + 2*MAX_POS_PADDED/2];
+      uint i11 = ((__global uint *)bi)[search_pos + 3*MAX_POS_PADDED/2];
+
+      ((__global uint *)bo_3)[search_pos]                  = i00 + i10;
+      ((__global uint *)bo_3)[search_pos+MAX_POS_PADDED/2] = i01 + i11;
+      ((__global uint *)bo_2)[search_pos]                  = i00 + i01;
+      ((__global uint *)bo_2)[search_pos+MAX_POS_PADDED/2] = i10 + i11;
+      ((__global uint *)bo_1)[search_pos]                  = (i00 + i01) + (i10 + i11);
+#endif
+    }
+}
+
+