Function cublasTester

tests/unittests/fp8_gemm_test/worker.cpp:207–616

// public API

int32_t cublasTester(const ProblemDesc& p)
{
    // Initialize input A, B and D
    // A: weight matrix, k * n
    // B: input matrix, m * k
    // D: output matrix, m * n
    float* f_hevAPtr = new float[p.batch * p.k * p.n];
    float* f_hevBPtr = new float[p.batch * p.m * p.k];
    float* f_hevDPtr = new float[p.batch * p.m * p.n];
    float* f_hevAPtr_trans = new float[p.batch * p.n * p.k]; // For TN GEMM, the weight should be transposed

    // const float max_rand_num = 0.01f;
    for (int b = 0; b < (int)p.batch; b++) {
        for (int i = 0; i < (int)(p.k); i++) {
            for (int j = 0; j < (int)(p.n); j++) {
                // f_hevAPtr[i * p.n + j] = (random() % 1000) / (1000.f / max_rand_num) - (max_rand_num / 2);
                // f_hevAPtr[i * p.n + j] = (random() % 1000) / 1000.f * 2.0f - 1.0f;
                // f_hevAPtr[i * p.n + j] = pow(-1, random() % 2) * (1 << (random() % 8)) * ((random() % 4) * 0.25 + 1.f);
                float exp_num = 1 << (random() % 8);
                float man_num = random() % 4 * 0.25 + 1.f;
                exp_num = random() % 2 == 0 ? exp_num * 1.0f : 1.0f / exp_num;
                man_num = random() % 2 == 0 ? man_num : -1.0f * man_num;
                f_hevAPtr[b * p.k * p.n + i * p.n + j] = exp_num * man_num;
                f_hevAPtr_trans[b * p.k * p.n + j * p.k + i] = f_hevAPtr[b * p.k * p.n + i * p.n + j];
            }
        }
    }

    for (int i = 0; i < (int)(p.batch * p.m * p.k); i++) {
        // f_hevBPtr[i] = (random() % 1000) / 1000.f * 2.0f - 1.0f;
        f_hevBPtr[i] = 1.0f;
    }
    for (int i = 0; i < (int)(p.batch * p.m * p.n); i++) {
        f_hevDPtr[i] = 0.0f;
    }

    // Baseline
    for (int b = 0; b < (int)p.batch; b++) {
        for (int i = 0; i < (int)p.m; i++) {
            for (int j = 0; j < (int)p.n; j++) {
                for (int k = 0; k < (int)p.k; k++) {
                    f_hevDPtr[b * p.m * p.n + i * p.n + j] =
                        f_hevDPtr[b * p.m * p.n + i * p.n + j] + f_hevBPtr[b * p.m * p.k + i * p.k + k] * p.bScale * f_hevAPtr[b * p.k * p.n + k * p.n + j] * p.aScale;
                }
            }
        }
    }
    
    printf("[INFO] fp32 input: \n");
    printMatrix(f_hevBPtr, p.m, p.k);
    printf("[INFO] fp32 weight: \n");
    printMatrix(f_hevAPtr, p.k, p.n);
    printf("[INFO] fp32 output: \n");
    printMatrix(f_hevDPtr, p.batch * p.m, p.n);

    // Collect amax scalar
    float* h_input_amax = new float(0.0f); // per tensor
    float* h_output_scaling = new float[p.n];