Exemplo n.º 1
0
int main(void)
{
	int* data = generateRandomData();
	filterKernel(data);
	free(data);

	return 0;
}
Exemplo n.º 2
0
/// <summary>
/// Get 15 minutes data series into the timeStamps, highData, lowData, openData, closeData 
/// and volData arrays.
/// </summary>
/// <param name="startDate">The starting date/time for the data series.</param>
/// <param name="endDate">The ending date/time for the data series.</param>
void CFinancedemoDlg::get15MinData(CString ticker, double startDate, double endDate)
{
    //
    // In this demo, we use a random number generator to generate the data. In practice,
    // you may get the data from a database or by other means. If you do not have 15 
    // minute data, you may modify the "drawChart" method below to not using 15 minute
    // data.
    //
    generateRandomData(ticker, startDate, endDate, 900);
}
Exemplo n.º 3
0
/// <summary>
/// Get daily data series into the timeStamps, highData, lowData, openData, closeData and
/// volData arrays.
/// </summary>
/// <param name="startDate">The starting date/time for the data series.</param>
/// <param name="endDate">The ending date/time for the data series.</param>
void CFinancedemoDlg::getDailyData(CString ticker, double startDate, double endDate)
{
    //
    // In this demo, we use a random number generator to generate the data. In practice,
    // you may get the data from a database or by other means. Replace the code below
    // with your own data acquisition code.
    //
    
    generateRandomData(ticker, startDate, endDate, 86400);
}
Exemplo n.º 4
0
/**
 *****************************************************************************
 * @ingroup dsaPerformance
 *      dsaGenRandom
 *
 * @description
 *     Populate a CpaFlatBuffer with a random number which is less than Q
 *
 *****************************************************************************/
void dsaGenRandom(CpaFlatBuffer* dsaRand, CpaFlatBuffer* dsaQ)
{
    /*generate random data */
    generateRandomData(dsaRand->pData, dsaRand->dataLenInBytes);
    /*make sure MSB is set */
    setCpaFlatBufferMSB(dsaRand);
    /*make sure its < q */
    makeParam1SmallerThanParam2(dsaRand->pData,
            dsaQ->pData, dsaRand->dataLenInBytes, CPA_TRUE);
}
Exemplo n.º 5
0
/// <summary>
/// Get monthly data series into the timeStamps, highData, lowData, openData, closeData and
/// volData arrays.
/// </summary>
/// <param name="startDate">The starting date/time for the data series.</param>
/// <param name="endDate">The ending date/time for the data series.</param>
void CFinancedemoDlg::getMonthlyData(CString ticker, double startDate, double endDate)
{
    //
    // In this demo, we use a random number generator to generate the data. In practice,
    // you may get the data from a database or by other means. If you do not have monthly
    // data, you may call "getDailyData" to get daily data first, and then call 
    // "convertDailyToMonthlyData" to convert it to monthly data, like:
    //
    //      getDailyData(startDate, endDate);
    //      convertDailyToMonthlyData();
    //
    generateRandomData(ticker, startDate, endDate, 86400 * 30);
}
Exemplo n.º 6
0
int main() {
	std::vector<T> scanInputs(DATA_SIZE);
	std::vector<T> scanOutputsCpu(DATA_SIZE);
	std::vector<T> scanOutputsGpu(DATA_SIZE);

	generateRandomData(scanInputs);

	blellochScanGpu(scanInputs, scanOutputsGpu);
	exclusiveScanCpu(scanInputs, scanOutputsCpu);

	verifyGpuScan(scanOutputsCpu, scanOutputsGpu);

	return 0;
}
Exemplo n.º 7
0
void Base64TestCase::EncodeDecodeRandom()
{
    size_t size = rand() * 3000 / RAND_MAX + 11;
    unsigned char *buff = new unsigned char[size];
    generateRandomData(buff, size);
    wxString str = wxBase64Encode(buff, size);
    wxMemoryBuffer mbuff = wxBase64Decode(str);
    CPPUNIT_ASSERT(memcmp(mbuff.GetData(), buff, mbuff.GetDataLen()) == 0);

    generateGibberish(buff, size);
    char *buff2 = new char[size];
    size_t realsize = size;
    CPPUNIT_ASSERT(wxBase64Decode(buff2, realsize, (char *)buff, size));
    CPPUNIT_ASSERT(wxBase64Encode(buff2, size, buff2, realsize));
}
Exemplo n.º 8
0
Aes256::Aes256(BinData key):
  key_( std::move(key) ),
  iv_( generateRandomData( ivSize() ) ),
  td_(MCRYPT_RIJNDAEL_256, MCRYPT_CFB)
{
  if( key_.size()!=iv_.size() )
    throw std::runtime_error("key and IV size differ");

  assert( static_cast<size_t>(mcrypt_enc_get_key_size(td_.get()))==keySize() );
  assert( static_cast<size_t>(mcrypt_enc_get_iv_size(td_.get())) ==ivSize()  );

  int ret;
  if( (ret = mcrypt_generic_init(td_.get(), key_.data(), key_.size(), iv_.data())) < 0 )
    throw std::runtime_error( (Util::ErrStrm{}<<"mcrypt_generic_init(): "<<mcrypt_strerror(ret)).str().c_str() );
}
Exemplo n.º 9
0
int main(){
	std::vector<int> histogramInputs(DATA_SIZE);
	std::vector<int> histogtamOutputsCpu(BINS);
	std::vector<int> histogtamOutputsGpu(BINS);

	generateRandomData(histogtamInputs);

	histogramGpu(histogtamInputs, histogtamOutputsGpu);
	histogramCpu(histogtamInputs, histogtamOutputsCpu);

	//printVector(scanInputs);
	//printVector(scanOutputsCpu);
	//printVector(scanOutputsGpu);

	return 0;
}
bool runTest(int argc, const char **argv)
{
    bool ok = true;

    float *host_output;
    float *device_output;
    float *input;
    float *coeff;

    int defaultDim;
    int dimx;
    int dimy;
    int dimz;
    int outerDimx;
    int outerDimy;
    int outerDimz;
    int radius;
    int timesteps;
    size_t volumeSize;
    memsize_t memsize;

    const float lowerBound = 0.0f;
    const float upperBound = 1.0f;

    // Determine default dimensions
    shrLog("Set-up, based upon target device GMEM size...\n");
    if (ok)
    {
        // Get the memory size of the target device
        shrLog(" getTargetDeviceGlobalMemSize\n");
        ok = getTargetDeviceGlobalMemSize(&memsize, argc, argv);
    }
    if (ok)
    {
        // We can never use all the memory so to keep things simple we aim to
        // use around half the total memory
        memsize /= 2;
        
        // Most of our memory use is taken up by the input and output buffers -
        // two buffers of equal size - and for simplicity the volume is a cube:
        //   dim = floor( (N/2)^(1/3) )
        defaultDim = (int)floor(pow((memsize / (2.0 * sizeof(float))), 1.0/3.0));

        // By default, make the volume edge size an integer multiple of 128B to
        // improve performance by coalescing memory accesses, in a real
        // application it would make sense to pad the lines accordingly
        int roundTarget = 128 / sizeof(float);
        defaultDim = defaultDim / roundTarget * roundTarget;
        defaultDim -= k_radius_default * 2;

        // Check dimension is valid
        if (defaultDim < k_dim_min)
        {
            shrLogEx(LOGBOTH | ERRORMSG, -1000, STDERROR);
            shrLog("\tinsufficient device memory (maximum volume on device is %d, must be between %d and %d).\n", defaultDim, k_dim_min, k_dim_max);
            ok = false;
        }

        else if (defaultDim > k_dim_max)
        {
            defaultDim = k_dim_max;
        }
    }

    // For QA testing, override default volume size
    if (ok)
    {
        if (shrCheckCmdLineFlag(argc, argv, "qatest"))
        {
            defaultDim = MIN(defaultDim, k_dim_qa);
        }
    }

    // Parse command line arguments
    if (ok)
    {
        char *dim = 0;
        if (shrGetCmdLineArgumentstr(argc, argv, "dimx", &dim))
        {
            dimx = (int)atoi(dim);
            if (dimx < k_dim_min || dimx > k_dim_max)
            {
                shrLogEx(LOGBOTH | ERRORMSG, -1001, STDERROR);
                shrLog("\tdimx out of range (%d requested, must be between %d and %d), see header files for details.\n", dimx, k_dim_min, k_dim_max);
                ok = false;
            }
        }
        else
        {
            dimx = defaultDim;
        }
        if (shrGetCmdLineArgumentstr(argc, argv, "dimy", &dim))
        {
            dimy = (int)atoi(dim);
            if (dimy < k_dim_min || dimy > k_dim_max)
            {
                shrLogEx(LOGBOTH | ERRORMSG, -1002, STDERROR);
                shrLog("\tdimy out of range (%d requested, must be between %d and %d), see header files for details.\n", dimy, k_dim_min, k_dim_max);
                ok = false;
            }
        }
        else
        {
            dimy = defaultDim;
        }
        if (shrGetCmdLineArgumentstr(argc, argv, "dimz", &dim))
        {
            dimz = (int)atoi(dim);
            if (dimz < k_dim_min || dimz > k_dim_max)
            {
                shrLogEx(LOGBOTH | ERRORMSG, -1003, STDERROR);
                shrLog("\tdimz out of range (%d requested, must be between %d and %d), see header files for details.\n", dimz, k_dim_min, k_dim_max);
                ok = false;
            }
        }
        else
        {
            dimz = defaultDim;
        }
        if (shrGetCmdLineArgumentstr(argc, argv, "radius", &dim))
        {
            radius = (int)atoi(dim);
            if (radius < k_radius_min || radius >= k_radius_max)
            {
                shrLogEx(LOGBOTH | ERRORMSG, -1004, STDERROR);
                shrLog("\tradius out of range (%d requested, must be between %d and %d), see header files for details.\n", radius, k_radius_min, k_radius_max);
                ok = false;
            }
        }
        else
        {
            radius = k_radius_default;
        }
        if (shrGetCmdLineArgumentstr(argc, argv, "timesteps", &dim))
        {
            timesteps = (int)atoi(dim);
            if (timesteps < k_timesteps_min || radius >= k_timesteps_max)
            {
                shrLogEx(LOGBOTH | ERRORMSG, -1005, STDERROR);
                shrLog("\ttimesteps out of range (%d requested, must be between %d and %d), see header files for details.\n", timesteps, k_timesteps_min, k_timesteps_max);
                ok = false;
            }
        }
        else
        {
            timesteps = k_timesteps_default;
        }
        if (dim)
            free(dim);
    }

    // Determine volume size
    if (ok)
    {
        outerDimx = dimx + 2 * radius;
        outerDimy = dimy + 2 * radius;
        outerDimz = dimz + 2 * radius;
        volumeSize = outerDimx * outerDimy * outerDimz;
    }
    
    // Allocate memory
    if (ok)
    {
        shrLog(" calloc host_output\n");
        if ((host_output = (float *)calloc(volumeSize, sizeof(float))) == NULL)
        {
            shrLogEx(LOGBOTH | ERRORMSG, -1006, STDERROR);
            shrLog("\tInsufficient memory for host_output calloc, please try a smaller volume (use --help for syntax).\n");
            ok = false;
        }
    }
    if (ok)
    {
        shrLog(" malloc input\n");
        if ((input = (float *)malloc(volumeSize * sizeof(float))) == NULL)
        {
            shrLogEx(LOGBOTH | ERRORMSG, -1007, STDERROR);
            shrLog("\tInsufficient memory for input malloc, please try a smaller volume (use --help for syntax).\n");
            ok = false;
        }
    }
    if (ok)
    {
        shrLog(" malloc coeff\n");
        if ((coeff = (float *)malloc((radius + 1) * sizeof(float))) == NULL)
        {
            shrLogEx(LOGBOTH | ERRORMSG, -1008, STDERROR);
            shrLog("\tInsufficient memory for coeff malloc, please try a smaller volume (use --help for syntax).\n");
            ok = false;
        }
    }

    // Create coefficients
    if (ok)
    {
        for (int i = 0 ; i <= radius ; i++)
        {
            coeff[i] = 0.1f;
        }
    }

    // Generate data
    if (ok)
    {
        shrLog(" generateRandomData\n\n");
        generateRandomData(input, outerDimx, outerDimy, outerDimz, lowerBound, upperBound);
    }

    if (ok)
    {
        shrLog("FDTD on %d x %d x %d volume with symmetric filter radius %d for %d timesteps...\n\n", dimx, dimy, dimz, radius, timesteps);
    }

    // Execute on the host
    if (ok)
    {
        shrLog("fdtdReference...\n");
        ok = fdtdReference(host_output, input, coeff, dimx, dimy, dimz, radius, timesteps);
        shrLog("fdtdReference complete\n");
    }

    // Allocate memory
    if (ok)
    {
        shrLog(" calloc device_output\n");
        if ((device_output = (float *)calloc(volumeSize, sizeof(float))) == NULL)
        {
            shrLogEx(LOGBOTH | ERRORMSG, -1009, STDERROR);
            shrLog("\tInsufficient memory for device output calloc, please try a smaller volume (use --help for syntax).\n");
            ok = false;
        }
    }

    // Execute on the device
    if (ok)
    {
        shrLog("fdtdGPU...\n");
        ok = fdtdGPU(device_output, input, coeff, dimx, dimy, dimz, radius, timesteps, argc, argv);
        shrLog("fdtdGPU complete\n");
    }

    // Compare the results
    if (ok)
    {
        float tolerance = 0.0001f;
        shrLog("\nCompareData (tolerance %f)...\n", tolerance);
        ok = compareData(device_output, host_output, dimx, dimy, dimz, radius, tolerance);
    }

    return ok;
}
Exemplo n.º 11
0
/**
 *****************************************************************************
 * @ingroup dsaPerformance
 *      dsaPerform
 *
 * @description
 *     This function generates all the DSA parameters required to perform a DSA
 *     sign and DSA verify operation. A user defined number of random messages
 *     are generated and signed, then the signature is verified
 *
 *****************************************************************************/
CpaStatus dsaPerform(dsa_test_params_t* setup)
{
    Cpa32U i=0;
    Cpa32U outerLoop = 0;
    CpaBoolean verifyStatus = CPA_TRUE;
    CpaStatus status = CPA_STATUS_SUCCESS;
    /*DSA parameters */
    /*DSA Q parameter, this shall be populated by the hard coded Q at the top
     * of this file */
    CpaFlatBuffer dsaQ = {0};
    /*random number X used to generate Y and Sign R&S */
    CpaFlatBuffer* dsaX = NULL;
    /*DSA P parameter, this shall be populated by the hard coded P at the top
         * of this file */
    CpaFlatBuffer dsaP = {0};
    /*H is used to generate G, H is hard coded to DEFAULT_H_VALUE */
    CpaFlatBuffer dsaH = {0};
    /* DSA G parameter used to generate Y, the signature R&S, and to verify */
    CpaFlatBuffer dsaG = {0};
    /*DSA Y parameter is used in the verification stage */
    CpaFlatBuffer* dsaY = NULL;
    /*K is a random number used in the generation of signature R&S */
    CpaFlatBuffer* dsaK = NULL;
    /*M is the message to be signed */
    CpaFlatBuffer* dsaM = NULL;
    /*R&S is used to store the DSA Signature */
    CpaFlatBuffer* dsaR = NULL;
    CpaFlatBuffer* dsaS = NULL;
    /*Z is the digest of the message in dsaM */
    CpaFlatBuffer* dsaZ = NULL;
    perf_data_t* pDsaData  = NULL;
    /*GCC compiler complains without the double {{}} to init the following
     * structures*/
    CpaCyDsaGParamGenOpData gOpData = {{0, NULL}, {0, NULL}, {0, NULL}};
    CpaCyDsaYParamGenOpData yOpData = {{0}};
    CpaCyDsaRSSignOpData rsOpData = {{0}};
    CpaCyDsaVerifyOpData* verifyOpData = NULL;
    Cpa8U* pDataPtr = NULL;
    Cpa32U sizeOfp = 0;
    Cpa8U* qDataPtr = NULL;
    Cpa32U sizeOfq = 0;
    Cpa32U node = 0;
    CpaCyDsaVerifyCbFunc cbFunc = NULL;

    status = sampleCodeCyGetNode(setup->cyInstanceHandle, &node);
    if(CPA_STATUS_SUCCESS != status)
    {
        PRINT_ERR("Could not determibne node for memory allocation\n");
        return status;
    }
    pDsaData = setup->performanceStats;
    pDsaData->threadReturnStatus = CPA_STATUS_FAIL;
    pDsaData->numOperations = (Cpa64U)setup->numBuffers * setup->numLoops;

    /*check the p and q input len and set the pointers to the data */
    if(MODULUS_1024_BIT / NUM_BITS_IN_BYTE == setup->pLenInBytes &&
            EXPONENT_160_BIT / NUM_BITS_IN_BYTE == setup->qLenInBytes)
    {
        pDataPtr = dsa_1024_160_p;
        qDataPtr = dsa_1024_160_q;
        sizeOfp = sizeof(dsa_1024_160_p);
        sizeOfq = sizeof(dsa_1024_160_q);
    }
    else if(MODULUS_2048_BIT / NUM_BITS_IN_BYTE == setup->pLenInBytes &&
            EXPONENT_224_BIT / NUM_BITS_IN_BYTE == setup->qLenInBytes)
    {
        pDataPtr = dsa_2048_224_p;
        qDataPtr = dsa_2048_224_q;
        sizeOfp = sizeof(dsa_2048_224_p);
        sizeOfq = sizeof(dsa_2048_224_q);
    }
    else if(MODULUS_2048_BIT / NUM_BITS_IN_BYTE == setup->pLenInBytes &&
            EXPONENT_256_BIT / NUM_BITS_IN_BYTE == setup->qLenInBytes)
    {
        pDataPtr = dsa_2048_256_p;
        qDataPtr = dsa_2048_256_q;
        sizeOfp = sizeof(dsa_2048_256_p);
        sizeOfq = sizeof(dsa_2048_256_q);
    }
    else if(MODULUS_3072_BIT / NUM_BITS_IN_BYTE == setup->pLenInBytes &&
            EXPONENT_256_BIT / NUM_BITS_IN_BYTE == setup->qLenInBytes)
    {
        pDataPtr = dsa_3072_256_p;
        qDataPtr = dsa_3072_256_q;
        sizeOfp = sizeof(dsa_3072_256_p);
        sizeOfq = sizeof(dsa_3072_256_q);
    }
    else
    {
        PRINT_ERR("P & Q len not supported\n");
        /*thread status is init to fail so just reutrn fail here*/
        return CPA_STATUS_FAIL;
    }
    /* Completion used in callback */
    sampleCodeSemaphoreInit(&pDsaData->comp, 0);

#define ALLOC_STRUCT(ptr, size) \
do{ \
    ptr = qaeMemAlloc(size * setup->numBuffers); \
    if(NULL == ptr) \
    { \
        PRINT_ERR("Could not allocate memory\n"); \
        FREE_DSA_MEM; \
        return CPA_STATUS_FAIL; \
    } \
    memset(ptr,0,size * setup->numBuffers); \
}while(0)

    /*Allocate all the buffers */
    ALLOC_STRUCT(dsaX, sizeof(CpaFlatBuffer));
    ALLOC_STRUCT(dsaY, sizeof(CpaFlatBuffer));
    ALLOC_STRUCT(dsaK, sizeof(CpaFlatBuffer));
    ALLOC_STRUCT(dsaM, sizeof(CpaFlatBuffer));
    ALLOC_STRUCT(dsaR, sizeof(CpaFlatBuffer));
    ALLOC_STRUCT(dsaS, sizeof(CpaFlatBuffer));
    ALLOC_STRUCT(dsaZ, sizeof(CpaFlatBuffer));
    ALLOC_STRUCT(verifyOpData, sizeof(CpaCyDsaVerifyOpData));
/************************************************************************
 * STAGE 1 Setup up the DSA parameters, generate X, G, Y, K, Z,
 *          generate user defined number of messages to be signed
 *          calculate the digest of the messages
 *          sign all the messages
 *          setup the verification data structure
 **************************************************************************/
    /*set Q */
    ALLOC_FLAT_BUFF_DATA(setup->cyInstanceHandle, &dsaQ,
            setup->qLenInBytes, qDataPtr, sizeOfq, FREE_DSA_MEM);

    /*generate X for each buffer */
    for(i=0; i<setup->numBuffers; i++)
    {
        /*Choose X is generated by random method, where 0 < X < Q */
        ALLOC_FLAT_BUFF_DATA(setup->cyInstanceHandle, &dsaX[i],
                setup->qLenInBytes, NULL, 0, FREE_DSA_MEM);
        dsaGenRandom(&dsaX[i], &dsaQ);
    }

    /*set P */
    ALLOC_FLAT_BUFF_DATA(setup->cyInstanceHandle, &dsaP,
            setup->pLenInBytes, pDataPtr, sizeOfp, FREE_DSA_MEM);

    /***************************************************************************
     * set genG opData and generate G
     * ************************************************************************/

    /*H is required to genG */
    ALLOC_FLAT_BUFF_DATA(setup->cyInstanceHandle, &dsaH,
            setup->pLenInBytes, NULL, 0, FREE_DSA_MEM);
    memset(dsaH.pData, 0, dsaH.dataLenInBytes);
    dsaH.pData[setup->pLenInBytes-1] = DEFAULT_H_VALUE;

    /*allocate space for G */
    ALLOC_FLAT_BUFF_DATA(setup->cyInstanceHandle, &dsaG,
            setup->pLenInBytes, NULL, 0, FREE_DSA_MEM);

    /*set opData to generate G */
    gOpData.P.pData = dsaP.pData;
    gOpData.P.dataLenInBytes = dsaP.dataLenInBytes;
    gOpData.Q.pData = dsaQ.pData;
    gOpData.Q.dataLenInBytes = dsaQ.dataLenInBytes;
    gOpData.H.pData = dsaH.pData;
    gOpData.H.dataLenInBytes = dsaH.dataLenInBytes;
    status = dsaGenG(setup->cyInstanceHandle, &gOpData, &dsaG);
    if(CPA_STATUS_SUCCESS != status)
    {
        PRINT_ERR("Failed to generate DSA parameter G\n");
        FREE_DSA_MEM;
        return CPA_STATUS_FAIL;
    }

    /*generate a Y for each buffer */
    for(i=0;i<setup->numBuffers;i++)
    {
        /*set the opData to gen Y */
        ALLOC_FLAT_BUFF_DATA(setup->cyInstanceHandle, &dsaY[i],
                setup->pLenInBytes, NULL, 0, FREE_DSA_MEM);
        yOpData.P.pData = dsaP.pData;
        yOpData.P.dataLenInBytes = dsaP.dataLenInBytes;
        yOpData.G.pData = dsaG.pData;
        yOpData.G.dataLenInBytes = dsaG.dataLenInBytes;
        yOpData.X.pData = dsaX[i].pData;
        yOpData.X.dataLenInBytes = dsaX[i].dataLenInBytes;
        status = dsaGenY(setup->cyInstanceHandle,&yOpData,&dsaY[i]);
        if(CPA_STATUS_SUCCESS != status)
        {
            PRINT_ERR("Error Generating Y for buffer %d\n", i);
            /*free all the pData buffers allocated and Array of pointers
             * allocated */
            FREE_DSA_MEM;
            return CPA_STATUS_FAIL;
        }

        /*Generate a random per-message value K, where 0 < K < Q. */
        ALLOC_FLAT_BUFF_DATA(setup->cyInstanceHandle, &dsaK[i],
                setup->qLenInBytes, NULL, 0, FREE_DSA_MEM);
        dsaGenRandom(&dsaK[i], &dsaQ);

        /*generate a message to sign */
        /*allocate space for message */
        ALLOC_FLAT_BUFF_DATA(setup->cyInstanceHandle, &dsaM[i],
                setup->pLenInBytes, NULL, 0, FREE_DSA_MEM);

        /*allocate space for digest of message */
        ALLOC_FLAT_BUFF_DATA(setup->cyInstanceHandle, &dsaZ[i],
                setup->qLenInBytes, NULL, 0, FREE_DSA_MEM);

        /*generate random message */
        generateRandomData(dsaM[i].pData, dsaM[i].dataLenInBytes);

        /*calculate digest of message */
        status = dsaGenZ(setup->cyInstanceHandle,
                &dsaM[i],
                setup->hashAlg,
                &dsaZ[i]);
        if(CPA_STATUS_SUCCESS != status)
        {
            PRINT_ERR("Error Generating Z for buffer %d\n", i);
            FREE_DSA_MEM;
            return CPA_STATUS_FAIL;
        }

        /*Gen R & S signature */
        rsOpData.G.pData = dsaG.pData;
        rsOpData.G.dataLenInBytes = dsaG.dataLenInBytes;
        rsOpData.K.pData = dsaK[i].pData;
        rsOpData.K.dataLenInBytes = dsaK[i].dataLenInBytes;
        rsOpData.P.pData = dsaP.pData;
        rsOpData.P.dataLenInBytes = dsaP.dataLenInBytes;
        rsOpData.Q.pData = dsaQ.pData;
        rsOpData.Q.dataLenInBytes = dsaQ.dataLenInBytes;
        rsOpData.X.pData = dsaX[i].pData;
        rsOpData.X.dataLenInBytes = dsaX[i].dataLenInBytes;
        rsOpData.Z.pData = dsaZ[i].pData;
        rsOpData.Z.dataLenInBytes = dsaZ[i].dataLenInBytes;
        ALLOC_FLAT_BUFF_DATA(setup->cyInstanceHandle, &dsaR[i],
                setup->qLenInBytes, NULL, 0, FREE_DSA_MEM);
        ALLOC_FLAT_BUFF_DATA(setup->cyInstanceHandle, &dsaS[i],
                setup->qLenInBytes, NULL, 0, FREE_DSA_MEM);
        status = dsaGenRS(setup->cyInstanceHandle,
                &rsOpData,
                &dsaR[i],
                &dsaS[i]);
        if(CPA_STATUS_SUCCESS != status)
        {
            PRINT_ERR("Error Generating R&S for buffer %d\n", i);
            FREE_DSA_MEM;
            return CPA_STATUS_FAIL;
        }

        /*Verify signature */

        verifyOpData[i].P.pData = dsaP.pData;
        verifyOpData[i].P.dataLenInBytes = dsaP.dataLenInBytes;
        verifyOpData[i].Q.pData = dsaQ.pData;
        verifyOpData[i].Q.dataLenInBytes = dsaQ.dataLenInBytes;
        verifyOpData[i].G.pData= dsaG.pData;
        verifyOpData[i].G.dataLenInBytes = dsaG.dataLenInBytes;
        verifyOpData[i].Y.pData= dsaY[i].pData;
        verifyOpData[i].Y.dataLenInBytes = dsaY[i].dataLenInBytes;
        verifyOpData[i].Z.pData= dsaZ[i].pData;
        verifyOpData[i].Z.dataLenInBytes = dsaZ[i].dataLenInBytes;
        verifyOpData[i].R.pData= dsaR[i].pData;
        verifyOpData[i].R.dataLenInBytes = dsaR[i].dataLenInBytes;
        verifyOpData[i].S.pData= dsaS[i].pData;
        verifyOpData[i].S.dataLenInBytes = dsaS[i].dataLenInBytes;
    }
    /*set the callback function if asynchronous mode is set*/
    if(ASYNC == setup->syncMode)
    {
        cbFunc = dsaVerifyCb;
    }


/************************************************************************
 * STAGE 2 repeatedly verify all the signatures and measure the performance
 ************************************************************************* */

    /*this barrier will wait until all threads get to this point */
    sampleCodeBarrier();
    /* get a timestamp before submitting any requests. After submitting
     * all requests a final timestamp is taken in the callback function.
     * These two times and the number of requests submitted are used  to
     * calculate operations per second  */
    pDsaData->startCyclesTimestamp = sampleCodeTimestamp();
    for(outerLoop = 0; outerLoop<setup->numLoops; outerLoop++)
    {
        for(i=0;i<setup->numBuffers;i++)
        {
            do
            {
                status = cpaCyDsaVerify(setup->cyInstanceHandle,
                    cbFunc,
                    pDsaData,
                    &verifyOpData[i],
                    &verifyStatus);
                if(CPA_STATUS_RETRY == status)
                {
                     pDsaData->retries++;
                     /*once we get to many retries, perform a context switch
                      * to give the acceleration engine a small break */
                     if(RETRY_LIMIT == (pDsaData->retries % (RETRY_LIMIT+1)))
                     {
                         AVOID_SOFTLOCKUP;
                     }
                 }
             } while (CPA_STATUS_RETRY == status);
            /*if for some reason the DSA verify returns fail, decrease the
             * numOperations expected in the callback so that the code does not
             * wait forever */
            if(CPA_STATUS_SUCCESS != status)
            {
                PRINT_ERR("DSA Verify function failed with status:%d\n",
                        status);
                break;
            }
        }
        if(CPA_STATUS_SUCCESS != status)
        {
            break;
        }
    }
    if (CPA_STATUS_SUCCESS == status)
    {
        status = waitForResponses(pDsaData, setup->syncMode, setup->numBuffers,
                setup->numLoops);
    }

    /*free Arrays of buffer pointers and pData */
    FREE_DSA_MEM;
    sampleCodeSemaphoreDestroy(&pDsaData->comp);
    pDsaData->threadReturnStatus = status;
    if(CPA_STATUS_SUCCESS != setup->performanceStats->threadReturnStatus)
    {
        status = CPA_STATUS_FAIL;
    }
return status;
}