Wsrtjtyk

I created a program in CUDA to multiply two matrices together. I used multiple blocks and also increased the amount of elements each thread computes. I measured the execution time for multiple block sizes and multiple workloads for each thread, but I'm a little confused by the results. Changing the block size changes the execution time, but changing how many elements each thread should compute doesn't change the execution time at all. I'm not sure if there's something wrong with my code or if I am just misunderstanding the problem. I would think that as the number of elements each thread must compute increases, the execution time should increase as well. I am getting correct output however so I don't understand what could be wrong.

In my code, TILE_WIDTH (B) represents the block size and W_WIDTH (W) represents how many elements each thread should compute. So, a BxB block should compute BWxBW elements with each thread computing WxW elements.

Here's the code to invoke the kernel. As W increases, the number of blocks decreases. Width is the size of one side of a matrix (4096).

    dim3 dimGrid(Width/(TILE_WIDTH*W_WIDTH), Width/(TILE_WIDTH*W_WIDTH));

    dim3 dimBlock(TILE_WIDTH, TILE_WIDTH);

    MatrixMulKernel_sharedmemory<<<dimGrid, dimBlock>>>(ad, bd, cd, Width);

Here's the kernel:

__global__ void MatrixMulKernel_sharedmemory(float* ad, float* bd, float* cd, int Width) {

    __shared__ float ads[TILE_WIDTH][TILE_WIDTH];

    __shared__ float bds[TILE_WIDTH][TILE_WIDTH];



    int Bx = blockIdx.x;

    int By = blockIdx.y;



    int Tx = threadIdx.x;

    int Ty = threadIdx.y;



    int rowd = By * TILE_WIDTH * W_WIDTH + Ty;

    int columnd = Bx * TILE_WIDTH * W_WIDTH+ Tx;

    int rowds;

    int columnds;



    for (int m = 0; m < W_WIDTH; m++) {

    for (int n = 0; n < W_WIDTH; n++) {

    rowds = rowd + m*TILE_WIDTH;

    columnds = columnd + n*TILE_WIDTH;

    float Cvalue = 0;



    for(int i = 0; i < Width /( TILE_WIDTH); i++) {

            ads[Ty][Tx] = ad[rowds * Width + i * TILE_WIDTH + Tx];

            bds[Ty][Tx] = bd[(i*TILE_WIDTH + Ty)*Width + columnds];

            __syncthreads();





    for (int k = 0; k < TILE_WIDTH; k++) {

            Cvalue += ads[Ty][k] * bds[k][Tx];

            __syncthreads();

    }

    }



    cd[rowds * Width + columnds] = Cvalue;



    }

    }

    }