Function test_gemm_loop

cpp/4_CUDA_Libraries/batchCUBLAS/batchCUBLAS.cpp:395–621

template <typename T_ELEM>
int test_gemm_loop(struct gemmOpts &opts, float err, double max_relative_error, cublasHandle_t handle)
{
    struct gemmTestParams<T_ELEM> params;
    cudaStream_t                 *streamArray = 0;
    cublasStatus_t                status1, status2, status3;
    T_ELEM                       *A           = NULL;
    T_ELEM                       *B           = NULL;
    T_ELEM                       *C           = NULL;
    T_ELEM                      **devPtrA     = 0;
    T_ELEM                      **devPtrB     = 0;
    T_ELEM                      **devPtrC     = 0;
    T_ELEM                      **devPtrA_dev = NULL;
    T_ELEM                      **devPtrB_dev = NULL;
    T_ELEM                      **devPtrC_dev = NULL;
    int                           matrixM, matrixN, matrixK;
    int                           rowsA, rowsB, rowsC;
    int                           colsA, colsB, colsC;
    int                           matrixSizeA, matrixSizeB, matrixSizeC;
    int                           errors;
    double                        start, stop;

    printf("Testing %cgemm\n", *opts.elem_type);

    matrixM = (opts.m) ? opts.m : BENCH_MATRIX_M;
    matrixN = (opts.n) ? opts.n : BENCH_MATRIX_N;
    matrixK = (opts.k) ? opts.k : BENCH_MATRIX_K;

    rowsA = imax(1, matrixM);
    colsA = imax(1, matrixK);
    rowsB = imax(1, matrixK);
    colsB = imax(1, matrixN);
    rowsC = imax(1, matrixM);
    colsC = imax(1, matrixN);

    matrixSizeA = rowsA * colsA;
    matrixSizeB = rowsB * colsB;
    matrixSizeC = rowsC * colsC;

    devPtrA = (T_ELEM **)malloc(opts.N * sizeof(*devPtrA));
    devPtrB = (T_ELEM **)malloc(opts.N * sizeof(*devPtrB));
    devPtrC = (T_ELEM **)malloc(opts.N * sizeof(*devPtrC));

    for (int i = 0; i < opts.N; i++) {
        cudaError_t err1 = cudaMalloc((void **)&devPtrA[i], matrixSizeA * sizeof(devPtrA[0][0]));
        cudaError_t err2 = cudaMalloc((void **)&devPtrB[i], matrixSizeB * sizeof(devPtrB[0][0]));
        cudaError_t err3 = cudaMalloc((void **)&devPtrC[i], matrixSizeC * sizeof(devPtrC[0][0]));

        if ((err1 != cudaSuccess) || (err2 != cudaSuccess) || (err3 != cudaSuccess)) {
            CLEANUP();
            fprintf(stderr, "!!!! GPU memory allocation error\n");
            return CUBLASTEST_FAILED;
        }
    }

    // For batched processing we need those arrays on the device
    if (opts.test_method == tmBatched) {
        cudaError_t err1 = cudaMalloc((void **)&devPtrA_dev, opts.N * sizeof(*devPtrA));
        cudaError_t err2 = cudaMalloc((void **)&devPtrB_dev, opts.N * sizeof(*devPtrB));