C++ 提速的新发现

雷达

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

: w3 Y. g2 g+ J) @: @: q9 ~自相关两层循环，内层循环涉及浮点数计算，试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了，看来问题并不在浮点计算。

& P& r" L( a* {& Q0 g" [2 s速度优化问题真的很有意思啊。

欢迎大家继续讨论

数值分析

拉下来？拉多少？
把代码贴上来看看？
; W: n- J" @: X5 ]+ M
5 d2 D" p" E& j6 E" O" N. G& U难道分支预测不准破坏流水线执行？不该啊。

沉宝

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

风雨无阻

Maybe Debug mode?

雷达

: d! ?5 U( b  x( t6 X" ]

数值分析 发表于 2022-9-24 23:04
拉下来？拉多少？
/ W4 a* r: a7 x+ W* j把代码贴上来看看？

2 C, z- I! _) o# s! c3 ?! H
1 [) N8 V+ Q5 f4 y  p6 x6 f$ m0 n, Pvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
{
/ j% d+ z) Y( J, f        comp temp, xtimesy;
3 e+ j3 Z0 n" C) D' q        xtimesy.re = 0;
        xtimesy.im = 0;
* j' d1 o, z3 B6 t        int j0 = lenB - 1;
        int    i, j, i1, reali;
        if (lenA % 2 == 1)
, S, x. r7 Q& w, T+ T1 w: A                reali = lenA + 1;
        else
                reali = lenA;
        reali /= 2;

$ u1 m; f- o( {2 v* i1 X        int nconv = reali + lenB;
' A2 b' m7 k2 k6 e$ Y5 `0 @        //#pragma omp parallel for
8 j! i  t! g2 q3 x" Z# s' b. i        for (i = reali; i < nconv; i++)
% {& h. J; Q' x$ ^        {
                temp.re = 0;
  u1 [4 I/ d7 a9 o2 ?                temp.im = 0;
                i1 = i;
# o6 v3 t! T; ]: n/ r% d                for (j = j0; j >= 0; j--)
. v$ U: T+ @  e; a. X/ _                {
9 k' k9 q% r# K! }1 q3 H. O( ?                        /* floating date operation */
                }
        }
5 _7 u: D7 ]. \7 o( D}

8 ^0 w( q% J& V& L& t; Q" qxcorr函数代码如上，comp是复数struct, 做过长度为11、19两个矢量的测试，和octave结果完全一样
+ |3 [" c8 @5 V- j
9 W- z8 L% y$ J8 ?$ a0 t红色部分是内循环，现在其内部操作都comment out 了, j0大概是 6000。
现在call xcorr 100次，耗时78s.

如果把红色部分内循环本身完全comment out， call xcorr 1000次，耗时 <1s.

雷达

风雨无阻 发表于 2022-9-24 23:33
$ u& d2 |/ x1 W1 {0 VMaybe Debug mode?

" \( \9 O8 V& E3 U9 b! O- A1 k
不应该，看我上面的回复。

! K6 @9 R: Q3 D7 L- k我更怀疑是 VS 社区版的问题

数值分析

& R# ~& J0 p7 F( u* S# l

雷达 发表于 2022-9-24 23:54
; H) |8 O% X4 ^, Svoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
4 l+ [5 L# [2 l3 @0 [% R2 g* }{
' g( M9 @8 g; F; [8 h        comp temp, xtimesy;

0 w0 `2 j7 e5 ]# t+ Y这个不是这么比的吧。。。
/ @9 D/ p; B0 P9 _5 x
您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。
8 i' P) T0 Z2 m) H1 s7 E  L
& q6 O& r6 b4 n8 R! N( N而加上内循环，光jmp和dec指令就至少多执行了6000个，慢个几十倍不是正常的么？

雷达

数值分析 发表于 2022-9-25 00:20
9 Y- J  [$ P5 A, V8 n4 w# q& q5 ?这个不是这么比的吧。。。
' z5 k7 I" h4 }0 p) [$ X6 T0 o
您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。

$ Q3 V& ]! O3 y有道理。
所以存在内循环速度就上不去，把内循环取消，改成两个向量直接点乘再求和应该就会好得多，记得 numeric 库里有算向量内积的，我回头试试。

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

沉宝

雷达 发表于 2022-9-25 00:46
' b" L) @2 X% n/ j  A. H- p, }有道理。
所以存在内循环速度就上不去，把内循环取消，改成两个向量直接点乘再求和应该就会好得多，这大 ...

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

沉宝

数值分析 发表于 2022-9-25 00:20
这个不是这么比的吧。。。
& X2 ^& j& L* O7 e5 d
您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。

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

8 ^( z0 \  t2 I9 l8 ^$ f
现在的CPU，可以把判断、jmp和dec指令全部融合进一个µOp（微操作，CPU内部流水线上的执行单位）。如果循环这样跑，花不了多少时间。

数值分析

/ i& W. a1 ]# l

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

( u% a7 ?* U; ^* ]: U8 b% O! R
是的，兄台说的对。

9 C  ^. s# v) z4 D, h( x/ p其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。

5 p" L7 `. N/ @雷达兄构造测试用例的时候，屏蔽掉了所有计算的部分，使得剩下的都是overhead，这样run time比较的结果就显得好像不合理了。如果把计算加回去，计算部分的run time会dominate，结果就不那么离谱了。因为不好说，所以用指令数对比的方式试图直观地说明这一点。

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

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

雷达

; s! E5 G8 `) L$ c1 l; B/ d  O# J

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

3 F& y3 I8 c2 V6 \9 H
! ?; ~( Z1 `) m+ |" d7 ?又写了个小实验，没有调用子函数，双层循环，外层6千次，内循环30万次空转，有或没有空转内循环，时间差一倍，我上面这个差的太多了。

我已经完全懵了。

沉宝

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

时间差一倍的结果可以接受。
6 S8 m; X/ i0 e2 n/ R
% a* }# A9 i/ S/ x1 {; j9 s8 {0 j/ @你还是用profile工具看看吧。现在大家都主观瞎猜。

数值分析

  f+ j; x3 F' g. B% a6 S3 A

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

/ M; O' K/ E; C. v

. N# n% X$ T% r
4 x8 P  t5 _" T# X# |能不能把这个也贴上来，看看和上一个有什么不同？

雷达

2 I: D8 E: N: g3 J; n) w3 v

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

3 e( c+ g/ k& M' w  l% Q( y5 ~理了理思路，重新做了一个测试。
做了两个 vector 和 两个 float *, 都长 100000
外循环 6000，里面先做随机数生成，模拟真实环境，避免数据的 cache.
' \' w, l1 H2 o3 P% K% h
内循环试了4种方法，
% \  n4 f* M" F; `- l; y$ r% O& a9 a1. 直接调用 vector inner_product 247s
2. vector 循环点乘累加 237s
& e- O& @8 [2 s3 m5 L. f3. float * 循环点乘累加 204s
4. 空循环 100000 次 202s
+ e3 w+ S) R# R1 x% a
% H' q4 T0 y4 I( ?) O不做内循环 200s
' }+ z* o3 q  \- F4 T$ F
" R' |3 R' g' I/ b: X9 ~' V: j你昨天说的对，内循环本身占比是很小的，大头在其他处理。
另外可以看到， float * 循环点乘累加 并不差，比用vector 还更快。

至于我那个原始程序，还有一些疑问，见5楼，其他都不变仅仅是有无空的内循环就有很大不同，这是不对的，也许有一些其他缺陷我没有看到。（也许可以改成 while 试试）
" U6 u  o6 l! a
（为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ？方括号 i 消失了。 LOL . 改成  jj 好了，原来 方括号里的 i 是斜体标志  LOL）

# S% x. [0 P! V/ p

        std::vector < float > vec1(N);
5 p6 l  o) I; a        std::vector < float > vec2(N);
7 `$ c1 o8 W! H  ?0 _        float* b1 = new float[N];
        float* b2 = new float[N];
5 H' [& p: a1 x- O- W5 L
; }0 _% J( n7 ~4 o        for (int j = 0; j < 6000; j++)
  A9 [+ m# e) y2 ~        {
                std::generate(vec1.begin(), vec1.end(), []() {
                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;
                        });

4 ^9 i  R  S4 F8 O2 o                std::generate(vec2.begin(), vec2.end(), []() {
2 u1 ~: H& B2 h5 E% ]. C" R                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;
                        });
7 d, s1 C) X9 v
0 W# s1 q2 ]" [7 C( K8 @( u                for (size_t jj = 0; jj < vec1.size(); jj++)
                {
. g3 L+ O7 X3 u! N5 g: O4 h                        b1[jj] = vec1[jj];
                }
4 i+ ?6 r8 S, S
2 h+ Y6 Y3 r) b                for (size_t jj = 0; jj < vec2.size(); jj++)
% b4 a: w* z9 B, v1 v                {
' F3 }$ g5 @- y2 ^" [* U9 J3 a                        b2[jj] = vec2[jj];
                }

                //Method - 1  N=100000 247s  
+ X8 P4 }( {/ j                //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);
$ L) K+ F! X" a1 l5 a                                
                //Method - 2  N=100000  237s
4 X5 D1 S& E5 [* b                /*
                for (int jj = 0; jj < N ; jj++)
                {
                        fresult += vec1[jj] * vec2[jj];
; v4 H. s/ Z- H* r& A1 _                }
  Y7 F( U. }# v2 J+ V                */
) c0 X- S4 Y/ m8 n, X0 }2 q9 H                                
" U: H1 B5 ^/ u- G# R7 _( z! v) p                //Method - 3  N=100000 204s
                /*
                for (int jj = 0; jj < N; jj++)
                {
                        fresult += b1[jj] * b2[jj];
                }
                */
' O) ]% y0 c  r- D/ u5 w) |1 M+ ]0 ?
                //Method - 4   202s
                /*
  \2 E  l. w1 g, K- X                for (int jj = 0; jj < N; jj++)
9 ]" I6 J* `! ~1 m2 S" \- v& g+ l8 Y                {
, {' [2 A' a) _2 B$ O, p2 P6 f4 k                        
                }
0 E( V& X( A; u) a8 R: K                */
                //comment out all methods, N=100000  202s               
, H2 i$ H1 u  W* E+ C- G        }
% p, m" w2 O" m' p
3 Y/ e( ~) U; j6 g1 i. C. p- p        delete []b1;
# p3 c! o0 F- ]$ Y* h" D2 f        delete []b2;

机器猫

瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同？
) f- O! i6 t4 H3 Z# i2 t5 b+ G% C  @
你第二个试验里面的j在循环里面又重新定义了啊，你确定真的跑了6000次？
2 L2 {2 {+ z' L- [; p  f9 z

雷达

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

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

内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
" k8 [" k6 c7 N9 z, n
- C  Y! [% V2 \# G  f) U不和它较劲了，瞎耽误工夫，我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。

机器猫

雷达 发表于 2022-9-27 01:16
内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL

" b) k) S" ]5 \0 Y2 U不和它 ...

: Y$ x& k1 O1 R+ |
不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的，很有可能是在stack上，这样内存读写会更多，要是再碰上每次都需要加载cache就更慢了。
后面一个是在循环那里定义的，说不定编译器就把它优化成register变量了

opensrc

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

雷声

雷达 发表于 2022-9-24 23:54
0 P( K) D3 K: k; R1 Mvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
{
        comp temp, xtimesy;

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