C++ 提速的新发现

雷达

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

自相关两层循环，内层循环涉及浮点数计算，试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了，看来问题并不在浮点计算。
. [. e2 q) ]  @& n+ [" `4 v4 s
速度优化问题真的很有意思啊。
9 y7 T1 o2 P% y) P, [* T2 c9 z
欢迎大家继续讨论

数值分析

拉下来？拉多少？
7 \8 \# J% H& p8 L* p  w0 b+ ~把代码贴上来看看？
5 z( Q. F' ?) H2 L
9 x' f  m' V# N3 @8 E7 H难道分支预测不准破坏流水线执行？不该啊。

沉宝

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

风雨无阻

Maybe Debug mode?

雷达

数值分析 发表于 2022-9-24 23:04
' P/ Y8 p8 \# ^; I8 C拉下来？拉多少？
把代码贴上来看看？

, x( @. Q, W; v* U. hvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
( s% g" w! t$ `. \" \! ]6 z* q{
        comp temp, xtimesy;
4 r, w. c- K, C5 j& G        xtimesy.re = 0;
5 R3 E2 j- b% ^' d8 }        xtimesy.im = 0;
( R! O% T! C, N3 b  {9 s6 K0 {7 E/ k        int j0 = lenB - 1;
2 V, T* P; O5 r6 c4 V        int    i, j, i1, reali;
        if (lenA % 2 == 1)
                reali = lenA + 1;
        else
# B4 G' Q2 v! D4 @                reali = lenA;
* r- A' A3 c; f  |4 [7 U5 F6 \6 u        reali /= 2;

        int nconv = reali + lenB;
) I5 d" c3 w) _        //#pragma omp parallel for
& C9 j$ E# X( u9 b  n) l        for (i = reali; i < nconv; i++)
3 [7 f& Q- E. c- d1 q. [& n        {
( j; h( u/ \! {* N                temp.re = 0;
+ i  q/ e% A* r3 W  \2 x5 M- p                temp.im = 0;
                i1 = i;
                for (j = j0; j >= 0; j--)
                {
0 D) a+ o/ t" W6 C. t                        /* floating date operation */
% m5 r8 Q( h1 ?8 M                }
        }
}
8 r5 O: n0 n9 ~
4 D2 K6 ^1 O6 ?/ f9 k4 p: Q, h8 qxcorr函数代码如上，comp是复数struct, 做过长度为11、19两个矢量的测试，和octave结果完全一样
2 O5 e, V. V8 q
) t4 ?5 j$ K& i  b% N; ^) c: x. V红色部分是内循环，现在其内部操作都comment out 了, j0大概是 6000。
3 m' ]4 [0 }. X1 m$ @现在call xcorr 100次，耗时78s.
5 V0 h  d( I" V3 R* K
如果把红色部分内循环本身完全comment out， call xcorr 1000次，耗时 <1s.
, `5 Z) \6 Q/ _. q
# ^" Q( b+ [. j" r

雷达

风雨无阻 发表于 2022-9-24 23:33
& ^: [7 o- w7 P+ f( ?Maybe Debug mode?

不应该，看我上面的回复。
9 C& W. ?' X. @0 i7 P
我更怀疑是 VS 社区版的问题

数值分析

9 ]+ m. W, T4 a! ^0 T: ~

雷达 发表于 2022-9-24 23:54
& ?' ^1 I+ }& n1 Y4 `void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
/ y9 \$ b4 I0 h! q{
        comp temp, xtimesy;

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

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

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

雷达

数值分析 发表于 2022-9-25 00:20
$ L8 D8 R1 {, l( ~0 V这个不是这么比的吧。。。
) p9 @' o  l* q  i! X% [* {# N
您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。

. ]* P8 F+ T, _% E0 W
- J1 S6 ?2 x! ?/ L有道理。
所以存在内循环速度就上不去，把内循环取消，改成两个向量直接点乘再求和应该就会好得多，记得 numeric 库里有算向量内积的，我回头试试。

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

沉宝

雷达 发表于 2022-9-25 00:46
有道理。
' c" F9 R& N+ ~( |4 `所以存在内循环速度就上不去，把内循环取消，改成两个向量直接点乘再求和应该就会好得多，这大 ...

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

沉宝

数值分析 发表于 2022-9-25 00:20
% a) W( y/ \! h这个不是这么比的吧。。。

/ H: k" w, z/ S8 [( A您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。

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

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

数值分析

( |+ Y+ q0 x# q5 f& G# F: h

沉宝 发表于 2022-9-25 01:48
8 c- a2 }4 `! q, B现在的CPU，可以把判断、jmp和dec指令全部融合进一个µOp（微操作，CPU内部流水线上的执行单位）。如果 ...

. X" p6 x1 v- Y& X是的，兄台说的对。

: F* G8 y6 K& q其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。

雷达兄构造测试用例的时候，屏蔽掉了所有计算的部分，使得剩下的都是overhead，这样run time比较的结果就显得好像不合理了。如果把计算加回去，计算部分的run time会dominate，结果就不那么离谱了。因为不好说，所以用指令数对比的方式试图直观地说明这一点。
$ T9 y7 k3 C" I' m6 C9 u
比如说，如果有计算，那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做，另一边是六千个循环，那六千个循环比什么都不做慢几十倍了，就不是那么不合理了。
, C: N, O% z# q; f. ~
当然也有可能像兄台说的，是优化参数的问题，但我觉得更多地是测试用例设计的不合理。

雷达

, j1 x* @/ ]9 D3 _

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

" l0 K+ a! S$ M" |& o1 f* _$ g- O& s又写了个小实验，没有调用子函数，双层循环，外层6千次，内循环30万次空转，有或没有空转内循环，时间差一倍，我上面这个差的太多了。
; h" u& U7 O. G( P, F. p
) Y1 ~* M2 Y7 G- a我已经完全懵了。

沉宝

雷达 发表于 2022-9-25 04:47
9 u8 O" ]0 g2 x7 ^5 A. G0 _又写了个小实验，没有调用子函数，双层循环，外层6千次，内循环30万次空转，有或没有空转内循环，时间差 ...

* p- ^2 Z) r  |5 m9 V/ t时间差一倍的结果可以接受。

8 W7 g8 F: _6 Q你还是用profile工具看看吧。现在大家都主观瞎猜。

数值分析

. s& d# E9 V) ], H1 M9 I# ?

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

( Y0 l, |5 p0 H2 s. _$ P: K3 R( I
( q% f- `) T2 v  O  a
- x) D$ [. x4 i" }2 g4 r# }能不能把这个也贴上来，看看和上一个有什么不同？

雷达

3 r- H0 s. V( `2 q7 l

数值分析 发表于 2022-9-25 14:58
5 ~9 a0 u* e. O0 e能不能把这个也贴上来，看看和上一个有什么不同？

理了理思路，重新做了一个测试。
做了两个 vector 和 两个 float *, 都长 100000
: }& e3 J" y2 F2 J% Y6 f( E3 a外循环 6000，里面先做随机数生成，模拟真实环境，避免数据的 cache.
" f# L' W" A* ^* Z- _
内循环试了4种方法，
1. 直接调用 vector inner_product 247s
2. vector 循环点乘累加 237s
: B) F% c( @9 [, z3 C3. float * 循环点乘累加 204s
4. 空循环 100000 次 202s
! C& {' M# v1 z& }8 b% D
不做内循环 200s
7 X# _( j& n4 v' r
# e% W. D& }  ]* X& r7 z你昨天说的对，内循环本身占比是很小的，大头在其他处理。
+ L+ g! j9 p- {4 _1 j# D7 N另外可以看到， float * 循环点乘累加 并不差，比用vector 还更快。
- M# j- @1 i0 C! U. i% l' Z
; w  ~5 `7 K  w* U至于我那个原始程序，还有一些疑问，见5楼，其他都不变仅仅是有无空的内循环就有很大不同，这是不对的，也许有一些其他缺陷我没有看到。（也许可以改成 while 试试）
) g- g' F8 d! ?% ?4 ~' w& [
8 W% t$ A7 R" S8 O# k) k（为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ？方括号 i 消失了。 LOL . 改成  jj 好了，原来 方括号里的 i 是斜体标志  LOL）

        std::vector < float > vec1(N);
        std::vector < float > vec2(N);
7 ^! b" F6 C9 \0 ?% ~5 t        float* b1 = new float[N];
        float* b2 = new float[N];

        for (int j = 0; j < 6000; j++)
- \- t9 _2 [: d3 q- n        {
! v- m" [& {! R; j. i) Q1 Z- ]                std::generate(vec1.begin(), vec1.end(), []() {
& @4 a1 R3 I; I9 `% H' e0 s  \$ K                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;
- b6 r6 {# j9 S                        });

8 k; l: W# y8 X# D6 b( J8 W                std::generate(vec2.begin(), vec2.end(), []() {
                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;
                        });
: `& w: ]" i) a8 j& d8 k& d
                for (size_t jj = 0; jj < vec1.size(); jj++)
' V7 L" _% D3 G1 ^; |( Z- C( _                {
$ [2 v6 b- G9 O  N3 ~3 D                        b1[jj] = vec1[jj];
                }

3 t$ H4 @" l5 v; k) r8 Q                for (size_t jj = 0; jj < vec2.size(); jj++)
" q& C7 H/ R( H3 A3 C( C) J                {
: t! t" H0 |, M  W2 R: F                        b2[jj] = vec2[jj];
                }
8 t$ ]3 Y: \- V5 P
# w7 W5 d* n2 L+ X* o                //Method - 1  N=100000 247s  
- R& k2 s7 b* I, y" k4 K                //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);
' ]7 {0 r, O# i2 i2 N+ V9 n                                
                //Method - 2  N=100000  237s
                /*
6 ^6 b8 v' H% W2 o                for (int jj = 0; jj < N ; jj++)
/ s$ L) h! v4 H1 w                {
0 i8 I( H3 l! C* k0 X* }9 F( F4 N                        fresult += vec1[jj] * vec2[jj];
/ ^4 v$ V0 M8 j! J& c( v: L# [                }
                */
* N) e" x) d  a3 U2 a0 z) B                                
' |0 W+ b+ ?$ P$ {( v6 U( j                //Method - 3  N=100000 204s
& ?: ?0 B% b! ?( {' T                /*
7 H) o6 F0 k& ^3 }* A9 E1 X                for (int jj = 0; jj < N; jj++)
: O5 y/ k+ f9 x1 F" b2 I                {
                        fresult += b1[jj] * b2[jj];
                }
% h5 Z2 c" J1 j                */
0 P6 h) O0 ^* S0 w/ y% C4 J
                //Method - 4   202s
( V( T# Q5 e+ B* q                /*
                for (int jj = 0; jj < N; jj++)
                {
                        
( o8 l8 k  |. O' w7 R0 Y                }
6 N, i6 W8 `" H2 D2 q; D2 N" z                */
( _3 q0 H3 p+ h! E! z                //comment out all methods, N=100000  202s               
        }
' {6 G# u, w7 u  |) B
- v1 T+ o, C% x: @        delete []b1;
        delete []b2;

" }7 R7 r4 r: W4 c

机器猫

瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同？
# w! f% Z. O* W9 S! @
你第二个试验里面的j在循环里面又重新定义了啊，你确定真的跑了6000次？

雷达

机器猫 发表于 2022-9-27 00:15
( l8 d* Z6 D) O2 h瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同？

3 P/ N; U2 l0 `1 U$ Q7 O! L' ^你第二个试验里面的j在循环里面又重新定义 ...

内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
$ Y, y, Z0 C9 ~9 |
不和它较劲了，瞎耽误工夫，我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。

机器猫

雷达 发表于 2022-9-27 01:16
内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
9 x5 O, n3 i- ?7 e- {# Z+ l+ _: w
) h! g# ?$ j! g" z不和它 ...

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

opensrc

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

雷声

雷达 发表于 2022-9-24 23:54
void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
! a; B; L# m. m! H; V5 w4 {& j{
! P8 O1 ^: ^3 F        comp temp, xtimesy;

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