C++ 提速的新发现

雷达

C++ 比 Octave 慢好多，怎么破？
- k7 S, ~! g  T  o- R! {
4 w7 U( N! W  C6 E5 B- B自相关两层循环，内层循环涉及浮点数计算，试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了，看来问题并不在浮点计算。

% `# a0 A. U( o% E1 D3 ]$ w速度优化问题真的很有意思啊。

欢迎大家继续讨论

数值分析

拉下来？拉多少？
把代码贴上来看看？
. ^) C% d, X3 Q+ z5 E
$ h0 `) ~) h% ?' J/ }- A! T$ a难道分支预测不准破坏流水线执行？不该啊。

沉宝

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

风雨无阻

Maybe Debug mode?

雷达

数值分析 发表于 2022-9-24 23:04
' L& V7 K+ G# B( v/ v. o拉下来？拉多少？
, ~+ d2 ?3 i; `6 ~把代码贴上来看看？

void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
0 P" h& A( D, I; _9 k' j* q( e{
# Q" Z1 F7 _6 R4 H' N! B" G( Q. P        comp temp, xtimesy;
$ h8 W. ]8 @+ m) |  N        xtimesy.re = 0;
        xtimesy.im = 0;
5 o5 D, K0 B3 {% @# }* ]        int j0 = lenB - 1;
; Q. J; p! O3 R# ?3 B        int    i, j, i1, reali;
        if (lenA % 2 == 1)
! P6 p7 x( T+ z. P# e                reali = lenA + 1;
        else
2 |7 [4 _/ j! b. Z                reali = lenA;
: R9 {/ X4 X6 x0 C7 U- K- @2 o        reali /= 2;
; D; q$ V. Y- R& {2 O
5 P5 k* a$ j- ~        int nconv = reali + lenB;
/ ^' g3 ?* f/ Z. p( B6 g        //#pragma omp parallel for
$ K$ [1 M6 A- e; X# _* H        for (i = reali; i < nconv; i++)
        {
                temp.re = 0;
$ f6 x/ `2 m* N* J7 I# M8 W                temp.im = 0;
                i1 = i;
) e) N  z1 a: g0 Q$ l0 R# X- o& A                for (j = j0; j >= 0; j--)
+ l( z& I3 {: N1 r/ {                {
                        /* floating date operation */
# f  u/ j: G0 b2 b$ `1 K. i$ P3 N                }
/ y( V3 u& W( o0 M- e        }
+ ]3 g1 k+ s+ d6 i% ?+ J}

xcorr函数代码如上，comp是复数struct, 做过长度为11、19两个矢量的测试，和octave结果完全一样
! j: P. I" n3 k) \* B1 Q7 `
红色部分是内循环，现在其内部操作都comment out 了, j0大概是 6000。
4 D) k' o' h3 O: k现在call xcorr 100次，耗时78s.

8 q$ d* Q. E% H3 B如果把红色部分内循环本身完全comment out， call xcorr 1000次，耗时 <1s.

雷达

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

  N0 a6 Z5 h3 \; B# `
3 m( i* E( q: i不应该，看我上面的回复。
/ |5 J: X/ ]# B
, \& x6 [) r& l# |( y我更怀疑是 VS 社区版的问题

数值分析

雷达 发表于 2022-9-24 23:54
* f5 S) S/ M# O% ]void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
{
+ b+ _! o3 D. I        comp temp, xtimesy;

1 H  k0 H1 w5 g8 R% F+ f! }
这个不是这么比的吧。。。
4 p+ z9 T7 a) Z# X! b
& G. V$ n- r" R  }) [6 v您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。

" s" P1 _; T. Y! D; B  `+ U而加上内循环，光jmp和dec指令就至少多执行了6000个，慢个几十倍不是正常的么？

雷达

数值分析 发表于 2022-9-25 00:20
& O0 k+ z; @! X) A3 p# |8 B5 `这个不是这么比的吧。。。
' |- d% r' ~1 w8 G
! t7 C, o# [  ?您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。

+ a! P5 X) a/ R
有道理。
! Z' }; S1 k" _1 X5 [+ }$ z所以存在内循环速度就上不去，把内循环取消，改成两个向量直接点乘再求和应该就会好得多，记得 numeric 库里有算向量内积的，我回头试试。

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

沉宝

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

% L# k2 b4 `9 ?: b% y% c7 t# S你两个试验之间就差了一个空循环， call 1000次按理不会有秒级差异，可能还是编译器优化的问题。举个例子，把循环本身翻译成机器指令loop或dec/jnz，两者速度上会差很多
3 s0 H5 q( I, Z+ ~' @) fWhy is the loop instruction slow? Couldn't Intel have implemented it efficiently?

沉宝

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

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

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

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

数值分析

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

/ @# m& Y( y- y" e; o1 @$ Q是的，兄台说的对。

( a- D' w; ~# l! X; @! i9 |" `$ P, M其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。

雷达兄构造测试用例的时候，屏蔽掉了所有计算的部分，使得剩下的都是overhead，这样run time比较的结果就显得好像不合理了。如果把计算加回去，计算部分的run time会dominate，结果就不那么离谱了。因为不好说，所以用指令数对比的方式试图直观地说明这一点。
8 ]5 R1 I( c2 \
# x0 x2 l+ a4 W" N比如说，如果有计算，那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做，另一边是六千个循环，那六千个循环比什么都不做慢几十倍了，就不是那么不合理了。
1 X4 m4 G( k. C( @' o0 |* R
( N7 @- e0 g$ J+ }当然也有可能像兄台说的，是优化参数的问题，但我觉得更多地是测试用例设计的不合理。

雷达

- M5 s8 I8 D" E, H" W) @7 f3 s

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

  |1 D8 H% A) f! v3 r( Q
/ N' o* [. l- M7 R$ S2 p又写了个小实验，没有调用子函数，双层循环，外层6千次，内循环30万次空转，有或没有空转内循环，时间差一倍，我上面这个差的太多了。

我已经完全懵了。

沉宝

雷达 发表于 2022-9-25 04:47
* O  h# v# A$ p: D  l% m- U又写了个小实验，没有调用子函数，双层循环，外层6千次，内循环30万次空转，有或没有空转内循环，时间差 ...

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

你还是用profile工具看看吧。现在大家都主观瞎猜。

数值分析

; G. j1 t7 V% U8 h7 V

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

! s; K% l5 M  {# u- X3 P7 z

能不能把这个也贴上来，看看和上一个有什么不同？

雷达

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

% o+ R( O  P; w( n理了理思路，重新做了一个测试。
, ^. r; g: m4 e' d! z- M做了两个 vector 和 两个 float *, 都长 100000
外循环 6000，里面先做随机数生成，模拟真实环境，避免数据的 cache.

) f/ O1 n* U  a9 o内循环试了4种方法，
1. 直接调用 vector inner_product 247s
2. vector 循环点乘累加 237s
3. float * 循环点乘累加 204s
' y0 `. b6 V* t; N3 ^, i4. 空循环 100000 次 202s
+ b2 z- F. I7 j
不做内循环 200s

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

* L  x/ F; |' h至于我那个原始程序，还有一些疑问，见5楼，其他都不变仅仅是有无空的内循环就有很大不同，这是不对的，也许有一些其他缺陷我没有看到。（也许可以改成 while 试试）
) d% D. f# i& U. a
" q: G- ?2 r. e% S/ Z; x5 t（为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ？方括号 i 消失了。 LOL . 改成  jj 好了，原来 方括号里的 i 是斜体标志  LOL）

        std::vector < float > vec1(N);
        std::vector < float > vec2(N);
, s. o' R& h( R; t4 }/ s7 ~        float* b1 = new float[N];
* l! N* b' ~9 \7 E# A4 a2 C        float* b2 = new float[N];

+ }, c0 v4 M! S0 v+ B! D        for (int j = 0; j < 6000; j++)
8 E/ y; e1 x7 K/ c# N) k+ A, \        {
                std::generate(vec1.begin(), vec1.end(), []() {
. R: M" i4 i* K# [7 Q                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;
                        });

                std::generate(vec2.begin(), vec2.end(), []() {
- t  j* b7 h9 x7 h, @& H                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;
                        });
: R' \/ B. b' V( H% D6 E- V6 Y
                for (size_t jj = 0; jj < vec1.size(); jj++)
                {
                        b1[jj] = vec1[jj];
                }

8 S' s7 b# f  W% B/ S- f5 Q+ o                for (size_t jj = 0; jj < vec2.size(); jj++)
/ O$ e! t  `/ D                {
                        b2[jj] = vec2[jj];
4 N: Q9 y2 T1 g, O. g, Y                }
# w# N+ ^% i' L- }4 k
                //Method - 1  N=100000 247s  
                //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);
2 O8 J. R+ y- L% ]* N                                
                //Method - 2  N=100000  237s
2 E$ @( a8 A, e# M9 G$ o                /*
1 Q! w7 f" y9 a                for (int jj = 0; jj < N ; jj++)
                {
                        fresult += vec1[jj] * vec2[jj];
, i( [& x% Z* L2 D                }
2 y: {9 S1 a$ r) D1 S                */
  D- a: b& r% F1 \/ t                                
% @! v/ N& f, R4 U                //Method - 3  N=100000 204s
                /*
                for (int jj = 0; jj < N; jj++)
                {
                        fresult += b1[jj] * b2[jj];
# u. s, x$ w% i2 y                }
5 N; k6 j1 _3 i- Q                */

                //Method - 4   202s
+ g0 _2 R9 n5 C4 L( Q. X' K# s                /*
; e) N) C9 Z8 W# o# ]2 `                for (int jj = 0; jj < N; jj++)
& w: I  E# n, B- x                {
; ?$ k; {( d: _* p6 @' R                        
1 P6 g4 {' H- b                }
+ b$ K3 V0 \4 F. W; w8 F; t                */
                //comment out all methods, N=100000  202s               
        }
4 o& g4 X6 F9 L/ V" n
  U' R* l; j# F( h0 e        delete []b1;
" B+ i; w- s3 y. W) j        delete []b2;

机器猫

瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同？
) t4 o. W+ K& v  n
你第二个试验里面的j在循环里面又重新定义了啊，你确定真的跑了6000次？

雷达

机器猫 发表于 2022-9-27 00:15
7 f' d$ J  A, n. h: C瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同？
2 O6 P8 n  Z- |2 y+ Y! @5 P5 f' t" s
! |; m3 Z2 A1 M1 [* D! V  ?你第二个试验里面的j在循环里面又重新定义 ...

内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
. U  V& k% a3 f( i) |$ o: o( J
不和它较劲了，瞎耽误工夫，我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。

机器猫

雷达 发表于 2022-9-27 01:16
% F6 w7 h  K4 K& G& s- M, o内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
" r7 r1 [) [  T
不和它 ...

7 k6 ?/ c+ r" [, Q& A
+ Z) `1 p0 ?- u* ]( O不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的，很有可能是在stack上，这样内存读写会更多，要是再碰上每次都需要加载cache就更慢了。
后面一个是在循环那里定义的，说不定编译器就把它优化成register变量了

opensrc

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

雷声

雷达 发表于 2022-9-24 23:54
! Y# F2 ?9 [( s5 V' D7 U' }void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
{
1 r' N& a+ u- J        comp temp, xtimesy;

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