C++ 提速的新发现

雷达 · 发表于 2022-9-24 22:54:26

C++ 比 Octave 慢好多，怎么破？

自相关两层循环，内层循环涉及浮点数计算，试验了一下把内层循环内部全都 comment out 只留个壳子, 但空的内层循环本身就把速度拉下来了，看来问题并不在浮点计算。

速度优化问题真的很有意思啊。

欢迎大家继续讨论

数值分析 · 发表于 2022-9-24 23:04:16

拉下来？拉多少？
把代码贴上来看看？

难道分支预测不准破坏流水线执行？不该啊。

沉宝 · 发表于 2022-9-24 23:15:41

会不会代码本身的缺陷阻止了自动优化？另外，硬件配置和开发环境可能也有关系。

风雨无阻 · 发表于 2022-9-24 23:33:02

Maybe Debug mode?

雷达 · 发表于 2022-9-24 23:54:10

本帖最后由雷达于 2022-9-24 23:57 编辑

数值分析发表于 2022-9-24 23:04
6 v) p' u" Y& u( K3 S拉下来？拉多少？
3 F0 t5 h8 B% [: ?1 u8 [$ T) H& t把代码贴上来看看？

void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
{
comp temp, xtimesy;
xtimesy.re = 0;
xtimesy.im = 0;
int j0 = lenB - 1;
int i, j, i1, reali;
if (lenA % 2 == 1)
reali = lenA + 1;
else
reali = lenA;
reali /= 2;

int nconv = reali + lenB;
//#pragma omp parallel for
for (i = reali; i < nconv; i++)
{
temp.re = 0;
temp.im = 0;
i1 = i;
for (j = j0; j >= 0; j--)
{
/* floating date operation */
}
}
}

xcorr函数代码如上，comp是复数struct, 做过长度为11、19两个矢量的测试，和octave结果完全一样

红色部分是内循环，现在其内部操作都comment out 了, j0大概是 6000。
现在call xcorr 100次，耗时78s.

如果把红色部分内循环本身完全comment out， call xcorr 1000次，耗时 <1s.

雷达 · 发表于 2022-9-25 00:17:17

风雨无阻发表于 2022-9-24 23:331 [: |9 G3 Y0 X/ ]7 p5 s" s% T
Maybe Debug mode?

不应该，看我上面的回复。

我更怀疑是 VS 社区版的问题

数值分析 · 发表于 2022-9-25 00:20:10

本帖最后由数值分析于 2022-9-25 00:24 编辑

雷达发表于 2022-9-24 23:54
; | n5 I) k( s/ avoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
0 ]4 R* K: \- o+ O4 b0 W{& j* n9 w/ M) v; w% @1 r5 G
comp temp, xtimesy;

这个不是这么比的吧。。。

您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。

而加上内循环，光jmp和dec指令就至少多执行了6000个，慢个几十倍不是正常的么？

雷达 · 发表于 2022-9-25 00:46:56

本帖最后由雷达于 2022-9-25 01:09 编辑

数值分析发表于 2022-9-25 00:20
5 L) D! \1 K" C0 h( k这个不是这么比的吧。。。/ D: C1 w2 a: S! N5 |3 F6 f
0 O$ d4 U9 ]7 S' [6 b7 L5 l
您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。

有道理。
所以存在内循环速度就上不去，把内循环取消，改成两个向量直接点乘再求和应该就会好得多，记得 numeric 库里有算向量内积的，我回头试试。

我先尝试尽量用标准库，一个小程序，不想搞得太复杂。多谢了

沉宝 · 发表于 2022-9-25 01:27:53

雷达发表于 2022-9-25 00:46
4 }$ s" p$ k# O! n" c有道理。
0 e) A) H2 V( c所以存在内循环速度就上不去，把内循环取消，改成两个向量直接点乘再求和应该就会好得多，这大 ...

你两个试验之间就差了一个空循环， call 1000次按理不会有秒级差异，可能还是编译器优化的问题。举个例子，把循环本身翻译成机器指令loop或dec/jnz，两者速度上会差很多
Why is the loop instruction slow? Couldn't Intel have implemented it efficiently?

沉宝 · 发表于 2022-9-25 01:48:51

数值分析发表于 2022-9-25 00:20# F4 V; E- p; x& p$ J! J$ W
这个不是这么比的吧。。。) P9 c4 @, \, D8 H# G5 L

& t5 P; M$ h+ y8 j$ n$ e0 i您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。

而加上内循环，光jmp和dec指令就至少多执行了6000个

现在的CPU，可以把判断、jmp和dec指令全部融合进一个µOp（微操作，CPU内部流水线上的执行单位）。如果循环这样跑，花不了多少时间。

数值分析 · 发表于 2022-9-25 02:06:44

本帖最后由数值分析于 2022-9-25 02:16 编辑

沉宝发表于 2022-9-25 01:48
- q& a @/ `1 A7 J y现在的CPU，可以把判断、jmp和dec指令全部融合进一个µOp（微操作，CPU内部流水线上的执行单位）。如果 ...

是的，兄台说的对。

其实我想说的是真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。

雷达兄构造测试用例的时候，屏蔽掉了所有计算的部分，使得剩下的都是overhead，这样run time比较的结果就显得好像不合理了。如果把计算加回去，计算部分的run time会dominate，结果就不那么离谱了。因为不好说，所以用指令数对比的方式试图直观地说明这一点。

比如说，如果有计算，那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做，另一边是六千个循环，那六千个循环比什么都不做慢几十倍了，就不是那么不合理了。

当然也有可能像兄台说的，是优化参数的问题，但我觉得更多地是测试用例设计的不合理。

雷达 · 发表于 2022-9-25 04:47:43

本帖最后由雷达于 2022-9-25 04:49 编辑

沉宝发表于 2022-9-25 01:276 h8 _5 }' `: [& ~: n2 `
你两个试验之间就差了一个空循环， call 1000次按理不会有秒级差异，可能还是编译器优化的问题。举个例子 ...

又写了个小实验，没有调用子函数，双层循环，外层6千次，内循环30万次空转，有或没有空转内循环，时间差一倍，我上面这个差的太多了。

我已经完全懵了。

沉宝 · 发表于 2022-9-25 05:51:23

雷达发表于 2022-9-25 04:47
) H$ ~( Q: l3 `$ W6 q又写了个小实验，没有调用子函数，双层循环，外层6千次，内循环30万次空转，有或没有空转内循环，时间差 ...

时间差一倍的结果可以接受。

你还是用profile工具看看吧。现在大家都主观瞎猜。

数值分析 · 发表于 2022-9-25 14:58:59

本帖最后由数值分析于 2022-9-25 15:38 编辑

雷达发表于 2022-9-25 04:47: c9 v! D7 O7 _9 C. B: u b( Q
又写了个小实验，没有调用子函数，双层循环，外层6千次，内循环30万次空转，有或没有空转内循环，时间差 ...

能不能把这个也贴上来，看看和上一个有什么不同？

雷达 · 发表于 2022-9-26 01:30:03

本帖最后由雷达于 2022-9-27 01:17 编辑

数值分析发表于 2022-9-25 14:58% r X# ]' p, |' C" ?) I0 l) P
能不能把这个也贴上来，看看和上一个有什么不同？

理了理思路，重新做了一个测试。
做了两个 vector 和两个 float *, 都长 100000
外循环 6000，里面先做随机数生成，模拟真实环境，避免数据的 cache.

内循环试了4种方法，
1. 直接调用 vector inner_product 247s
2. vector 循环点乘累加 237s
3. float * 循环点乘累加 204s
4. 空循环 100000 次 202s

不做内循环 200s

你昨天说的对，内循环本身占比是很小的，大头在其他处理。
另外可以看到， float * 循环点乘累加并不差，比用vector 还更快。

至于我那个原始程序，还有一些疑问，见5楼，其他都不变仅仅是有无空的内循环就有很大不同，这是不对的，也许有一些其他缺陷我没有看到。（也许可以改成 while 试试）

（为什么下面我贴的 b1 加方括号里的 i , 显示出来却是 b1 ？方括号 i 消失了。 LOL . 改成 jj 好了，原来方括号里的 i 是斜体标志 LOL）

      std::vector < float > vec1(N);
, }4 L  A1 i2 p1 }+ g8 b+ `& D. T       std::vector < float > vec2(N);
, B1 g$ S2 i' ], T9 {, p       float* b1 = new float[N];
" O- ]8 B% i: J- @; M( S       float* b2 = new float[N];. C6 b2 d& ~, U$ L8 q

3 Z* p* N+ g: B       for (int j = 0; j < 6000; j++)
8 E3 E. \, R+ B- U8 n       {5 b, H$ @9 f1 {$ f  j" \
            std::generate(vec1.begin(), vec1.end(), []() {7 N2 d2 g6 U1 s+ }+ x
                     return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;
; s/ V" |2 ^& o) ]                      });% G4 b( ?. P( |

) n5 }# E! H- {             std::generate(vec2.begin(), vec2.end(), []() {3 C* }. B' h$ u+ @1 ~
                     return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;
! G; j1 U2 ]4 h! s, M$ Y( k                      });
( T' l+ Z: P, a+ \9 M
% C) f# d: i8 l3 T$ J  |* l' o% ]             for (size_t jj = 0; jj < vec1.size(); jj++)
  [1 ~, C5 y9 g+ Y! ~             {
8 z, H3 q$ F. U( H5 v0 i2 E                      b1[jj] = vec1[jj];
  p& I+ \' M7 \8 q! D' t             }
& |+ b+ e8 s  F# O6 P
  K. e1 m  ^9 a) ^5 o- b+ s& f             for (size_t jj = 0; jj < vec2.size(); jj++)0 u8 n9 E+ T5 e5 ~% G
            {
$ m7 n! K% R/ U9 B7 F7 s                      b2[jj] = vec2[jj];
$ Z/ _1 h  h9 D             }
' W2 }" c1 v! c
  w3 a! x+ ]( A& c9 d- d; U3 y             //Method - 1  N=100000 247s
1 V. D1 q( z4 J0 }             //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);
! C1 A* b3 z; H' ?                               2 f# |: O8 A$ Y. }, ]) {0 D4 I: v
            //Method - 2  N=100000  237s
! Y6 R6 h' Z, D/ J: y% L4 E             /*
3 D/ |- B. i: g) ]             for (int jj = 0; jj < N ; jj++)( V* A: j; @, q- }
            {6 {0 K6 J# P$ a# q. d5 V
                     fresult += vec1[jj] * vec2[jj];9 w6 ~/ a+ Z( H2 A. R
            }
' g4 [( q, L5 n9 Y6 M             */9 H9 C' [1 G5 {
                              5 }9 D0 {3 w9 z/ E; h; Y" [
            //Method - 3  N=100000 204s
! R' o0 ^4 L  [. T6 q$ R7 o* m8 H             /*, C- G5 @4 o5 v
            for (int jj = 0; jj < N; jj++)
3 g9 I6 q  J. F             {4 f6 K4 h9 A$ h( A: n
                     fresult += b1[jj] * b2[jj];
/ n- M  O  _- k% T$ t! A             }
( P, C. F$ m% E             */
7 g$ ^- @$ x2 Q5 S' ]; L
, l2 \; A3 B7 X5 Q3 p6 _, P# U2 [             //Method - 4 202s' g6 w1 ?$ m; r& ?
            /*
) |6 p+ N! @% R  d8 p5 g0 v             for (int jj = 0; jj < N; jj++)
4 I5 K: a) n8 S0 r             {
: o# k/ y+ k+ e3 j7 a
- e+ Y! {& ]9 o) X             }
" o" ?! s, l8 T, G; k' |             */9 K' G: O' j: B3 {. ]. t4 ]
            //comment out all methods, N=100000  202s             1 ^7 @( E4 G! a( ]/ r6 W" \- m
      }
4 x4 a) P/ n7 w+ G
* P7 P* F0 {0 |7 V- u) \2 @       delete []b1;6 ?# R3 s8 t3 ~* D9 p
      delete []b2;

机器猫 · 发表于 2022-9-27 00:15:38

瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同？

你第二个试验里面的j在循环里面又重新定义了啊，你确定真的跑了6000次？

雷达 · 发表于 2022-9-27 01:16:03

机器猫发表于 2022-9-27 00:15
. v) J6 ~8 t0 i: g$ |2 a1 g% h( N1 z瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同？$ z. H$ v5 q' K# u3 F
- [9 J8 W( v* G K* @
你第二个试验里面的j在循环里面又重新定义 ...

内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累、LOL

不和它较劲了，瞎耽误工夫，我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。

机器猫 · 发表于 2022-9-27 02:06:58

雷达发表于 2022-9-27 01:16. \4 L; W" p% z; q% B" Z
内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累、LOL
5 ?8 V& O+ Y& L
不和它 ...

不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的，很有可能是在stack上，这样内存读写会更多，要是再碰上每次都需要加载cache就更慢了。
后面一个是在循环那里定义的，说不定编译器就把它优化成register变量了

opensrc · 发表于 2022-9-27 07:25:57

一个无关问题，为什么爱坛的帖子里在我这里有好些奇怪的东东在里面，是防拷贝措施吗？

雷声 · 发表于 2022-9-27 20:29:50

雷达发表于 2022-9-24 23:54
0 S7 N! A3 m. y, V. x- G* i6 i' B4 lvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)% q- g9 u& d. A6 H- w, s
{
# h) \+ i. r" E" ` comp temp, xtimesy;

这个code里面如果Openmp没有被注释掉的话，那么temp那个变量应该是定义在循环里面，否则线程之间会存在争夺写入那个temp的风险。
内层for循环如果没有内部操作的话，编译时应该被优化掉了，和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化？
VS社区版没有问题，我工作用的就是社区版，设置正常的话不会比商业版差。以前游说头头用Intel Compiler，他说不想花钱，而且差不了多少，就一直用到现在。

		自动登录	找回密码
密码			注册

[信息技术] C++ 提速的新发现

评分