C++ 提速的新发现

雷达

C++ 比 Octave 慢好多，怎么破？
0 g! {% K, D0 G
自相关两层循环，内层循环涉及浮点数计算，试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了，看来问题并不在浮点计算。
9 P( X& H+ D) ~5 g( Y
速度优化问题真的很有意思啊。
4 x# K0 c9 F0 c2 c$ Z% L; g; e& Q
3 e+ O' w4 w. l6 t0 H) c+ W欢迎大家继续讨论

数值分析

拉下来？拉多少？
" Q/ k! f# v6 {* P4 r4 c6 \把代码贴上来看看？

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

沉宝

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

风雨无阻

Maybe Debug mode?

雷达

: w: w2 B. S6 T/ `

数值分析 发表于 2022-9-24 23:04
7 O/ s( a- y' z4 r; ~  L拉下来？拉多少？
2 Z+ F/ U; }! i$ C* }$ [' Z/ {; D5 d把代码贴上来看看？

* B% x, M  g7 M6 z! i  M, {
void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
9 }; k2 |3 Q7 _) L- C  t8 W5 [{
        comp temp, xtimesy;
        xtimesy.re = 0;
( }; F* r( o0 f, u        xtimesy.im = 0;
2 g, N- i5 t6 W. v        int j0 = lenB - 1;
        int    i, j, i1, reali;
" s) [3 @+ k: i7 A! ?8 h        if (lenA % 2 == 1)
* W) f0 C5 g6 V                reali = lenA + 1;
        else
, @! X+ ?- s8 b) M$ a5 n9 c                reali = lenA;
, u& e. H0 b$ c        reali /= 2;
, n! |( Z% l9 F9 ~) _1 E, k$ A7 L
        int nconv = reali + lenB;
5 C" D/ Y! ?8 R$ m# }        //#pragma omp parallel for
% f: w" s5 s* Y# x        for (i = reali; i < nconv; i++)
$ m: M/ Y! A$ C  \: G+ f        {
                temp.re = 0;
* R7 m! h1 ]  v( c. |1 e6 ?4 h                temp.im = 0;
' C5 M9 A$ B, L% y* E                i1 = i;
+ o4 A2 j- \  z  K0 `: M1 x4 I                for (j = j0; j >= 0; j--)
: ]' k$ @8 S, s/ N2 y9 \                {
9 ~# ~+ K9 B; x. f                        /* floating date operation */
! b4 M& t- v- U                }
        }
}

xcorr函数代码如上，comp是复数struct, 做过长度为11、19两个矢量的测试，和octave结果完全一样
4 N* U9 `" P! q8 |" ?  ?% G
- G3 ]+ |3 T3 k  N* C, i红色部分是内循环，现在其内部操作都comment out 了, j0大概是 6000。
现在call xcorr 100次，耗时78s.
- a8 L, y# l' K' J8 F
如果把红色部分内循环本身完全comment out， call xcorr 1000次，耗时 <1s.
' e7 L& o$ ^4 F, K# S; Z% z" g
5 T' n4 Y& G/ k0 ~7 z0 O  A( D8 }

雷达

风雨无阻 发表于 2022-9-24 23:33
1 B4 N# O) T, V- d* B3 `5 ^$ zMaybe Debug mode?

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

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

数值分析

雷达 发表于 2022-9-24 23:54
) m& `7 j+ l' H  F. W% |+ D# }void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
$ r# A' y$ f) U5 O- y: L{
) }7 N( C, h/ O+ h# |( i" k% N        comp temp, xtimesy;

& d, n6 P3 r7 {4 ~. S; A  s  z
4 |: `' J0 }' ^5 b  B. r这个不是这么比的吧。。。
5 d; C# F) \6 i7 g* l- G9 o  |$ F: w
' D$ ?: Y; R) Y$ B% p+ w: `1 K您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。
& L% H, P8 z# S: T8 d' a- u* g' ]
. M8 d6 U) f$ N- @而加上内循环，光jmp和dec指令就至少多执行了6000个，慢个几十倍不是正常的么？

雷达

数值分析 发表于 2022-9-25 00:20
这个不是这么比的吧。。。
8 A* f  x, u) N! }2 n; J$ E% K; A
您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。

8 B  B! S2 z8 V6 `/ m; s/ u+ {, v
& Y* i, h8 v. m有道理。
; L* I0 n# k9 S5 @所以存在内循环速度就上不去，把内循环取消，改成两个向量直接点乘再求和应该就会好得多，记得 numeric 库里有算向量内积的，我回头试试。
: {7 h6 [1 r1 s: \# h6 a; t
3 k5 \4 h. a* w! P我先尝试尽量用标准库，一个小程序，不想搞得太复杂。多谢了

沉宝

雷达 发表于 2022-9-25 00:46
, z/ _2 }* v1 {: ^  I4 X有道理。
: @2 J5 T2 `% m5 U  Y所以存在内循环速度就上不去，把内循环取消，改成两个向量直接点乘再求和应该就会好得多，这大 ...

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

沉宝

数值分析 发表于 2022-9-25 00:20
这个不是这么比的吧。。。
* d% L$ A" g2 k" S/ ^2 Q! k
3 S" p, Y" W# A您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。

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

% E2 f9 w  I3 y
/ z; i( ]5 l9 D; a现在的CPU，可以把判断、jmp和dec指令全部融合进一个µOp（微操作，CPU内部流水线上的执行单位）。如果循环这样跑，花不了多少时间。

数值分析

# K$ `! {: J4 j: r2 g) P

沉宝 发表于 2022-9-25 01:48
9 U1 z$ h: H" t6 h6 E现在的CPU，可以把判断、jmp和dec指令全部融合进一个µOp（微操作，CPU内部流水线上的执行单位）。如果 ...

1 d% ]4 p0 I* U
是的，兄台说的对。
1 T5 Y, G" P. n: a' Q  A9 @
  q' @9 B; F  k: y7 k' ~: a其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。
  j0 i; |, D5 J+ ], E5 B
雷达兄构造测试用例的时候，屏蔽掉了所有计算的部分，使得剩下的都是overhead，这样run time比较的结果就显得好像不合理了。如果把计算加回去，计算部分的run time会dominate，结果就不那么离谱了。因为不好说，所以用指令数对比的方式试图直观地说明这一点。

比如说，如果有计算，那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做，另一边是六千个循环，那六千个循环比什么都不做慢几十倍了，就不是那么不合理了。
: _" z  r  }4 B
当然也有可能像兄台说的，是优化参数的问题，但我觉得更多地是测试用例设计的不合理。

雷达

) l/ A. T/ a! j% g& R" J4 ]

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

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

1 T( _+ X% M/ d2 u我已经完全懵了。

沉宝

雷达 发表于 2022-9-25 04:47
/ _, A6 v" K% H: Q8 |) A又写了个小实验，没有调用子函数，双层循环，外层6千次，内循环30万次空转，有或没有空转内循环，时间差 ...

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

' a9 Y/ p3 I2 r  o# |你还是用profile工具看看吧。现在大家都主观瞎猜。

数值分析

& `7 Z3 X. |5 |3 e- ], l9 ]) n  E

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

) a6 b& O' e/ V, S4 U! p' F3 U1 t
+ `; |4 t2 t' R1 a5 K
# U, o' W4 t" H2 H) ]# j+ k& I
能不能把这个也贴上来，看看和上一个有什么不同？

雷达

数值分析 发表于 2022-9-25 14:58
1 `3 Q8 |9 A' t, w' b0 z9 g能不能把这个也贴上来，看看和上一个有什么不同？

( N- {+ \( ]3 F  h# J0 r3 u# f理了理思路，重新做了一个测试。
做了两个 vector 和 两个 float *, 都长 100000
% j% s/ {. c6 o7 i0 S# ?外循环 6000，里面先做随机数生成，模拟真实环境，避免数据的 cache.

内循环试了4种方法，
! u7 v. I) }3 w2 W1. 直接调用 vector inner_product 247s
5 W+ Q0 m- W' q6 i9 Z2. vector 循环点乘累加 237s
3. float * 循环点乘累加 204s
4. 空循环 100000 次 202s
) k$ K0 O* V3 E
- R5 b, E& R2 ?不做内循环 200s

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

至于我那个原始程序，还有一些疑问，见5楼，其他都不变仅仅是有无空的内循环就有很大不同，这是不对的，也许有一些其他缺陷我没有看到。（也许可以改成 while 试试）
" B2 |- o( r/ q6 R7 @
4 i) W" Z& W8 f' `3 U) e（为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ？方括号 i 消失了。 LOL . 改成  jj 好了，原来 方括号里的 i 是斜体标志  LOL）

        std::vector < float > vec1(N);
        std::vector < float > vec2(N);
4 `1 R1 S1 \- [' x        float* b1 = new float[N];
- U+ q$ r$ G& d  ?' o        float* b2 = new float[N];
/ G0 ^4 E1 h& I7 Z# Z
. \! W  b5 b: c' ~" E! o        for (int j = 0; j < 6000; j++)
  ?( d4 Q* c4 \2 {$ b8 j        {
) O* l3 z) H7 o7 ~; C/ C# E                std::generate(vec1.begin(), vec1.end(), []() {
                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;
, a% Y# Q" D( p( a                        });

; L% w9 W8 |* ?7 G7 s' \                std::generate(vec2.begin(), vec2.end(), []() {
                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;
9 W% E  L! c! z0 U$ ]! G                        });
! F4 y& }3 C1 x0 h2 |
                for (size_t jj = 0; jj < vec1.size(); jj++)
                {
                        b1[jj] = vec1[jj];
8 H* ?8 @1 c2 D+ H, T) h                }

                for (size_t jj = 0; jj < vec2.size(); jj++)
) P) ^/ ^- n- ~                {
7 Q! U2 w0 @+ H0 \: p# v+ V                        b2[jj] = vec2[jj];
2 V% L9 U5 e; ]  u3 ?                }

                //Method - 1  N=100000 247s  
  T- o' B" t5 N( E+ ~                //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);
4 k8 T) p4 U3 z                                
6 M+ T, ?5 M5 R5 r$ L3 D, i0 Q                //Method - 2  N=100000  237s
                /*
                for (int jj = 0; jj < N ; jj++)
                {
; F5 c, H! G/ l% K                        fresult += vec1[jj] * vec2[jj];
( ?* [( ^# t/ v0 m9 }$ |0 J                }
                */
                                
6 z- n* E1 x2 t5 i0 I9 `% F                //Method - 3  N=100000 204s
, O" S$ {0 D6 p  r, j) c# y6 W                /*
/ O( ]3 h7 Z  Q* H/ E1 H                for (int jj = 0; jj < N; jj++)
$ J8 w! z; I( H0 U# w) U                {
                        fresult += b1[jj] * b2[jj];
. e' o7 Q+ u0 @" Y# V                }
                */
3 c- k5 ]# t/ `* N3 s' D# p* f4 L
6 K! n% J% k/ s1 z                //Method - 4   202s
/ ]. Q* R$ `0 s1 L                /*
3 e7 q; h# D; i9 A                for (int jj = 0; jj < N; jj++)
  ^. Q0 i- t* n- w; o. p: G+ W                {
1 k8 c  Y7 L) y2 q                        
# }9 M- M, s1 R( c' q' c; m                }
0 X& A0 I3 S3 e8 K/ ]: v: l6 R! \                */
                //comment out all methods, N=100000  202s               
" \6 W& x- [( t' f% G        }
) R- q1 W5 b* W8 A; C
        delete []b1;
        delete []b2;

机器猫

瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同？
9 g. ~, x6 t8 o  n9 D2 Y
4 w" T8 L/ T9 R3 Q3 x; w你第二个试验里面的j在循环里面又重新定义了啊，你确定真的跑了6000次？
8 @& S# n* U% s& |) m

雷达

机器猫 发表于 2022-9-27 00:15
瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同？
0 h8 D4 E  D0 o9 T* n) S6 ?
你第二个试验里面的j在循环里面又重新定义 ...

! H8 h; y  M6 X5 p  p7 B8 `内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
; w1 r/ t# n( a1 k2 A7 ~; s' G
+ M, k- h- y) G7 W" x不和它较劲了，瞎耽误工夫，我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。

机器猫

雷达 发表于 2022-9-27 01:16
" c" F6 o+ P3 I1 T, P$ e$ x内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
; ~# i# q  ]  u' X
8 y7 {6 h4 W( [( ]# z不和它 ...

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

opensrc

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

雷声

雷达 发表于 2022-9-24 23:54
( b/ o  x# F+ F2 Z7 }void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
4 m0 ~8 F1 ^$ O$ _5 t- U{
        comp temp, xtimesy;

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