C++ 提速的新发现

雷达

C++ 比 Octave 慢好多，怎么破？
! B: W: D0 N+ Q% e$ X" N5 X
- q/ N# o* Z4 L, C0 f自相关两层循环，内层循环涉及浮点数计算，试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了，看来问题并不在浮点计算。

4 D8 C! S' }# f) @1 n* N速度优化问题真的很有意思啊。

欢迎大家继续讨论

数值分析

拉下来？拉多少？
% @, c4 n: i( V* ^# w6 q把代码贴上来看看？
9 F2 z* N* h, g* i/ h/ k7 T( X
难道分支预测不准破坏流水线执行？不该啊。

沉宝

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

风雨无阻

Maybe Debug mode?

雷达

数值分析 发表于 2022-9-24 23:04
2 \  j& O  O4 `8 S8 x% X拉下来？拉多少？
. R# r# H8 n) F# d% l2 O7 {" {把代码贴上来看看？

" N' E' c1 o+ B- K, u6 |0 d$ o) t
void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
- @# w$ Y' M2 ~! g! C{
% s, R5 n, u6 ?9 c        comp temp, xtimesy;
        xtimesy.re = 0;
% Y* W0 M& X. |        xtimesy.im = 0;
% U' _( X# `- E7 U  j) m1 Y        int j0 = lenB - 1;
0 C3 C, [$ P$ @% a5 W9 g5 R        int    i, j, i1, reali;
        if (lenA % 2 == 1)
4 `- I1 C, a- m- ^/ `; |6 w3 ~4 k                reali = lenA + 1;
        else
, c% s* O1 ?  V9 b' o" B( |                reali = lenA;
8 w) u) y5 k; r6 h# ]& v        reali /= 2;
+ _9 Y( |) n, [; Q# O
        int nconv = reali + lenB;
        //#pragma omp parallel for
( _/ P1 M, F$ j; S" Q        for (i = reali; i < nconv; i++)
8 o  J% |4 |# \8 N3 w        {
" w; }9 r/ r7 L$ m3 N- j                temp.re = 0;
# ~7 U7 r8 D; ~4 I' y& |* P) ^- v                temp.im = 0;
                i1 = i;
                for (j = j0; j >= 0; j--)
                {
1 Q3 @$ m/ z% g" U% v7 \+ o                        /* floating date operation */
                }
9 N/ F( O) d& I- m        }
* T& ]# y+ ]: B( [}

  a) d7 c3 z% }' c; @xcorr函数代码如上，comp是复数struct, 做过长度为11、19两个矢量的测试，和octave结果完全一样

红色部分是内循环，现在其内部操作都comment out 了, j0大概是 6000。
; a' d- N! u: j8 U( n现在call xcorr 100次，耗时78s.
% x& ]& j+ X& @+ V! {# ~, \. `
如果把红色部分内循环本身完全comment out， call xcorr 1000次，耗时 <1s.

9 V+ u+ G4 G- s$ e% V( W9 S

雷达

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

不应该，看我上面的回复。
/ r: R6 }: F6 z. ~! G
+ i$ f: s; N/ q0 n( X; w3 A我更怀疑是 VS 社区版的问题

数值分析

  n  n9 [2 t, P0 j1 f. F# V

雷达 发表于 2022-9-24 23:54
* w0 \% j" D" v3 @( Yvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
4 ?" U! n& W. G+ N- S" S{
% u! N: B! m" J: W, X1 I3 p6 f        comp temp, xtimesy;

9 S2 b$ M! \' A5 J+ k$ d
( n9 f- o. f7 g- {这个不是这么比的吧。。。

您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。
$ d/ B1 `' ^% f
而加上内循环，光jmp和dec指令就至少多执行了6000个，慢个几十倍不是正常的么？

雷达

  y  g: E) C1 F9 A

数值分析 发表于 2022-9-25 00:20
这个不是这么比的吧。。。
) Q: Z. |+ h( U- y
+ c7 ?& c& C8 l$ ?您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。

有道理。
5 t/ \" R9 E; V所以存在内循环速度就上不去，把内循环取消，改成两个向量直接点乘再求和应该就会好得多，记得 numeric 库里有算向量内积的，我回头试试。
/ {* i& ?8 H" ?; O5 G7 H: R- \
! t4 b6 _$ z! i! R我先尝试尽量用标准库，一个小程序，不想搞得太复杂。多谢了

沉宝

雷达 发表于 2022-9-25 00:46
0 k5 V6 k  r* L有道理。
$ V$ [, `* f9 \4 A+ S9 E* X: J所以存在内循环速度就上不去，把内循环取消，改成两个向量直接点乘再求和应该就会好得多，这大 ...

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

沉宝

数值分析 发表于 2022-9-25 00:20
这个不是这么比的吧。。。
& d4 s  K. ^  C
您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。

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

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

数值分析

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

) h; M. d3 s4 x% z; s
  \7 N9 S4 |" V是的，兄台说的对。
" U2 }* ^0 y) T
. S3 y5 B7 [) S: j  r: Z# X3 `其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。

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

& _* p, L% a* l2 t% G+ i& C( O比如说，如果有计算，那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做，另一边是六千个循环，那六千个循环比什么都不做慢几十倍了，就不是那么不合理了。
; U; O) K% K, ~% F
" B5 }; W) A- q0 d, W; ?3 {当然也有可能像兄台说的，是优化参数的问题，但我觉得更多地是测试用例设计的不合理。

雷达

  X4 a1 ?" r) Q+ U( J0 T

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

6 f" B# |2 p2 W$ S+ L! c
, i3 W  g* j4 M9 v5 C) i9 G又写了个小实验，没有调用子函数，双层循环，外层6千次，内循环30万次空转，有或没有空转内循环，时间差一倍，我上面这个差的太多了。

$ L' N. z( {3 ?4 x5 J* `我已经完全懵了。

沉宝

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

时间差一倍的结果可以接受。
0 d* `7 u( T7 h; l3 r8 F# x: G7 ^
. Z0 g# Y6 B9 R你还是用profile工具看看吧。现在大家都主观瞎猜。

数值分析

雷达 发表于 2022-9-25 04:47
  @) ~9 z  h0 A3 E. m& n. o: d: k又写了个小实验，没有调用子函数，双层循环，外层6千次，内循环30万次空转，有或没有空转内循环，时间差 ...

+ `& Q- r/ [$ r8 ?
9 p; ?$ N$ N; o
- i- C7 k+ d7 F. T: D6 @4 W! P
/ C( N) ~/ O- j+ Y能不能把这个也贴上来，看看和上一个有什么不同？

雷达

$ U3 `7 a' M1 _$ e& I' j

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

理了理思路，重新做了一个测试。
6 ]9 x/ q1 @! D7 P+ L) r做了两个 vector 和 两个 float *, 都长 100000
外循环 6000，里面先做随机数生成，模拟真实环境，避免数据的 cache.
1 \) R( t2 C8 I5 x
内循环试了4种方法，
1. 直接调用 vector inner_product 247s
2. vector 循环点乘累加 237s
" R8 {2 h; j: L  q6 f* [3. float * 循环点乘累加 204s
. f- q: i5 i* {3 d' \$ D4. 空循环 100000 次 202s
# f1 {) `' X& t: ^& r4 z) R% z
( i/ x& V2 i- g5 f1 s9 Y不做内循环 200s
. ^3 P8 L* m7 J  d5 D( g8 g
你昨天说的对，内循环本身占比是很小的，大头在其他处理。
/ N9 n% Q, r8 |, c; R另外可以看到， float * 循环点乘累加 并不差，比用vector 还更快。

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

5 c: H+ r3 o# M, h（为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ？方括号 i 消失了。 LOL . 改成  jj 好了，原来 方括号里的 i 是斜体标志  LOL）
* h- a7 s( X  t+ g9 y! \
* `' N- s( Q( L3 z! r

        std::vector < float > vec1(N);
        std::vector < float > vec2(N);
        float* b1 = new float[N];
4 b: f9 c: O4 u, m* o6 Y& O1 b        float* b2 = new float[N];
$ D/ e7 G% e7 z! M( C8 i' H
        for (int j = 0; j < 6000; j++)
        {
- P' U. l+ T4 f0 h2 Z                std::generate(vec1.begin(), vec1.end(), []() {
5 R6 ?' L6 D9 T. |* V0 J! B9 ~! g                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;
                        });
9 q" `0 ]7 z5 [: f* _. _
1 Z0 I# P9 `) {) }7 Y                std::generate(vec2.begin(), vec2.end(), []() {
                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;
$ M* c9 g! Q. a0 G                        });
' D# e  n: d+ J* f5 S, P9 `6 R
3 q, k. _( G7 J8 V. O. F$ t                for (size_t jj = 0; jj < vec1.size(); jj++)
                {
                        b1[jj] = vec1[jj];
                }

                for (size_t jj = 0; jj < vec2.size(); jj++)
4 `2 k4 O3 t1 p/ }                {
                        b2[jj] = vec2[jj];
. t5 N1 G- @; Q7 Z0 K$ k                }

                //Method - 1  N=100000 247s  
' h3 S& d  m5 l+ U                //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);
                                
                //Method - 2  N=100000  237s
                /*
                for (int jj = 0; jj < N ; jj++)
( }  ~, x2 u0 f- F, m; e, a                {
                        fresult += vec1[jj] * vec2[jj];
                }
1 M* [3 v1 l. a6 W                */
: ^3 w0 q5 a2 L& c- E7 p$ J                                
+ G% d+ c  z$ j; v+ r6 `  O                //Method - 3  N=100000 204s
% f# _9 W' c# K: Y. |- ~. Z                /*
9 Y% s2 q; e. E- @                for (int jj = 0; jj < N; jj++)
                {
0 T5 g  |2 O. k0 L                        fresult += b1[jj] * b2[jj];
( H  n; F8 S1 {/ q                }
                */
( u, J. B2 J, O( P3 v( ?
5 M7 b& ^/ ^$ K- D                //Method - 4   202s
                /*
5 i( f  o/ l) b! U                for (int jj = 0; jj < N; jj++)
                {
                        
. b' F! ~, O$ \+ b                }
                */
                //comment out all methods, N=100000  202s               
        }

        delete []b1;
        delete []b2;

7 U* x4 j) L) U1 H( N4 S- C, p

机器猫

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

& }5 Q$ z+ h' A. J  _9 P你第二个试验里面的j在循环里面又重新定义了啊，你确定真的跑了6000次？
" t6 h. C6 z9 B( Z3 b& n

雷达

机器猫 发表于 2022-9-27 00:15
7 B. J( S/ l9 t6 O* A& B瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同？

& F, B2 m0 S* N6 ~. F' R' W你第二个试验里面的j在循环里面又重新定义 ...

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

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

机器猫

雷达 发表于 2022-9-27 01:16
( U+ Q( y: }) r9 N2 E内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
: q! H5 f8 `/ h  p
" I, b7 J  e) n. N2 B不和它 ...

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

opensrc

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

雷声

雷达 发表于 2022-9-24 23:54
" Q# \5 `5 C8 evoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
{
        comp temp, xtimesy;

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