C++ 提速的新发现

雷达

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

自相关两层循环，内层循环涉及浮点数计算，试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了，看来问题并不在浮点计算。
( ?! A, b) y; w+ _: k8 \+ `3 w5 n% r
速度优化问题真的很有意思啊。

欢迎大家继续讨论

数值分析

拉下来？拉多少？
把代码贴上来看看？

3 ~4 D4 L& V! i& x( X难道分支预测不准破坏流水线执行？不该啊。

沉宝

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

风雨无阻

Maybe Debug mode?

雷达

7 [* a0 F# I4 q) z

数值分析 发表于 2022-9-24 23:04
! f- }2 y; r, B6 \5 X2 c拉下来？拉多少？
把代码贴上来看看？

( c, E" |7 Q" X6 f
void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
1 c6 b( @8 t" \6 j3 z{
        comp temp, xtimesy;
/ P8 y$ s/ r/ O6 t2 x        xtimesy.re = 0;
5 R6 ]* B# |$ H- x  ]5 `: a        xtimesy.im = 0;
        int j0 = lenB - 1;
        int    i, j, i1, reali;
) Y4 P' e# O! I9 Y: h        if (lenA % 2 == 1)
1 x. u( N7 H$ a                reali = lenA + 1;
4 B- ^# H) U8 Z& Q0 p        else
" C. w5 @" X: P% X                reali = lenA;
" R& c. O# L- H1 H        reali /= 2;

        int nconv = reali + lenB;
        //#pragma omp parallel for
        for (i = reali; i < nconv; i++)
        {
( D+ s5 `/ s0 }) A% d                temp.re = 0;
                temp.im = 0;
                i1 = i;
                for (j = j0; j >= 0; j--)
                {
                        /* floating date operation */
8 Y% X2 L* ^, B7 F5 O0 c) E: m                }
( w; ~" ~6 f; H! N* m8 ~        }
; T  Y9 f/ B) T, F+ Y5 D}
8 a0 M/ K* p3 Z+ R% v& J) S
6 ]- j! G& s/ r0 R6 d. I" ^3 s( g, Gxcorr函数代码如上，comp是复数struct, 做过长度为11、19两个矢量的测试，和octave结果完全一样

& _' T; z, |) H红色部分是内循环，现在其内部操作都comment out 了, j0大概是 6000。
现在call xcorr 100次，耗时78s.

0 z( l, h% V+ B7 b  y$ f如果把红色部分内循环本身完全comment out， call xcorr 1000次，耗时 <1s.

5 @& b3 f6 V& v0 a3 \4 L' ]

雷达

风雨无阻 发表于 2022-9-24 23:33
# q4 p, i" C8 u* h+ F, zMaybe Debug mode?

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

我更怀疑是 VS 社区版的问题

数值分析

雷达 发表于 2022-9-24 23:54
void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
{
6 x+ H: P( E2 t! R        comp temp, xtimesy;

这个不是这么比的吧。。。
: N. I- `* C1 k( B% a% e% \1 c( B
您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。

" [+ G! D' V8 Z而加上内循环，光jmp和dec指令就至少多执行了6000个，慢个几十倍不是正常的么？

雷达

数值分析 发表于 2022-9-25 00:20
2 l% k& U8 l# t9 i( q这个不是这么比的吧。。。
2 t+ b4 X" b4 A( b9 F* r* w
) ]& y+ N9 W3 W) F( f! r您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。

( \8 f# L: Q5 {+ X$ Z8 }
有道理。
4 L/ e+ H0 F+ j, h所以存在内循环速度就上不去，把内循环取消，改成两个向量直接点乘再求和应该就会好得多，记得 numeric 库里有算向量内积的，我回头试试。

1 U6 J9 `$ H  l( C8 T6 P我先尝试尽量用标准库，一个小程序，不想搞得太复杂。多谢了

沉宝

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

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

沉宝

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

3 ?: f4 S! g6 _% U您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。

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

) E- o9 S1 Y- A: y# r现在的CPU，可以把判断、jmp和dec指令全部融合进一个µOp（微操作，CPU内部流水线上的执行单位）。如果循环这样跑，花不了多少时间。

数值分析

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

是的，兄台说的对。

/ W2 j( j% m2 |其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。
0 D" o* a# e6 `$ \4 H0 L
雷达兄构造测试用例的时候，屏蔽掉了所有计算的部分，使得剩下的都是overhead，这样run time比较的结果就显得好像不合理了。如果把计算加回去，计算部分的run time会dominate，结果就不那么离谱了。因为不好说，所以用指令数对比的方式试图直观地说明这一点。
' |! k) E! i0 B# E# x
  C/ u' `8 _9 e" v. A比如说，如果有计算，那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做，另一边是六千个循环，那六千个循环比什么都不做慢几十倍了，就不是那么不合理了。

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

雷达

5 k" }5 D4 u# L; ^. v

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

又写了个小实验，没有调用子函数，双层循环，外层6千次，内循环30万次空转，有或没有空转内循环，时间差一倍，我上面这个差的太多了。
. ~* z$ I& ^# U9 K
我已经完全懵了。

沉宝

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

时间差一倍的结果可以接受。
. Q5 f7 c& X& B+ g- R. Z
6 a# F" ~: u7 D% m5 C( s" e7 W  t- ~你还是用profile工具看看吧。现在大家都主观瞎猜。

数值分析

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

7 G1 v; m7 {& f; U

0 |8 {- l1 }' k
7 Q  {$ e5 E1 C- q$ B能不能把这个也贴上来，看看和上一个有什么不同？

雷达

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

理了理思路，重新做了一个测试。
3 U; P3 h; E$ T$ L, E7 |做了两个 vector 和 两个 float *, 都长 100000
. q  |+ E' v1 V. ^- {" n外循环 6000，里面先做随机数生成，模拟真实环境，避免数据的 cache.

内循环试了4种方法，
; H4 j( [: V4 u3 S; M# t) J1. 直接调用 vector inner_product 247s
2. vector 循环点乘累加 237s
1 p" e; z" l7 C* W3. float * 循环点乘累加 204s
/ j" I5 \% v0 Q7 B4. 空循环 100000 次 202s
& ?7 W, x1 A0 u9 K1 m; R6 U
" Z8 Z5 W: G7 D+ y+ Y不做内循环 200s
6 f  J, R6 H4 z! I0 Q- U" T0 h
3 j. {: E9 v( l5 M( R  p你昨天说的对，内循环本身占比是很小的，大头在其他处理。
另外可以看到， float * 循环点乘累加 并不差，比用vector 还更快。

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

（为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ？方括号 i 消失了。 LOL . 改成  jj 好了，原来 方括号里的 i 是斜体标志  LOL）

( k7 _. x  u$ J; O5 I( N8 a' R

        std::vector < float > vec1(N);
        std::vector < float > vec2(N);
        float* b1 = new float[N];
1 \$ ~& w+ f: ^* q        float* b2 = new float[N];

        for (int j = 0; j < 6000; j++)
8 L$ b6 H4 x2 I9 X# g        {
+ v* B7 v! n: W* x  M                std::generate(vec1.begin(), vec1.end(), []() {
                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;
" V. m5 |! {/ m" f8 U                        });

. [3 N. n3 y* c5 x+ i- D: N                std::generate(vec2.begin(), vec2.end(), []() {
, t" Y8 u& a$ A! z7 A, t                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;
                        });
. t! z1 S6 L2 I; N- f
                for (size_t jj = 0; jj < vec1.size(); jj++)
                {
9 ?" V( \0 J; u) I9 \5 M  [                        b1[jj] = vec1[jj];
7 O) E+ x7 A7 d6 y9 I                }
: a* A( G1 R5 g0 O
9 A' p/ V4 {2 A8 G/ ?; H6 R                for (size_t jj = 0; jj < vec2.size(); jj++)
% `7 z. q+ [- S                {
                        b2[jj] = vec2[jj];
. ?' J6 @6 g, `6 ^0 m. r$ l% x& Y                }

1 b! l5 n- g3 x0 q0 _: j' b7 ?, u                //Method - 1  N=100000 247s  
1 U  C) w$ t, I- q                //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);
) X0 p# y; V# a( k2 X  v                                
                //Method - 2  N=100000  237s
                /*
                for (int jj = 0; jj < N ; jj++)
                {
4 x# g; U- l% c                        fresult += vec1[jj] * vec2[jj];
                }
4 K5 m- W: Z& O- `0 v                */
                                
9 S! ~" B- T  t                //Method - 3  N=100000 204s
6 o& N6 L; r5 a+ {                /*
# Y4 U" u) a0 ?" b                for (int jj = 0; jj < N; jj++)
) u- A- \4 D. v4 C6 q' W; ^                {
6 y7 y& g6 \5 v- X8 U3 @5 q9 }. m                        fresult += b1[jj] * b2[jj];
                }
% d2 ]( H3 h% z0 p7 ]! ^  G                */
: s2 P$ X$ i! f
                //Method - 4   202s
                /*
; k2 y) v2 M7 U; i, Y( K: [; r                for (int jj = 0; jj < N; jj++)
                {
                        
                }
                */
7 P# W/ D+ Y+ ]' W: M4 Z2 b                //comment out all methods, N=100000  202s               
        }

1 ?$ C+ u; @9 [        delete []b1;
        delete []b2;

机器猫

瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同？
9 u# B/ |$ A4 e. r  P
你第二个试验里面的j在循环里面又重新定义了啊，你确定真的跑了6000次？
' J) \# t! N& Q3 V7 u  w# P

雷达

机器猫 发表于 2022-9-27 00:15
: ?! t# S" V& l% b$ \+ u+ S瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同？
. q8 p8 I! e% S) f" I
你第二个试验里面的j在循环里面又重新定义 ...

" t- c/ \  @3 s. o内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL

) B$ F7 L  x. S# d不和它较劲了，瞎耽误工夫，我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。

机器猫

雷达 发表于 2022-9-27 01:16
3 w# D0 Q7 x3 M2 B! A6 Q9 d内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
2 }" `0 m+ G' N
不和它 ...

# b) Q. T4 Z* \9 |# E1 o8 N! d
' V, W4 @0 R: O, v+ P# x不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的，很有可能是在stack上，这样内存读写会更多，要是再碰上每次都需要加载cache就更慢了。
0 Y6 Y  i  z/ n) {2 Z" Y后面一个是在循环那里定义的，说不定编译器就把它优化成register变量了

opensrc

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

雷声

雷达 发表于 2022-9-24 23:54
- g+ {, `+ c  Q& h0 f* r% Bvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
{
        comp temp, xtimesy;

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