C++ 提速的新发现

雷达

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

! I5 D5 r9 |3 }8 g自相关两层循环，内层循环涉及浮点数计算，试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了，看来问题并不在浮点计算。
* t4 t" t9 r3 ^( q
速度优化问题真的很有意思啊。

欢迎大家继续讨论

数值分析

拉下来？拉多少？
8 i$ m: l9 _: z% m/ p; l把代码贴上来看看？
" k8 c5 ~, M2 O0 [$ m
3 U  p6 A4 d6 x+ o, ~6 y' N8 B难道分支预测不准破坏流水线执行？不该啊。

沉宝

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

风雨无阻

Maybe Debug mode?

雷达

8 Q/ {, Z" h7 x2 [9 I3 f

数值分析 发表于 2022-9-24 23:04
6 Z+ G/ X% t) F* R" i9 x拉下来？拉多少？
) ^3 f( C3 m2 H% i把代码贴上来看看？

void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
9 T/ x& b: z- r- v* Z8 K5 I{
; e% A3 f& w; ?- Z7 ~; v+ r+ ?        comp temp, xtimesy;
        xtimesy.re = 0;
        xtimesy.im = 0;
        int j0 = lenB - 1;
        int    i, j, i1, reali;
        if (lenA % 2 == 1)
2 ~- N! V2 C* k# I; o( i                reali = lenA + 1;
6 Y8 s. I) `6 x7 w8 q3 Q" O# f        else
  S4 x9 ^3 U; c! Z6 S                reali = lenA;
( H4 k, m; y0 E/ U# g        reali /= 2;
2 ^# Z8 L8 \2 E
        int nconv = reali + lenB;
% H+ o9 I! \* r9 S+ T) i/ U        //#pragma omp parallel for
+ K: o4 K) Q, {" Q        for (i = reali; i < nconv; i++)
        {
* x; z* m4 X* l                temp.re = 0;
                temp.im = 0;
                i1 = i;
! B: P; i) C& h                for (j = j0; j >= 0; j--)
9 `0 {- O9 p& s                {
                        /* floating date operation */
                }
( ^. }: m9 }) p0 B5 \' m        }
3 A" Y2 _" C+ ~  D8 {}

$ P) F) l- Z& X* kxcorr函数代码如上，comp是复数struct, 做过长度为11、19两个矢量的测试，和octave结果完全一样
7 r: b8 x4 G7 J) i1 C: S! H
红色部分是内循环，现在其内部操作都comment out 了, j0大概是 6000。
4 ?" F. C; i' g9 b现在call xcorr 100次，耗时78s.

: s; G- ^9 m1 w% n* U如果把红色部分内循环本身完全comment out， call xcorr 1000次，耗时 <1s.
7 N' u5 ?4 I6 G9 L5 O6 u$ s+ f
+ p2 o4 d* a  |3 G

雷达

风雨无阻 发表于 2022-9-24 23:33
% q8 E) U0 v. xMaybe Debug mode?

不应该，看我上面的回复。

4 i( r6 d# Y9 _" t1 y  ^$ \% f我更怀疑是 VS 社区版的问题

数值分析

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

; H  s$ M2 N/ A" s这个不是这么比的吧。。。

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

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

雷达

' Y. t) s+ E6 n3 W

数值分析 发表于 2022-9-25 00:20
/ z+ D( R/ ^9 I' n这个不是这么比的吧。。。
( s7 L! y* X0 O; @" e
您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。

有道理。
) W) T2 @: z" I4 S( R所以存在内循环速度就上不去，把内循环取消，改成两个向量直接点乘再求和应该就会好得多，记得 numeric 库里有算向量内积的，我回头试试。

7 K8 k( C! P  i& Y6 ~3 I我先尝试尽量用标准库，一个小程序，不想搞得太复杂。多谢了

沉宝

雷达 发表于 2022-9-25 00:46
7 _% t* B7 \$ @+ G有道理。
5 ?( @6 K. k) N8 Z所以存在内循环速度就上不去，把内循环取消，改成两个向量直接点乘再求和应该就会好得多，这大 ...

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

沉宝

数值分析 发表于 2022-9-25 00:20
1 V+ `% `5 N' j这个不是这么比的吧。。。

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

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

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

数值分析

  }/ B9 r" n+ x8 g( t. @

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

4 A: E4 c) _# {  B8 i/ F: P
5 K7 `4 a8 B" Q9 W" u2 ^$ j. }* }, _是的，兄台说的对。
# f+ X2 O  J7 `6 p  n4 K: _
/ A2 ?6 G+ y' G1 ~8 x* a) i其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。
% ^6 ~) o6 B3 i+ g. O& p
雷达兄构造测试用例的时候，屏蔽掉了所有计算的部分，使得剩下的都是overhead，这样run time比较的结果就显得好像不合理了。如果把计算加回去，计算部分的run time会dominate，结果就不那么离谱了。因为不好说，所以用指令数对比的方式试图直观地说明这一点。
* H# q6 V' X. h- m6 i7 _
比如说，如果有计算，那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做，另一边是六千个循环，那六千个循环比什么都不做慢几十倍了，就不是那么不合理了。

- I/ b6 _3 ^$ Z5 b1 R当然也有可能像兄台说的，是优化参数的问题，但我觉得更多地是测试用例设计的不合理。

雷达

; i% ^; n& C* H: i2 j1 O

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

又写了个小实验，没有调用子函数，双层循环，外层6千次，内循环30万次空转，有或没有空转内循环，时间差一倍，我上面这个差的太多了。
+ b0 ]2 I* l$ q* N6 q4 M" S; B
/ e; _/ \$ Z" R# E我已经完全懵了。

沉宝

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

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

* U7 v* |& I- G7 _; w) z# G你还是用profile工具看看吧。现在大家都主观瞎猜。

数值分析

3 P5 i' s  t+ i- B: `" f' M

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

# k; R; r* B; y5 n+ m: Z& A

, l; O. ^+ y4 Y
2 W. g& q) Y: h* O) D能不能把这个也贴上来，看看和上一个有什么不同？

雷达

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

理了理思路，重新做了一个测试。
% B) j$ j, `8 x0 w做了两个 vector 和 两个 float *, 都长 100000
外循环 6000，里面先做随机数生成，模拟真实环境，避免数据的 cache.
3 Y+ {" z2 ~- }8 k
内循环试了4种方法，
1. 直接调用 vector inner_product 247s
2. vector 循环点乘累加 237s
3. float * 循环点乘累加 204s
% h# o# U. v! a5 t6 R4. 空循环 100000 次 202s

不做内循环 200s
( W3 \5 q  T/ d$ W' Q" ?0 e9 \
! [1 F' ^- ]$ G& ~6 h你昨天说的对，内循环本身占比是很小的，大头在其他处理。
% }4 I$ t; v, H( ]6 K& ]另外可以看到， float * 循环点乘累加 并不差，比用vector 还更快。

至于我那个原始程序，还有一些疑问，见5楼，其他都不变仅仅是有无空的内循环就有很大不同，这是不对的，也许有一些其他缺陷我没有看到。（也许可以改成 while 试试）
' d9 a0 R" R7 ^6 b
1 B+ Z; `% @1 K. r) g（为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ？方括号 i 消失了。 LOL . 改成  jj 好了，原来 方括号里的 i 是斜体标志  LOL）

3 ?5 N) |: C( \/ B8 q

        std::vector < float > vec1(N);
        std::vector < float > vec2(N);
        float* b1 = new float[N];
        float* b2 = new float[N];

        for (int j = 0; j < 6000; j++)
        {
                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));;
                        });
; d7 O. |6 _+ N9 K3 k
; Y6 E3 q: O- z                for (size_t jj = 0; jj < vec1.size(); jj++)
* H* z4 Y: P% B3 ~                {
                        b1[jj] = vec1[jj];
8 s. |0 Z3 L9 ^0 e9 Y; k8 S8 A; l                }

/ R- P$ N$ Z: o% `* B- O                for (size_t jj = 0; jj < vec2.size(); jj++)
5 j5 I; b" p7 h  z& b0 y                {
# m  C7 Y! z$ Z+ B$ O6 P                        b2[jj] = vec2[jj];
4 t: E, P( y, f; i                }
, w# d5 k/ Q$ ]6 u  ]
                //Method - 1  N=100000 247s  
                //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);
/ X: B. B) f( ^& H9 N/ @9 g; S                                
                //Method - 2  N=100000  237s
2 s* Y$ O2 U! z0 C                /*
) [% M) f0 Q6 N5 m+ c+ a                for (int jj = 0; jj < N ; jj++)
9 W6 |0 M- ?$ n4 ~* O! @7 [. N                {
                        fresult += vec1[jj] * vec2[jj];
                }
1 V: N3 G7 i8 U) Y$ C                */
& @9 f, ^2 E" j9 w6 q' d                                
# I- R) Y' ?1 ?- B8 F* I. L; u                //Method - 3  N=100000 204s
+ c% Z' Y7 F) n( I& c                /*
                for (int jj = 0; jj < N; jj++)
' r( p0 [5 g6 l+ l: r) k                {
, E0 Q6 K6 e8 _0 x: f/ p5 {                        fresult += b1[jj] * b2[jj];
                }
                */
! D' y/ }/ {( i
5 q$ }' w3 g+ W                //Method - 4   202s
# W& Q" {$ ^- W% C+ T                /*
4 K: x( y% [  q+ q3 B6 x: r                for (int jj = 0; jj < N; jj++)
* a, \7 p8 o- v2 b4 S! A                {
( [) {0 H. J* F) n7 G! E* D                        
; R2 |2 o* M& j* ]                }
                */
& H* S/ m6 ]# k- s# h                //comment out all methods, N=100000  202s               
" e9 E% t- f- E0 ~        }
6 r9 C0 K' P, k$ T" R2 c
" u- Q6 X" D5 K# W+ @$ u2 C        delete []b1;
        delete []b2;

- S( }# {* G* j

机器猫

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

+ O; H; `+ x# T1 }' ^; k你第二个试验里面的j在循环里面又重新定义了啊，你确定真的跑了6000次？
$ q( Z: M2 ?3 ?4 B

雷达

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

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

# J6 K5 l6 U7 N/ w: O0 ?内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
  ^( k0 x( X0 ~5 i
0 g$ _7 r2 u% k/ l! O- y- R  C3 S1 f不和它较劲了，瞎耽误工夫，我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。

机器猫

雷达 发表于 2022-9-27 01:16
内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
; B1 d' h$ ^$ P) F: R5 {2 j6 }) m
' v4 W* G) |# {/ c) T3 I不和它 ...

1 p7 F& z! a% F# x( ?8 M
! Z6 z9 i* m- [1 |% o3 _4 J6 X不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的，很有可能是在stack上，这样内存读写会更多，要是再碰上每次都需要加载cache就更慢了。
. d. p* q" U; I0 h2 J2 K后面一个是在循环那里定义的，说不定编译器就把它优化成register变量了

opensrc

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

雷声

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

1 N7 g8 ^$ \! H6 z  z; a' z这个code里面如果Openmp没有被注释掉的话，那么temp那个变量应该是定义在循环里面，否则线程之间会存在争夺写入那个temp的风险。
, M; l; {" w1 M5 @4 Z5 y0 k内层for循环如果没有内部操作的话，编译时应该被优化掉了，和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化？
VS社区版没有问题，我工作用的就是社区版，设置正常的话不会比商业版差。以前游说头头用Intel Compiler，他说不想花钱，而且差不了多少，就一直用到现在。