C++ 提速的新发现

雷达

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

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

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

; e3 Z2 @# t/ P0 _+ T% Y欢迎大家继续讨论

数值分析

拉下来？拉多少？
3 o/ b; T8 X- s! f把代码贴上来看看？

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

沉宝

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

风雨无阻

Maybe Debug mode?

雷达

3 J% v6 K. p  C! x, G0 |0 Q

数值分析 发表于 2022-9-24 23:04
. |) |0 j; b; ~: {) N$ E$ c拉下来？拉多少？
, X" J5 y5 k$ [( m+ C+ Q2 X把代码贴上来看看？

8 H8 k1 U: |3 N2 ?/ X
( [& [  r% K2 Z! O1 G# T: ]void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
% X% R# Q- G, Z7 T4 @{
        comp temp, xtimesy;
        xtimesy.re = 0;
        xtimesy.im = 0;
        int j0 = lenB - 1;
        int    i, j, i1, reali;
1 ]3 W1 p' h9 v0 a& j* U9 K        if (lenA % 2 == 1)
+ L9 ~# [9 {# P& Z* x                reali = lenA + 1;
        else
. H3 M  d- s3 b+ ?* J) I  h: J1 T$ k                reali = lenA;
5 X( ]3 u. i* ?        reali /= 2;

        int nconv = reali + lenB;
        //#pragma omp parallel for
        for (i = reali; i < nconv; i++)
5 A4 ^( N5 A5 w3 a  d        {
& ?6 H* m* x" o& S                temp.re = 0;
, h# Z; t: }9 C+ F                temp.im = 0;
4 ^' ^$ i2 x0 ]% H/ Q  L, o: K9 d                i1 = i;
" {' s1 c' C0 B) z% x8 C                for (j = j0; j >= 0; j--)
& {& e, x/ j; d9 V; E                {
                        /* floating date operation */
& W5 F! k# B( B                }
        }
}
( x% Q: i$ ^$ K3 b
: n5 A# g% Z7 d+ ?2 A2 ]xcorr函数代码如上，comp是复数struct, 做过长度为11、19两个矢量的测试，和octave结果完全一样

红色部分是内循环，现在其内部操作都comment out 了, j0大概是 6000。
现在call xcorr 100次，耗时78s.
+ [) n' N* V6 E9 N- }& O
如果把红色部分内循环本身完全comment out， call xcorr 1000次，耗时 <1s.

雷达

风雨无阻 发表于 2022-9-24 23:33
1 C, s: T3 s6 A0 E/ u. cMaybe Debug mode?

' K: T3 d7 n' T# e& ?0 t' o
不应该，看我上面的回复。

" h4 t# e- o7 N我更怀疑是 VS 社区版的问题

数值分析

雷达 发表于 2022-9-24 23:54
void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
{
        comp temp, xtimesy;

" K/ \' Q% Y2 N7 i2 F* @# U这个不是这么比的吧。。。
8 T: m4 z2 q5 @6 y4 N5 _0 T
您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。

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

雷达

+ a3 I$ H! X/ ~8 S* W

数值分析 发表于 2022-9-25 00:20
这个不是这么比的吧。。。

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

9 {* \7 f5 G; N/ B3 S& J- g
有道理。
所以存在内循环速度就上不去，把内循环取消，改成两个向量直接点乘再求和应该就会好得多，记得 numeric 库里有算向量内积的，我回头试试。
6 m. n; g- F/ b; s9 |+ d' m
我先尝试尽量用标准库，一个小程序，不想搞得太复杂。多谢了

沉宝

雷达 发表于 2022-9-25 00:46
有道理。
6 s" e% B/ V5 P2 F' j+ K1 R) }所以存在内循环速度就上不去，把内循环取消，改成两个向量直接点乘再求和应该就会好得多，这大 ...

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

沉宝

数值分析 发表于 2022-9-25 00:20
% D' R# ^- J' }  W( m这个不是这么比的吧。。。

* M( n' L3 F0 X5 |您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。

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

* u8 t2 \$ _7 M, a. ^) x4 H
现在的CPU，可以把判断、jmp和dec指令全部融合进一个µOp（微操作，CPU内部流水线上的执行单位）。如果循环这样跑，花不了多少时间。

数值分析

. ~& `; Z# `) L1 c, U7 h( C/ e

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

  h+ z! A9 y6 R0 _6 q
, @9 U8 I/ L7 s2 X/ s+ y4 J是的，兄台说的对。
+ `( ?' S+ E/ j% e) _
其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。

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

比如说，如果有计算，那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做，另一边是六千个循环，那六千个循环比什么都不做慢几十倍了，就不是那么不合理了。
2 ^* q, f# w& G
* h! f6 P# Z$ M. Q, @当然也有可能像兄台说的，是优化参数的问题，但我觉得更多地是测试用例设计的不合理。

雷达

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

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

我已经完全懵了。

沉宝

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

8 g0 f3 `7 L& L3 B' t+ p时间差一倍的结果可以接受。

) N# U( P  }* L$ ?) C! E你还是用profile工具看看吧。现在大家都主观瞎猜。

数值分析

" a. L- ?. K5 M+ z  U4 `/ F: d

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

. q; M+ }. y1 C9 M能不能把这个也贴上来，看看和上一个有什么不同？

雷达

2 U  O2 I/ }' G, t# c* D

数值分析 发表于 2022-9-25 14:58
4 f2 |, `! F, `5 y1 }9 v- ~能不能把这个也贴上来，看看和上一个有什么不同？

" N1 W9 H" @8 ^% X% k* f5 U8 n理了理思路，重新做了一个测试。
( \4 K8 }5 f! ]" f- r做了两个 vector 和 两个 float *, 都长 100000
# z$ o& i5 l( Q" q% V外循环 6000，里面先做随机数生成，模拟真实环境，避免数据的 cache.
7 ^7 O8 u1 R. D7 ]  W
内循环试了4种方法，
1. 直接调用 vector inner_product 247s
2. vector 循环点乘累加 237s
, ]# u  [7 r+ |0 A' W9 h3. float * 循环点乘累加 204s
4. 空循环 100000 次 202s

$ M9 B: `- ]' z不做内循环 200s
  O7 J/ H' S0 [0 q% j. @
你昨天说的对，内循环本身占比是很小的，大头在其他处理。
另外可以看到， float * 循环点乘累加 并不差，比用vector 还更快。
# N0 u* |# z" P. y
至于我那个原始程序，还有一些疑问，见5楼，其他都不变仅仅是有无空的内循环就有很大不同，这是不对的，也许有一些其他缺陷我没有看到。（也许可以改成 while 试试）

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

        std::vector < float > vec1(N);
        std::vector < float > vec2(N);
        float* b1 = new float[N];
        float* b2 = new float[N];
9 V/ P, B' ^5 _7 ~3 r8 Z
: }9 l3 z/ ?' D3 H; _7 T9 w# I        for (int j = 0; j < 6000; j++)
6 r1 K  f8 z- N! P1 N8 g        {
9 G% C2 @7 o4 E0 c                std::generate(vec1.begin(), vec1.end(), []() {
                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;
                        });

                std::generate(vec2.begin(), vec2.end(), []() {
                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;
                        });
# T& p* ?! C; P( D, G9 Q
                for (size_t jj = 0; jj < vec1.size(); jj++)
) z2 A, ]1 ^0 m6 H" ~                {
                        b1[jj] = vec1[jj];
$ P- a- X3 @+ ^5 P& x/ P2 ^) E: A                }
1 O& [/ N  T0 p  D# g3 H* D
+ W' Q/ a8 y5 c! C/ W# B. d4 R                for (size_t jj = 0; jj < vec2.size(); jj++)
( x5 j  \9 E2 x. @* v8 Z                {
                        b2[jj] = vec2[jj];
                }
3 M7 `- {: h# P$ t% S( _2 f
7 \$ O8 W  w' Y7 M                //Method - 1  N=100000 247s  
                //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);
0 Z/ Y2 m& x; o8 @                                
                //Method - 2  N=100000  237s
                /*
( k5 o* e* ~+ ~  z- f3 _8 x* ^9 U                for (int jj = 0; jj < N ; jj++)
                {
( J9 o8 E; w7 C; Q, o                        fresult += vec1[jj] * vec2[jj];
                }
                */
6 @1 ^" m4 _3 ~4 _" T) y& R                                
                //Method - 3  N=100000 204s
' }0 r" w: j' X                /*
% \, `" N: @1 l                for (int jj = 0; jj < N; jj++)
. c7 C) D  O% O- }5 Y$ ~7 f1 x                {
                        fresult += b1[jj] * b2[jj];
                }
7 [6 e+ S# g! q( c                */

                //Method - 4   202s
                /*
                for (int jj = 0; jj < N; jj++)
; ]$ F# g' E; a# d, |* Q                {
                        
                }
2 @  b! R& L3 C                */
$ W* b2 A6 K7 n2 b2 F                //comment out all methods, N=100000  202s               
        }
4 n, s) H% |$ p/ t
: G9 f4 X! d" y( E3 f" s0 \7 U* [  I        delete []b1;
7 }5 h8 [$ J( i# K& w        delete []b2;

. K9 F+ n: n( O8 \, |

机器猫

瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同？
/ j* k+ V1 A. a3 w- C: Y8 k
你第二个试验里面的j在循环里面又重新定义了啊，你确定真的跑了6000次？
( ^8 S5 R" r5 |

雷达

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

你第二个试验里面的j在循环里面又重新定义 ...

( l7 _2 q+ B% ]1 t4 D: ?内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL

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

机器猫

雷达 发表于 2022-9-27 01:16
1 s3 W4 v2 W/ O  u  |内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
, k- V/ s$ K: Z6 A8 p
不和它 ...

2 N0 C! m5 U1 q: q; b5 I
6 ~. D5 ~0 Z% V4 m# [不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的，很有可能是在stack上，这样内存读写会更多，要是再碰上每次都需要加载cache就更慢了。
后面一个是在循环那里定义的，说不定编译器就把它优化成register变量了

opensrc

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

雷声

雷达 发表于 2022-9-24 23:54
void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
" R/ U) `; h5 _, \- W+ @! i) ^{
        comp temp, xtimesy;

, _, m9 q4 K' b- ]7 A& x这个code里面如果Openmp没有被注释掉的话，那么temp那个变量应该是定义在循环里面，否则线程之间会存在争夺写入那个temp的风险。
: R' d' }: C0 Z# d* x内层for循环如果没有内部操作的话，编译时应该被优化掉了，和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化？
3 k" y& F; X  `2 H; c4 JVS社区版没有问题，我工作用的就是社区版，设置正常的话不会比商业版差。以前游说头头用Intel Compiler，他说不想花钱，而且差不了多少，就一直用到现在。