Gemv with half precision cannot get correct result. #561

// API test
#include <CL/cl.h>
#include <clblast.h>
#include <clblast_half.h>
#include <vector>
#include <chrono>
#include <iostream>

static void printDeviceInfo(cl_device_id device) {
    char buffer[1024];
    // device name
    clGetDeviceInfo(device, CL_DEVICE_NAME, sizeof(buffer), buffer, nullptr);
    std::cout << "Device Name: " << buffer << std::endl;

    // device vendor
    clGetDeviceInfo(device, CL_DEVICE_VENDOR, sizeof(buffer), buffer, nullptr);
    std::cout << "Device Vendor: " << buffer << std::endl;

    // device version
    clGetDeviceInfo(device, CL_DEVICE_VERSION, sizeof(buffer), buffer, nullptr);
    std::cout << "Device Version: " << buffer << std::endl;

    // drvier version
    clGetDeviceInfo(device, CL_DRIVER_VERSION, sizeof(buffer), buffer, nullptr);
    std::cout << "Driver Version: " << buffer << std::endl;

    // OpenCL version
    clGetDeviceInfo(device, CL_DEVICE_OPENCL_C_VERSION, sizeof(buffer), buffer, nullptr);
    std::cout << "OpenCL C Version: " << buffer << std::endl;
}

static void ConvertToHalf(const std::vector<float>& input, std::vector<cl_half>& output) {
    output.reserve(input.size());
    output.resize(input.size());
    for (size_t i = 0; i < input.size(); ++i) {
        output[i] = FloatToHalf(input[i]);
    }
}

static void ConvertToFloat(const std::vector<cl_half>& input, std::vector<float>& output) {
    output.reserve(input.size());
    output.resize(input.size());
    for (size_t i = 0; i < input.size(); ++i) {
        output[i] = HalfToFloat(input[i]);
    }
}

void test_gemm()
{

}

void test_gemv(cl_device_id device, cl_context context, cl_command_queue queue)
{
    const size_t m = 16384;
    const size_t n = 2048;

    std::vector<float> host_a(m * n, 1.1f);
    std::vector<float> host_x(16384, 1.0f);
    std::vector<float> host_y(2048, 0.0f);

    cl_mem a_buffer = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, host_a.size() * sizeof(float), host_a.data(), nullptr);
    cl_mem x_buffer = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, host_x.size() * sizeof(float), host_x.data(), nullptr);
    cl_mem y_buffer = clCreateBuffer(context, CL_MEM_WRITE_ONLY, host_y.size() * sizeof(float), nullptr, nullptr);
    clFinish(queue); // Ensure memory operations are complete

    using Parameters = std::unordered_map<std::string, size_t>;

    // params
    Parameters tuned_params = {
        {"WGS1", 64},
        {"WPT1", 1},
        {"VW2", 1},
        {"WGS2", 64},
        {"WPT2",1}
    };

    // use tuned params
    clblast::OverrideParameters(device, "XgemvFast", clblast::Precision::kSingle, tuned_params);

    // Performance measurement
    double totalTime = 0.0;
    for (int i = 0; i < 10; i++) {
        auto start = std::chrono::steady_clock::now();
        
        auto status = clblast::Gemv<float>(clblast::Layout::kRowMajor, clblast::Transpose::kYes, m, n, 
                        1.0f, 
                        a_buffer, 0, n, 
                        x_buffer, 0, 1, 
                        0.0f, 
                        y_buffer, 0, 1, 
                        &queue, nullptr);
        if (status != clblast::StatusCode::kSuccess) {
            std::cerr << "[TEST] Gemv error: " << static_cast<int>(status) << std::endl;
        }

        clFinish(queue);
        auto elapsed_time = std::chrono::duration<double,std::milli>(std::chrono::steady_clock::now() - start).count();
        std::cout << "No. "<< i << " GEMV execution time: " << elapsed_time << " ms" << std::endl;
        totalTime += elapsed_time;
    }

    double averageTime = totalTime / 10.0;
    std::cout << "GEMV execution time: " << averageTime << " ms" << std::endl;

    // Result
    clEnqueueReadBuffer(queue, y_buffer, CL_TRUE, 0, host_y.size() * sizeof(float), host_y.data(), 0, nullptr, nullptr);
    std::cout << "Result : ";
    for (int i = 0; i < 10; ++i) {
        std::cout << host_y[i] << " ";
    }
    std::cout << std::endl;

    // release 
    clReleaseMemObject(a_buffer);
    clReleaseMemObject(x_buffer);
    clReleaseMemObject(y_buffer);
}

void test_gemv_half(cl_device_id device, cl_context context, cl_command_queue queue)
{
    const size_t m = 16384;
    const size_t n = 2048;

    std::vector<float> host_a_float(m * n, 1.1f);
    std::vector<float> host_x_float(16384, 1.0f);
    std::vector<float> host_y_float(2048, 0.0f);

    std::vector<cl_half> host_a;
    std::vector<cl_half> host_x;
    std::vector<cl_half> host_y;

    ConvertToHalf(host_a_float, host_a);
    ConvertToHalf(host_x_float, host_x);
    host_y.resize(2048, FloatToHalf(0.0f));

    cl_mem a_buffer = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, host_a.size() * sizeof(cl_half), host_a.data(), nullptr);
    cl_mem x_buffer = clCreateBuffer(context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, host_x.size() * sizeof(cl_half), host_x.data(), nullptr);
    cl_mem y_buffer = clCreateBuffer(context, CL_MEM_WRITE_ONLY, host_y.size() * sizeof(cl_half), nullptr, nullptr);
    clFinish(queue); // Ensure memory operations are complete

    // params
    using Parameters = std::unordered_map<std::string, size_t>;
    Parameters tuned_params = {
        {"WGS1", 64},
        {"WPT1", 1},
        {"VW2", 1},
        {"WGS2", 64},
        {"WPT2",1}
    };

    // use tuned params
    // clblast::OverrideParameters(device, "XgemvFast", clblast::Precision::kHalf, tuned_params);

    // Performance measurement
    double totalTime = 0.0;
    for (int i = 0; i < 10; i++) {
        auto start = std::chrono::steady_clock::now();
        
        auto status = clblast::Gemv<cl_half>(clblast::Layout::kRowMajor, clblast::Transpose::kYes, m, n, 
                        FloatToHalf(1.0f), 
                        a_buffer, 0, n, 
                        x_buffer, 0, 1, 
                        FloatToHalf(0.0f), 
                        y_buffer, 0, 1, 
                        &queue, nullptr);
        if (status != clblast::StatusCode::kSuccess) {
            std::cerr << "[TEST] Gemv error: " << static_cast<int>(status) << std::endl;
        }

        clFinish(queue);
        auto elapsed_time = std::chrono::duration<double,std::milli>(std::chrono::steady_clock::now() - start).count();
        std::cout << "No. "<< i << " GEMV execution time: " << elapsed_time << " ms" << std::endl;
        totalTime += elapsed_time;
    }

    double averageTime = totalTime / 10.0;
    std::cout << "GEMV execution time: " << averageTime << " ms" << std::endl;

    // Result
    clEnqueueReadBuffer(queue, y_buffer, CL_TRUE, 0, host_y.size() * sizeof(cl_half), host_y.data(), 0, nullptr, nullptr);
    ConvertToFloat(host_y, host_y_float);

    std::cout << "Result : ";
    for (int i = 0; i < 10; ++i) {
        std::cout << host_y_float[i] << " ";
    }
    std::cout << std::endl;

    // release 
    clReleaseMemObject(a_buffer);
    clReleaseMemObject(x_buffer);
    clReleaseMemObject(y_buffer);
}

int main() {

    cl_platform_id platform;
    cl_device_id device;
    cl_context context;
    cl_command_queue queue;

    clGetPlatformIDs(1, &platform, nullptr);
    clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 1, &device, nullptr);
    printDeviceInfo(device);
    context = clCreateContext(nullptr, 1, &device, nullptr, nullptr, nullptr);
    queue = clCreateCommandQueue(context, device, 0, nullptr);

    test_gemv(device, context, queue);
    test_gemv_half(device, context, queue);

    clReleaseCommandQueue(queue);
    clReleaseContext(context);

    return 0;
}