自学教程：C++ CHECK_ALLOCATION函数代码示例

int ScanLargeArrays::setupScanLargeArrays(){    // input buffer size    cl_uint sizeBytes = length * sizeof(cl_float);    // allocate memory for input arrray    input = (cl_float*)malloc(sizeBytes);    CHECK_ALLOCATION(input, "Failed to allocate host memory. (input)");    // random initialisation of input    sampleCommon->fillRandom<cl_float>(input, length, 1, 0, 255);    // allocate memory for output buffer    output = (cl_float*)malloc(sizeBytes);    CHECK_ALLOCATION(output, "Failed to allocate host memory. (output)");    // if verification is enabled    if(verify)    {        // allocate memory for verification output array        verificationOutput = (cl_float*)malloc(sizeBytes);        CHECK_ALLOCATION(verificationOutput, "Failed to allocate host memory. (verify)");        memset(verificationOutput, 0, sizeBytes);    }    // Unless quiet mode has been enabled, print the INPUT array    if(!quiet)     {        sampleCommon->printArray<cl_float>("Input",                                            input,                                            length,                                            1);    }    return SDK_SUCCESS;}

int ScanLargeArrays::initialize(){    // Call base class Initialize to get default configuration    if(this->SDKSample::initialize() != SDK_SUCCESS)        return SDK_FAILURE;    streamsdk::Option* array_length = new streamsdk::Option;    CHECK_ALLOCATION(array_length,"Memory Allocation error.(array_length)");    array_length->_sVersion = "x";    array_length->_lVersion = "length";    array_length->_description = "Length of the input array";    array_length->_type = streamsdk::CA_ARG_INT;    array_length->_value = &length;    sampleArgs->AddOption(array_length);    delete array_length;    streamsdk::Option* iteration_option = new streamsdk::Option;    CHECK_ALLOCATION(iteration_option,"Memory Allocation error.(iteration_option)");    iteration_option->_sVersion = "i";    iteration_option->_lVersion = "iterations";    iteration_option->_description = "Number of iterations to execute kernel";    iteration_option->_type = streamsdk::CA_ARG_INT;    iteration_option->_value = &iterations;    sampleArgs->AddOption(iteration_option);    delete iteration_option;    return SDK_SUCCESS;}

int BinomialOption::initialize(){    // Call base class Initialize to get default configuration    CHECK_ERROR(this->SDKSample::initialize(), SDK_SUCCESS, "OpenCL Resource Intilization failed");    streamsdk::Option* num_samples = new streamsdk::Option;    CHECK_ALLOCATION(num_samples, "Error. Failed to allocate memory (num_samples)/n");    num_samples->_sVersion = "x";    num_samples->_lVersion = "samples";    num_samples->_description = "Number of samples to be calculated";    num_samples->_type = streamsdk::CA_ARG_INT;    num_samples->_value = &numSamples;    sampleArgs->AddOption(num_samples);    delete num_samples;    streamsdk::Option* num_iterations = new streamsdk::Option;    CHECK_ALLOCATION(num_iterations, "Error. Failed to allocate memory (num_iterations)/n");    num_iterations->_sVersion = "i";    num_iterations->_lVersion = "iterations";    num_iterations->_description = "Number of iterations for kernel execution";    num_iterations->_type = streamsdk::CA_ARG_INT;    num_iterations->_value = &iterations;    sampleArgs->AddOption(num_iterations);    delete num_iterations;    return SDK_SUCCESS;}

intBinomialOption::setupBinomialOption(){    // Make numSamples multiple of 4    numSamples = (numSamples / 4)? (numSamples / 4) * 4: 4;#if defined (_WIN32)    randArray = (cl_float*)_aligned_malloc(numSamples * sizeof(cl_float4), 16);#else    randArray = (cl_float*)memalign(16, numSamples * sizeof(cl_float4));#endif    CHECK_ALLOCATION(randArray, "Failed to allocate host memory. (randArray)");        for(int i = 0; i < numSamples * 4; i++)    {        randArray[i] = (float)rand() / (float)RAND_MAX;    }#if defined (_WIN32)    output = (cl_float*)_aligned_malloc(numSamples * sizeof(cl_float4), 16);#else    output = (cl_float*)memalign(16, numSamples * sizeof(cl_float4));#endif    CHECK_ALLOCATION(output, "Failed to allocate host memory. (output)");    memset(output, 0, numSamples * sizeof(cl_float4));    return SDK_SUCCESS;}

int SimpleConvolution::initialize(){   // Call base class Initialize to get default configuration   if  (this->SDKSample::initialize() != SDK_SUCCESS)       return SDK_FAILURE;   // Now add customized options    streamsdk::Option* width_option = new streamsdk::Option;    CHECK_ALLOCATION(width_option, "Memory allocation error./n");    width_option->_sVersion = "x";    width_option->_lVersion = "width";    width_option->_description = "Width of the input matrix";    width_option->_type = streamsdk::CA_ARG_INT;    width_option->_value = &width;    sampleArgs->AddOption(width_option);    delete width_option;    streamsdk::Option* height_option = new streamsdk::Option;    CHECK_ALLOCATION(height_option, "Memory allocation error./n");    height_option->_sVersion = "y";    height_option->_lVersion = "height";    height_option->_description = "Height of the input matrix";    height_option->_type = streamsdk::CA_ARG_INT;    height_option->_value = &height;    sampleArgs->AddOption(height_option);    delete height_option;    streamsdk::Option* mask_width = new streamsdk::Option;    CHECK_ALLOCATION(mask_width, "Memory allocation error./n");    maskWidth = 3;    mask_width->_sVersion = "m";    mask_width->_lVersion = "masksize";    mask_width->_description = "Width of the mask matrix";    mask_width->_type = streamsdk::CA_ARG_INT;    mask_width->_value = &maskWidth;    sampleArgs->AddOption(mask_width);    delete mask_width;    streamsdk::Option* num_iterations = new streamsdk::Option;    CHECK_ALLOCATION(num_iterations, "Memory allocation error./n");    num_iterations->_sVersion = "i";    num_iterations->_lVersion = "iterations";    num_iterations->_description = "Number of iterations for kernel execution";    num_iterations->_type = streamsdk::CA_ARG_INT;    num_iterations->_value = &iterations;    sampleArgs->AddOption(num_iterations);    delete num_iterations;   return SDK_SUCCESS;}

static int get_desired_platform(const char *substr,                                cl_platform_id *platform_id_out,                                cl_int *err){    cl_int _err = CL_SUCCESS;    cl_uint i, num_platforms;    cl_platform_id *platform_ids = NULL;    char *platform_name = NULL;    assert(platform_id_out != NULL);    if (!err) err = &_err;    *err = clGetPlatformIDs(0, NULL, &num_platforms);    CHECK_CL_ERROR(*err);    platform_ids = malloc(sizeof(*platform_ids) * num_platforms);    CHECK_ALLOCATION(platform_ids);    *err = clGetPlatformIDs(num_platforms, platform_ids, NULL);    CHECK_CL_ERROR(*err);    for (i = 0; i < num_platforms; i++) {        size_t platform_name_size;        *err = clGetPlatformInfo(platform_ids[i], CL_PLATFORM_NAME, 0, NULL,                                 &platform_name_size);        CHECK_CL_ERROR(*err);        platform_name = realloc(platform_name,                                sizeof(*platform_name) * platform_name_size);        CHECK_ALLOCATION(platform_name);        *err = clGetPlatformInfo(platform_ids[i], CL_PLATFORM_NAME,                                 platform_name_size, platform_name, NULL);        CHECK_CL_ERROR(*err);        if (DEBUG)            printf("Platform %u: /"%s/"/n", i, platform_name);        if (strstr(platform_name, substr))            break;    }    if (i < num_platforms)        *platform_id_out = platform_ids[i];    else        goto error; /* No platforms found */    free(platform_ids);    free(platform_name);    return 0;error:    free(platform_ids);    free(platform_name);    return -1;}

intSobelFilter::verifyResults(){    if(!byteRWSupport)    {        return SDK_SUCCESS;    }    if(sampleArgs->verify)    {        // reference implementation        sobelFilterCPUReference();        float *outputDevice = new float[width * height * pixelSize];        CHECK_ALLOCATION(outputDevice,                         "Failed to allocate host memory! (outputDevice)");        float *outputReference = new float[width * height * pixelSize];        CHECK_ALLOCATION(outputReference, "Failed to allocate host memory!"                         "(outputReference)");        // copy uchar data to float array        for(int i = 0; i < (int)(width * height); i++)        {            outputDevice[i * 4 + 0] = outputImageData[i].s[0];            outputDevice[i * 4 + 1] = outputImageData[i].s[1];            outputDevice[i * 4 + 2] = outputImageData[i].s[2];            outputDevice[i * 4 + 3] = outputImageData[i].s[3];            outputReference[i * 4 + 0] = verificationOutput[i * 4 + 0];            outputReference[i * 4 + 1] = verificationOutput[i * 4 + 1];            outputReference[i * 4 + 2] = verificationOutput[i * 4 + 2];            outputReference[i * 4 + 3] = verificationOutput[i * 4 + 3];        }        // compare the results and see if they match        if(compare(outputReference,                   outputDevice,                   width * height * 4))        {            std::cout << "Passed!/n" << std::endl;            delete[] outputDevice;            delete[] outputReference;            return SDK_SUCCESS;        }        else        {            std::cout << "Failed/n" << std::endl;            delete[] outputDevice;            delete[] outputReference;            return SDK_FAILURE;        }    }    return SDK_SUCCESS;}

intMatrixMulDouble::setupMatrixMulDouble(){    // allocate and init memory used by host  inputA[widthA][heightA]    cl_uint inputSizeBytes0 = widthA * heightA * sizeof(cl_double);    inputA = (cl_double*) malloc(inputSizeBytes0);    CHECK_ALLOCATION(inputA, "Failed to allocate host memory. (inputA)");    // allocate and init memory used by host inputB[widthB][heightB]    cl_uint inputSizeBytes1 = widthB * heightB * sizeof(cl_double);    inputB = (cl_double*) malloc(inputSizeBytes1);    CHECK_ALLOCATION(inputB, "Failed to allocate host memory. (inputB)");    // random initialisation of input    fillRandom<cl_double>(inputA, widthA, heightA, 0, 10);    fillRandom<cl_double>(inputB, widthB, heightB, 0, 10);    // allocate memory for output[widthB][heightA]    cl_uint outputSizeBytes = heightA * widthB * sizeof(cl_double);    output = (cl_double*) malloc(outputSizeBytes);    CHECK_ALLOCATION(output, "Failed to allocate host memory. (output)");    // allocate memory for output[widthB][heightA] of reference implemenation    if(sampleArgs->verify)    {        refOutput = (cl_double*) malloc(outputSizeBytes);        CHECK_ALLOCATION(refOutput, "Failed to allocate host memory. (refOutput)");        memset(refOutput, 0, outputSizeBytes);    }    /*     * Unless quiet mode has been enabled, print the INPUT arrays     */    if(!sampleArgs->quiet)    {        printArray<cl_double>(            "inputA",            inputA,            widthA,            1);        printArray<cl_double>(            "inputB",            inputB,            widthB,            1);    }    return SDK_SUCCESS;}

int DeviceFission::initialize(){    // Call base class Initialize to get default configuration    if(this->SDKSample::initialize())        return SDK_FAILURE;    // Now add customized options    streamsdk::Option* array_length = new streamsdk::Option;    CHECK_ALLOCATION(array_length, "Memory allocation error./n");    array_length->_sVersion = "x";    array_length->_lVersion = "length";    array_length->_description = "Length of the Input array (Default value 1024)";    array_length->_type = streamsdk::CA_ARG_INT;    array_length->_value = &length;    sampleArgs->AddOption(array_length);    delete array_length;	streamsdk::Option* bool_cpu2gpu = new streamsdk::Option;	CHECK_ALLOCATION(bool_cpu2gpu, "Memory allocation error./n");	bool_cpu2gpu->_sVersion = "g";	bool_cpu2gpu->_lVersion = "cpu2gpu";	bool_cpu2gpu->_description = "Switch to migrate memory object from sub device to GPU before run kernels.(0 or 1, where 0 is disable, 1 is enable)";	bool_cpu2gpu->_type = streamsdk::CA_ARG_INT;	bool_cpu2gpu->_value = &cpu2gpuValue;	sampleArgs->AddOption(bool_cpu2gpu);	delete bool_cpu2gpu;	streamsdk::Option* bool_cpu2cpu = new streamsdk::Option;	CHECK_ALLOCATION(bool_cpu2cpu, "Memory allocation error./n");	bool_cpu2cpu->_sVersion = "c";	bool_cpu2cpu->_lVersion = "cpu2cpu";	bool_cpu2cpu->_description = "Switch to migrate memory object from sub device to another sub device before run kernels. (0 or 1, where 0 is disable, 1 is enable)";	bool_cpu2cpu->_type = streamsdk::CA_ARG_INT;	bool_cpu2cpu->_value = &cpu2cpuValue;	sampleArgs->AddOption(bool_cpu2cpu);	delete bool_cpu2cpu;	streamsdk::Option* load_gpu = new streamsdk::Option;	CHECK_ALLOCATION(load_gpu, "Memory allocation error./n");	load_gpu->_sVersion = "";	load_gpu->_lVersion = "loadgpu";	load_gpu->_description = "Load GPU binary image and execute on GPU";	load_gpu->_type = streamsdk::CA_ARG_STRING;	load_gpu->_value = &loadBinaryGPU;	sampleArgs->AddOption(load_gpu);	delete load_gpu;    return SDK_SUCCESS;}

intSobelFilter::readInputImage(std::string inputImageName){    // load input bitmap image    inputBitmap.load(inputImageName.c_str());    // error if image did not load    if(!inputBitmap.isLoaded())    {        std::cout << "Failed to load input image!";        return SDK_FAILURE;    }    // get width and height of input image    height = inputBitmap.getHeight();    width = inputBitmap.getWidth();    // allocate memory for input & output image data    inputImageData  = (cl_uchar4*)malloc(width * height * sizeof(cl_uchar4));    CHECK_ALLOCATION(inputImageData, "Failed to allocate memory! (inputImageData)");    // allocate memory for output image data    outputImageData = (cl_uchar4*)malloc(width * height * sizeof(cl_uchar4));    CHECK_ALLOCATION(outputImageData,                     "Failed to allocate memory! (outputImageData)");    // initializa the Image data to NULL    memset(outputImageData, 0, width * height * pixelSize);    // get the pointer to pixel data    pixelData = inputBitmap.getPixels();    if(pixelData == NULL)    {        std::cout << "Failed to read pixel Data!";        return SDK_FAILURE;    }    // Copy pixel data into inputImageData    memcpy(inputImageData, pixelData, width * height * pixelSize);    // allocate memory for verification output    verificationOutput = (cl_uchar*)malloc(width * height * pixelSize);    CHECK_ALLOCATION(verificationOutput,                     "verificationOutput heap allocation failed!");    // initialize the data to NULL    memset(verificationOutput, 0, width * height * pixelSize);    return SDK_SUCCESS;}

int GlobalMemoryBandwidth::setupGlobalMemoryBandwidth(){    //Make vectorSize as 4 if -v option is 3.     //This memeory alignment is required as per OpenCL for type3 vectors     if(vectorSize == 3)    {        vec3 = true;        vectorSize = 4;    }    /**     * Allocate memory required for global buffer      * This includes both single and linear(cached and uncached) reads      */    cl_uint sizeElement = vectorSize * sizeof(cl_float);    cl_uint readLength = length + (NUM_READS * 1024 / sizeElement) + EXTRA_BYTES;    cl_uint size = readLength * vectorSize * sizeof(cl_float);    input = (cl_float*)malloc(size);    CHECK_ALLOCATION(input, "Failed to allocate host memory. (input)");    outputReadSingle = (cl_float*)malloc(length * vectorSize * sizeof(cl_float));    CHECK_ALLOCATION(outputReadSingle, "Failed to allocate host memory. (outputReadSingle)");    memset(outputReadSingle, 0, length * vectorSize * sizeof(cl_float));    outputReadLinear = (cl_float*)malloc(length * vectorSize * sizeof(cl_float));    CHECK_ALLOCATION(outputReadLinear, "Failed to allocate host memory. (outputReadLinear)");    memset(outputReadLinear, 0, length * vectorSize * sizeof(cl_float));    outputReadLU = (cl_float*)malloc(length * vectorSize * sizeof(cl_float));    CHECK_ALLOCATION(outputReadLU, "Failed to allocate host memory. (outputReadLU)");    memset(outputReadLU, 0, length * vectorSize * sizeof(cl_float));    outputWriteLinear = (cl_float*)malloc(size);    CHECK_ALLOCATION(outputWriteLinear, "Failed to allocate host memory. (outputWriteLinear)");    memset(outputWriteLinear, 0, size);    // random initialisation of input     sampleCommon->fillRandom<cl_float>(input,                                         readLength * vectorSize,                                        1,                                        0,                                        10);    return SDK_SUCCESS;}

int MatrixMulImage::setupMatrixMulImage(){    // allocate and init memory used by host  input0[width0][height0]    cl_uint inputSizeBytes0 = width0 * height0 * sizeof(cl_float);    input0 = (cl_float *) malloc(inputSizeBytes0);    CHECK_ALLOCATION(input0, "Failed to allocate host memory. (input0)");    // allocate and init memory used by host input1[width1][height1]    cl_uint inputSizeBytes1 = width1 * height1 * sizeof(cl_float);    input1 = (cl_float *) malloc(inputSizeBytes1);    CHECK_ALLOCATION(input1, "Failed to allocate host memory. (input1)");        // random initialisation of input    sampleCommon->fillRandom<cl_float>(input0, width0, height0, 0, 10);    sampleCommon->fillRandom<cl_float>(input1, width1, height1, 0, 10);    // allocate memory for output[width1][height0]    cl_uint outputSizeBytes = height0 * width1 * sizeof(cl_float);    output = (cl_float *) malloc(outputSizeBytes);    CHECK_ALLOCATION(output, "Failed to allocate host memory. (output)");    // allocate memory for output[width1][height0] of reference implemenation    if(verify)    {        verificationOutput = (cl_float *) malloc(outputSizeBytes);        CHECK_ALLOCATION(verificationOutput, "Failed to allocate host memory. (verificationOutput)");        memset(verificationOutput, 0, outputSizeBytes);    }    /*      * Unless quiet mode has been enabled, print the INPUT arrays     */    if(!quiet)     {        sampleCommon->printArray<cl_float>(            "Input0",             input0,             width0,             1);        sampleCommon->printArray<cl_float>(            "Input1",             input1,             width1,             1);    }    return SDK_SUCCESS;}

intImageOverlap::readImage(std::string mapImageName,std::string verifyImageName){    // load input bitmap image     mapBitmap.load(mapImageName.c_str());	verifyBitmap.load(verifyImageName.c_str());    // error if image did not load     if(!mapBitmap.isLoaded())    {        sampleCommon->error("Failed to load input image!");        return SDK_FAILURE;    }    // get width and height of input image    height = mapBitmap.getHeight();    width = mapBitmap.getWidth();	image_desc.image_width=width;	image_desc.image_height=height;    // allocate memory for map image data     mapImageData = (cl_uchar4*)malloc(width * height * sizeof(cl_uchar4));    CHECK_ALLOCATION(mapImageData,"Failed to allocate memory! (mapImageData)");    // allocate memory for fill image data     fillImageData = (cl_uchar4*)malloc(width * height * sizeof(cl_uchar4));    CHECK_ALLOCATION(fillImageData,"Failed to allocate memory! (fillImageData)");    // initializa the Image data to NULL     memset(fillImageData, 0, width * height * pixelSize);    // get the pointer to pixel data     pixelData = mapBitmap.getPixels();    CHECK_ALLOCATION(pixelData,"Failed to read mapBitmap pixel Data!");    // Copy pixel data into mapImageData    memcpy(mapImageData, pixelData, width * height * pixelSize);    // allocate memory for verification output    verificationImageData = (cl_uchar4*)malloc(width * height * pixelSize);    CHECK_ALLOCATION(pixelData,"verificationOutput heap allocation failed!");	pixelData = verifyBitmap.getPixels();	CHECK_ALLOCATION(pixelData,"Failed to read verifyBitmap pixel Data!");	// Copy pixel data into verificationOutput	memcpy(verificationImageData, pixelData, width * height * pixelSize);	    return SDK_SUCCESS;}

intDeviceFission::setupDeviceFission(){    // Make sure length is multiple of group size * numSubDevices    unsigned int mulFactor = (unsigned int)groupSize * numSubDevices;    length = (length < mulFactor) ? mulFactor : length;    length = (length / mulFactor) * mulFactor;	// Calculate half length	half_length = length >> 1;	// Deal with options: cpu2cpu and cpu2gpu	if(cpu2gpuValue != 0 && cpu2cpuValue != 0)	{		std::cout << "cpu2gpu and cpu2cpu can't be both true. Disable cpu2cpu."<< std::endl;		cpu2cpuValue = 0;	}	if(cpu2gpuValue != 0)	{		std::cout << "Enable cpu2gpu mode."<< std::endl;		cpu2gpu = CL_TRUE;	}	if(cpu2cpuValue != 0)	{		std::cout << "Enable cpu2cpu mode."<< std::endl;		cpu2cpu = CL_TRUE;	}	// Get allocate memory for input buffer    input = (cl_int*)malloc(half_length * sizeof(cl_int));    CHECK_ALLOCATION(input, "Failed to allocate host memory. (input)");    // Random initialisation of input    sampleCommon->fillRandom<cl_int>(input, half_length, 1, 1, 8);    // Unless quiet mode has been enabled, print the INPUT array    if(!quiet) 		sampleCommon->printArray<cl_int>("Input:", input, half_length, 1);	// Get allocate memory for subOutput buffer    subOutput = (cl_int*)malloc(length * sizeof(cl_int));    CHECK_ALLOCATION(subOutput, "Failed to allocate host memory. (subOutput)");	// Get allocate memory for gpuOutput buffer	gpuOutput = (cl_int*)malloc(length * sizeof(cl_int));	CHECK_ALLOCATION(gpuOutput, "Failed to allocate host memory. (gpuOutput)");    return SDK_SUCCESS;}

/******************************************************************************* Implementation of BoltSample::initialize()                                  *******************************************************************************/int BoltSample::initialize(){    int defaultOptions = 6;    boltsdk::Option *optionList = new boltsdk::Option[defaultOptions];    CHECK_ALLOCATION(optionList, "Error. Failed to allocate memory (optionList)/n");    optionList[0]._sVersion = "q";    optionList[0]._lVersion = "quiet";    optionList[0]._description = "Quiet mode. Suppress most text output.";    optionList[0]._type = boltsdk::CA_NO_ARGUMENT;    optionList[0]._value = &quiet;    optionList[1]._sVersion = "e";    optionList[1]._lVersion = "verify";    optionList[1]._description = "Verify results against reference implementation.";    optionList[1]._type = boltsdk::CA_NO_ARGUMENT;    optionList[1]._value = &verify;    optionList[2]._sVersion = "t";    optionList[2]._lVersion = "timing";    optionList[2]._description = "Print timing related statistics.";    optionList[2]._type = boltsdk::CA_NO_ARGUMENT;    optionList[2]._value = &timing;    optionList[3]._sVersion = "v";    optionList[3]._lVersion = "version";    optionList[3]._description = "Bolt lib & runtime version string.";    optionList[3]._type = boltsdk::CA_NO_ARGUMENT;    optionList[3]._value = &version;    optionList[4]._sVersion = "x";    optionList[4]._lVersion = "samples";    optionList[4]._description = "Number of sample input values.";    optionList[4]._type = boltsdk::CA_ARG_INT;    optionList[4]._value = &samples;    optionList[5]._sVersion = "i";    optionList[5]._lVersion = "iterations";    optionList[5]._description = "Number of iterations.";    optionList[5]._type = boltsdk::CA_ARG_INT;    optionList[5]._value = &iterations;    sampleArgs = new boltsdk::BoltCommandArgs(defaultOptions, optionList);    CHECK_ALLOCATION(sampleArgs, "Failed to allocate memory. (sampleArgs)/n");                    return SDK_SUCCESS;}

intLDSBandwidth::setupLDSBandwidth(){    /**     * Make vectorSize as 4 if -v option is 3.     * This memory alignment is required as per OpenCL for type3 vectors     */    if(vectorSize == 3)    {        vec3 = true;        vectorSize = 4;    }    else if((1 != vectorSize) && (2 != vectorSize) && (4 != vectorSize) &&            (8 != vectorSize) && (16 != vectorSize))    {        std::cout << "The vectorsize can only be one of 1,2,3(4),4,8,16!" << std::endl;        return SDK_FAILURE;    }    // host output    output = (cl_float*)malloc(length * vectorSize * sizeof(cl_float));    CHECK_ALLOCATION(output, "Failed to allocate host memory. (output)");    return SDK_SUCCESS;}

int SimpleConvolution::verifyResults(){    if(verify)    {        verificationOutput = (cl_uint *) malloc(width * height * sizeof(cl_uint ));        CHECK_ALLOCATION(verificationOutput, "Failed to allocate host memory. (verificationOutput)");        /*          * reference implementation         */        cl_uint2 inputDimensions = {width    , height};        cl_uint2 maskDimensions  = {maskWidth, maskHeight};        simpleConvolutionCPUReference(verificationOutput, input, mask, width, height,                                        maskWidth, maskHeight);        // compare the results and see if they match        if(memcmp(output, verificationOutput, height*width*sizeof(cl_uint )) == 0)        {            std::cout<<"Passed!/n" << std::endl;            return SDK_SUCCESS;        }        else        {            std::cout<<"Failed/n" << std::endl;            return SDK_FAILURE;        }    }    return SDK_SUCCESS;}

 /** *********************************************************************** * @fn initialize * @brief Initialize the resources used by tests * @return 0 on success Positive if expected and Non-zero on failure **********************************************************************/ int initialize() {     int defaultOptions = 5;     Option *optionList = new Option[defaultOptions];     CHECK_ALLOCATION(optionList, "Error. Failed to allocate memory (optionList)/n");     optionList[0]._sVersion = "q";     optionList[0]._lVersion = "quiet";     optionList[0]._description = "Quiet mode. Suppress all text output.";     optionList[0]._type = CA_NO_ARGUMENT;     optionList[0]._value = &quiet;     optionList[1]._sVersion = "e";     optionList[1]._lVersion = "verify";     optionList[1]._description = "Verify results against reference implementation.";     optionList[1]._type = CA_NO_ARGUMENT;     optionList[1]._value = &verify;     optionList[2]._sVersion = "t";     optionList[2]._lVersion = "timing";     optionList[2]._description = "Print timing.";     optionList[2]._type = CA_NO_ARGUMENT;     optionList[2]._value = &timing;     optionList[3]._sVersion = "v";     optionList[3]._lVersion = "version";     optionList[3]._description = "AMD APP SDK version string.";     optionList[3]._type = CA_NO_ARGUMENT;     optionList[3]._value = &version;     optionList[4]._sVersion = "d";     optionList[4]._lVersion = "deviceId";     optionList[4]._description =         "Select deviceId to be used[0 to N-1 where N is number devices available].";     optionList[4]._type = CA_ARG_INT;     optionList[4]._value = &deviceId;     _numArgs = defaultOptions;     _options = optionList;     return SDK_SUCCESS; }

int DwtHaar1D::calApproxFinalOnHost(){    // Copy inData to hOutData    cl_float *tempOutData = (cl_float*)malloc(signalLength * sizeof(cl_float));    CHECK_ALLOCATION(tempOutData, "Failed to allocate host memory. (tempOutData)");    memcpy(tempOutData, inData, signalLength * sizeof(cl_float));    for(cl_uint i = 0; i < signalLength; ++i)    {        tempOutData[i] = tempOutData[i] / sqrt((float)signalLength);    }    cl_uint length = signalLength;    while(length > 1u)    {        for(cl_uint i = 0; i < length / 2; ++i)        {            cl_float data0 = tempOutData[2 * i];            cl_float data1 = tempOutData[2 * i + 1];            hOutData[i] = (data0 + data1) / sqrt((float)2);            hOutData[length / 2 + i] = (data0 - data1) / sqrt((float)2);        }        // Copy inData to hOutData        memcpy(tempOutData, hOutData, signalLength * sizeof(cl_float));        length >>= 1;    }    FREE(tempOutData);    return SDK_SUCCESS;}

static VAStatus tng_yuv_processor_CreateContext(    object_context_p obj_context,    object_config_p __maybe_unused obj_config){    VAStatus vaStatus = VA_STATUS_SUCCESS;    context_DEC_p dec_ctx = (context_DEC_p) obj_context->format_data;    context_yuv_processor_p ctx;    ctx = (context_yuv_processor_p) malloc(sizeof(struct context_yuv_processor_s));    CHECK_ALLOCATION(ctx);    /* ctx could be create in/out another dec context */    ctx->has_dec_ctx = 0;    ctx->src_surface = NULL;    if (!dec_ctx) {        dec_ctx = (context_DEC_p) malloc(sizeof(struct context_DEC_s));        if(dec_ctx == NULL) {            free(ctx);            vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;            drv_debug_msg(VIDEO_DEBUG_ERROR, "%s fails with '%d' at %s:%d/n", __FUNCTION__, vaStatus, __FILE__, __LINE__);            return vaStatus;        }        obj_context->format_data = (void *)dec_ctx;        ctx->has_dec_ctx = 1;        vaStatus = vld_dec_CreateContext(dec_ctx, obj_context);        DEBUG_FAILURE;    }    dec_ctx->yuv_ctx = ctx;    dec_ctx->process_buffer = tng_yuv_processor_process_buffer;    return vaStatus;}

int MersenneTwister::initialize(){    // Call base class Initialize to get default configuration    if(sampleArgs->initialize() != SDK_SUCCESS)    {        return SDK_FAILURE;    }    // add an option for getting blockSize from commandline    Option* num_option = new Option;    CHECK_ALLOCATION(num_option, "Memory Allocation error./n");    num_option->_sVersion = "x";    num_option->_lVersion = "numRands";    num_option->_description = "Number of random numbers to be generated";    num_option->_type = CA_ARG_INT;    num_option->_value = &numRands;    sampleArgs->AddOption(num_option);    delete num_option;    Option* factor_option = new Option;    CHECK_ALLOCATION(factor_option,"Memory Allocation error./n");    factor_option->_sVersion = "y";    factor_option->_lVersion = "factor";    factor_option->_description = "Each seed generates 'factor' random numbers";    factor_option->_type = CA_ARG_INT;    factor_option->_value = &mulFactor;    sampleArgs->AddOption(factor_option);    delete factor_option;    Option* iteration_option = new Option;    CHECK_ALLOCATION(iteration_option, "Memory Allocation error./n");    iteration_option->_sVersion = "i";    iteration_option->_lVersion = "iterations";    iteration_option->_description = "Number of iterations to execute kernel";    iteration_option->_type = CA_ARG_INT;    iteration_option->_value = &iterations;    sampleArgs->AddOption(iteration_option);    delete iteration_option;    return SDK_SUCCESS;}

intGaussianNoise::readInputImage(std::string inputImageName){    // load input bitmap image     std::string filePath = inputImageName;    inputBitmap.load(filePath.c_str());    // error if image did not load     if(!inputBitmap.isLoaded())    {        sampleCommon->error("Failed to load input image!");        return SDK_FAILURE;    }    // get width and height of input image     height = inputBitmap.getHeight();    width = inputBitmap.getWidth();    // allocate memory for input & output image data      inputImageData  = (cl_uchar4*)malloc(width * height * sizeof(cl_uchar4));    CHECK_ALLOCATION(inputImageData, "Failed to allocate memory! (inputImageData)");    // allocate memory for output image data     outputImageData = (cl_uchar4*)malloc(width * height * sizeof(cl_uchar4));    CHECK_ALLOCATION(outputImageData, "Failed to allocate memory! (outputImageData)");    // initializa the Image data to NULL     memset(outputImageData, 0, width * height * pixelSize);    // get the pointer to pixel data     pixelData = inputBitmap.getPixels();    // error check     if(pixelData == NULL)    {        sampleCommon->error("Failed to read pixel Data!");        return SDK_FAILURE;    }    // Copy pixel data into inputImageData     memcpy(inputImageData, pixelData, width * height * pixelSize);    return SDK_SUCCESS;}

int ConstantBandwidth::setupConstantBandwidth(){    //Make vectorSize as 4 if -v option is 3.     //This memeory alignment is required as per OpenCL for type3 vectors     if(vectorSize == 3)    {        vec3 = true;        vectorSize = 4;    }	else if((1 != vectorSize) && (2 != vectorSize) && (4 != vectorSize) && (8 != vectorSize) && (16 != vectorSize))	{		std::cout << "The vectorsize can only be one of 1,2,3(4),4,8,16!" << std::endl;		return SDK_FAILURE;	}    // Allocate memory     cl_uint size = (WAVEFRONT + NUM_READS) * vectorSize * sizeof(cl_float);    input = (cl_float*)malloc(size);    CHECK_ALLOCATION(input, "Failed to allocate host memory. (input)");    // Allocate memory for output buffer    output = (cl_float*)malloc(length * vectorSize * sizeof(cl_float));    CHECK_ALLOCATION(output, "Failed to allocate host memory. (output)");       if(verify)    {        cl_uint size = length * vectorSize * sizeof(cl_float);        verificationOutput = (cl_float*)malloc(size);        CHECK_ALLOCATION(verificationOutput, "Failed to allocate host memory. (verificationOutput)");    }        // random initialisation of input    sampleCommon->fillRandom<cl_float>(input,                                        (WAVEFRONT + NUM_READS) * vectorSize,                                        1,                                        0,                                        10);	    return SDK_SUCCESS;}

int BitonicSort::initialize(){    // Call base class Initialize to get default configuration    CHECK_ERROR(this->SDKSample::initialize(), SDK_SUCCESS, "OpenCL resource initilization failed");           // Now add customized options    streamsdk::Option* array_length = new streamsdk::Option;    CHECK_ALLOCATION(array_length, "Memory allocation error./n");        array_length->_sVersion = "x";    array_length->_lVersion = "length";    array_length->_description = "Length of the array to be sorted";    array_length->_type = streamsdk::CA_ARG_INT;    array_length->_value = &length;    sampleArgs->AddOption(array_length);    delete array_length;       streamsdk::Option* sort_order = new streamsdk::Option;    CHECK_ALLOCATION(sort_order, "Memory allocation error./n");    sort_order->_sVersion = "s";    sort_order->_lVersion = "sort";    sort_order->_description = "Sort in descending/ascending order[desc/asc]";    sort_order->_type = streamsdk::CA_ARG_STRING;    sort_order->_value = &sortDescending;    sampleArgs->AddOption(sort_order);    delete sort_order;    streamsdk::Option* num_iterations = new streamsdk::Option;    CHECK_ALLOCATION(num_iterations, "Memory allocation error./n");    num_iterations->_sVersion = "i";    num_iterations->_lVersion = "iterations";    num_iterations->_description = "Number of iterations for kernel execution";    num_iterations->_type = streamsdk::CA_ARG_INT;    num_iterations->_value = &iterations;    sampleArgs->AddOption(num_iterations);    delete num_iterations;    return SDK_SUCCESS;}

 /** *************************************************************************** * @fn initialize * @brief Initialize the resources used by tests * @return SDK_SUCCESS on success, SDK_FAILURE otherwise **************************************************************************/ int initialize() {   int defaultOptions = 7;   Option *optionList = new Option[defaultOptions];   CHECK_ALLOCATION(optionList,                    "Error. Failed to allocate memory (optionList)/n");   optionList[0]._sVersion = "";   optionList[0]._lVersion = "device";   optionList[0]._description = "Explicit device selection for Bolt";   std::string optionStr = "[auto|";   optionStr.append("OpenCL");   optionStr.append("|SerialCpu");   optionStr.append(((enable_tbb) ? "|MultiCoreCpu" : ""));   optionStr.append("]");   optionList[0]._usage = optionStr;   optionList[0]._type = CA_ARG_STRING;   optionList[0]._value = &runMode;   optionList[1]._sVersion = "q";   optionList[1]._lVersion = "quiet";   optionList[1]._description = "Quiet mode. Suppress most text output.";   optionList[1]._usage = "";   optionList[1]._type = CA_NO_ARGUMENT;   optionList[1]._value = &quiet;   optionList[2]._sVersion = "e";   optionList[2]._lVersion = "verify";   optionList[2]._description =       "Verify results against reference implementation.";   optionList[2]._usage = "";   optionList[2]._type = CA_NO_ARGUMENT;   optionList[2]._value = &verify;   optionList[3]._sVersion = "t";   optionList[3]._lVersion = "timing";   optionList[3]._description = "Print timing related statistics.";   optionList[3]._usage = "";   optionList[3]._type = CA_NO_ARGUMENT;   optionList[3]._value = &timing;   optionList[4]._sVersion = "v";   optionList[4]._lVersion = "version";   optionList[4]._description = "Bolt lib & runtime version string.";   optionList[4]._usage = "";   optionList[4]._type = CA_NO_ARGUMENT;   optionList[4]._value = &version;   optionList[5]._sVersion = "x";   optionList[5]._lVersion = "samples";   optionList[5]._description = "Number of sample input values.";   optionList[5]._usage = "[value]";   optionList[5]._type = CA_ARG_INT;   optionList[5]._value = &samples;   optionList[6]._sVersion = "i";   optionList[6]._lVersion = "iterations";   optionList[6]._description = "Number of iterations.";   optionList[6]._usage = "[value]";   optionList[6]._type = CA_ARG_INT;   optionList[6]._value = &iterations;   _numArgs = defaultOptions;   _options = optionList;   return SDK_SUCCESS; }

int main(int argc, char *argv[]){	int ecode;	bfcc_options bfopts = {0};	if (parse_arguments(argc, argv, &bfopts) != 0)	{		return -2;	}	FILE *f = stdin;	if (bfopts.input_file != 0)	{		f = fopen(bfopts.input_file, "r");		if (!f)		{			fprintf(stderr, "Unknown file./n");			return ERROR_FILE_NOT_FOUND;		}	}	c99_options opts;	c99_options_default(&opts);		backend back = create_c99_backend(&opts);	ecode = back.begin(&back, stdout);	FATAL_IF_ERROR(ecode, "Backend preamble generation");	tokeniser *t = tokeniser_setup(f);	CHECK_ALLOCATION(t, "Tokeniser setup");	while (1)	{		token tok;		int error = tokeniser_next(t, &tok);		if (IS_ERROR(error))		{			fprintf(stderr,  "Tokenisation error detected: %d./n", error);			return ERROR_TOKENISATION;		}		if (tok == token_eof)			break;				if (IS_ERROR(back.emit(&back, stdout, (token) tok)))		{			fprintf(stderr, "Failure encountered when translating token: %s/n", token_name((token) tok));		}	}	ecode = back.end(&back, stdout);	FATAL_IF_ERROR(ecode, "Backend could not finish")	return 0;}

int DwtHaar1D::setupDwtHaar1D(){    // signal length must be power of 2    signalLength = sampleCommon->roundToPowerOf2<cl_uint>(signalLength);    unsigned int levels = 0;    int result = getLevels(signalLength, &levels);    CHECK_ERROR(result,SDK_SUCCESS, "signalLength > 2 ^ 23 not supported");    // Allocate and init memory used by host    inData = (cl_float*)malloc(signalLength * sizeof(cl_float));    CHECK_ALLOCATION(inData, "Failed to allocate host memory. (inData)");    for(unsigned int i = 0; i < signalLength; i++)    {        inData[i] = (cl_float)(rand() % 10);    }    dOutData = (cl_float*) malloc(signalLength * sizeof(cl_float));    CHECK_ALLOCATION(dOutData, "Failed to allocate host memory. (dOutData)");    memset(dOutData, 0, signalLength * sizeof(cl_float));    dPartialOutData = (cl_float*) malloc(signalLength * sizeof(cl_float));    CHECK_ALLOCATION(dPartialOutData, "Failed to allocate host memory.(dPartialOutData)");    memset(dPartialOutData, 0, signalLength * sizeof(cl_float));    hOutData = (cl_float*)malloc(signalLength * sizeof(cl_float));    CHECK_ALLOCATION(hOutData, "Failed to allocate host memory. (hOutData)");    memset(hOutData, 0, signalLength * sizeof(cl_float));    if(!quiet)    {        sampleCommon->printArray<cl_float>("Input Signal", inData, 256, 1);    }	    return SDK_SUCCESS;}

NTSTATUSNTAPIRawChannelCreate(IN PSAC_CHANNEL Channel){    CHECK_PARAMETER(Channel);    /* Allocate the output buffer */    Channel->OBuffer = SacAllocatePool(SAC_RAW_OBUFFER_SIZE, GLOBAL_BLOCK_TAG);    CHECK_ALLOCATION(Channel->OBuffer);    /* Allocate the input buffer */    Channel->IBuffer = SacAllocatePool(SAC_RAW_IBUFFER_SIZE, GLOBAL_BLOCK_TAG);    CHECK_ALLOCATION(Channel->IBuffer);    /* Reset all flags and return success */    Channel->OBufferIndex = 0;    Channel->OBufferFirstGoodIndex = 0;    Channel->ChannelHasNewIBufferData = FALSE;    Channel->ChannelHasNewOBufferData = FALSE;    return STATUS_SUCCESS;}

intFastWalshTransform::setupFastWalshTransform(){    cl_uint inputSizeBytes;    if(length < 512)    {        length = 512;    }    // allocate and init memory used by host    inputSizeBytes = length * sizeof(cl_float);    input = (cl_float *) malloc(inputSizeBytes);    CHECK_ALLOCATION(input, "Failed to allocate host memory. (input)");    output = (cl_float *) malloc(inputSizeBytes);    CHECK_ALLOCATION(output, "Failed to allocate host memory. (output)");    // random initialisation of input    fillRandom<cl_float>(input, length, 1, 0, 255);    if(sampleArgs->verify)    {        verificationInput = (cl_float *) malloc(inputSizeBytes);        CHECK_ALLOCATION(verificationInput,                         "Failed to allocate host memory. (verificationInput)");        memcpy(verificationInput, input, inputSizeBytes);    }    // Unless sampleArgs->quiet mode has been enabled, print the INPUT array.    if(!sampleArgs->quiet)    {        printArray<cl_float>(            "Input",            input,            length,            1);    }    return SDK_SUCCESS;}

intMersenneTwister::setupMersenneTwister(){    // Calculate width and height from numRands    numRands = numRands / 4;    numRands = (numRands / GROUP_SIZE)? (numRands / GROUP_SIZE) * GROUP_SIZE:               GROUP_SIZE;    unsigned int tempVar1 = (unsigned int)sqrt((double)numRands);    tempVar1 = (tempVar1 / GROUP_SIZE)? (tempVar1 / GROUP_SIZE) * GROUP_SIZE:               GROUP_SIZE;    numRands = tempVar1 * tempVar1;    width = tempVar1;    height = width;    // Allocate and init memory used by host#if defined (_WIN32)    seeds = (cl_uint*)_aligned_malloc(width * height * sizeof(cl_uint4), 16);#else    seeds = (cl_uint*)memalign(16, width * height * sizeof(cl_uint4));#endif    CHECK_ALLOCATION(seeds,"Failed to allocate host memory. (seeds)");    deviceResult = (cl_float *) malloc(width * height * mulFactor * sizeof(                                           cl_float4));    CHECK_ALLOCATION(deviceResult,                     "Failed to allocate host memory. (deviceResult)");    for(int i = 0; i < width * height * 4; ++i)    {        seeds[i] = (unsigned int)rand();    }    memset((void*)deviceResult, 0, width * height * mulFactor * sizeof(cl_float4));    return SDK_SUCCESS;}