C++ 提速的新发现

雷达

C++ 比 Octave 慢好多，怎么破？
, ^5 c: T3 [: a: p/ b. D. e
/ b- m: g1 O7 c( n- C6 L" ~自相关两层循环，内层循环涉及浮点数计算，试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了，看来问题并不在浮点计算。
% a; y) [( K9 ^( X# d
速度优化问题真的很有意思啊。
+ _5 G( W9 _; o6 ]
欢迎大家继续讨论

数值分析

拉下来？拉多少？
4 R0 }) L7 _" U  d把代码贴上来看看？

难道分支预测不准破坏流水线执行？不该啊。

沉宝

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

风雨无阻

Maybe Debug mode?

雷达

- w5 Z. ~$ ^! f- T* A/ D/ ^- f

数值分析 发表于 2022-9-24 23:04
0 C# {" \# U' ^, \( o( G/ J% |7 {. i拉下来？拉多少？
& i6 h7 L* l/ m, v把代码贴上来看看？

# X# Q/ |# s4 b5 U
void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
{
        comp temp, xtimesy;
        xtimesy.re = 0;
* N& o9 N' p& y7 R        xtimesy.im = 0;
        int j0 = lenB - 1;
' e) C; E( u3 Z4 Q        int    i, j, i1, reali;
        if (lenA % 2 == 1)
% Y6 b8 W  Z7 K/ w! }! V                reali = lenA + 1;
/ W8 ?% Z/ A/ U9 Y) O& N* X        else
                reali = lenA;
, e6 n2 c0 h* z6 W3 p# e/ ]        reali /= 2;
  J4 p) {+ t# \6 H) z# [2 B
        int nconv = reali + lenB;
. ~7 n2 Y. a2 J8 B# h5 q- T# C        //#pragma omp parallel for
        for (i = reali; i < nconv; i++)
        {
                temp.re = 0;
                temp.im = 0;
3 ]+ U- k. F$ T, l/ c0 n& _! j3 L5 t                i1 = i;
4 l; w& y; Z+ n% P5 Y                for (j = j0; j >= 0; j--)
                {
                        /* floating date operation */
7 R) L7 j3 K0 J                }
3 C" U; W: x. F9 S) {' v        }
}
$ V/ x5 Q3 l! j, \9 x
: Y$ v2 m/ b$ p: `. O; `! rxcorr函数代码如上，comp是复数struct, 做过长度为11、19两个矢量的测试，和octave结果完全一样

2 `( c/ E' |! J8 s. d& F1 R% h9 N红色部分是内循环，现在其内部操作都comment out 了, j0大概是 6000。
  Z3 }% Q' ?0 N0 F# H' Y) m现在call xcorr 100次，耗时78s.

" K$ @) b2 k& ]. X- H! M/ k如果把红色部分内循环本身完全comment out， call xcorr 1000次，耗时 <1s.

! k9 I/ L( r' k

雷达

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

0 R- C" y9 z: O1 w
不应该，看我上面的回复。

( [3 }6 y% M8 l, o1 V6 d我更怀疑是 VS 社区版的问题

数值分析

雷达 发表于 2022-9-24 23:54
void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
9 x5 G) b9 l; H# A{
# w1 p$ m/ n/ z: a1 D! E6 ]" c- \2 j        comp temp, xtimesy;

4 z; @5 O9 w4 Z+ Q& y: ~这个不是这么比的吧。。。

! n* M/ {3 J( q0 d" d% w您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。
5 M1 {8 o  Q4 C9 v5 Q1 q9 O
而加上内循环，光jmp和dec指令就至少多执行了6000个，慢个几十倍不是正常的么？

雷达

) N0 k0 Z( I7 Q% X2 K

数值分析 发表于 2022-9-25 00:20
; P$ T$ T) a( c4 P5 I( Q- W这个不是这么比的吧。。。

. i7 e4 d; Y: D& ~- d您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。

, t7 H- S' {! ]0 X0 D0 _有道理。
1 r5 F* P* |  |, ], \$ G$ n所以存在内循环速度就上不去，把内循环取消，改成两个向量直接点乘再求和应该就会好得多，记得 numeric 库里有算向量内积的，我回头试试。
9 j& l# q! K1 I6 G* s7 A: ~
我先尝试尽量用标准库，一个小程序，不想搞得太复杂。多谢了

沉宝

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

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

沉宝

数值分析 发表于 2022-9-25 00:20
这个不是这么比的吧。。。
6 Q' c7 Y5 T, s3 c
& Q' W1 c' G% t2 L) V9 b您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。

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

. x2 l6 v9 l8 ]
- T: i4 `0 m2 e. r现在的CPU，可以把判断、jmp和dec指令全部融合进一个µOp（微操作，CPU内部流水线上的执行单位）。如果循环这样跑，花不了多少时间。

数值分析

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

: _+ r% w! @: D) w6 I/ a' P是的，兄台说的对。

1 v/ }- x* C& h其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。
9 W  r9 r/ M" C# e$ A
雷达兄构造测试用例的时候，屏蔽掉了所有计算的部分，使得剩下的都是overhead，这样run time比较的结果就显得好像不合理了。如果把计算加回去，计算部分的run time会dominate，结果就不那么离谱了。因为不好说，所以用指令数对比的方式试图直观地说明这一点。

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

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

雷达

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

/ K9 d! f; b' z6 Z9 L+ h
又写了个小实验，没有调用子函数，双层循环，外层6千次，内循环30万次空转，有或没有空转内循环，时间差一倍，我上面这个差的太多了。
7 j1 G# J# h/ j% ^7 A6 p& C, c
我已经完全懵了。

沉宝

雷达 发表于 2022-9-25 04:47
  N0 y; F) Q* a: ^5 i$ m又写了个小实验，没有调用子函数，双层循环，外层6千次，内循环30万次空转，有或没有空转内循环，时间差 ...

# ?' C+ h* M' R$ w# J7 {2 O时间差一倍的结果可以接受。
0 [& g! E4 X) L: `# {% @9 N. T- b
$ c( t- }. z1 H4 f9 n; e你还是用profile工具看看吧。现在大家都主观瞎猜。

数值分析

6 H4 V6 p0 z' ~( F

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

' Q! \8 }1 K5 o% j4 x% @6 @
0 {3 R) X$ E9 Y: h; Z5 y8 B

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

雷达

' k5 o: f, d' \" y

数值分析 发表于 2022-9-25 14:58
2 u4 B% @0 R- ?: U/ ~3 I0 I能不能把这个也贴上来，看看和上一个有什么不同？

( q( {  v" S1 m: ~7 S理了理思路，重新做了一个测试。
做了两个 vector 和 两个 float *, 都长 100000
- v/ n1 w$ ]1 s外循环 6000，里面先做随机数生成，模拟真实环境，避免数据的 cache.

内循环试了4种方法，
1. 直接调用 vector inner_product 247s
2. vector 循环点乘累加 237s
3. float * 循环点乘累加 204s
4. 空循环 100000 次 202s
+ D7 }* b" i/ j
不做内循环 200s
9 A  R  i# p5 [" m
你昨天说的对，内循环本身占比是很小的，大头在其他处理。
9 `' _5 e9 p$ C; M- h5 N8 ?$ [1 v另外可以看到， float * 循环点乘累加 并不差，比用vector 还更快。

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

6 j8 z" z0 ~8 z  E6 V5 {( E（为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ？方括号 i 消失了。 LOL . 改成  jj 好了，原来 方括号里的 i 是斜体标志  LOL）

        std::vector < float > vec1(N);
        std::vector < float > vec2(N);
        float* b1 = new float[N];
$ X! H+ |7 n( \) e        float* b2 = new float[N];
" e0 g) y( O2 S0 z% g
! n4 [1 t8 ]& `  q* i& u4 h! {        for (int j = 0; j < 6000; j++)
        {
8 c& z2 y, k& z" X3 W) I) A                std::generate(vec1.begin(), vec1.end(), []() {
& ]* w7 t. U/ C8 z5 x' O  r( D% }                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;
4 Z6 A( \. a/ i+ o: f3 @; w8 @                        });
& l$ N2 a1 z  r8 \! c( I0 R! x
1 `, \$ g  ~& N$ w4 h" P% T                std::generate(vec2.begin(), vec2.end(), []() {
                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;
                        });
* S3 R1 Z7 e/ D) k/ G/ w. [0 }
                for (size_t jj = 0; jj < vec1.size(); jj++)
                {
/ S% z# R1 R5 z$ ]0 x/ Y' u                        b1[jj] = vec1[jj];
                }

                for (size_t jj = 0; jj < vec2.size(); jj++)
                {
1 T! A; u' l# O* u( b                        b2[jj] = vec2[jj];
& a$ }. L8 h0 f5 i% f+ L1 g! _" K                }

                //Method - 1  N=100000 247s  
                //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);
1 i- e  O7 J" h  c2 B; L                                
* i! f- @, \+ F1 |) @3 J" j5 R                //Method - 2  N=100000  237s
                /*
                for (int jj = 0; jj < N ; jj++)
3 Z- X7 R* v3 h/ W+ e! ~                {
4 A5 I$ B" r$ d' V                        fresult += vec1[jj] * vec2[jj];
3 [5 D6 ^6 `+ @2 o7 I                }
8 h8 h: t8 L9 ^' j5 V, ~                */
                                
                //Method - 3  N=100000 204s
8 |4 @! ]' s* W: }% _( O  t5 ^) U* i                /*
# e# u! e8 T' P) d, ~                for (int jj = 0; jj < N; jj++)
                {
                        fresult += b1[jj] * b2[jj];
                }
+ f& N, y( U* M* |5 @! o                */

                //Method - 4   202s
                /*
3 G6 n3 x. N) Y' ?! O7 j6 ~                for (int jj = 0; jj < N; jj++)
6 Y; J. b2 S* B2 I  j- {, Z3 J                {
                        
: H' b: _+ l- P( _2 j                }
! H- z7 [  C' ]: o                */
                //comment out all methods, N=100000  202s               
        }

# E# n9 b3 l& H  @7 {* M) E' h( m        delete []b1;
1 i" V3 k2 u- i2 O. n        delete []b2;

机器猫

瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同？
" B! H. J0 V) R5 ~5 w
6 b, ~$ J6 W* R0 W  O" U3 D你第二个试验里面的j在循环里面又重新定义了啊，你确定真的跑了6000次？

雷达

机器猫 发表于 2022-9-27 00:15
5 z! B. ]: M) Z4 Z4 F瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同？

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

内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
8 M, @7 p0 Z% K+ {. F7 g
8 N( x4 u& T1 e' V3 N& u# E7 ^- a不和它较劲了，瞎耽误工夫，我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。

机器猫

雷达 发表于 2022-9-27 01:16
内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
( l% z! J; S$ }; B+ }* j/ L' d
不和它 ...

7 P9 V9 o1 k- Z; C) i% N, ?
不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的，很有可能是在stack上，这样内存读写会更多，要是再碰上每次都需要加载cache就更慢了。
% ~7 e. L5 p9 j( v( E! t后面一个是在循环那里定义的，说不定编译器就把它优化成register变量了

opensrc

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

雷声

雷达 发表于 2022-9-24 23:54
void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
5 O: w6 w3 V) J+ N  O$ F  ]6 P{
        comp temp, xtimesy;

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