C++ 提速的新发现

雷达

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

6 c% b0 w7 |) e自相关两层循环，内层循环涉及浮点数计算，试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了，看来问题并不在浮点计算。
) a4 `% E( ]0 }5 p( H* O7 o
1 T( w% o/ a* W5 B; ?$ ~速度优化问题真的很有意思啊。
- ~3 K9 p8 y$ _9 [( B3 ^2 y
9 w% L8 ]' g- _) C1 r, X欢迎大家继续讨论

数值分析

拉下来？拉多少？
, G: P, ]/ l3 ^6 M把代码贴上来看看？

& p; C0 N! ~& ^1 L难道分支预测不准破坏流水线执行？不该啊。

沉宝

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

风雨无阻

Maybe Debug mode?

雷达

1 B7 ]3 E  q3 u2 h

数值分析 发表于 2022-9-24 23:04
4 F9 J0 Y5 b5 I4 S# a" A; J3 o拉下来？拉多少？
把代码贴上来看看？

void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
9 ^2 S9 R/ ^; _- D{
' `7 x% W2 b' D+ i* `        comp temp, xtimesy;
( D8 h$ K2 O* z7 I7 d        xtimesy.re = 0;
        xtimesy.im = 0;
        int j0 = lenB - 1;
        int    i, j, i1, reali;
        if (lenA % 2 == 1)
                reali = lenA + 1;
        else
                reali = lenA;
2 x# `1 \, x, z! @, Y        reali /= 2;
$ G6 T) Z: Y( E/ d$ v
1 Z0 g7 l/ @; ~1 ~! Z0 @        int nconv = reali + lenB;
        //#pragma omp parallel for
, y) X0 V" T6 j- l        for (i = reali; i < nconv; i++)
        {
" R3 }5 Y% a9 u                temp.re = 0;
                temp.im = 0;
1 C4 |! K: \( H! f$ p6 n* c  r                i1 = i;
                for (j = j0; j >= 0; j--)
1 h. V6 U7 F9 D+ y! P7 U' H$ m                {
                        /* floating date operation */
& t4 o1 j, w. p4 m8 Z' c                }
        }
( Q1 K0 y" s0 K: q) b$ W- D$ M. I}

  Q3 f- w  c: X5 S( d5 ~+ W2 c) M4 qxcorr函数代码如上，comp是复数struct, 做过长度为11、19两个矢量的测试，和octave结果完全一样
6 G$ i8 {. \- x5 N; v' t/ ~& ^* G
  t; C9 `: t. H; S8 P红色部分是内循环，现在其内部操作都comment out 了, j0大概是 6000。
现在call xcorr 100次，耗时78s.

6 `" O4 O8 q; a. }. D, k8 j( y! c如果把红色部分内循环本身完全comment out， call xcorr 1000次，耗时 <1s.
8 H& S7 C$ o% l) P
, \" C2 h+ J8 n0 s- x/ R

雷达

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

! A% ^- d9 u( X( H4 a8 D. N
不应该，看我上面的回复。
( X' j; B5 U$ N% z
我更怀疑是 VS 社区版的问题

数值分析

雷达 发表于 2022-9-24 23:54
3 ^5 V: ?; \, M, }! i) j* Lvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
{
  j3 S# U8 H: `5 A. Y) h2 e        comp temp, xtimesy;

; y) C  ]. n5 \/ Y% i& l1 _9 N
* n# m+ J( h. k' X* I/ e这个不是这么比的吧。。。

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

! B* {' S6 j( ]9 K7 M0 D7 L5 b而加上内循环，光jmp和dec指令就至少多执行了6000个，慢个几十倍不是正常的么？

雷达

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

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

9 z8 _  s  T- l5 w
有道理。
, p) Q/ ^* Q# i$ \9 k' w所以存在内循环速度就上不去，把内循环取消，改成两个向量直接点乘再求和应该就会好得多，记得 numeric 库里有算向量内积的，我回头试试。
: y2 Y; l! E# u5 A$ E. B
我先尝试尽量用标准库，一个小程序，不想搞得太复杂。多谢了

沉宝

雷达 发表于 2022-9-25 00:46
$ J& e5 ?# U; h1 f! c: y1 L2 R2 ]有道理。
9 q8 T5 I! F5 T: O9 D* }# B所以存在内循环速度就上不去，把内循环取消，改成两个向量直接点乘再求和应该就会好得多，这大 ...

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

沉宝

数值分析 发表于 2022-9-25 00:20
这个不是这么比的吧。。。
5 q8 L/ {5 d  {8 V2 F# p- W2 f
' k+ \7 ~9 d" U% u. `; V您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。

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

7 @) G  W( a4 b( F- v& g/ R
现在的CPU，可以把判断、jmp和dec指令全部融合进一个µOp（微操作，CPU内部流水线上的执行单位）。如果循环这样跑，花不了多少时间。

数值分析

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

  h" l6 n, w* v# l. @  K
3 a1 j, f; {7 b8 Y" R& z. o' _. p; s4 ?是的，兄台说的对。

- f  M' I( n! C$ A' Q0 b其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。
& Z. F! A, |# h, M
& K9 |4 D2 T7 p5 {' r- i. P雷达兄构造测试用例的时候，屏蔽掉了所有计算的部分，使得剩下的都是overhead，这样run time比较的结果就显得好像不合理了。如果把计算加回去，计算部分的run time会dominate，结果就不那么离谱了。因为不好说，所以用指令数对比的方式试图直观地说明这一点。

# u. x  N  a. u0 l# {比如说，如果有计算，那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做，另一边是六千个循环，那六千个循环比什么都不做慢几十倍了，就不是那么不合理了。

! M; [# j8 z6 r0 M当然也有可能像兄台说的，是优化参数的问题，但我觉得更多地是测试用例设计的不合理。

雷达

( `0 W) C3 w! ]

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

又写了个小实验，没有调用子函数，双层循环，外层6千次，内循环30万次空转，有或没有空转内循环，时间差一倍，我上面这个差的太多了。
2 [4 o5 F; I/ h% ~" L& V7 x
' L' z; f) K0 e1 |我已经完全懵了。

沉宝

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

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

5 c! Q( b$ `2 _; d( J你还是用profile工具看看吧。现在大家都主观瞎猜。

数值分析

雷达 发表于 2022-9-25 04:47
& R  U9 U  D$ v1 ?" w$ d, {: O又写了个小实验，没有调用子函数，双层循环，外层6千次，内循环30万次空转，有或没有空转内循环，时间差 ...

( n7 d/ |/ @2 H8 }3 q% Z
2 b& {- e9 X7 f2 j9 N

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

雷达

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

5 f8 H6 w( v9 s1 s$ I& g1 Y理了理思路，重新做了一个测试。
& {# q% h4 d* N4 }4 O& u做了两个 vector 和 两个 float *, 都长 100000
外循环 6000，里面先做随机数生成，模拟真实环境，避免数据的 cache.

内循环试了4种方法，
1. 直接调用 vector inner_product 247s
2. vector 循环点乘累加 237s
" c9 ]) e  y. ]& R$ i, a9 W( I3. float * 循环点乘累加 204s
4. 空循环 100000 次 202s

不做内循环 200s

- m- B4 y2 O, z" W6 i, k4 |! n# M你昨天说的对，内循环本身占比是很小的，大头在其他处理。
$ i8 Q5 l5 o: r& f' W) O另外可以看到， float * 循环点乘累加 并不差，比用vector 还更快。

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

! B& T3 A2 c' c4 B7 D2 s（为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ？方括号 i 消失了。 LOL . 改成  jj 好了，原来 方括号里的 i 是斜体标志  LOL）
3 X% E. g7 d4 W0 z' _6 C
  q9 N6 r& K. r2 [

        std::vector < float > vec1(N);
        std::vector < float > vec2(N);
        float* b1 = new float[N];
        float* b2 = new float[N];
7 a. f# o, W) r2 l( @
        for (int j = 0; j < 6000; j++)
        {
                std::generate(vec1.begin(), vec1.end(), []() {
1 y# z% {' E7 }, Z8 H1 g                        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));;
                        });

, m# q4 N/ A8 k& v2 j" W# ^% g3 T                for (size_t jj = 0; jj < vec1.size(); jj++)
                {
2 O. W7 f/ _1 E; ~                        b1[jj] = vec1[jj];
# D( F* q6 W- _  t/ m: P5 L                }

                for (size_t jj = 0; jj < vec2.size(); jj++)
! J* r1 n& {7 V) Q9 p1 {                {
5 A% L7 u- ~. o' D7 o                        b2[jj] = vec2[jj];
                }
4 b7 }/ K6 F* l8 o* n- F+ h) k) e% b
                //Method - 1  N=100000 247s  
. e- x* q0 T( }9 E2 ]8 m0 {. t                //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);
                                
                //Method - 2  N=100000  237s
! s; H1 Z+ y. W, g/ n                /*
7 f9 T* y  q! Q                for (int jj = 0; jj < N ; jj++)
                {
  _$ n0 g) s$ |$ n                        fresult += vec1[jj] * vec2[jj];
; O' X2 `( i1 D( c                }
                */
                                
# y4 ?: w& h, f1 E5 K( ?; i                //Method - 3  N=100000 204s
$ W6 l1 P' `  N8 j                /*
                for (int jj = 0; jj < N; jj++)
9 ?, W+ `2 G) s* |# ]                {
                        fresult += b1[jj] * b2[jj];
                }
; _1 n" a. y" N. k1 k                */
$ F0 a1 ?( [8 n/ M# V' }
                //Method - 4   202s
& `% e; o7 b  V/ R" v; u                /*
/ G$ g$ H  Z. x' o0 ~                for (int jj = 0; jj < N; jj++)
! x( ^. I; S/ ]1 E# N0 F                {
                        
                }
                */
                //comment out all methods, N=100000  202s               
        }

        delete []b1;
        delete []b2;

机器猫

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

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

雷达

机器猫 发表于 2022-9-27 00:15
瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同？
0 `; s5 e; }' H" p. K
你第二个试验里面的j在循环里面又重新定义 ...

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

6 y7 S2 Q% L0 M+ x9 s8 k" [不和它较劲了，瞎耽误工夫，我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。

机器猫

雷达 发表于 2022-9-27 01:16
内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
/ w: @; a2 l- q- {
$ [% R7 c6 {; Z' ?) o* `; u7 S不和它 ...

/ e( a2 Z5 K/ u6 @/ X" G2 e& f
2 g% @& w/ _& U1 V5 D) @3 h不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的，很有可能是在stack上，这样内存读写会更多，要是再碰上每次都需要加载cache就更慢了。
后面一个是在循环那里定义的，说不定编译器就把它优化成register变量了

opensrc

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

雷声

雷达 发表于 2022-9-24 23:54
1 E. r; Z& X/ f; q1 P$ Uvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
& d# l1 k% k7 E+ ?, w# f" `) q& {{
- t, ~# D. u( g: S# E0 k/ z+ `        comp temp, xtimesy;

4 r( X9 b5 b6 q+ [这个code里面如果Openmp没有被注释掉的话，那么temp那个变量应该是定义在循环里面，否则线程之间会存在争夺写入那个temp的风险。
" e& s6 m2 R# L内层for循环如果没有内部操作的话，编译时应该被优化掉了，和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化？
4 C+ T9 q- b9 I( v% j% TVS社区版没有问题，我工作用的就是社区版，设置正常的话不会比商业版差。以前游说头头用Intel Compiler，他说不想花钱，而且差不了多少，就一直用到现在。