# cuda-operator

**Repository Path**: bleedingfight/cuda-operator

## Basic Information

- **Project Name**: cuda-operator
- **Description**: No description available
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2024-12-24
- **Last Updated**: 2024-12-30

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# TensorCore计算

## 内存数据对应数学矩阵

一个内存中的矩阵$A_{4\times4}$ = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]，$B_{4\times 3}$=[6, 12, 6, 0, 4, 8, 7, 6, 12, 4, 7, 5]的$3\times4$矩阵。

### $A_{4\times4}$行优先$B_{4\times3}$行优先

$$
C_{4\times3}=A_{4\times4}B_{4\times3} =
\begin{bmatrix}
1&2&3&4\\
5&6&7&8\\
9&10&11&12\\
13&14&15&16
\end{bmatrix}
\begin{bmatrix}
6&12& 6\\
0&4&8\\
7&6&12\\
4&7&5
\end{bmatrix}
=\begin{bmatrix}
43&66&78\\
111&182&202\\
179&298&326\\
247&414&450\\
\end{bmatrix}
$$

### $A_{4\times4}$列优先$B_{4\times3}$行优先

$$
C_{4\times3}=A_{4\times4}B_{4\times3} =
\begin{bmatrix}
1&5&9&13\\
2&6&10&14\\
3&7&11&15\\
4&8&12&16
\end{bmatrix}
\begin{bmatrix}
6&12& 6\\
0&4&8\\
7&6&12\\
4&7&5
\end{bmatrix}=
\begin{bmatrix}
121&177& 219\\
138&206&250\\
155&235&281\\
172&264&312
\end{bmatrix}
$$

### $A_{4\times4}$行优先$B_{4\times3}$列优先

$$
C_{4\times3}=A_{4\times4}B_{4\times3} =
\begin{bmatrix}
1&2&3&4\\
5&6&7&8\\
9&10&11&12\\
13&14&15&16
\end{bmatrix}
\begin{bmatrix}
6&4&12\\
12&8&4\\
6&7&7\\
0&6&5
\end{bmatrix}
=\begin{bmatrix}
48&65&61\\
144&165&173\\
240&265&285\\
336&365&397\\
\end{bmatrix}
$$

### $A_{4\times4}$列优先$B_{4\times3}$列优先

$$
C_{4\times3}=A_{4\times4}B_{4\times3} =
\begin{bmatrix}
1&5&9&13\\
2&6&10&14\\
3&7&11&15\\
4&8&12&16
\end{bmatrix}
\begin{bmatrix}
6&4&12\\
12&8&4\\
6&7&7\\
0&6&5
\end{bmatrix}
=\begin{bmatrix}
120&185&160\\
144&210&188\\
168&235&216\\
192&260&244\\
\end{bmatrix}
$$

## 对于一个大矩阵的计算细节

现在矩阵$C_{32\times16} = A_{32\times32}B_{32\times16}（m = 32,K = 32,n=16）$，通过我们行列优先计算实例，我们能发现对于二维矩阵，如果行优先存储则索引lda=矩阵列，否则为矩阵行。TensorCore计算是Warp粒度的，这里我们假设输入$4\times128$，这样按照32个warp，我们可以得到$16\times32$个warp。我们按照$4\times4$组织我们的warp。

这里我们的A矩阵$32\times32$可以分成两个16。$A_{32\tiems32}$分块之后能有4个$16\times 16$的计算块。因为是行优先，所以这四个块的起点分别是：

- 0
- 0+16
- 0+16\*32
- 0+16\*32+16
  对于$T_0-T_{31}$号线程，它们属于warpM=0的区域，它们负责的起点数据就是0，而对于$T_{32}-T_{64}$号线程。其属于warpM = 1。负责的数据块是0+16\*32。因此：

  | 线性线程ID | 所在warp的行索引(warpM) | 所在warp的列索引(warpN) |   数据偏移   |
  | :--------: | :---------------------: | :---------------------: | :----------: |
  |    0-31    |            0            |            0            |      0       |
  |   32-63    |            1            |            0            | $16\times32$ |
  |   64-96    |            2            |            0            | $32\times32$ |
  |   96-128   |            3            |            o            | $48\times32$ |

## 待弄明白的问题

1. TensorCore计算的时候内存布局是怎样的？
2. 超过$16\times 16$的矩阵TensorCore上是如何轮转的？
3. 行优先存储和列优先存储