C++ 提速的新发现

雷达

C++ 比 Octave 慢好多，怎么破？
# B8 g- y1 l- |$ N  A" g. ?
. o5 a" B6 h7 a9 @. ^自相关两层循环，内层循环涉及浮点数计算，试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了，看来问题并不在浮点计算。

  Q9 x3 ?7 q: K* r速度优化问题真的很有意思啊。
/ k. j/ w/ h5 M. v6 v
, H7 c7 \+ E( c2 Q欢迎大家继续讨论

数值分析

拉下来？拉多少？
4 u+ v8 S8 l% n6 s- b3 U把代码贴上来看看？
3 x- z9 ]# d" \; U$ L* K9 Q; D! {
. H9 R0 E4 y4 p4 |1 K难道分支预测不准破坏流水线执行？不该啊。

沉宝

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

风雨无阻

Maybe Debug mode?

雷达

' y! @4 Y- `7 H+ p

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

0 w7 c4 C! H: p2 K
void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
{
        comp temp, xtimesy;
        xtimesy.re = 0;
- E6 `/ d5 H8 R# [. R        xtimesy.im = 0;
7 F5 b) K  R1 }$ L7 ^        int j0 = lenB - 1;
- m* s0 ]6 ]! }: n3 l9 S5 L* O        int    i, j, i1, reali;
        if (lenA % 2 == 1)
6 y. |& O0 ]9 t+ K9 h; y; i                reali = lenA + 1;
" W4 h% i9 P' ]8 I" R# g. p        else
* @: H, o2 @# J" j                reali = lenA;
4 \4 J5 b% }; u. N! J        reali /= 2;

        int nconv = reali + lenB;
- q1 J# f) Q( B6 _8 z0 A        //#pragma omp parallel for
) T# B; K+ G0 n: }6 y        for (i = reali; i < nconv; i++)
5 ~/ D! N- x# p6 n8 ]        {
                temp.re = 0;
& m$ `* }- K' ]' Z* Z; Q                temp.im = 0;
+ A5 {) ^) g* {' C/ d+ W# C) _( k* L: p1 C                i1 = i;
. j! N8 i3 q6 n9 a$ `                for (j = j0; j >= 0; j--)
4 x1 r8 z: Q  K                {
                        /* floating date operation */
                }
, R' C" [( G8 A. |        }
% X# V3 E+ G8 O* Y}
( a8 @$ y4 g% e9 ^
xcorr函数代码如上，comp是复数struct, 做过长度为11、19两个矢量的测试，和octave结果完全一样
9 s0 L0 v; v) g8 @+ L9 }
9 f4 o$ X" B0 c红色部分是内循环，现在其内部操作都comment out 了, j0大概是 6000。
3 ]" l! D- }3 J7 j$ J现在call xcorr 100次，耗时78s.
, N0 g3 R8 W- d- |! H
4 S( u1 |+ O6 p$ z. a+ O) @3 b如果把红色部分内循环本身完全comment out， call xcorr 1000次，耗时 <1s.

雷达

风雨无阻 发表于 2022-9-24 23:33
' p1 ~; k. @  h8 k+ s, Q5 p5 JMaybe Debug mode?

) r0 E% ?1 V! b, z' h- z
' e+ y0 ]$ |& Q( n不应该，看我上面的回复。

( g9 Y% U% n# |0 i$ f1 F) ?我更怀疑是 VS 社区版的问题

数值分析

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

  n6 t6 Z3 b" V/ v4 r: z这个不是这么比的吧。。。

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

0 ]9 k$ M5 J# {# T; k而加上内循环，光jmp和dec指令就至少多执行了6000个，慢个几十倍不是正常的么？

雷达

数值分析 发表于 2022-9-25 00:20
" w) _/ Y, u" ]+ f这个不是这么比的吧。。。

) O2 ~9 A( k# v您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。

有道理。
! u3 ?. N% F9 \7 B& W( S! J所以存在内循环速度就上不去，把内循环取消，改成两个向量直接点乘再求和应该就会好得多，记得 numeric 库里有算向量内积的，我回头试试。
) e2 A' O: H3 J- J) D
我先尝试尽量用标准库，一个小程序，不想搞得太复杂。多谢了

沉宝

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

你两个试验之间就差了一个空循环， call 1000次按理不会有秒级差异，可能还是编译器优化的问题。举个例子，把循环本身翻译成机器指令loop或dec/jnz，两者速度上会差很多
" R6 m# R9 D$ O( d, D; P' Y: E$ xWhy is the loop instruction slow? Couldn't Intel have implemented it efficiently?

沉宝

数值分析 发表于 2022-9-25 00:20
/ P2 n9 P# G* H6 Y9 w. s这个不是这么比的吧。。。

( Z7 U3 @4 c2 ~. S您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。

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

9 H- ]5 |$ i  t  B. q: `) f4 K
现在的CPU，可以把判断、jmp和dec指令全部融合进一个µOp（微操作，CPU内部流水线上的执行单位）。如果循环这样跑，花不了多少时间。

数值分析

1 z3 g7 o# v$ ~

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

5 q* U+ c) i+ M6 W* o  }
" M* C* T2 ^4 v/ c是的，兄台说的对。
$ n  A. L# j, j
其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。
/ H6 d3 s! ]: J/ O1 q5 f
1 e- o1 e. `% T+ R6 d! L雷达兄构造测试用例的时候，屏蔽掉了所有计算的部分，使得剩下的都是overhead，这样run time比较的结果就显得好像不合理了。如果把计算加回去，计算部分的run time会dominate，结果就不那么离谱了。因为不好说，所以用指令数对比的方式试图直观地说明这一点。
5 W  Z  L8 f% q( r
# V: l- R& i* K3 s) H) [比如说，如果有计算，那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做，另一边是六千个循环，那六千个循环比什么都不做慢几十倍了，就不是那么不合理了。
2 L2 I2 x: A2 y, L8 A: z
当然也有可能像兄台说的，是优化参数的问题，但我觉得更多地是测试用例设计的不合理。

雷达

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

3 p8 _6 @8 n( h: s5 z, k6 }) n4 ]
* K$ Y0 V: f9 E: j0 {4 [% l7 x又写了个小实验，没有调用子函数，双层循环，外层6千次，内循环30万次空转，有或没有空转内循环，时间差一倍，我上面这个差的太多了。

+ r/ n) x5 b& Y: R我已经完全懵了。

沉宝

雷达 发表于 2022-9-25 04:47
+ z8 b: ~# C  A* X: _% ?! a; a+ q又写了个小实验，没有调用子函数，双层循环，外层6千次，内循环30万次空转，有或没有空转内循环，时间差 ...

& Z8 v# G+ a7 Y' V时间差一倍的结果可以接受。
* K& ^  @# C- T
你还是用profile工具看看吧。现在大家都主观瞎猜。

数值分析

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

: |2 M2 Z' R4 ~' B- @0 z
能不能把这个也贴上来，看看和上一个有什么不同？

雷达

1 A- D! R5 J5 q

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

理了理思路，重新做了一个测试。
; C/ V* T' X  M: o5 j4 \做了两个 vector 和 两个 float *, 都长 100000
' r4 C% E7 {4 G/ t. b外循环 6000，里面先做随机数生成，模拟真实环境，避免数据的 cache.
' E1 A1 c) @- m# Q' D5 h" i
, F, F: z  m4 F, U2 u  b内循环试了4种方法，
1. 直接调用 vector inner_product 247s
2. vector 循环点乘累加 237s
3. float * 循环点乘累加 204s
4. 空循环 100000 次 202s

! o# a( }% w  {6 |  j# P+ R; ?: l不做内循环 200s

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

$ Y' e- M  X* M; [: A8 I2 I至于我那个原始程序，还有一些疑问，见5楼，其他都不变仅仅是有无空的内循环就有很大不同，这是不对的，也许有一些其他缺陷我没有看到。（也许可以改成 while 试试）
8 d1 v5 I9 a3 Q3 h
（为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ？方括号 i 消失了。 LOL . 改成  jj 好了，原来 方括号里的 i 是斜体标志  LOL）

        std::vector < float > vec1(N);
        std::vector < float > vec2(N);
/ m( W- v3 z6 {5 B8 N2 X        float* b1 = new float[N];
; @: ]' m$ T, Y2 @7 D        float* b2 = new float[N];
3 A7 k. p, I& L2 y3 B0 v
/ q( W7 D( D7 X" f& H        for (int j = 0; j < 6000; j++)
        {
, S4 o) K4 ^# V8 Q9 X                std::generate(vec1.begin(), vec1.end(), []() {
+ c$ m: R( r# h" V# Q                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;
& N* }; R- @& x* M                        });

+ @1 V& w  E& a" V) u9 l: \9 s                std::generate(vec2.begin(), vec2.end(), []() {
                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;
- R& G$ d2 N& A: _) N( K/ S                        });

                for (size_t jj = 0; jj < vec1.size(); jj++)
# l7 K5 d- M) K1 L3 ~                {
                        b1[jj] = vec1[jj];
9 ]) W# }! r9 ]5 d                }

                for (size_t jj = 0; jj < vec2.size(); jj++)
                {
0 o4 K+ I6 N, W9 }7 s  N4 Z                        b2[jj] = vec2[jj];
0 ~& t8 l7 Z4 |- {2 A6 m2 Y                }

                //Method - 1  N=100000 247s  
                //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);
                                
; O7 |( K3 A/ a/ ]3 j! @9 d                //Method - 2  N=100000  237s
                /*
                for (int jj = 0; jj < N ; jj++)
                {
1 ~8 l  _, ?8 U' A6 G                        fresult += vec1[jj] * vec2[jj];
                }
) m  {7 B( g7 R8 F                */
$ j8 a- B3 C  {9 X+ ^                                
                //Method - 3  N=100000 204s
                /*
( U7 n. [8 m6 @                for (int jj = 0; jj < N; jj++)
# m: L+ S! A9 g7 ^5 {) w                {
' `2 X2 k5 Y8 J" m                        fresult += b1[jj] * b2[jj];
                }
                */

                //Method - 4   202s
. \4 Z5 @# z) w- J3 A9 ?                /*
                for (int jj = 0; jj < N; jj++)
                {
                        
                }
/ d7 c# T& T' m1 ]% |                */
                //comment out all methods, N=100000  202s               
        }
) u$ ~) E! V- Q8 [0 l
        delete []b1;
5 W/ y* p! W, O) l2 R  w+ a        delete []b2;

机器猫

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

你第二个试验里面的j在循环里面又重新定义了啊，你确定真的跑了6000次？

雷达

机器猫 发表于 2022-9-27 00:15
2 u6 A* w/ ]9 h! l% e" x, D$ E8 ]1 C瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同？

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

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

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

机器猫

雷达 发表于 2022-9-27 01:16
内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
2 ^- y6 V/ o  B& K1 d5 T" d
( U4 c6 q% Q3 ?5 [& V3 b不和它 ...

3 P9 d& H" ], o0 D$ G不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的，很有可能是在stack上，这样内存读写会更多，要是再碰上每次都需要加载cache就更慢了。
  H6 i& L0 _" T$ X7 X: [. d3 J后面一个是在循环那里定义的，说不定编译器就把它优化成register变量了

opensrc

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

雷声

雷达 发表于 2022-9-24 23:54
void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
8 K$ p7 d2 e9 v& |1 ]/ x& s{
7 v( E1 s% {& ^& h8 }6 n0 A1 k0 X        comp temp, xtimesy;

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