阿东阿言

1D Convolution

Tue, 14 Jul 2026 00:00:00 GMT

解析#

该题要实现一个执行一维卷积运算的程序。

给定一个输入数组和一个卷积核（滤波器），计算卷积后的输出。卷积运算应满足“有效”边界条件，即卷积核仅应用于与输入完全重叠的区域。

卷积操作其实很简单，就是将卷积核和数组内元素先求积再求和而已。

答案#

1
#include <cuda_runtime.h>
2

3
__global__ void convolution_1d_kernel(const float* input, const float* kernel, float* output,
4
    int input_size, int kernel_size) {
5
        int idx = blockIdx.x * blockDim.x + threadIdx.x;
6
        int output_size = input_size - kernel_size + 1;
7
        if (idx < output_size) {
8
            float sum = 0.0f;
9
            for (int i = 0; i < kernel_size; i++) {
10
                sum += input[idx + i] * kernel[i];
11
            }
12
            output[idx] = sum;
13
        }
14
    }
15

16
// input, kernel, output are device pointers (i.e. pointers to memory on the GPU)
17
extern "C" void solve(const float* input, const float* kernel, float* output, int input_size,
18
                      int kernel_size) {
19
    int output_size = input_size - kernel_size + 1;
20
    int threadsPerBlock = 256;
21
    int blocksPerGrid = (output_size + threadsPerBlock - 1) / threadsPerBlock;
22

23
    convolution_1d_kernel<<<blocksPerGrid, threadsPerBlock>>>(input, kernel, output, input_size,
24
                                                              kernel_size);
25
    cudaDeviceSynchronize();
26
}

展开收起

Gaussian Error Gated Linear Unit

Tue, 14 Jul 2026 00:00:00 GMT

题目#

答案#

1
#include <cuda_runtime.h>
2

3
__global__ void geglu_kernel(const float* input, float* output, int halfN) {
4
    int idx = blockDim.x * blockIdx.x + threadIdx.x;
5
    if (idx >= halfN) return;
6

7
    float x1 = input[idx];
8
    float x2 = input[idx + halfN];
9

10

11
    const float inv_sqrt2 = 0.70710678118f;
12

13
    float gelu = 0.5f * x2 * (1.0f + erff(x2 * inv_sqrt2));
14

15
    output[idx] = x1 * gelu;
16
}
17

18
// input, output are device pointers
19
extern "C" void solve(const float* input, float* output, int N) {
20
    int halfN = N / 2;
21
    int threadsPerBlock = 256;
22
    int blocksPerGrid = (halfN + threadsPerBlock - 1) / threadsPerBlock;
23

24
    geglu_kernel<<<blocksPerGrid, threadsPerBlock>>>(input, output, halfN);
25
    cudaDeviceSynchronize();
26
}

展开收起

Interleave Arrays

Tue, 14 Jul 2026 00:00:00 GMT

问题#

答案#

1
#include <cuda_runtime.h>
2

3
__global__ void interleave_kernel(const float* A, const float* B, float* output, int N) {
4
    int idx = blockDim.x * blockIdx.x + threadIdx.x;
5
    if (idx >= N) return;
6
    output[2 * idx] = A[idx];
7
    output[2 * idx + 1] = B[idx];
8
}
9

10
// A, B, output are device pointers (i.e. pointers to memory on the GPU)
11
extern "C" void solve(const float* A, const float* B, float* output, int N) {
12
    int threadsPerBlock = 256;
13
    int blocksPerGrid = (N + threadsPerBlock - 1) / threadsPerBlock;
14

15
    interleave_kernel<<<blocksPerGrid, threadsPerBlock>>>(A, B, output, N);
16
    cudaDeviceSynchronize();
17
}

展开收起

Leaky ReLU

Tue, 14 Jul 2026 00:00:00 GMT

题面#

和 ReLU 大同小异。

答案#

1
#include <cuda_runtime.h>
2

3
__global__ void leaky_relu_kernel(const float* input, float* output, int N) {
4
    int idx = blockDim.x * blockIdx.x + threadIdx.x;
5
    if (idx < N) {
6
        output[idx] = input[idx] > 0 ? input[idx] : 0.01 * input[idx];
7
    }
8
}
9

10
// input, output are device pointers (i.e. pointers to memory on the GPU)
11
extern "C" void solve(const float* input, float* output, int N) {
12
    int threadsPerBlock = 256;
13
    int blocksPerGrid = (N + threadsPerBlock - 1) / threadsPerBlock;
14

15
    leaky_relu_kernel<<<blocksPerGrid, threadsPerBlock>>>(input, output, N);
16
    cudaDeviceSynchronize();
17
}

展开收起

Matrix Copy

Tue, 14 Jul 2026 00:00:00 GMT

题面#

答案#

1
#include <cuda_runtime.h>
2

3
__global__ void copy_matrix_kernel(const float* A, float* B, int total) {
4
    int idx = blockDim.x * blockIdx.x + threadIdx.x;
5
    if (idx > total) { return; }
6
    if (idx < total) {
7
        B[idx] = A[idx];
8
    }
9
}
10

11
// A, B are device pointers (i.e. pointers to memory on the GPU)
12
extern "C" void solve(const float* A, float* B, int N) {
13
    int total = N * N;
14
    int threadsPerBlock = 256;
15
    int blocksPerGrid = (total + threadsPerBlock - 1) / threadsPerBlock;
16
    copy_matrix_kernel<<<blocksPerGrid, threadsPerBlock>>>(A, B, total);
17
    cudaDeviceSynchronize();
18
}

展开收起

Matrix Multiplication

Tue, 14 Jul 2026 00:00:00 GMT

题面#

答案#

1
#include <cuda_runtime.h>
2

3
__global__ void matrix_multiplication_kernel(const float* A, const float* B, float* C, int M, int N, int K) {
4
    int k = blockDim.x * blockIdx.x + threadIdx.x; // Col
5
    int m = blockDim.y * blockIdx.y + threadIdx.y; // Row
6
    int idx = m * K + k; // ALL
7
    if ((k < K) && (m < M)) {
8
        float sum = 0;
9
        for (int n = 0; n < N; n++) {
10
            sum += A[m * N + n] * B[n * K + k];
11
        }
12
        C[idx] += sum;
13
    }
14
}
15

16
// A, B, C are device pointers (i.e. pointers to memory on the GPU)
17
extern "C" void solve(const float* A, const float* B, float* C, int M, int N, int K) {
18
    dim3 threadsPerBlock(16, 16);
19
    dim3 blocksPerGrid((K + threadsPerBlock.x - 1) / threadsPerBlock.x,
20
                       (M + threadsPerBlock.y - 1) / threadsPerBlock.y);
21

22
    matrix_multiplication_kernel<<<blocksPerGrid, threadsPerBlock>>>(A, B, C, M, N, K);
23
    cudaDeviceSynchronize();
24
}

展开收起

核心循环图解#

线程 → 目标位置#

每个线程负责计算 C 的一个元素：

1
int k = blockDim.x * blockIdx.x + threadIdx.x;  // C 的列号
2
int m = blockDim.y * blockIdx.y + threadIdx.y;  // C 的行号
3
int idx = m * K + k;                             // 在 C 中的线性索引

1
        k=0    k=1    k=2
2
     ┌──────┬──────┬──────┐
3
m=0  │ T0,0 │ T0,1 │ T0,2 │  ← 每个格子一个线程
4
m=1  │ T1,0 │ T1,1 │ T1,2 │
5
     └──────┴──────┴──────┘

索引公式对照#

代码	数学含义	解释
`m * N + n`	A[m][n]	A 有 N 列，行主序存储
`n * K + k`	B[n][k]	B 有 K 列，行主序存储
`m * K + k`	C[m][k]	C 有 K 列，行主序存储

注意#

代码中 C[idx] += sum 是累加而非赋值。如果 C 未被调用方清零，会叠加到垃圾值上。常规矩阵乘法应使用 =，除非有意做增量累加。

Matrix Transpose

Tue, 14 Jul 2026 00:00:00 GMT

题面#

答案#

1
#include <cuda_runtime.h>
2

3
__global__ void matrix_transpose_kernel(const float* input, float* output, int rows, int cols) {
4
    int row = blockDim.y * blockIdx.y + threadIdx.y;
5
    int col = blockDim.x * blockIdx.x + threadIdx.x;
6

7
    if (row >= rows || col >= cols) return;
8

9
    int input_index = row * cols + col;
10
    int output_index = col * rows + row;
11

12
    output[output_index] = input[input_index];
13
}
14

15
// input, output are device pointers (i.e. pointers to memory on the GPU)
16
extern "C" void solve(const float* input, float* output, int rows, int cols) {
17
    dim3 threadsPerBlock(16, 16);
18
    dim3 blocksPerGrid((cols + threadsPerBlock.x - 1) / threadsPerBlock.x,
19
                       (rows + threadsPerBlock.y - 1) / threadsPerBlock.y);
20

21
    matrix_transpose_kernel<<<blocksPerGrid, threadsPerBlock>>>(input, output, rows, cols);
22
    cudaDeviceSynchronize();
23
}

展开收起

两级组织：Grid → Block → Thread#

CUDA 线程按两级结构组织，每个线程的全局坐标由 三部分拼成：

1
row = blockIdx.y × blockDim.y + threadIdx.y
2
col = blockIdx.x × blockDim.x + threadIdx.x

部分	含义	类比
`blockIdx`	你在第几个块	第几辆车
`blockDim`	每块多少线程	每辆车多少座位
`threadIdx`	你在块内排第几	车里的第几排第几座

示例计算#

假设 blockDim = (16, 16)，某线程在 Block(1,0) 中处于 threadIdx = (2, 3)：

1
col = 1×16 + 2 = 18   ← 前面 1 整块(16列) + 块内第 2 个
2
row = 0×16 + 3 = 3    ← 前面 0 整块 + 块内第 3 个

→ 该线程负责计算 output 的 [18][3]（对应 input 的 [3][18]）。

转置中的应用#

1
int input_index  = row * cols + col;   // input[row][col]
2
int output_index = col * rows + row;   // output[col][row]  ← 行列互换

每个线程读一个元素，写一个元素，无需同步——天然并行。

RainBow Table

Tue, 14 Jul 2026 00:00:00 GMT

题面#

答案#

1
#include <cuda_runtime.h>
2

3
__device__ unsigned int fnv1a_hash(unsigned int input) {
4
    const unsigned int FNV_PRIME = 16777619;
5
    const unsigned int OFFSET_BASIS = 2166136261;
6

7
    unsigned int hash = OFFSET_BASIS;
8

9
    for (int byte_pos = 0; byte_pos < 4; byte_pos++) {
10
        unsigned char byte = (input >> (byte_pos * 8)) & 0xFFu;
11
        hash = (hash ^ byte) * FNV_PRIME;
12
    }
13

14
    return hash;
15
}
16

17
__global__ void fnv1a_hash_kernel(const int* input, unsigned int* output, int N, int R) {
18
    int idx = blockDim.x * blockIdx.x + threadIdx.x;
19
    if (idx >= N) return;
20

21
    unsigned int val = static_cast<unsigned int>(input[idx]);
22

23
    for (int r = 0; r < R; r++) {
24
        val = fnv1a_hash(val);
25
    }
26

27
    output[idx] = val;
28
}
29

30
// input, output are device pointers (i.e. pointers to memory on the GPU)
31
extern "C" void solve(const int* input, unsigned int* output, int N, int R) {
32
    int threadsPerBlock = 256;
33
    int blocksPerGrid = (N + threadsPerBlock - 1) / threadsPerBlock;
34

35
    fnv1a_hash_kernel<<<blocksPerGrid, threadsPerBlock>>>(input, output, N, R);
36
    cudaDeviceSynchronize();
37
}

展开收起

ReLU

Tue, 14 Jul 2026 00:00:00 GMT

题面#

答案#

1
#include <cuda_runtime.h>
2

3
__global__ void relu_kernel(const float* input, float* output, int N) {
4
    int idx = blockDim.x * blockIdx.x + threadIdx.x;
5
    if (idx < N) {
6
        output[idx] = input[idx] > 0 ? input[idx] : 0;
7
    }
8
}
9

10
// input, output are device pointers (i.e. pointers to memory on the GPU)
11
extern "C" void solve(const float* input, float* output, int N) {
12
    int threadsPerBlock = 256;
13
    int blocksPerGrid = (N + threadsPerBlock - 1) / threadsPerBlock;
14

15
    relu_kernel<<<blocksPerGrid, threadsPerBlock>>>(input, output, N);
16
    cudaDeviceSynchronize();
17
}

展开收起

Reverse Array

Tue, 14 Jul 2026 00:00:00 GMT

原题链接🔗

1
#include <cuda_runtime.h>
2

3
__global__ void reverse_array(float* input, int N) {
4
    int idx = blockDim.x * blockIdx.x + threadIdx.x;
5
    if (idx < N / 2) {
6
        float tmp = input[idx];
7
        input[idx] = input[N - 1 - idx];
8
        input[N - 1 - idx] = tmp;
9
    }
10
}
11

12
// input is device pointer
13
extern "C" void solve(float* input, int N) {
14
    int threadsPerBlock = 256;
15
    int blocksPerGrid = (N + threadsPerBlock - 1) / threadsPerBlock;
16

17
    reverse_array<<<blocksPerGrid, threadsPerBlock>>>(input, N);
18
    cudaDeviceSynchronize();
19
}

展开收起

Sigmoid Linear Unit

Tue, 14 Jul 2026 00:00:00 GMT

题面#

答案#

1
#include <cuda_runtime.h>
2

3
__global__ void silu_kernel(const float* input, float* output, int N) {
4
    int idx = blockDim.x * blockIdx.x + threadIdx.x;
5
    if (idx > N) return;
6
    float sigma = 1.0 / (1.0 + exp(-input[idx]));
7
    float ans = input[idx] * sigma;
8
    output[idx] = ans;
9
}
10

11
// input, output are device pointers
12
extern "C" void solve(const float* input, float* output, int N) {
13
    int threadsPerBlock = 256;
14
    int blocksPerGrid = (N + threadsPerBlock - 1) / threadsPerBlock;
15

16
    silu_kernel<<<blocksPerGrid, threadsPerBlock>>>(input, output, N);
17
    cudaDeviceSynchronize();
18
}

展开收起

Simple Inference

Tue, 14 Jul 2026 00:00:00 GMT

题面#

答案#

1
import torch
2
import torch.nn as nn
3

4

5
# input, model, and output are on the GPU
6
def solve(input: torch.Tensor, model: nn.Module, output: torch.Tensor):
7
    weights = model.weight.T
8
    res = input @ weights
9
    if model.bias is not None:
10
        res = res + model.bias
11
    output.copy_(res)

Swish-Gated Linear Unit

Tue, 14 Jul 2026 00:00:00 GMT

题面#

答案#

1
#include <cuda_runtime.h>
2

3
__global__ void swiglu_kernel(const float* input, float* output, int halfN) {
4
    int idx = blockDim.x * blockIdx.x + threadIdx.x;
5
    int half = N / 2;
6
    if (idx >= N) return;
7
    float x1 = input[idx];
8
    float x2 = input[idx + half];
9
    float sigma = 1.0 / (1.0 + exp(-x1))
10
    float silu = x1 * sigma;
11
    float swiglu = silu * x2;
12
}
13

14
// input, output are device pointers
15
extern "C" void solve(const float* input, float* output, int N) {
16
    int halfN = N / 2;
17
    int threadsPerBlock = 256;
18
    int blocksPerGrid = (halfN + threadsPerBlock - 1) / threadsPerBlock;
19

20
    swiglu_kernel<<<blocksPerGrid, threadsPerBlock>>>(input, output, halfN);
21
    cudaDeviceSynchronize();
22
}

展开收起

Value Clipping

Tue, 14 Jul 2026 00:00:00 GMT

问题#

答案#

1
#include <cuda_runtime.h>
2

3
__global__ void clip_kernel(const float* input, float* output, float lo, float hi, int N) {
4
    int idx = blockDim.x * blockIdx.x + threadIdx.x;
5
    if (idx >= N) return;
6
    if (input[idx] >= lo && input[idx] <= hi) {
7
        output[idx] = input[idx];
8
    } else if (input[idx] < lo) {
9
        output[idx] = lo;
10
    } else {
11
        output[idx] = hi;
12
    }
13
}
14

15
// input, output are device pointers
16
extern "C" void solve(const float* input, float* output, float lo, float hi, int N) {
17
    int threadsPerBlock = 256;
18
    int blocksPerGrid = (N + threadsPerBlock - 1) / threadsPerBlock;
19

20
    clip_kernel<<<blocksPerGrid, threadsPerBlock>>>(input, output, lo, hi, N);
21
    cudaDeviceSynchronize();
22
}

展开收起

扩展和移位

Tue, 14 Jul 2026 00:00:00 GMT

扩展和移位#

符号扩展#

当把短位宽的带符号数存入长位宽寄存器时，需要对多出的位进行填充。符号扩展的对象是带符号数。

正数的扩展#

符号位不变（= 0），所有扩展位用 0 填充。

整数向左扩展填 0
小数向右扩展填 0

例：8 位 +5（00000101）→ 16 位 00000000 00000101

负数的扩展#

取决于该负数用的是何种编码：

原码表示#

方向	规则
整数	在符号位和数值位之间填充 0
小数	在数值位之后填充 0

例：8 位原码 -5 = 10000101 → 16 位 = 10000000 00000101

补码表示#

方向	规则
整数	向左扩展，填充符号位（即 1）
小数	向右扩展，填充 0

例：8 位补码 -5 = 11111011 → 16 位 = 11111111 11111011

补码整数扩展时填符号位（而非 0）是保证数值不变的关键。填 0 的话 11111011 会变成 00000000 11111011 = 251，而不是 −5。

溢出判断（乘法）#

两个 int（32 位）相乘得到 64 位乘积，但寄存器只能保留低 32 位。如何判断溢出？

1
64位乘积：1111 1111 1111 1111 1111 │ 1111 1111 ... 0010 0000 1111 0111
2
         ←────── 高 32 位 ────────→│←─────── 低 32 位 ───────────────→
3
                                   │
4
                            红色虚线：32位寄存器截断位置

判断规则：查看高 32 位是否全是 0（正数）或全是 1（负数补码）。如果不是，说明低 32 位表示不了完整的 64 位结果 → 溢出。

移位操作#

左移#

x≪kx \ll kx≪k：x 向左移动 k 位，右端补 k 个 0。每左移一位相当于乘以 2。

右移#

x≫kx \gg kx≫k：x 向右移动 k 位。分为两种：

类型	左端填充	适用场景
逻辑右移	补 k 个 0	无符号数
算术右移	补 k 个最高位的值（符号位）	带符号数

算术右移示例#

x=1100x = 1100x=1100（补码表示 −4），算术右移 2 位：

1
1100  ──算术>>2──→  1111
2

3
补码: -4         补码: -1
4
         (除以 4)

算术右移 2 位 = 除以 22=42^2 = 422=4：−4÷4=−1-4 \div 4 = -1−4÷4=−1 ✓

算术右移保持了符号，逻辑右移不保持。

补码加减运算电路#

一个电路同时实现加法和减法，关键是利用补码的性质：−Y=Yˉ+1-Y = \bar{Y} + 1−Y=Yˉ+1。

1
                          ┌────────────┐
2
                     Sub ─┤  Cin       │
3
                          │            │
4
     X ──────────────────┤            │──────→ F (结果)
5
                          │  加法器     │
6
           ┌──┐  ┌───────┤            ├──→ Cout
7
     Y ────┤~ ├──┤ 1     │            │──→ OF
8
           └──┘  │ MUX   │            │──→ SF
9
                 │       │            │──→ ZF
10
            Y ───┤ 0     │            │──→ CF
11
                 └──┬────┘            │
12
                    │     ┌───────────┘
13
                    Y'

Sub（控制信号）	MUX 输出 Y′Y'Y′	Cin	实际运算
0	Y′=YY' = YY′=Y（选通 0 端）	0	F=X+YF = X + YF=X+Y（加法）
1	Y′=YˉY' = \bar{Y}Y′=Yˉ（选通 1 端）	1	F=X+Yˉ+1=X−YF = X + \bar{Y} + 1 = X - YF=X+Yˉ+1=X−Y（减法）

::: tip Sub == Cin 减法时 Sub=1，同时把 Cin 也置为 1，从而完成 Yˉ+1=−Y\bar{Y} + 1 = -YYˉ+1=−Y 的转换。 :::

数据表示

Tue, 14 Jul 2026 00:00:00 GMT

数据表示#

补码的表示范围#

假设机器字长为 n 位，补码可表示的数值范围：

−2 n−1 ≤ n位补码 ≤ 2 n−1−1-2^{\,n-1} \;\leq\; n\text{位补码} \;\leq\; 2^{\,n-1} - 1−2n−1≤n位补码≤2n−1−1

字长	范围	举例
8 位	−128-128−128 ~ 127127127	`int8_t`
16 位	−32768-32768−32768 ~ 327673276732767	`int16_t`
32 位	−231-2^{31}−231 ~ 231−12^{31}-1231−1	`int`
64 位	−263-2^{63}−263 ~ 263−12^{63}-1263−1	`long long`

不对称的原因：补码中负数比正数多一个（没有 −0），最小负数的绝对值比最大正数大 1。

移码#

为什么引入移码？#

浮点数的指数（阶码）可正可负。如果用补码表示指数，比较浮点数大小时会出问题。

比如两个正浮点数，指数分别是 +2 和 -3：

补码：+2 = 00000010， -3 = 11111101
用无符号比较，11111101 反而 > 00000010，比较器会认为指数 -3 比 +2 大 ✗

移码的思路：把整个指数范围往上”平移”一个固定值（偏置量），让所有存储的指数都变成非负数。这样用无符号整数比较就能正确判断浮点数大小，硬件比较器大大简化。

一句话：移码把有符号指数映射到无符号范围，让硬件用同一套比较电路就能比较浮点数。

计算公式#

移码 = 真值 + 偏置值

精度	指数位数	偏置值	公式
单精度 (float)	8 位	127 (2⁷−1)	移码 = 真值 + 127
双精度 (double)	11 位	1023 (2¹⁰−1)	移码 = 真值 + 1023

通式：偏置值 = 2ⁿ⁻¹ − 1（n 为指数位数）

举例#

单精度下，真值指数 = -3：

移码 = -3 + 127 = 124
二进制：01111100

真值指数 = +2：

移码 = 2 + 127 = 129
二进制：10000001

现在无符号比较：129 > 124 ✓，正确反映了指数大小关系。

移码的本质#

移码的核心思想：把真值整体向上平移 2n−12^{n-1}2n−1，使所有值变成非负，从而能用无符号比较器做大小判断。

1
真值范围：  -2^(n-1)  ──────── 0 ──────── 2^(n-1)-1
2
                │                 │                 │
3
                ▼  +2^(n-1)       ▼  +2^(n-1)       ▼  +2^(n-1)
4
移码范围：       0  ──────── 2^(n-1) ──────── 2^n-1

项目	说明
偏置值的设置	机器字长为 n 时，偏置值 = 2n−12^{n-1}2n−1
真值最小值	−2n−1-2^{n-1}−2n−1 → 移码 = 000
真值最大值	2n−1−12^{n-1}-12n−1−1 → 移码 = 2n−12^n-12n−1

移码是 IEEE 754 浮点数的基础，详见浮点数和 IEEE 754。

数据的宽度和存储#

常见的数据类型与宽度#

C 语言中基本数据类型的典型宽度（以 32/64 位通用平台为准）：

类型	`char`	`short`	`int`	`float`	`double`
字节数	1 B	2 B	4 B	4 B	8 B
位数	8 bit	16 bit	32 bit	32 bit	64 bit

unsigned 仅表示无符号，不改变数据宽度——宽度由后面的类型决定。例如 unsigned int 仍然是 4 字节。

各种”字长”#

1. 机器字长（CPU 字长）#

最核心的概念。指 CPU 一次能处理的二进制位数，等于通用寄存器、ALU、数据总线的宽度。

常说的”32 位 CPU""64 位 CPU”就是指机器字长
机器字长越长，单次运算能处理的数据越大，寻址范围也越大

2. 存储字长#

一个存储单元中存放的二进制位数。通常与机器字长相等，但不一定。

存储字长 = 机器字长 → 一个存取周期就能读写一个完整的机器字
主存常按字节编址（每个地址对应 8 位），但一次读出可能是 32 或 64 位

3. 指令字长#

一条指令的二进制位数。

定长指令字：所有指令长度相同（如 MIPS 固定 32 位）
变长指令字：不同指令长度不同（如 x86，指令从 1 字节到 15 字节）
指令字长可以是机器字长的整数倍，也可以不是

4. 数据字长#

数据总线上一次传输的二进制位数，通常等于机器字长。

总结对比#

名称	含义	典型值 (64位机)
机器字长	CPU一次处理的位数	64 bit
存储字长	存储单元存放的位数	64 bit（常对齐）
指令字长	一条指令的位数	不定（x86变长）
数据字长	数据总线一次传的位数	64 bit

关键区别：机器字长是 CPU 决定的”能力上限”；指令字长取决于指令集设计，可以和机器字长不同；存储字长取决于存储器设计。

字节顺序（端序）#

多字节数据在内存中的存放顺序有两种策略。以 int x = 12345678H（占 4 字节）为例：

大端存储（Big-Endian）#

数据高位放在地址低位，数据低位放在地址高位。

地址	0800H	0801H	0802H	0803H
数据	12H	34H	56H	78H

最高字节 12H 在最低地址 → 符合人类读写习惯
网络字节序（TCP/IP）采用大端

小端存储（Little-Endian）#

数据高位放在地址高位，数据低位放在地址低位。

地址	0800H	0801H	0802H	0803H
数据	78H	56H	34H	12H

最低字节 78H 在最低地址 → 便于 CPU 做不同宽度的类型转换
x86 / ARM（默认）采用小端

关键：字节序只影响字节之间的排列，一个编址单位（1 字节）内部的 bit 顺序不受影响。78H 无论在哪个地址，其内部 bit 排列不变。

浮点数和 IEEE 754

Tue, 14 Jul 2026 00:00:00 GMT

浮点数和 IEEE 754#

浮点数的表示格式#

为什么需要浮点数？#

定点数的小数点位置固定，表示范围非常有限。比如 32 位定点数，若 16 位整数 + 16 位小数，最大只能表示约 65536。

浮点数的思路：模仿科学计数法，让小数点可以”浮动”，用有限的位数表示极大的动态范围。

十进制科学计数法：3.14×108\text{十进制科学计数法：} \quad 3.14 \times 10^8十进制科学计数法：3.14×108二进制浮点数：(−1)s×M×2E\text{二进制浮点数：} \quad (-1)^{s} \times M \times 2^{E}二进制浮点数：(−1)s×M×2E

三个核心字段#

字段	含义	作用
符号 s（sign）	0 表示正，1 表示负	决定正负
尾数 M（mantissa / significand）	有效数字部分	决定精度
阶码 E（exponent）	指数，用移码存储	决定范围

阶码使用移码而非补码的原因，见数据表示#移码。核心原因：移码让硬件用无符号比较器就能正确比较浮点数大小。

真值公式#

通用形式：

N=(−1)s×M×rEN = (-1)^{s} \times M \times r^{E}N=(−1)s×M×rE

其中 rrr 是基数（二进制下 r=2r = 2r=2）。尾数 MMM 通常是纯小数或带一位整数。

浮点数的规格化#

什么是规格化？#

当一个浮点数有多种等价表示时，硬件处理会很麻烦。例如十进制下：

0.12×102=1.2×101=12×100=120×10−10.12 \times 10^2 = 1.2 \times 10^1 = 12 \times 10^0 = 120 \times 10^{-1}0.12×102=1.2×101=12×100=120×10−1

规格化就是规定统一形式：让尾数的最高位是有效数字。

对于二进制，规格化要求尾数的最高位为 1（即 1≤M<21 \leq M < 21≤M<2）：

1.01101×25✓0.101101×26×(非规格化)1.01101 \times 2^5 \quad \checkmark \qquad 0.101101 \times 2^6 \quad \times \quad\text{(非规格化)}1.01101×25✓0.101101×26×(非规格化)

隐藏位（Hidden Bit）#

既然规格化后尾数的整数部分永远是 1，那就不需要存储它。IEEE 754 用这个”隐藏位”白嫖一位精度。

23 位存储 + 1 位隐藏 = 24 位有效精度（单精度） 52 位存储 + 1 位隐藏 = 53 位有效精度（双精度）

非规格化数（Denormalized Numbers）#

如果只允许规格化形式，最接近 0 的就是 1.0×2−1261.0 \times 2^{-126}1.0×2−126（单精度），再小的数就会下溢到 0，造成精度断层。

IEEE 754 用阶码全 0 的特殊编码表示非规格化数，此时隐藏位变为 0：

M=0.fraction,E=−126 (单精度)M = 0.\text{fraction}, \quad E = -126\ (\text{单精度})M=0.fraction,E=−126 (单精度)

这样就能平滑过渡到 0（gradual underflow）。

浮点数的加减运算#

浮点数加减不能直接对尾数做运算——阶码不同相当于”数量级”不同。需要经过以下步骤：

五步流程#

1. 对阶 ⟶ 2. 尾数加减 ⟶ 3. 规格化 ⟶ 4. 舍入 ⟶ 5. 溢出判断\begin{array}{c} \text{1. 对阶} \;\longrightarrow\; \text{2. 尾数加减} \;\longrightarrow\; \text{3. 规格化} \;\longrightarrow\; \text{4. 舍入} \;\longrightarrow\; \text{5. 溢出判断} \end{array}1. 对阶⟶2. 尾数加减⟶3. 规格化⟶4. 舍入⟶5. 溢出判断

第一步：对阶（Align Exponents）#

原则：小阶向大阶看齐。阶码小的那个数的尾数右移，阶码增大。

为什么小阶向大阶？若大阶向小阶看齐，尾数左移会丢失高位——那可是最显著的数字。

E差=∣EA−EB∣E_{\text{差}} = |E_A - E_B|E差=∣EA−EB∣

阶码小的尾数右移 E差E_{\text{差}}E差位，阶码同步增加到与另一个相同。

第二步：尾数加减#

对阶完成后，两个尾数直接做加减（此时阶码相同了）。

第三步：规格化#

运算结果可能不再满足规格化形式。两个极端情况：

尾数溢出：和 ≥2\geq 2≥2（如 1.101+1.011=11.0001.101 + 1.011 = 11.0001.101+1.011=11.000）→ 尾数右移 1 位，阶码 +1
尾数过小：结果高位有多个 0（如 1.001−1.000=0.0011.001 - 1.000 = 0.0011.001−1.000=0.001）→ 尾数左移直到最高位为 1，阶码同步减小

第四步：舍入（Rounding）#

规格化后，尾数可能超出可存储的位数，需要舍入。详见 IEEE 754 舍入与精度。

第五步：溢出判断#

阶码超出最大表示范围 → 上溢（overflow），通常变为 ±∞\pm\infty±∞
阶码低于最小表示范围 → 下溢（underflow），变为 0 或非规格化数

完整示例#

计算 1.5+0.751.5 + 0.751.5+0.75（十进制）在单精度下的过程：

步骤	A=1.5A = 1.5A=1.5	B=0.75B = 0.75B=0.75
真值	1.5=1.1×201.5 = 1.1 \times 2^01.5=1.1×20	0.75=1.1×2−10.75 = 1.1 \times 2^{-1}0.75=1.1×2−1
符号/阶码/尾数	s=0, E=0, M=1.1	s=0, E=-1, M=1.1

1. 对阶：B 的阶码 -1 小于 A 的阶码 0，差 = 1。B 的尾数右移 1 位：

MB=1.1→右移1位0.11,EB=0M_B = 1.1 \xrightarrow{\text{右移1位}} 0.11, \quad E_B = 0MB=1.1右移1位0.11,EB=0

2. 尾数加：

MA+MB=1.1+0.11=10.01M_A + M_B = 1.1 + 0.11 = 10.01MA+MB=1.1+0.11=10.01

3. 规格化：尾数 10.01≥210.01 \geq 210.01≥2，右移 1 位：

M=1.001,E=0+1=1M = 1.001, \quad E = 0 + 1 = 1M=1.001,E=0+1=1

4. 舍入：1.0011.0011.001 在 23 位精度内，无变化。

5. 结果：(−1)0×1.001×21=10.012=2.25(-1)^0 \times 1.001 \times 2^1 = 10.01_2 = 2.25(−1)0×1.001×21=10.012=2.25 ✓

IEEE 754 格式#

IEEE 754 是浮点数的事实标准（1985 年制定，2008/2019 年修订），几乎所有的 CPU 和 GPU 都遵循。

两种常用精度#

精度	总位数	符号	阶码	尾数（存储）	尾数（有效）	偏置值
单精度 (float)	32	1	8	23	24	127
双精度 (double)	64	1	11	52	53	1023

偏置值通式：bias=2n−1−1bias = 2^{n-1} - 1bias=2n−1−1（nnn 为阶码位数）

阶码编码与特殊值#

阶码使用保留编码来区分不同情况：

阶码（移码）	尾数	含义
000…0000\ldots 0000…0	`= 0`	±0
000…0000\ldots 0000…0	`≠ 0`	非规格化数（denormalized）
000…1000\ldots 1000…1 ~ 111…0111\ldots 0111…0	任意	规格化数（normalized）
111…1111\ldots 1111…1	`= 0`	±∞（无穷大）
111…1111\ldots 1111…1	`≠ 0`	NaN（Not a Number）

特殊值详解#

零（±0）#

IEEE 754 区分 +0 和 -0。两者在比较时视为相等，但在除法中行为不同（1/+0=+∞1/+0 = +\infty1/+0=+∞，1/−0=−∞1/-0 = -\infty1/−0=−∞）。

无穷大（±∞）#

上溢时产生。∞\infty∞ 可以参与运算：

3+∞=∞3 + \infty = \infty3+∞=∞
3/∞=03 / \infty = 03/∞=0
∞−∞=NaN\infty - \infty = \text{NaN}∞−∞=NaN（未定义）

NaN（Not a Number）#

非法操作的结果：0/00/00/0、∞−∞\infty - \infty∞−∞、−1\sqrt{-1}−1、∞×0\infty \times 0∞×0。

NaN 有两种：

Signaling NaN (sNaN)：触发异常，用于调试
Quiet NaN (qNaN)：静默传播，不触发异常

关键特性：NaN≠NaN\text{NaN} \neq \text{NaN}NaN=NaN，任何与 NaN 的比较都返回 false。检查 NaN 只能用 isnan()。

数值范围#

精度	最小正规格化数	最大正数	最小正非规格化数
单精度	2−126≈1.18×10−382^{-126} \approx 1.18 \times 10^{-38}2−126≈1.18×10−38	≈3.40×1038\approx 3.40 \times 10^{38}≈3.40×1038	2−149≈1.40×10−452^{-149} \approx 1.40 \times 10^{-45}2−149≈1.40×10−45
双精度	2−1022≈2.23×10−3082^{-1022} \approx 2.23 \times 10^{-308}2−1022≈2.23×10−308	≈1.80×10308\approx 1.80 \times 10^{308}≈1.80×10308	2−1074≈4.94×10−3242^{-1074} \approx 4.94 \times 10^{-324}2−1074≈4.94×10−324

IEEE 754 舍入与精度#

为什么需要舍入？#

浮点数的尾数位数有限。运算结果的有效位数如果超过存储容量，就必须舍入。IEEE 754 规定了四种舍入模式。

四种舍入模式#

模式	行为	应用
舍入到最近偶数 (roundTiesToEven)	舍入到最近值；正好在中间时取最低位为 0 的值（偶数）	默认模式，最常用
向 0 舍入 (roundTowardZero)	直接截断，绝对值变小	C 语言的类型转换
向 +∞ 舍入 (roundTowardPositive)	总是向上取	区间算术上界
向 -∞ 舍入 (roundTowardNegative)	总是向下取	区间算术下界

舍入到最近偶数为啥是默认？#

普通的”四舍五入”在大量运算中会有统计偏差——中间值总是向上舍，导致结果系统性偏大。而最近偶数模式在中间值上有一半情况向上、一半情况向下，无偏。

需要舍入的值	舍入到最近偶数
1.4 → 1	✓（更近）
1.6 → 2	✓（更近）
1.5 → 2	偶数（1 是奇数，2 是偶数）
2.5 → 2	偶数（3 是奇数，2 是偶数）

保护位、舍入位、粘贴位（Guard, Round, Sticky）#

硬件用额外的三个位来确保舍入正确：

位	含义
Guard (G)	尾数最低位之后的第一位
Round (R)	Guard 位之后的第二位
Sticky (S)	Round 之后所有位的逻辑或（只要后面有任何 1，S 就是 1）

舍入决策：

若 G=0 → 截断
若 G=1 且 R=S=0 → 最近偶数（看最低位）
若 G=1 且 (R=1 或 S=1) → 向上进位

C 语言中的浮点数类型#

类型映射#

C 类型	IEEE 754 对应	位数	有效数字（十进制）
`float`	单精度	32	~7 位
`double`	双精度	64	~15-16 位
`long double`	平台相关	x86: 80; ARM: 128	取决于实现

默认类型：C 中浮点字面量（如 3.14）默认为 double。赋给 float 时发生隐式转换。

float.h 关键宏#

1
#include <float.h>
2

3
// float
4
FLT_MAX       // ≈ 3.402823e+38    最大正数
5
FLT_MIN       // ≈ 1.175494e-38    最小正规格化数
6
FLT_EPSILON   // ≈ 1.192093e-07    1.0 与下一个可表示数之差
7
FLT_DIG       // 6                  十进制有效位数
8

9
// double
10
DBL_MAX       // ≈ 1.797693e+308
11
DBL_MIN       // ≈ 2.225074e-308
12
DBL_EPSILON   // ≈ 2.220446e-16
13
DBL_DIG       // 15
14

15
// true minimum (denormalized)
16
FLT_TRUE_MIN  // ≈ 1.401298e-45    最小正非规格化数
17
DBL_TRUE_MIN  // ≈ 4.940656e-324

展开收起

FLT_EPSILON 不是最小正数，而是1 和下一个可表示浮点数之间的距离——即浮点数的”分辨率”。

常见陷阱#

1. 不要用 `==` 比较浮点数#

1
float a = 0.1f + 0.2f;  // 实际可能是 0.30000001
2
if (a == 0.3f)           // 可能是 false！
3
    printf("equal\n");
4

5
// ✅ 正确做法：用容差
6
if (fabs(a - 0.3f) < 1e-6)
7
    printf("approximately equal\n");

2. 大数吃小数（Catastrophic Cancellation）#

1
float big   = 1.0e8f;
2
float small = 1.0f;
3
float sum   = big + small;  // sum 仍然是 1.0e8f
4
// small 被"吞掉了"，因为单精度只有约 7 位有效数字

当两个数数量级差超过有效位数时，较小的数对结果完全无贡献。

3. 结合律不成立#

浮点加减不满足结合律：

(a+b)+c≠a+(b+c)(a + b) + c \neq a + (b + c)(a+b)+c=a+(b+c)

1
float a = 1.0e8f, b = -1.0e8f, c = 1.0f;
2
(a + b) + c  // = 0 + 1 = 1 ✓
3
a + (b + c)  // = 1.0e8 - 1.0e8 = 0 ✗

编译器不能随意重排浮点运算顺序（除非开启 -ffast-math）。

4. 浮点数到整数的截断#

1
int x = (int)3.14f;   // x = 3（向 0 截断）
2
int y = (int)-3.14f;  // y = -3（向 0 截断，不是向下取整！）

溢出判别

Tue, 14 Jul 2026 00:00:00 GMT

溢出判别#

什么是溢出？#

补码加减运算的结果超出了给定位数能表示的范围。溢出只对带符号数有意义——无符号数超出范围叫”进位/借位”（看 CF），不叫溢出。

溢出发生的四种情况#

仅有以下四种情况会产生溢出：

#	运算	说明
①	正数 + 正数 = 负数	两个正数相加，结果符号位变 1
②	负数 + 负数 = 正数	两个负数相加，结果符号位变 0
③	正数 − 负数 = 负数	正数减负数，结果符号位变 1
④	负数 − 正数 = 正数	负数减正数，结果符号位变 0

①和②互为镜像（加法溢出），③和④互为镜像（减法溢出）。

溢出判别方法#

方法一：采用一位符号位 + 进位判断#

设 CsC_sCs（= CnC_nCn）为符号位的进位，C1C_1C1（= Cn−1C_{n-1}Cn−1）为最高数据位的进位：

CsC_sCs	C1C_1C1	溢出？
0	0	无溢出
0	1	溢出
1	0	溢出
1	1	无溢出

逻辑表达式：

OF=Cs⊕C1=Cn⊕Cn−1OF = C_s \oplus C_1 = C_n \oplus C_{n-1}OF=Cs⊕C1=Cn⊕Cn−1

两个进位相同时无溢出，不同时溢出。这是硬件最简单的实现方式。

方法二：双符号位法#

给结果设置两个符号位 Ss1S_{s1}Ss1 和 Ss2S_{s2}Ss2，Ss1S_{s1}Ss1（最高位）代表真正的符号。

Ss1Ss2S_{s1}S_{s2}Ss1Ss2	含义
`00`	结果为正数，无溢出
`01`	正溢出（两个正数相加溢出）
`10`	负溢出（两个负数相加溢出）
`11`	结果为负数，无溢出

判断规则：两个符号位相同则无溢出，不同则有溢出。

两种方法本质等价——双符号位中的 Ss2S_{s2}Ss2 就是单符号位法中的 C1C_1C1。

溢出逻辑表达式#

设 AsA_sAs、BsB_sBs 分别为两个操作数的符号位，SsS_sSs 为结果的符号位：

V=As⋅Bs⋅Sˉs+Aˉs⋅Bˉs⋅SsV = A_s \cdot B_s \cdot \bar{S}_s + \bar{A}_s \cdot \bar{B}_s \cdot S_sV=As⋅Bs⋅Sˉs+Aˉs⋅Bˉs⋅Ss

AsA_sAs	BsB_sBs	SsS_sSs	V	场景
0	0	1	1	正 + 正 = 负
1	1	0	1	负 + 负 = 正

第一项 AsBsSˉsA_s B_s \bar{S}_sAsBsSˉs：两正相加得负 → 正溢出
第二项 AˉsBˉsSs\bar{A}_s \bar{B}_s S_sAˉsBˉsSs：两负相加得正 → 负溢出
V=1V = 1V=1 时表示溢出

其他组合（正+负、负+正）理论上有 V=0V=0V=0，不会产生溢出。

原码乘法#

算法原理#

n 位原码乘法：被乘数 XXX，乘数 YYY。符号位单独处理（异或），数值部分按绝对值做无符号乘法。

核心循环：重复 n 轮「判断 + 加法 + 右移」：

Y 的最低位	操作
1	加上被乘数，右移
0	加上 0，右移

寄存器与流程#

使用三个寄存器：乘积寄存器 P、乘数寄存器 Y、进位位 C。

1
    C │     P      │     Y
2
   ───┼────────────┼──────────
3
    0 │  0000      │  1011     ← 初始状态（X = 0.1101, Y = 0.1011）

每一轮：

判断 Y 的最低位
加法 P = P + (判断结果)
右移 {C, P, Y} 整体右移一位，Y 移出的位丢弃，P 的 LSB 进入 Y 的 MSB

示例#

X=−0.1101X = -0.1101X=−0.1101, Y=0.1011Y = 0.1011Y=0.1011，求 X×YX \times YX×Y。

符号：Xs⊕Ys=1⊕0=1X_s \oplus Y_s = 1 \oplus 0 = 1Xs⊕Ys=1⊕0=1（结果为负）。

数值部分（4 位无符号乘法，做 4 轮）：

轮次	P	Y	操作
初始	0000	1011	—
1	1101	1011	Y最低=1，+X(=1101)
	0110	1101	右移
2	0011	0110	Y最低=1，+X
	1001	1011	右移
3	0100	1101	Y最低=0，+0
	0010	0110	右移
4	1111	0110	Y最低=1，+X
	0111	1011	右移 ← 结束

结果：符号位 = 1，数值 = 0.0111 1011。

X×Y=−0.10001111X \times Y = -0.10001111X×Y=−0.10001111

每次「判断+加法」后都要把部分积更新到 P 中再做「右移」。完成 n 轮后算法结束。

计算机系统概述

Tue, 14 Jul 2026 00:00:00 GMT

计算机系统概述#

冯诺依曼机#

冯·诺依曼结构是现代计算机的基础模型，由五大部件组成，所有部件围绕存储器协同工作。

五大功能部件#

部件	功能
输入设备	接收外部的计算步骤和初始数据
存储器	存放指令和数据（“存储程序”工作方式的核心）
运算器	执行算术和逻辑运算
控制器	根据指令产生控制信号，协调各部件工作
输出设备	输出计算结果

三种信号线#

信号线类型	功能	流向示例
数据线	传输数据	输入设备 → 运算器 → 存储器；运算器 ↔ 控制器
控制线	控制信号	存储器 → 所有其他部件（发出读写等控制命令）
反馈线	状态反馈	各部件 → 存储器（通知操作完成或状态）

核心要点#

以存储器为中心，采用”存储程序”工作方式
计算机由运算器、控制器、存储器、输入设备和输出设备 5 个基本部件组成
指令和数据都以二进制形式存储，机器可以区分

抽象层转换#

计算机系统从底层物理器件到上层应用程序，分为 9 个抽象层次：

1
        ┌──────────────┐
2
   软件 │  应用（问题）   │  最终用户关心的层次
3
        │  算法          │
4
        │  编程（语言）   │
5
        │  操作系统/虚拟机 │
6
        ├──────────────┤  ← ISA 是软硬件分界线
7
   硬件 │  ISA           │  指令集体系结构
8
        │  微体系结构     │
9
        │  功能部件/RTL   │  寄存器传输级
10
        │  电路          │
11
        │  器件          │  晶体管、门电路等物理元件
12
        └──────────────┘

ISA（指令集体系结构） 是软硬件的分界线——它向上支撑操作系统和编译器，向下约束 CPU 微体系结构的设计。

用户分类#

最终用户：使用交互式界面
系统管理员：利用操作系统功能对系统进行配置、维护和管理
应用程序员：应用层，使用高级编程语言编写程序，可以感知计算机硬件和 OS 提供的软件接口
系统程序员：设计和开发系统软件，熟悉计算机底层的相关硬件和系统结构

透明：一个存在的事物或概念从某个角度来看似乎不存在，即对实际存在的事物或概念感觉不到。

从源文件到执行文件#

预处理 ⟶ 编译 ⟶ 汇编 ⟶ 链接\text{预处理} \;\longrightarrow\; \text{编译} \;\longrightarrow\; \text{汇编} \;\longrightarrow\; \text{链接}预处理⟶编译⟶汇编⟶链接

1
.cpp  →  .i  →  .s  →  .o  →  .exe

性能指标#

吞吐率：单位时间内完成的工作量
响应时间：从提交到完成所用的时间。用户感知时间 = CPU 时间 + 其他时间（包括 OS 阻塞态时间）
时钟周期：节拍器，CLK
时钟频率：CPU 时钟周期的倒数
CPI：Clock Cycles Per Instruction
MIPS：Million Instructions Per Second

运算部件

Tue, 14 Jul 2026 00:00:00 GMT

运算部件#

加法器#

全加器（Full Adder, FA）#

一位全加器有三个输入、两个输出：

信号	含义
AiA_iAi	被加数的第 i 位
BiB_iBi	加数的第 i 位
Ci−1C_{i-1}Ci−1	低位传来的进位（carry in）
SiS_iSi	本位和（sum）
CiC_iCi	向高位的进位（carry out）

逻辑表达式#

Si=Ai⊕Bi⊕Ci−1S_i = A_i \oplus B_i \oplus C_{i-1}Si=Ai⊕Bi⊕Ci−1Ci=(Ai⊕Bi) Ci−1+AiBiC_i = (A_i \oplus B_i)\,C_{i-1} + A_i B_iCi=(Ai⊕Bi)Ci−1+AiBi

示例#

Ai=1A_i = 1Ai=1, Bi=0B_i = 0Bi=0, Ci−1=0C_{i-1} = 0Ci−1=0（无进位）：

Si=1⊕0⊕0=1,Ci=(1⊕0)⋅0+1⋅0=0S_i = 1 \oplus 0 \oplus 0 = 1, \qquad C_i = (1 \oplus 0) \cdot 0 + 1 \cdot 0 = 0Si=1⊕0⊕0=1,Ci=(1⊕0)⋅0+1⋅0=0

结果：和为 1，进位为 0 ✓

串行进位加法器（Serial Carry Adder）#

将 n 个一位全加器首尾相连，就得到了 n 位串行进位加法器——实质上就是做二进制加法。

1
     A_n B_n          A_2 B_2          A_1 B_1
2
       │  │              │  │              │  │
3
    ┌──┴──┴──┐       ┌──┴──┴──┐       ┌──┴──┴──┐
4
C_n─┤  FA    ├─...──C_2┤  FA    ├─C_1───┤  FA    ├──C_0
5
    └────┬────┘       └────┬────┘       └────┬────┘
6
         S_n                S_2               S_1

每一位的进位必须等待低位计算完成，因此延迟随位数线性增长。

计算示例#

1
     1 1 0 1    (13)
2
  +  0 1 0 1    ( 5)
3
  ───────────
4
  = 1 0 0 1 0  (18)

黄色位表示进位链传播的过程。

进位前瞻（Carry Lookahead）#

串行进位的瓶颈在于：CiC_iCi 必须等 Ci−1C_{i-1}Ci−1 算完。进位前瞻的思路是用组合逻辑直接算出每一位的进位，无需等待。

定义两个中间信号：

信号	公式	含义
进位生成 GiG_iGi	Gi=AiBiG_i = A_i B_iGi=AiBi	本位自己就能产生进位
进位传播 PiP_iPi	Pi=Ai⊕BiP_i = A_i \oplus B_iPi=Ai⊕Bi	低位进位能从本位”穿过去”

则进位递推公式：

Ci=Gi+Pi⋅Ci−1C_i = G_i + P_i \cdot C_{i-1}Ci=Gi+Pi⋅Ci−1

展开到 C0C_0C0 后，所有进位可在 3 级门延迟内同时算出：

C1=G1+P1C0C2=G2+P2C1=G2+P2G1+P2P1C0C3=G3+P3C2=G3+P3G2+P3P2G1+P3P2P1C0C4=G4+P4C3=G4+P4G3+P4P3G2+P4P3P2G1+P4P3P2P1C0\begin{aligned} C_1 &= G_1 + P_1 C_0 \\ C_2 &= G_2 + P_2 C_1 = G_2 + P_2 G_1 + P_2 P_1 C_0 \\ C_3 &= G_3 + P_3 C_2 = G_3 + P_3 G_2 + P_3 P_2 G_1 + P_3 P_2 P_1 C_0 \\ C_4 &= G_4 + P_4 C_3 = G_4 + P_4 G_3 + P_4 P_3 G_2 + P_4 P_3 P_2 G_1 + P_4 P_3 P_2 P_1 C_0 \end{aligned}C1C2C3C4=G1+P1C0=G2+P2C1=G2+P2G1+P2P1C0=G3+P3C2=G3+P3G2+P3P2G1+P3P2P1C0=G4+P4C3=G4+P4G3+P4P3G2+P4P3P2G1+P4P3P2P1C0

结论：CiC_iCi 只取决于 AAA 和 BBB 的第 1 位到第 i 位以及 C0C_0C0，与中间进位无关。

带标志加法器#

加法器在输出结果的同时，还生成四个标志位（flag），供条件分支等指令使用：

1
              ┌─────────────────────┐
2
              │   OF   SF   ZF   CF │  ← 标志输出
3
              ├─────────────────────┤
4
     A ──────→│                     │──────→ F (n位和)
5
     B ──────→│      加法器         │
6
  Cin ──────→│                     │──────→ Cout
7
              └─────────────────────┘

标志	名称	含义
OF	Overflow Flag	溢出标志，OF=Cn⊕Cn−1OF = C_n \oplus C_{n-1}OF=Cn⊕Cn−1
SF	Sign Flag	符号标志，结果的最高位
ZF	Zero Flag	零标志，结果为 0 时置 1
CF	Carry Flag	进位标志，最高位向上进位

其中 CnC_nCn 为最高位（符号位）进位，Cn−1C_{n-1}Cn−1 为次高位进位。

OF 仅对带符号数运算有效。无符号数用 CF 判断溢出。

算术逻辑单元（ALU）#

ALU 是 CPU 的核心运算部件，根据控制信号选择不同的运算功能。

1
              ┌──────────────────────────┐
2
              │  OF   SF   ZF   CF       │  ← 标志
3
              ├──────────────────────────┤
4
     A ──────→│                          │──────→ F (n位结果)
5
     B ──────→│          ALU             │
6
  Cin ──────→│                          │──────→ Cout
7
ALUop ──────→│                          │  (s位操作选择)
8
              └──────────────────────────┘

端口	方向	说明
A, B	输入	n 位操作数
Cin	输入	进位输入
ALUop	输入	s 位操作控制端，决定执行什么功能（加/减/与/或/非等）
F	输出	n 位计算结果
Cout	输出	进位输出
OF, SF, ZF, CF	输出	状态标志

Color Inversion

Mon, 13 Jul 2026 00:00:00 GMT

Color Inversion#

题面#

答案#

1
#include <cuda_runtime.h>
2

3
__global__ void invert_kernel(unsigned char* image, int width, int height) {
4
    int x = blockDim.x * blockIdx.x + threadIdx.x;
5
    int id = x * 4;
6
    if (id < width * height * 4) {
7
        image[id] = 255 - image[id];
8
        image[id + 1] = 255 - image[id + 1];
9
        image[id + 2] = 255 - image[id + 2];
10
        image[id + 3] = image[id + 3];
11
    }
12
}
13
// image_input, image_output are device pointers (i.e. pointers to memory on the GPU)
14
extern "C" void solve(unsigned char* image, int width, int height) {
15
    int threadsPerBlock = 256;
16
    int blocksPerGrid = (width * height + threadsPerBlock - 1) / threadsPerBlock;
17

18
    invert_kernel<<<blocksPerGrid, threadsPerBlock>>>(image, width, height);
19
    cudaDeviceSynchronize();
20
}

展开收起

通道为：（R,G,B,ALPHA）就是前三个通道是 RGB 通道，需要进行取反，也就是原值换成 255 - 原值，而第四个通道表示的是透明度，不需要变。

Matrix Addition

Mon, 13 Jul 2026 00:00:00 GMT

Matrix Addition#

题面#

答案#

1
#include <cuda_runtime.h>
2

3
__global__ void matrix_add(const float* A, const float* B, float* C, int N) {
4
    int i = blockIdx.x * blockDim.x + threadIdx.x;
5
    if (i < N * N) {
6
        C[i] = A[i] + B[i];
7
    }
8
}
9

10
// A, B, C are device pointers (i.e. pointers to memory on the GPU)
11
extern "C" void solve(const float* A, const float* B, float* C, int N) {
12
    int threadsPerBlock = 256;
13
    int blocksPerGrid = (N * N + threadsPerBlock - 1) / threadsPerBlock;
14

15
    matrix_add<<<blocksPerGrid, threadsPerBlock>>>(A, B, C, N);
16
    cudaDeviceSynchronize();
17
}

展开收起

面向对象基础常识

Sun, 12 Jul 2026 00:00:00 GMT

C++ 面向对象基础#

访问权限#

权限	类自身（成员/友元）	派生类（成员/友元）	外部/普通用户
public	✓	✓	✓
protected	✓	✓	✗
private	✓	✗	✗

虚析构#

delete p 只会删除静态类型，如果 p 指向 Base 这个基类，那么 delete 无法删除它的派生类 Derived，比如 Base* p = new Derived(); , 但使用虚析构就可以了: virtual ~Base();

1
class Animal {
2
  public:
3
    ~Animal() { cout << "~Animal\n"; }
4
};
5

6
class Dog : public Animal {
7
  char* name_;
8
  public:
9
    Dog(const char* s) {
10
      name_ = new char[20];
11
      cout << "Dog born\n";
12
    }
13
    ~Dog() {
14
    delete[] name_;
15
    cout << "~Dog\n";
16
    }
17
};
18

19
int main() {
20
  Animal* p = new Dog("Tom");
21
  delete p;
22
  return 0;
23
}

展开收起

派生类权限：#

分两步看：基类成员的原始权限 + 继承方式，取更严格的那个。

基类权限	`public` 继承	`protected` 继承	`private` 继承
`public`	public	protected	private
`protected`	protected	protected	private
`private`	不可直接访问	不可直接访问	不可直接访问

1
class Base {
2
public:    int a;
3
protected: int b;
4
private:   int c;   // 派生类永远不能直接碰
5
};
6

7
class Pub : public Base {
8
    // a: public,  b: protected,  c: 不可访问
9
};
10

11
class Pro : protected Base {
12
    // a: protected,  b: protected,  c: 不可访问
13
};
14

15
class Pri : private Base {
16
    // a: private,  b: private,  c: 不可访问
17
};

展开收起

上面的权限指的是”对外展示的权限”，而不是派生类”内部访问的权限”。

内部访问：只看基类自己的权限标签（public/protected/private），不管你怎么继承。
外部访问：才看继承方式，那是”降级规则”——把基类成员的对外可见度往下压一级或两级。

友元 & Tips#

友元关系不能继承、不能交换也不能传递
友元函数不是成员函数，只是一个类对一个函数的访问授权。
友元函数是 private 权限。
private 是本类成员函数可访问，protected 是本类和派生类，public 是任何地方都可以访问。
类内定义的函数默认是内联函数，但是类内声明但是在类外定义的函数要加上 inline 关键字。
inline 用于实现而非用于声明。
析构和构造函数都必须在类内声明，但可以在类外定义。
delete 删除一个动态对象，会先析构，再释放其占用的内存。
类的定义体中包括：数据成员、成员函数和成员的访问控制信息。
静态成员数据由该类的所以实例化对象共享，其生命周期是整个程序周期。
i 和 j 声明在 A 的 public: 之前，默认就是 private。到了 B::make() 里想直接访问，就碰壁了。

1
class A {
2
  int i, j;
3
  public:
4
    void get();
5
};
6
class B : public A {
7
  int k;
8
  public:
9
    void make();
10
};
11

12
void B::make() {
13
  k = i * j;
14
}

类内可以定义赋值语句，但是不能有执行语句，比如：

1
class B {
2
  int k;
3
  int z = 42;
4
  int z = x * y;
5
  k = 1; // false
6
};

虚析构函数的作用是避免在 delete 基类指针时，只析构基类部分，漏掉派生类部分，造成资源泄露。
语法上不存在虚构造函数，但可以通过虚函数（如 clone()）实现类似效果。

1
class Base {
2
public:
3
    virtual ~Base() {}
4
    virtual Base* clone() const = 0;   // 虚函数模拟"虚构造"
5
};
6

7
class Derived : public Base {
8
public:
9
    Derived* clone() const override {
10
        return new Derived(*this);
11
    }
12
};

纯虚函数是一个在基类中说明虚函数，它在该基类中没有定义，但要求任何派生类中的可访问性的规定是相同的。

静态 & 常#

静态成员函数只能访问静态成员变量，且它属于整个类，可以用 static void show() 和 Student::show() 也可以通过对象访问普通成员变量，比如：

1
class A {
2
public:
3
  int x;
4
  static void set(A &a) {
5
    a.x = 100;
6
  }
7
};
8

9
int main() {
10
  A obj;
11
  A::set(obj);
12
  cout << obj.x << endl;
13
}

由于数据隐藏的必要，静态成员数据通常为 private（私有成员）。
X a[3] *p[2] 里面实际上只调用了 3 次构造函数，因为 X 类的指针类型数组没有实例化对象，无需调用构造函数。
int *p = new A | new A[10] | new int[3]{1,2,3} | int[5]{} （初始化为0）
常成员函数案例：void show() const
常对象只能调用常成员函数，不能修改成员变量。

多态#

静态多态：编译时#

包括函数重载和运算符重载

1
// 函数重载
2
int add(int a, int b)    { return a + b; }
3
double add(double a, double b) { return a + b; }
4

5
// 模板
6
template<typename T>
7
T max(T a, T b) { return a > b ? a : b; }

运算符重载：复数相加

1
class Complex {
2
  double real, imag;
3
public:
4
  Complex(double r = 0, double i = 0) {
5
    real = r;
6
    imag = i;
7
  }
8
  virtual ~Complex() {
9
    cout << "Complex deleted" << endl;
10
  }
11

12
  // getter 函数，让外部能读取私有成员
13
  double getReal() const { return real; }
14
  double getImag() const { return imag; }
15

16
  // 声明为友元函数，使其可以访问私有成员
17
  friend Complex operator+(const Complex& om1, const Complex& om2);
18
  friend Complex operator+(const int il, const Complex& om1);
19
};
20

21
Complex operator+(const Complex& om1, const Complex& om2) {
22
  Complex temp;
23
  temp.real = om1.real + om2.real;
24
  temp.imag = om1.imag + om2.imag;
25
  return temp;
26
}
27

28
Complex operator+(const int il, const Complex& om1) {
29
  Complex temp;
30
  temp.real = om1.real + il;
31
  temp.imag = om1.imag;
32
  return temp;
33
}
34

35

36
int main() {
37
  Complex a(5.2, -1.3);
38
  Complex b(1.1, 0.3);
39
  Complex c = a + b;
40
  cout << c.getReal() << " " << c.getImag() << endl;
41
  Complex d = operator+(1, a);
42
  cout << d.getReal() << " " << d.getImag() << endl;
43
}

展开收起

运算符重载函数

成员运算符函数
友元函数重载
双目运算符函数
单目运算符函数

Tips

不能用友元函数重载的运算符是：= | () | [ ] | -> 其余都可以，因为这些运算符必须是非静态成员函数，这是C++标准的硬性规定。
= 可以被重载，但是重载了的= 函数不能被继承。（不能继承实际是被系统缺省定义替换掉了）
每一个类对象实例在创建的时候，如果用户没有定义“赋值运算符重载函数”编译器会自动生成一个隐含和默认的“赋值运算符重载函数”。
除= 以外的所有基类运算符都会被自动继承。

类的 6 个默认成员函数

分类	默认成员函数	作用
初始化	构造函数	对象初始化
销毁	析构函数	对象销毁
拷贝	拷贝构造函数	创建对象时复制数据
赋值	赋值运算符重载（operator=）	对已有对象赋值
取地址	operator&	获取普通对象地址
取地址	const operator&	获取 const 对象地址

重载 = 和 <<

1
 // 重载 =
2
class Complex {
3
  double real, imag;
4
public:
5
  Complex(double r = 0, double i = 0) : real(r), imag(i) {};
6
  Complex& operator=(const Complex& c) {
7
    if (this == &c) { return *this; }
8
    real = c.real;
9
    imag = c.imag;
10
    return *this;
11
  }
12
  friend ostream& operator<<(ostream& os, const Complex& c);
13
};
14

15
ostream& operator<<(ostream& os, const Complex& c) {
16
  os << "(" << c.real << " + " << c.imag << "i)";
17
  return os;
18
}
19

20
 // 重载 <<
21
class Complex {
22
  double real, imag;
23
public:
24
  Complex(double r, double i) : real(r), imag(i) {};
25
  friend ostream& operator<<(ostream& os, const Complex& c);
26
};
27
ostream& operator<<(ostream& os, const Complex& c) {
28
  os << c.real << " + " << c.imag << "i";
29
  return os;
30
}

展开收起

重载圆括号和中括号（必须用成员函数）

1
class Array {
2
  int data[10];
3
public:
4
  Array() {
5
    for (int i = 0; i < 10; i++) { data[i] = i; }
6
  }
7
  int& operator[](int i) {
8
    return data[i];
9
  }
10
  int operator()(int i) {
11
    return data[i] * data[i];
12
  }
13
};

动态多态：运行时#

1
class Animal {
2
public:
3
    virtual void speak() = 0;   // 虚函数
4
};
5
class Dog : public Animal {
6
public:
7
    void speak() override { cout << "wang wang"; }
8
};
9

10
Animal* p = new Dog();
11
p->speak();  // 运行时通过虚表找到 Dog::speak，输出"wang wang"

异常#

1
double divide(double a, double b) {
2
  if (b == 0) throw runtime_error("can not be 0");
3
  return a / b;
4
}
5
int main() {
6
  try {
7
    cout << divide(10, 0);
8
  } catch (const runtime_error e) {
9
    cerr << "err: " << e.what() << endl;
10
  }
11
}

模板#

1
#include <bits/stdc++.h>
2
using namespace std;
3

4
template <class AT>
5
  AT max(AT x,AT y){return (x>y)?x:y;}
6
int main(){
7
  int x1=1,y1=2;
8
  cout<<max(x1,y1)<<endl;
9
  float x3=1.1,y3=2.2;
10
  cout<<max(x3,y3)<<endl;
11
  char x4='a',y4='b';
12
  cout<<max(x4,y4)<<endl;
13
  int x2 = 3;
14
  char y2 = 4;
15
  cout << max(x2, y2) << endl;
16
}

展开收起

C++ 函数调用的一般顺序 C++中函数调用的一般顺序为： (1)寻找一个参数完全匹配的函数，若找到则调用之，否则：(2)寻找一个函数模板，若找到则将其实例化为一个模板函数，然后调用之，否则： (3)寻找重载函数，考察有无可通过产生参数匹配的函数，若有则调用之。

类模板和模板类的区别

1
template<typename T>
2
class Stack {          // ← 这是"类模板"
3
    T* data;
4
    void push(const T&);
5
};
6

7
Stack<int> s;          // ← Stack<int> 是一个"模板类"（实例化后的具体类）
8
Stack<double> d;       // ← Stack<double> 是另一个"模板类"

输入输出#

1
ios_base
2
  └── ios
3
        ├── ostream   ← 输出流
4
        │     └── ofstream  (文件输出)
5
        │     └── ostringstream (字符串输出)
6
        ├── istream   ← 输入流
7
        └── iostream  ← 双向流（同时继承 istream 和 ostream）

缺省#

1
class A {};
2
// 等价于
3
class A : private B {};
4
struct A {};
5
// 等价于
6
struct A : public B {};

Softmax

Sun, 12 Jul 2026 00:00:00 GMT

Softmax#

LeetGPU 题面#

warp 级 max 和 sum#

1
/* Warp-level reduction operation */
2

3
template<int WARP_SIZE = 32>
4
__device__ __forceinline__ float warp_max(float val) {
5
#pragma unroll
6
    for (int mask = WARP_SIZE >> 1; mask >= 1; mask >>= 1) {
7
        val = fmaxf(val, __shfl_xor_sync(0xffffffff, val, mask));
8
    }
9
    return val;
10
}

修饰词 & 内联标识#

`forceinline`#

其中，__forceinline__ 是 CUDA 函数修饰符，强制编译器内联该函数，无视启发式阈值。

节省函数调用开销，包括寄存器保存、恢复和指令跳转等操作。
代价：代码膨胀，寄存器压力增加，可能降低占用率。
常用于小函数、device 函数、被 #pragma unroll 循环体内调用的函数。

`#pragma unroll`#

#pragma unroll 是 CUDA 编译器指令，告诉编译器完全展开紧跟其后的 for 循环。

像上述的代码中所示的那样， WARP_SIZE = 32，所以 mask 的取值序列是 16-8-4-2-1，编译器会将循环展开为：

1
val = fmaxf(val, __shfl_xor_sync(0xffffffff, val, 16));
2
val = fmaxf(val, __shfl_xor_sync(0xffffffff, val, 8));
3
val = fmaxf(val, __shfl_xor_sync(0xffffffff, val, 4));
4
val = fmaxf(val, __shfl_xor_sync(0xffffffff, val, 2));
5
val = fmaxf(val, __shfl_xor_sync(0xffffffff, val, 1));

之所以我们需要用到它，是因为它可以：

消除循环控制开销
更多指令级并行（ILP）
编译器优化机会

::: tip 指令级并行：处理器同时执行多条不相干的指令，而不是串行等待。 :::

`__shfl_xor_sync`#

warp_max 用来在一个 warp 内求所有线程的最大值，并将最大值广播到 warp 中每个线程。

fmaxf 函数是求浮点数中的最大值。

__shfl_xor_sync 函数是 CUDA warp shuffle 指令，让同一个 warp 内的线程直接交换寄存器值，不走共享内存，不经过显存。

三个参数的含义#

参数	含义
`0xffffffff`	参与掩码，32 位全 1 = warp 内 32 个线程全部参与
`val`	当前线程要交换的寄存器值
`mask`	XOR 偏移量，目标线程 ID = 当前线程 ID XOR mask

工作机制#

以 mask = 16 为例：

1
线程 0  ←→ XOR 16 →  线程 16
2
线程 1  ←→ XOR 16 →  线程 17
3
线程 2  ←→ XOR 16 →  线程 18
4
...
5
线程 15 ←→ XOR 16 →  线程 31

__shfl_xor_sync 返回配对线程的 val 值。当前线程拿到对方的 val，对方也拿到当前线程的 val。

为什么用 XOR 而不是固定配对#

XOR 天然形成蝶形交换（butterfly shuffle），这是经典并行归约的通信模式：

1
轮次  mask=16:  线程0←→线程16,  线程1←→线程17, ...  (跨半区交换)
2
轮次  mask=8 :  线程0←→线程8,   线程1←→线程9,  ...  (跨1/4区交换)
3
轮次  mask=4 :  线程0←→线程4,   线程1←→线程5,  ...  (跨1/8区交换)
4
轮次  mask=2 :  线程0←→线程2,   线程1←→线程3,  ...
5
轮次  mask=1 :  线程0←→线程1,   线程2←→线程3,  ...

每轮每个线程拿到配对线程的值和自己的值做 fmaxf，5 轮后所有 32 个线程都持有全 warp 的最大值。

和共享内存方案对比#

对比项	`__shfl_xor_sync`	共享内存归约
延迟	~1 cycle（寄存器级）	~20+ cycles（共享内存访问）
需要 `__syncthreads()`	不需要	需要
额外内存	无	需要分配 shared memory

这就是为什么 warp-level reduction 几乎总是用 shuffle 指令而不是共享内存——寄存器交换是目前 GPU 上最快的线程间通信方式。

核心机制： XOR 保证每轮交换不出重复配对，蝶形把局部最大值逐层往外扩散，log₂N 轮覆盖全 warp。没有共享内存，没有同步屏障，纯寄存器交换，一个 cycle 完成。

三个场景不可以用该方法#

跨 warp 不行：shuffle 只在同一个 warp 内通信。
通信模式固定：特定场景。
线程分歧会出错：某些线程走了不同分支（if/else)。

指令	行为	典型场景
`__shfl_sync`	从指定线程广播	广播常量、配置
`__shfl_up_sync`	拿上方线程的值	前缀和、流式处理
`__shfl_down_sync`	拿下方线程的值	前缀和（反向）、数据移位
`__shfl_xor_sync`	XOR 蝶形配对	归约（求和、求最大值）

求和也是一样#

1
template<int WARP_SIZE = 32>
2
__device__ __forceinline__ float warp_sum(float val) {
3
#pragma unroll
4
    for (int mask = WARP_SIZE >> 1; mask >= 1; mask >>= 1) {
5
        // warp 内共享内存 寄存器直传 32 个线程
6
        val += __shfl_xor_sync(0xffffffff, val, mask);
7
    }
8
    return val;
9
}

Block 级 max 和 sum#

1
template<int BLOCK_SIZE = 256>
2
__device__ __forceinline__ float block_max(float val) {
3
    constexpr int WARP_SIZE = 32;
4
    constexpr int NUM_WARPS = (BLOCK_SIZE + WARP_SIZE - 1) / WARP_SIZE;
5

6
    const int warp_id = threadIdx.x / WARP_SIZE;
7
    const int lane_id = threadIdx.x % WARP_SIZE;
8

9
    static __shared__ float shared_mem[NUM_WARPS];
10

11
    const float warp_max_val = warp_max<WARP_SIZE>(val);
12

13
    if (lane_id == 0) {
14
        shared_mem[warp_id] = warp_max_val;
15
    }
16

17
    __syncthreads();
18

19
    const float thread_val = (lane_id < NUM_WARPS) ? shared_mem[lane_id] : -FLT_MAX;
20
    const float total_max = warp_max<WARP_SIZE>(thread_val);
21

22
    return total_max;
23
}

展开收起

如上述代码所示，先求出一个 BLOCK 内的 WARP 数量，然后将线程 ID 拆分成 “哪个 warp” 和 “warp 里哪个”。

为什么只让 lane 0 写？ warp 内 32 线程持有的 warp_max_val 都相同（归约结果广播了）。32 个线程写同一个值到同一个位置 → 浪费带宽，且可能写冲突。lane_id == 0 防重复写入。

接下来干什么？ shared_mem 现在存的是每个 warp 的局部最大值，下一步再对这些值做一次归约，得到全局最大值。这是经典的两级归约：warp 内部归约 → 跨 warp 归约。

`__syncthreads()`#

屏障指令。block 内所有线程都到达这条线，才一起放行。

为什么需要它： 共享内存跨 warp 读写，写方（各个 warp 的 lane 0 写 shared_mem）和读方（warp 0 的 lane 0-7 读 shared_mem）之间没有硬件保证顺序。不加屏障 → 可能读到旧值。

1
warp 0:  写 shared_mem[0]  ─┐
2
warp 1:  写 shared_mem[1]  ─┤ 全到 → 同时放行
3
warp 2:  写 shared_mem[2]  ─┤
4
warp 3:  写 shared_mem[3]  ─┘
5
                              ↓
6
                         开始读 shared_mem，值全写完，正确。

第二级归约#

__syncthreads() 之后，shared_mem 存的是每个 warp 的局部最大值。接下来用 lane_id < NUM_WARPS 做边界检查：

lane_id < NUM_WARPS → 取 shared_mem[lane_id]（有效 warp 最大值）
其余 lane → 填 -FLT_MAX（负无穷，参与比较但永不获胜）

然后对 32 线程的 thread_val 再跑一次 warp_max，有效值留下，占位值被淘汰，得出全局最大值。

为何复用 warp_max： NUM_WARPS ≤ 32（256 线程 / 32 = 8），一级归约结果正好装进一个 warp。用 -FLT_MAX 填充多余 lane，同一个函数搞定两级归约。

求和也是一样#

1
/* Block-level reduction operations */
2

3
template<int BLOCK_SIZE = 256>
4
__device__ __forceinline__ float block_sum(float val) {
5
    constexpr int WARP_SIZE = 32;
6
    constexpr int NUM_WARPS = (BLOCK_SIZE + WARP_SIZE - 1) / WARP_SIZE;
7

8
    const int warp_id = threadIdx.x / WARP_SIZE;
9
    const int lane_id = threadIdx.x % WARP_SIZE;
10

11
    // warp 间 共享内存 同一个 block 内的所有 warp
12
    static __shared__ float shared_mem[NUM_WARPS];
13

14
    const float warp_sum_val = warp_sum<WARP_SIZE>(val);
15

16
    if (lane_id == 0) {
17
        shared_mem[warp_id] = warp_sum_val;
18
    }
19

20
    __syncthreads();
21

22
    const float thread_val = (lane_id < NUM_WARPS) ? shared_mem[lane_id] : 0.0f;
23
    const float total_sum = warp_sum<WARP_SIZE>(thread_val);
24

25
    return total_sum;
26
}

展开收起

softmax#

最后是将最大值和求和值拿来做 softmax 的运算。

1
/* Softmax kernel implementation */
2

3
template<int BLOCK_SIZE = 256>
4
__global__ void softmax_kernel(const float* input, float* output, const int N) {
5
    const int tid = threadIdx.x;
6

7
    // 找到所有线程中的最大值
8
    float max_val = -FLT_MAX;
9
    for (int i = tid; i < N; i += blockDim.x) {
10
        max_val = fmaxf(max_val, input[i]);
11
    }
12
    max_val = block_max<BLOCK_SIZE>(max_val);
13

14
    // 计算所有指数函数的和
15
    float sum_val = 0.0f;
16
    for (int i = tid; i < N; i += blockDim.x) {
17
        const float exp_val = expf(input[i] - max_val);
18
        sum_val += exp_val;
19
    }
20
    sum_val = block_sum<BLOCK_SIZE>(sum_val);
21

22
    // 计算最终的归一化值
23
    for (int i = tid; i < N; i += blockDim.x) {
24
        output[i] = expf(input[i] - max_val) / sum_val;
25
    }
26
}

展开收起

分层接力#

1
线程扫数据 → 局部 max
2
warp 归约  → warp max（第一级）
3
共享内存   → 传给 warp 0
4
warp 归约  → block max（第二级，全局值）

::: tip 每一级往上是吞吐压缩，256 → 8 → 1，O(log₂N) 而不是 O(N)。 :::

HOST#

1
/* HOST */
2
extern "C" void solve(const float* input, float* output, const int N) {
3
    constexpr int THREADS_PER_BLOCK = 1024;
4
    softmax_kernel<THREADS_PER_BLOCK><<<1, THREADS_PER_BLOCK>>>(input, output, N);
5
    cudaDeviceSynchronize();
6
}

Vector Addition

Sun, 12 Jul 2026 00:00:00 GMT

Vector Addition#

基本常识#

CPU = 一个聪明的酋长。脑子快，一次只做一件事。

GPU = 一千个笨原始人。每个都笨，但一千个笨的打赢一个聪明的。

主机 Host = CPU 世界，C++，酋长坐的位置。

设备 Device = GPU 世界，原始人的住处，不同内存，不同空间。

::: tip CPU 不能碰 GPU 内存。GPU 不能碰 CPU 内存，必须过桥传送数据，也就是 PCIe。 :::

三个魔法词#

1
__global__   void kernel()   { }
2
// CPU 调用, GPU 执行。"原始人，冲！"
3
__device__   void helper()   { }
4
// GPU 调, GPU 跑。原始人悄悄话。
5
__host__     void normal()   { }
6
// CPU 调, CPU 跑。普通C++。(默认，可省略)

线程层级：三层分离#

1
Grid 大营
2
  ├── Block 0 小部落
3
  │     ├── Thread 0 原始人
4
  │     ├── Thread 1
5
  │     └── Thread 2 ...
6
  ├── Block 1
7
  │     └── Thread 0, 1, 2 ...
8
  └── Block 2 ...

::: tip 每个 block 里，32 个 thread 组成一个 warp。 :::

内置变量：不同原始人有不同的身份划分#

1
threadIdx.x   // 我是部落里第几个原始人？    (0 到 blockDim.x-1)
2
blockIdx.x    // 我部落在大营里排第几？       (0 到 gridDim.x-1)
3
blockDim.x    // 我部落有多少原始人？         (比如 256)
4
gridDim.x     // 大营有多少部落？             (比如 4)

执行 <<< >>>：派遣原始人#

1
kernel<<<部落数, 每部落原始人数>>>(参数);

1
// 有1000个数。每个原始人处理1个。
2
// 需要1000个原始人。每部落最多256个。
3
int N = 1000;
4
int threads = 256;
5
int blocks = (N + threads - 1) / threads;  // 4 个部落
6

7
add_kernel<<<blocks, threads>>>(a, b, c, N);
8
//         4部落 × 256原始人 = 1024 个原始人。
9
// 最后一个部落：256 - 24 = 232个干活，24个摸鱼。

内存：四种石头#

内存	速度	谁能看见	生命周期	大小
全局	慢（像走到山上）	所有原始人，所有部落	整个程序	大（GB）
共享	快（像递给旁边兄弟）	同部落的原始人	一次kernel运行	小（48KB）
局部	快（口袋里的石头）	一个原始人	一次kernel运行	小
寄存器	瞬间（手里攥着）	一个原始人	一次kernel运行	最小（每原始人255个）

1
__global__ void example(float* global_arr) {
2
    // global_arr — 所有人都能看到。远处大石头上写着。
3

4
    __shared__ float shared_arr[256];  // 只有我部落能看到。篝火旁边。
5

6
    float local_val = 5.0f;  // 我口袋里的。寄存器或局部内存。
7
}

搬运内存：过桥费#

1
// 1. 分配 GPU 内存
2
float* d_data;  // "d_" 前缀 = device。原始人约定。
3
cudaMalloc(&d_data, N * sizeof(float));
4

5
// 2. 复制 CPU → GPU（给原始人送活儿）
6
cudaMemcpy(d_data, h_data, N * sizeof(float), cudaMemcpyHostToDevice);
7

8
// 3. 启动 kernel（原始人干活）
9
kernel<<<blocks, threads>>>(d_data, N);
10

11
// 4. 复制 GPU → CPU（原始人带结果回来）
12
cudaMemcpy(h_result, d_result, N * sizeof(float), cudaMemcpyDeviceToHost);
13

14
// 5. 释放 GPU 内存（打扫山洞）
15
cudaFree(d_data);

展开收起

::: details 五步法总结

cudaMalloc
cudaMemcpy
kernel <<<>>>
cudaMemcpy
cudaFree :::

`__syncthreads()` 同步：部落开会#

1
__global__ void example() {
2
    // 第一阶段：每个原始人摘果子
3
    shared_basket[threadIdx.x] = gather_berry();
4

5
    __syncthreads();  // 部落里所有原始人在此停下。等每个人。
6
    // 没摘完果子之前，谁也不许偷看篮子。
7

8
    // 第二阶段：现在安全了，可以数果子
9
    if (threadIdx.x == 0) {
10
        total = sum(shared_basket);  // 小队长统计。
11
    }
12
}

Warp：背后的真相#

::: warning GPU 欺骗了你，它看似只有 256 个原始人一起干活，现实是一个 Warp = 32 个原始人，GPU 一次只执行 32 个。这 32 个必须做同一条指令。（SIMD - 单指令多数据） :::

::: tip Warp 分支发散 = 坏文明 :::

1
if (threadIdx.x < 16) {
2
    do_A();  // 16 个原始人走 A 路。另外 16 个站着发呆。
3
} else {
4
    do_B();  // 16 个原始人走 B 路。另外 16 个站着发呆。
5
}
6
// 总时间 = A时间 + B时间。一半原始人永远在摸鱼。浪费！

::: tip 好代码避免 warp 里写 if-else。32 个原始人一起齐步走。 :::

第一个程序：Vector Addition#

题目#

代码#

1
#include <cuda_runtime.h>
2

3
__global__ void vector_add(const float* A, const float* B, float* C, int N) {
4
    int i = blockIdx.x * blockDim.x + threadIdx.x;
5
    if (i < N) {
6
        C[i] = A[i] + B[i];
7
    }
8
}
9

10
// A, B, C are device pointers (i.e. pointers to memory on the GPU)
11
extern "C" void solve(const float* A, const float* B, float* C, int N) {
12
    int threadsPerBlock = 256;
13
    int blocksPerGrid = (N + threadsPerBlock - 1) / threadsPerBlock;
14

15
    vector_add<<<blocksPerGrid, threadsPerBlock>>>(A, B, C, N);
16
    cudaDeviceSynchronize();
17
}

展开收起

代码速查表：军师级别的原始人专用#

干啥	咋写
GPU 函数	`__global__ void name(...)`
启动	`name<<<部落数, 原始人数>>>(参数)`
我的编号	`blockIdx.x * blockDim.x + threadIdx.x`
部落墙	`__shared__ float arr[大小]`
部落等齐	`__syncthreads()`
GPU 分配	`cudaMalloc(&ptr, 字节数)`
拷内存	`cudaMemcpy(目标, 源, 字节, 方向)`
等 GPU 干完	`cudaDeviceSynchronize()`
GPU 释放	`cudaFree(ptr)`