Result of Matrix Multiplication is all 0

Question

I'm trying code this C example but in C++. C code works fine but when i try to reproduce this in C++, in result matrix the first row is all 0's. I have no idea if other rows are correct either. I have spent several hours on this but couldn't figure out why the first row of resultant matrix is all 0.

my host code:

#define CL_HPP_ENABLE_EXCEPTIONS
#define CL_HPP_TARGET_OPENCL_VERSION 300

// we have a square matrix here!
#define AH 32;
#define AW 32;

#include 
#include 
#include 
#include 
#include 
#include 
#include 



int main()
{

    int r = AH;
    int c = AW;
    int elements = r * c;
    int datasize = elements * sizeof(float);

    float *matrixA = (float *)malloc(datasize);
    float *matrixB = (float *)malloc(datasize);
    float *matrixC = (float *)malloc(datasize); //result

    float *matrixC_CPU = (float *)malloc(datasize);

    // random nyumber
    std::random_device rd;
    std::mt19937 mt(rd());
    std::uniform_real_distribution gen(1.0f, 4.0f);

    // fill data
    for (size_t i = 0; i < elements; i++)
    {
        matrixA[i] = gen(mt);
        matrixB[i] = gen(mt);
    }


    std::vector platforms;
    cl::Platform::get(&platforms);

    for (auto platform : platforms)
    {
        std::cout << platform.getInfo() << std::endl;
        std::cout << platform.getInfo() << std::endl;
    }

    std::vector devices;
    cl::Device device;

    platforms[0].getDevices(CL_DEVICE_TYPE_ALL, &devices);
    
    for (auto _device : devices){
        std::cout << _device.getInfo() << std::endl;
    }
    device = devices[0];

    cl::Context ctx(device);

    cl::CommandQueue queue = cl::CommandQueue(ctx, device);

    cl::Buffer bufA = cl::Buffer(ctx, CL_MEM_READ_ONLY, datasize);
    queue.enqueueWriteBuffer(bufA, CL_TRUE, 0, datasize, matrixA);
    cl::Buffer bufB = cl::Buffer(ctx, CL_MEM_READ_ONLY, datasize);
    queue.enqueueWriteBuffer(bufB, CL_TRUE, 0, datasize, matrixB);
    cl::Buffer bufC = cl::Buffer(ctx, CL_MEM_WRITE_ONLY, datasize);
    queue.enqueueWriteBuffer(bufC, CL_TRUE, 0, datasize, matrixC);

    std::ifstream f("kernel.cl", std::ios::in);
    std::string kernelSource;

    std::stringstream ss;
    ss << f.rdbuf();
    kernelSource = ss.str();

    std::cout << kernelSource << std::endl;

    cl::Program program(ctx, kernelSource.c_str());
    program.build(device);

    cl::Kernel vec_add_kernel(program, "matrixMul");
    vec_add_kernel.setArg(0, bufC);
    vec_add_kernel.setArg(1, bufB);
    vec_add_kernel.setArg(2, bufA);
    vec_add_kernel.setArg(3, r);
    vec_add_kernel.setArg(4, c);

    cl::NDRange global(r, c);
    cl::NDRange local(32, 32);

    queue.enqueueNDRangeKernel(vec_add_kernel, 0, global, local);

    queue.enqueueReadBuffer(bufC, CL_TRUE, 0, datasize, matrixC);

    for (int i = 0; i < elements; i++)
    {
        if (i % r == 0)
            std::cout << std::endl;
        std::cout << matrixC[i] << " ";
    }


    return 0;

}

kernel.cl


/* kernel.cl 
 * Matrix multiplication: C = A * B.
 * Device code.
 */
 
// OpenCL Kernel
__kernel void
matrixMul(__global float* C, 
          __global float* A, 
          __global float* B, 
          int wA, int wB)
{
  
   int tx = get_global_id(0); 
   int ty = get_global_id(1);
 
   // value stores the element that is 
   // computed by the thread
   float value = 0;
   for (int k = 0; k < wA; ++k)
   {
      float elementA = A[ty * wA + k];
      float elementB = B[k * wB + tx];
      value += elementA * elementB;
   }
 
   // Write the matrix to device memory each 
   // thread writes one element
   C[ty * wA + tx] = value;
}

Result of Matrix Multiplication is all 0

Answers (1)

Related Questions