1. 功能库视角下的 cuFFT:一维复数变换能解决什么
cuFFT 是 CUDA 里最常用的频域功能库之一,我把一维复数变换的验证压缩成一条 roundtrip 管线:建计划、拷数据、正变换、逆变换、比误差。这个功能库解决的是“数据已经在设备端、需要频域结果但不想自己写蝶形运算”的场景,适合刚接触 CUDA 库的新手,也适合要把 FFT 塞进现有流程的熟手。它最反直觉的地方是逆变换不自动归一化:一次正向加一次逆向,时域幅度是原来的 N 倍,拿逆变换结果直接和原信号比,max_err 会大得让人怀疑人生。所以这篇从最小可跑程序开始,把 N、batch、就地变换和错误码逐个落到代码和参数上。
需要模型API调用? 免费领10W Token,多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. cuFFT 功能库的最小可跑程序:从 malloc 到 roundtrip 校验
我不喜欢一上来就讲频谱图,先把一条能稳定输出 max_err 的管线跑通。下面这个 simpleCUFFT.cu 的骨架只做三件事:在主机端生成两个余弦波叠加的复数信号,把它拷到设备端做一次 FORWARD 和一次 INVERSE,再把结果拷回来和原始信号按 N 倍比较。它不自己写 kernel,全部动作都落在 cuFFT 的计划、执行和销毁三个接口上。
2.1 数据准备:主机端两个余弦分量叠加
先看信号生成这一段。N 从命令行参数来,缺省是 1024;数据长度、计划长度和后面校验时的 N 必须是同一个值。两个余弦的频率位置分别是 8 和 20,幅度分别是 1 和 0.5,虚部全部置 0,所以它是标准的复数数组,而不是只取实部的半套输入。
cpp复制const int N = (argc > 1) ? atoi(argv[1]) : 1024;
// 主机端生成测试信号:实部是两个余弦波叠加,虚部为 0
cufftComplex* h_signal = (cufftComplex*)malloc(sizeof(cufftComplex) * N);
for (int i = 0; i < N; ++i) {
h_signal[i].x = cosf(2.0f * (float)M_PI * 8.0f * i / N)
+ 0.5f * cosf(2.0f * (float)M_PI * 20.0f * i / N);
h_signal[i].y = 0.0f;
}
这段代码的逻辑很直白:cufftComplex 有两个成员 x 和 y,分别装实部和虚部;数组长度 N 就是变换点数。i / N 把采样索引折算成归一化位置,8 和 20 是频率序号,而不是 Hz。这里用 malloc 分配主机内存,没有检查返回值,后面我会把它归到“错误被拖到最后”的坑里。新手照着抄时可以先假设分配成功,但工程化时不能省检查。
2.2 设备缓冲与计划:长度和类型必须一起对上
信号准备好后,下一步是设备端分配和拷贝。d_signal 是设备指针,cudaMalloc 按 sizeof(cufftComplex) * N 分配,cudaMemcpy 用 cudaMemcpyHostToDevice 把同一块数据搬过去。随后 cufftPlan1d 创建一个一维 C2C 计划,参数依次是句柄地址、N、变换类型和 batch。
cpp复制cufftComplex* d_signal = nullptr;
cudaMalloc((void**)&d_signal, sizeof(cufftComplex) * N);
cudaMemcpy(d_signal, h_signal, sizeof(cufftComplex) * N,
cudaMemcpyHostToDevice);
// 创建一维 C2C 计划
cufftHandle plan;
CHECK_CUFFT(cufftPlan1d(&plan, N, CUFFT_C2C, 1));
这里的参数取舍要看两件事。第一,CUFFT_C2C 表示复数到复数;既然前一段把 h_signal[i].y 设成 0,仍然用 C2C 是合理的,因为后面要拿复数结果做 roundtrip,不想在半路换类型。第二,最后那个 1 是 batch,表示这个计划一次处理一条长度为 N 的变换。数据只有一条,所以 batch 写 1,别看着它不起眼就随手改大;batch 一改,设备端数据的组织方式就从“一条 N 点”变成“多条 N 点连续排布”,长度算错时执行不会报错,结果却会错位。
我在这一步会先确认三件事再往下走:N 和 sizeof(cufftComplex) * N 是同一来源;d_signal 是设备指针而不是主机指针;plan 还没被执行和销毁。cudaMalloc、cudaMemcpy 在这个片段里没有显式检查返回值,这是后面排查时最容易被忽略的黑匣子。计划创建用了 CHECK_CUFFT 宏,至少能把 cufftResult 非 CUFFT_SUCCESS 的情况拦下来。
2.3 执行、逆变换与销毁:就地变换的调用顺序
真正执行时,FORWARD 和 INVERSE 都传入同一个 d_signal 作为输入和输出,这叫就地变换。第一次正向变换会把时域数据覆盖成频域数据,第二次逆向变换又把频域数据覆盖回时域数据;中间不额外申请频域缓冲区,因此省内存,但也意味着原始频域结果留不下来。
cpp复制// 正变换再逆变换,验证 roundtrip 误差
CHECK_CUFFT(cufftExecC2C(plan, d_signal, d_signal, CUFFT_FORWARD));
CHECK_CUFFT(cufftExecC2C(plan, d_signal, d_signal, CUFFT_INVERSE));
CHECK_CUFFT(cufftDestroy(plan));
这段的调用顺序不能拧。cufftExecC2C 的最后一个参数是方向,CUFFT_FORWARD 先做,CUFFT_INVERSE 后做;两个调用都返回 cufftResult,用 CHECK_CUFFT 包住是必要的,否则错误码会静默掉。cufftDestroy(plan) 放在两次执行之后,是因为计划句柄销毁后不能再拿它执行变换。材料里的写法是执行完就销毁,再拷回主机;这个顺序没有问题,但工程里要注意:如果还要对同一块数据再做一次变换,销毁必须往后挪。
我一般把“就地”理解成一把双刃剑。省掉一块设备缓冲区,代价是每执行一次就覆盖一次原数据;如果你既想看正向频谱,又想拿逆变换结果和原信号比较,就要在正向执行后先把频域数据拷走,或者另开设备缓冲区。这个程序只验管线通不通,不保存中间频谱,所以就地最省事。
2.4 误差校验:拿逆变换结果和原信号乘 N 比
结果从设备端拷回 h_back 后,循环里不是直接拿 h_back[i].x 和 h_signal[i].x 相减,而是先算 expected = h_signal[i].x * N。这是整个程序里最关键的校验判断,也是 cuFFT 最容易让人翻车的地方。
cpp复制cufftComplex* h_back = (cufftComplex*)malloc(sizeof(cufftComplex) * N);
cudaMemcpy(h_back, d_signal, sizeof(cufftComplex) * N,
cudaMemcpyDeviceToHost);
// 逆变换未归一化,所以期望值要乘 N
float max_err = 0.0f;
for (int i = 0; i < N; ++i) {
float expected = h_signal[i].x * N;
float err = fabsf(h_back[i].x - expected);
if (err > max_err) max_err = err;
}
printf("N=%d, max_err=%e\n", N, max_err);
max_err 只记录最大绝对误差,不逐点打印。这样做的好处是输出短,适合放进回归脚本;缺点是误差大时只能看到一个数,不能立刻定位到第几个点。排查阶段可以临时把 i 和 err 打出来,但验证管线阶段只看 max_err 就够了。材料里提到可以把误差阈值设为 1e-5,我的用法是:先看 max_err 是不是接近 0 的量级,再决定要不要收紧阈值;如果直接拿原始信号比,误差会被 N 倍放大,看起来像整条管线全错。
这套最小程序的价值在于“可重复”。同样的 N、同样的余弦叠加、同样的 FORWARD/INVERSE,每次跑出来的 max_err 应该在同一量级;一旦换 N 后结果突然变了,优先查计划长度和数据长度是否同步,而不是先怀疑 cuFFT 本身。
3. cuFFT 计划参数怎么定:N、batch、就地变换与数据布局
计划不是一句 cufftPlan1d 就完事,参数一旦和数据布局脱节,执行接口可能照样返回成功,结果却对不上。这个最小程序里只出现了四个关键对象:N、CUFFT_C2C、batch=1、就地变换。把它们的含义吃透,比背接口名更有用。
3.1 cufftPlan1d 的参数拆解
cufftPlan1d(&plan, N, CUFFT_C2C, 1) 这一行里,&plan 是句柄输出地址,N 是一维变换点数,CUFFT_C2C 是变换类型,最后的 1 是 batch。它的含义可以先用下面这张表压住,后面再逐项看边界。
| 参数 | 材料中的写法 | 含义 | 改动时要注意 |
|---|---|---|---|
| plan | cufftHandle plan |
计划句柄,后续执行和销毁都要用 | 销毁后不能继续执行 |
| N | atoi(argv[1]),缺省 1024 |
每条一维变换的点数 | 主机数组、设备数组、校验时的乘 N 都要同步 |
| type | CUFFT_C2C |
复数输入、复数输出 | 信号虚部为 0 也仍然按复数处理 |
| batch | 1 |
一次计划处理多少条变换 | 大于 1 时数据按多条连续排布,长度不能只按单条算 |
这张表里我最想强调的是 N 的“同步”属性。N 不是只出现在 cufftPlan1d 里,它还出现在 malloc、cudaMalloc、cudaMemcpy 的长度、余弦信号的 i / N、以及校验时的 h_signal[i].x * N。只要有一处用了另一个 N,程序不一定报错,但 max_err 会变得不可解释。新手常见的写法是计划里写死 1024,数据却按命令行传入的 N 分配;跑默认参数没事,一换参数就翻车。
CUFFT_C2C 的选择也要说清楚。这个程序生成的是 cufftComplex 数组,实部有值、虚部为 0,本质上仍然是复数数据。用 C2C 的好处是正变换和逆变换的输入输出类型一致,roundtrip 校验路径最短;如果换成实到复的变换,后面逆变换的类型和归一化判断都会变,不适合作为第一条验证管线。batch=1 则是最小闭环:一条数据、一个计划、一次执行,先把错误码和归一化跑通,再谈批量。
3.2 batch=1 的含义与多 batch 的边界
batch 参数放在 cufftPlan1d 的最后,材料里给的是 1。它的意思不是“执行一次”,而是“这个计划按一维变换处理 1 条数据”。执行 cufftExecC2C 时,设备缓冲区里放的就是一条长度为 N 的复数序列。数据只有一条时,batch=1 最直观,校验循环也只需要从 0 走到 N-1。
如果哪天要一次处理多条长度相同的信号,batch 可以大于 1,但数据布局会从“单条 N 点”变成“多条 N 点连续排列”。常见做法是把第 b 条信号放在偏移 b * N 处,总长度按 batch * N 来算。这个判断不是让你现在就改 batch,而是提醒你:cufftPlan1d 里的 batch 和 cudaMalloc 的长度、cudaMemcpy 的字节数是一组联动参数。只改计划里的 batch、不改缓冲区大小,执行接口可能不拦你,后面的 max_err 会变得像玄学。
材料里的程序没有用到多 batch,所以我不会在这里编一段多 batch 代码。更稳妥的工程习惯是:先把 batch=1 的 roundtrip 跑通,再把 batch 当作“数据条数”单独加一列回归。每次改 batch,都重新算三处长度:主机分配、设备分配、拷贝字节数。只要这三处对齐,batch 才不是负担。
3.3 就地变换的边界:d_signal 同时作输入输出
cufftExecC2C(plan, d_signal, d_signal, CUFFT_FORWARD) 里输入和输出是同一个指针,这就是就地变换。它的优点是省一块设备内存,缺点是正向结果会覆盖时域数据,逆向结果又会覆盖频域数据。对于这条 roundtrip 验证管线,覆盖不是问题,因为原始信号还留在主机端 h_signal 里,最后校验用的是主机端副本。
但就地变换有一条边界要记住:正向执行后,设备端 d_signal 已经不是原信号,而是频域数据;如果你在这个时刻拿它去和 h_signal 比,得到的误差没有意义。同理,逆变换之后 d_signal 回到时域,但幅度是原信号的 N 倍。程序里把“拷回主机”和“乘 N 比较”放在逆变换之后,顺序是对的。
我在工程里会先问自己:中间频谱要不要留?要留就不能全靠就地,必须另开设备缓冲区或者在正向执行后立刻拷回。不要留就可以继续用 d_signal 同时作输入输出。这个取舍不影响接口调用,但影响你排查时能不能看到中间结果。新手如果一上来就改成就地加多 batch,出错时连是哪一步覆盖的都看不清,很容易把参数问题误判成库的问题。
3.4 N 从 argv 来:计划与数据长度必须同步
程序用 (argc > 1) ? atoi(argv[1]) : 1024 取 N,这个写法很方便做回归,但也把“参数一致性”暴露出来了。N 一变,cufftPlan1d 里的 N 要变,malloc 和 cudaMalloc 的长度要变,cudaMemcpy 的字节数要变,校验时的 expected = h_signal[i].x * N 也要变。少改任何一处,程序都可能跑出一个看似正常的 max_err,实际比较的是两套不同长度的数据。
我的做法是把 N 只留一个来源:要么命令行,要么配置,要么常量,绝不在多个函数里各写一个 1024。材料里的程序在 main 里只声明一次 N,这是好习惯;如果把它拆成多个函数,就把 N 作为参数传下去,而不是让每个函数自己再算一遍。计划长度和数据长度同步之后,换 N 只是重新建计划、重新分配,不会引入新的逻辑分支。
还有一个容易忽略的点:cufftPlan1d 创建计划时已经绑定了 N。后续执行用的设备缓冲区长度必须至少覆盖这个 N;如果缓冲区比计划短,执行就越界,错误可能不会在 cufftExecC2C 里立刻暴露。我的检查顺序是先看计划里的 N,再看 cudaMalloc 的字节数,最后看 cudaMemcpy 的字节数。三处一致,才允许执行。
4. cuFFT 功能库的归一化与误差校验:为什么期望值要乘 N
roundtrip 程序跑通之后,最容易被误判的不是接口,而是归一化。cuFFT 的 FORWARD 和 INVERSE 都没有自动缩放,材料里的程序在注释里写得很清楚:逆变换未归一化,所以期望值要乘 N。理解这句话,比记住一个误差阈值更重要。
4.1 FORWARD 与 INVERSE 的缩放约定
一次 CUFFT_FORWARD 把时域复数序列变到频域,一次 CUFFT_INVERSE 再把频域变回时域。按材料里的代码,这两次执行都没有额外乘以 1/N 或别的缩放因子。于是正向加逆向走完,时域幅度不是 1 倍,而是 N 倍。这不是程序写错了,而是调用者需要自己处理归一化。
这个约定对校验逻辑的影响非常直接:h_back[i].x 是逆变换回来的时域值,它对应的是 h_signal[i].x * N,而不是 h_signal[i].x。如果忽略这一点,误差会随着 N 增大而线性放大。N=1024 时,看上去像每个点都偏了上千倍;新手很容易以为 cufftExecC2C 方向写反了,或者以为设备内存拷错了。实际上方向没错,只是比较基准错了。
我在看这段代码时会把它拆成两条线:一条是“库有没有正确执行”,另一条是“我有没有按库的缩放约定比较”。max_err 同时受这两条线影响。先确认比较基准乘了 N,再谈误差阈值;顺序反过来,就会在错误的方向上调参数。
4.2 校验代码的期望值乘 N
材料里的校验循环是:
cpp复制float max_err = 0.0f;
for (int i = 0; i < N; ++i) {
float expected = h_signal[i].x * N;
float err = fabsf(h_back[i].x - expected);
if (err > max_err) max_err = err;
}
printf("N=%d, max_err=%e\n", N, max_err);
这里只比较了实部 x,没有比较虚部 y。对这条测试信号来说可以接受,因为原始信号的虚部全为 0,逆变换回来的虚部理论上也接近 0;但严格校验时应该把虚部一起看,至少确认它没有异常放大。材料里的写法是“最直接方式”,不是完整频谱校验。新手可以先用实部判断管线通不通,熟手在工程回归里再加虚部和相对误差。
expected 里的乘 N 必须和计划里的 N 是同一个值。如果计划用 1024、校验用命令行传入的另一个 N,max_err 会被两层错误叠加:一层是长度不一致,一层是缩放不一致。排查时先打印 N 和 max_err 一起看,不要只看误差数值。材料里的 printf("N=%d, max_err=%e\n", N, max_err) 就是把长度和误差绑在一行输出,这个习惯很好。
4.3 误差阈值 1e-5 怎么用
材料里提到“如果把误差阈值设为 1e-5”,但没有让程序真的做阈值判断。我的用法是把它当成人眼之外的辅助线:先跑默认 N=1024,观察 max_err 的量级;如果远小于 1e-5,说明管线正常;如果和 1e-5 同一量级,先检查信号幅度和 N,再决定要不要收紧。不要一上来就把阈值写成 0,浮点余弦和 FFT 都有舍入误差,绝对 0 不现实。
1e-5 也不是万能阈值。信号幅度、N 的大小、单精度还是双精度都会影响误差量级。材料里的程序用 float 和 cosf,默认 N=1024,这个阈值适合作为“有没有明显错误”的粗筛,而不是精度认证。工程里更稳的做法是同时看绝对误差和相对误差;材料只给了绝对误差 max_err,那就先把它当成回归信号,不要把它包装成精度指标。
我一般会把阈值判断放在脚本层,而不是塞进 simpleCUFFT.cu 主流程。程序只输出 N 和 max_err,脚本拿这两个数做比较。这样换 N 时不用改 C++ 代码,阈值也能按场景调整。材料里的程序保持最小输出,正是为了这种用法。
4.4 常见误判:把逆变换结果直接和原信号比
最典型的误判是拿 h_back[i].x 直接减 h_signal[i].x,然后看到 max_err 很大,马上怀疑 cuFFT 的 FORWARD/INVERSE 写反了。实际上方向是对的,错在比较基准。材料里的注释已经点明“逆变换未归一化,所以期望值要乘 N”,这句话应该贴在校验循环旁边,而不是只放在代码块外面。
第二个误判是把“就地变换”当成“没有覆盖”。有人看到 d_signal 在执行后还能拷回主机,就以为原数据还在设备端;实际上第一次 FORWARD 已经把它覆盖成频域数据。要保留原信号,只能靠主机端 h_signal 或者另开设备缓冲区。材料里的程序用主机端副本做比较,所以没有这个问题;一旦你把生成信号的循环也搬到设备端,再执行就地变换,原信号就没地方找了。
第三个误判是只跑一次就下结论。max_err 是一个随机性很小的数,但换 N、换 batch、换信号幅度后都可能变。我的习惯是至少跑两个 N 看误差量级是否稳定,再看计划参数是否同步。材料里的程序支持命令行传 N,正好可以做这件事。不要在没有第二组参数的情况下,把一次输出当成库的固定行为。
5. 避坑与排查:cuFFT 计划、内存和错误码的五个翻车点
这条管线看起来短,真正翻车的地方集中在五类:归一化、执行错误码、内存检查、句柄生命周期、换 N 后计划没重建。下面每条都按“现象 → 原因 → 解决”写,现象来自这段最小程序能暴露的输出和调用顺序,原因不跳出材料里的接口和参数约束。
5.1 避坑一:max_err 大得离谱,先看归一化
现象:程序能跑完,cufftExecC2C 也没有返回非零,但 max_err 大得不像浮点误差,换 N 后误差还会跟着变大。原因通常不是 FFT 算错了,而是校验时拿逆变换结果直接和原信号比,没有乘 N;cuFFT 的 FORWARD 和 INVERSE 都没有自动缩放,一次正向加一次逆向之后时域幅度是原来的 N 倍。解决是把 expected 改成 h_signal[i].x * N,并且确认这个 N 和 cufftPlan1d 里的 N 是同一个值。如果乘了 N 仍然大,再查就地变换是否把原信号覆盖后还拿设备端数据当原始信号用;材料里的程序保留主机端 h_signal,就是为了避免这个混淆。
5.2 避坑二:cufftExecC2C 返回非零,查计划与设备指针
现象:CHECK_CUFFT(cufftExecC2C(...)) 打印 cuFFT error 并退出,或者执行方向明明写了 CUFFT_FORWARD 却拿不到可用结果。原因要分两层看:一层是计划句柄 plan 是否由 cufftPlan1d 成功创建,另一层是传给执行接口的 d_signal 是否是设备指针、长度是否覆盖计划里的 N。材料里的 CHECK_CUFFT 宏会把 cufftResult 非 CUFFT_SUCCESS 的情况拦下来,这比不看返回值强得多。解决是把计划创建、执行、销毁三处的句柄状态对齐:创建失败就不要执行;执行前确认 d_signal 来自 cudaMalloc 而不是主机 malloc;执行后不要把已经 cufftDestroy 的句柄再拿来用。
5.3 避坑三:cudaMalloc/cudaMemcpy 没检查,错误被拖到最后
现象:程序偶尔崩在 cudaMemcpy 或 cufftExecC2C,有时不崩但 max_err 完全不可解释。原因在材料里的代码只对 cufftPlan1d 和 cufftExecC2C 用了 CHECK_CUFFT,cudaMalloc、cudaMemcpy 的返回值没有显式检查;设备内存分配失败或拷贝失败后,后面的执行可能继续跑,错误被拖到最后的误差输出才暴露。解决是把设备分配和拷贝的返回值也纳入检查,失败就停在原地并打印是哪一步;同时确认 cudaMemcpy 的方向是 cudaMemcpyHostToDevice 和 cudaMemcpyDeviceToHost,不要写反。这个坑不花哨,但一旦出现,排起来很耗时间。
5.4 避坑四:cufftDestroy 之后还复用句柄
现象:程序在第二次执行或第二次运行时崩溃,或者计划创建成功、执行却报错。原因可能是 cufftDestroy(plan) 已经销毁了句柄,后面又拿同一个 plan 去执行;材料里的顺序是两次 cufftExecC2C 之后才 cufftDestroy,这个顺序不能提前。解决是给计划句柄画一条生命周期:cufftPlan1d 创建,cufftExecC2C 执行,cufftDestroy 销毁;销毁之后如果要再变换,重新建计划,不要复用旧句柄。工程里如果计划要跨多次调用复用,就把销毁放到所有执行结束之后,而不是跟着某一次执行走。
5.5 避坑五:换 N 后结果不对,计划没有跟着重建
现象:默认 N=1024 时 max_err 正常,命令行传入另一个 N 后误差突然变大,甚至程序行为变得不稳定。原因可能是数据按新 N 分配了,但 cufftPlan1d 仍然用旧 N 创建;或者计划重建了,cudaMemcpy 的字节数还按旧 N 算。解决是把 N 当成一个贯穿参数:主机分配、设备分配、拷贝字节数、计划创建、校验乘 N 全部从同一个来源取。材料里的程序在 main 里只声明一次 N,这个结构本身就是在防这个坑;如果你把它拆成多个函数,记得把 N 传进去,不要让每个函数各自写一个 1024。
6. 进阶用法与验证:把 simpleCUFFT 变成可复用的验证脚手架
最小程序跑通后,我不会马上把它改成一个大而全的频谱工具,而是先把它变成能重复跑的验证脚手架。材料里的程序已经具备两个好条件:N 可以从命令行来,输出只有 N 和 max_err。这两个条件足够做一轮参数回归,不需要再引入新的库或新的接口。
6.1 参数化回归:固定默认值,再换 N 看误差量级
我的回归表只盯三件事,不追求花哨的频谱展示:
| 检查项 | 看什么 | 通过标准 |
|---|---|---|
| 默认 N=1024 | max_err 是否在浮点误差量级 |
远小于 1e-5,且重复运行稳定 |
| 命令行换 N | 计划、分配、拷贝、校验是否同步 | max_err 没有随 N 突变到不可解释的量级 |
| 执行顺序 | FORWARD 在 INVERSE 之前,DESTROY 在两者之后 | 没有在销毁后复用句柄 |
这张表里的“通过标准”不是精度认证,只是回归门槛。默认 N=1024 来自材料,1e-5 也来自材料;换 N 时不要编造另一组性能数字,只看误差量级和调用顺序。每次换 N,我先确认 printf 里的 N 和计划里的 N 一致,再看 max_err 是否还在同一量级;如果不对,先查参数同步,不先怀疑 cuFFT。
6.2 我每次都要走的检查习惯
我现在跑 cuFFT 验证会按固定顺序走:先看 max_err 是否按 N 缩放,确认 expected = h_signal[i].x * N 没有被改回原始信号;再查 cufftPlan1d 里的 N、cudaMalloc 的字节数、cudaMemcpy 的字节数是不是同一个来源;最后才看正向和逆向的调用顺序以及 cufftDestroy 的位置。这个顺序听起来笨,但能挡住大部分“库是不是算错了”的误判。血泪经验是,越短的程序越容易在比较基准上翻车,而不是在接口本身翻车。
从那以后我每次跑 cuFFT 验证都先把这三步走完,再去看频谱;三步没走完,我不把 max_err 当成结论。希望帮到你。
