C++ 提速的新发现

雷达

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

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

8 z2 M7 m4 M+ r7 `9 c) q3 I+ g速度优化问题真的很有意思啊。

8 D) F1 c! [9 S% v4 n0 R欢迎大家继续讨论

数值分析

拉下来？拉多少？
6 P8 @/ Y  F8 {把代码贴上来看看？

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

沉宝

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

风雨无阻

Maybe Debug mode?

雷达

1 C. x9 d/ g& \

数值分析 发表于 2022-9-24 23:04
拉下来？拉多少？
把代码贴上来看看？

4 X' c# g5 r% ~- Lvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
( V5 P( }, ?( m, w{
        comp temp, xtimesy;
+ ~  J( i" m& I( g; B3 b        xtimesy.re = 0;
        xtimesy.im = 0;
        int j0 = lenB - 1;
        int    i, j, i1, reali;
        if (lenA % 2 == 1)
                reali = lenA + 1;
        else
7 R0 O  h1 _5 R! E% R0 d' ?" Y/ I# I                reali = lenA;
- I: L, @! Q( K4 g/ I8 b3 F        reali /= 2;
, ^1 s9 o: n1 E8 F" u
1 w% m% W: f' N) s3 Q        int nconv = reali + lenB;
        //#pragma omp parallel for
1 T- l3 o5 B+ P/ N0 g7 A' `& I: V        for (i = reali; i < nconv; i++)
+ n$ j& A/ X/ K5 i: U2 q        {
                temp.re = 0;
, m* A# W2 p4 C8 Q% n% G( X                temp.im = 0;
                i1 = i;
+ F: }1 s# _" g# ?% S+ k* @                for (j = j0; j >= 0; j--)
* O- q: {: e. w4 Y& P                {
* V0 T" i# u2 p" o/ {' i6 h2 ^                        /* floating date operation */
6 `* B6 v/ U" u' n% ?                }
0 ^- _" v( d$ s! m" c( V3 V& [        }
}

" N$ E6 j* s) f: ]$ y1 }. ], S1 ixcorr函数代码如上，comp是复数struct, 做过长度为11、19两个矢量的测试，和octave结果完全一样
) }: q& p7 k- ?; G; I
4 x) |' ~5 a# I; O4 M# G  }% Z红色部分是内循环，现在其内部操作都comment out 了, j0大概是 6000。
" O+ G/ c3 `3 O' |; I: @/ G现在call xcorr 100次，耗时78s.
8 I$ ]5 i/ z1 r- V0 d5 y
如果把红色部分内循环本身完全comment out， call xcorr 1000次，耗时 <1s.

雷达

风雨无阻 发表于 2022-9-24 23:33
Maybe Debug mode?

! b% |& R; \0 ^7 _不应该，看我上面的回复。

9 g) M0 ^" N# m我更怀疑是 VS 社区版的问题

数值分析

雷达 发表于 2022-9-24 23:54
void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
1 N# t9 u9 j8 e& `- |9 f; p{
        comp temp, xtimesy;

0 a) L2 ?" Z8 m; G/ d3 S/ _" Q这个不是这么比的吧。。。

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

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

雷达

7 T# e1 L1 w3 e( y- c9 o

数值分析 发表于 2022-9-25 00:20
3 H7 k" j( f/ y3 |* \7 r' w6 x这个不是这么比的吧。。。

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

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

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

沉宝

雷达 发表于 2022-9-25 00:46
+ f# P( k* Y, y$ r. d" g) O: |有道理。
4 C9 c' a8 P! @: l% x6 @所以存在内循环速度就上不去，把内循环取消，改成两个向量直接点乘再求和应该就会好得多，这大 ...

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

沉宝

数值分析 发表于 2022-9-25 00:20
/ H: T3 K+ [7 E这个不是这么比的吧。。。
- l9 K4 [5 E/ z0 f7 [9 c! |; m
您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。

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

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

数值分析

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

+ ]( C- F5 o# O" Y7 B* e
  a; F0 v0 M6 ~& M( ^是的，兄台说的对。

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

雷达兄构造测试用例的时候，屏蔽掉了所有计算的部分，使得剩下的都是overhead，这样run time比较的结果就显得好像不合理了。如果把计算加回去，计算部分的run time会dominate，结果就不那么离谱了。因为不好说，所以用指令数对比的方式试图直观地说明这一点。
+ q! g, }6 E8 ^: y( c* }
比如说，如果有计算，那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做，另一边是六千个循环，那六千个循环比什么都不做慢几十倍了，就不是那么不合理了。
' m/ X& N7 ^1 ^7 F: y5 N
当然也有可能像兄台说的，是优化参数的问题，但我觉得更多地是测试用例设计的不合理。

雷达

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

! }+ q, t- q% E. d
又写了个小实验，没有调用子函数，双层循环，外层6千次，内循环30万次空转，有或没有空转内循环，时间差一倍，我上面这个差的太多了。
/ I3 p( O: Y: Z4 G3 Y
; e; ?- d( K: q, n我已经完全懵了。

沉宝

雷达 发表于 2022-9-25 04:47
, e0 E0 ]2 O2 j  k2 B; m) X又写了个小实验，没有调用子函数，双层循环，外层6千次，内循环30万次空转，有或没有空转内循环，时间差 ...

" ^/ B0 v( r) @! X' h1 ]3 p时间差一倍的结果可以接受。
. Z: S; g. [$ ~
) |, X+ H) y4 v6 a3 ?4 n$ h3 n' X  o你还是用profile工具看看吧。现在大家都主观瞎猜。

数值分析

9 i9 b8 L3 _/ u3 I

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

$ K, {' j1 E) I0 c4 j

6 ]7 |, f$ ~- y3 @
" }8 x& H! X7 [能不能把这个也贴上来，看看和上一个有什么不同？

雷达

, ~, ?) h2 f/ c- V- S

数值分析 发表于 2022-9-25 14:58
+ ]8 e' x0 l9 x+ S& U9 ]能不能把这个也贴上来，看看和上一个有什么不同？

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

内循环试了4种方法，
8 u- O4 I5 t5 D1. 直接调用 vector inner_product 247s
" U1 k, Z  |4 X8 H! I4 `4 G: j( j2. vector 循环点乘累加 237s
6 t7 c9 J; a, t) E3. float * 循环点乘累加 204s
0 d6 ^: D6 p. |1 y9 }. J4. 空循环 100000 次 202s
& u8 s* g1 \3 z6 y* b
不做内循环 200s
- A9 T* P/ M# _) j# g% d1 l
' ?) ~: I$ s& B你昨天说的对，内循环本身占比是很小的，大头在其他处理。
3 G- X: N$ \" a; }另外可以看到， float * 循环点乘累加 并不差，比用vector 还更快。
4 e4 y" z6 V. Y- b" S. [
至于我那个原始程序，还有一些疑问，见5楼，其他都不变仅仅是有无空的内循环就有很大不同，这是不对的，也许有一些其他缺陷我没有看到。（也许可以改成 while 试试）

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

: e$ m% B, w; \6 ~

        std::vector < float > vec1(N);
        std::vector < float > vec2(N);
        float* b1 = new float[N];
: T4 a& A5 K9 d7 ~8 q0 b        float* b2 = new float[N];

        for (int j = 0; j < 6000; j++)
5 K" h3 Y" ], m  M2 g9 Z        {
$ w, ?( y6 p% E/ S                std::generate(vec1.begin(), vec1.end(), []() {
2 ]4 c) M7 J( _8 |. ~2 W                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;
                        });
8 w; v: n: W3 x% |
7 y8 l) S8 ], B# Y- E: L- n/ @                std::generate(vec2.begin(), vec2.end(), []() {
4 o$ \7 Q% V0 P- v                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;
                        });
# B/ a5 T- F- ^2 C7 {
                for (size_t jj = 0; jj < vec1.size(); jj++)
, i2 v7 d2 m& a' ?- D) s; u5 W1 U                {
4 R" A. g  j! o                        b1[jj] = vec1[jj];
/ ~7 S. l( D0 C                }
4 F; D- q0 `% P) O. s
, K, H# t/ b  d5 _+ k                for (size_t jj = 0; jj < vec2.size(); jj++)
                {
                        b2[jj] = vec2[jj];
$ @- W+ I( k7 A$ H: K, Y                }

                //Method - 1  N=100000 247s  
                //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);
( O4 [4 R9 {, m                                
. a5 ?4 Q8 v5 V+ X                //Method - 2  N=100000  237s
                /*
9 K( s& Y; d( @; z                for (int jj = 0; jj < N ; jj++)
                {
                        fresult += vec1[jj] * vec2[jj];
8 v8 b6 e$ U0 j9 L                }
                */
                                
                //Method - 3  N=100000 204s
                /*
                for (int jj = 0; jj < N; jj++)
                {
0 ]$ q& Y! a7 y: w- X4 O' `: w5 }                        fresult += b1[jj] * b2[jj];
                }
                */
, f* `( r3 i# j" j5 j
. t, P3 K" J+ `% z# H                //Method - 4   202s
4 p; i: v# R4 Y* p" G. X) I                /*
                for (int jj = 0; jj < N; jj++)
5 Y' y( Y! [' F                {
                        
( c3 w1 {% {9 G( U3 N! n                }
9 L! K. e/ K0 _                */
                //comment out all methods, N=100000  202s               
1 K" ^, ^4 O: Z8 W: B        }
+ u  M3 m, G, O3 R8 r6 E
. d6 F3 u8 h5 d. R  n        delete []b1;
        delete []b2;

机器猫

瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同？
, w2 d1 t' l0 z
你第二个试验里面的j在循环里面又重新定义了啊，你确定真的跑了6000次？

雷达

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

3 l9 D5 {4 v# Z9 x' _; e你第二个试验里面的j在循环里面又重新定义 ...

: q2 z' {$ F9 A. {' S内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
, D9 \" l1 h( u$ Y
不和它较劲了，瞎耽误工夫，我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。

机器猫

雷达 发表于 2022-9-27 01:16
内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
& ?6 {0 U7 c2 h9 K- U4 n0 @
; L" D0 z) ], q! Y# Z3 x不和它 ...

6 d5 n) |. w' D' A4 T
不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的，很有可能是在stack上，这样内存读写会更多，要是再碰上每次都需要加载cache就更慢了。
3 S: ]8 T7 V" |: D0 O$ C后面一个是在循环那里定义的，说不定编译器就把它优化成register变量了

opensrc

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

雷声

雷达 发表于 2022-9-24 23:54
1 h7 l7 |4 ~! L$ r+ J( a7 Qvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
1 B) Z7 Y+ z8 Z1 X& w{
        comp temp, xtimesy;

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