How __shared__ is working in the following code? - c++

Question

I am not getting line no 9 and 10; the index being used and calculated via the formula Col + (m*TILE_WIDTH + ty)*Width.
Can someone help me in understanding this code, i.e. the use of __shared__?
__global__ void MatrixMulKernel(float* Md, float* Nd, float* Pd, int Width)
{
__shared__float Mds[TILE_WIDTH][TILE_WIDTH];
__shared__float Nds[TILE_WIDTH][TILE_WIDTH];
3. int bx = blockIdx.x; int by = blockIdx.y;
4. int tx = threadIdx.x; int ty = threadIdx.y;
// Identify the row and column of the Pd element to work on
5. int Row = by * TILE_WIDTH + ty;
6. int Col = bx * TILE_WIDTH + tx;
7. float Pvalue = 0; ;
// Loop over the Md and Nd tiles required to compute the Pd element
8. for (int m = 0; m < Width/TILE_WIDTH; ++m) {
// Coolaborative loading of Md and Nd tiles into shared memory
9.Mds[ty][tx] = Md[Row*Width + (m*TILE_WIDTH + tx)];
10.Nds[ty][tx] = Nd[Col + (m*TILE_WIDTH + ty)*Width];
11.__syncthreads();
11. for (int k = 0; k < TILE_WIDTH; ++k)
12.Pvalue += Mds[ty][k] * Nds[k][tx];
13. Synchthreads();
}
Pd[Row*Width+Col] = Pvalue;
}

Answer 1

__shared__ memory is a fast (but small) on-chip resource for the GPU.
The matrices to be multiplied start out in global memory (Md and Nd). Lines 10 and 11:
Mds[ty][tx] = Md[Row*Width + (m*TILE_WIDTH + tx)]; // line 10
Nds[ty][tx] = Nd[Col + (m*TILE_WIDTH + ty)*Width]; // line 11
each load a "tile" (square sub-section) of the matrix to be multiplied (either Md or Nd) into a shared memory copy (Mds or Nds). The reason a single line of code can load a whole "tile" is because all threads of the threadblock execute that one line of code. As a result, a threadblock-size "chunk" or "tile" of data is moved from global to shared memory.
Once it is in shared memory, the actual multiplication is done in line 14. Since line 14 is operating out of shared memory instead of global memory, and because there is data reuse amongst adjacent threads in the block, the overall multiplication operation runs more quickly, because shared memory can be accessed more rapidly than global memory.
A similar code and description is provided in the programming guide.