C++ 提速的新发现

雷达

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

自相关两层循环，内层循环涉及浮点数计算，试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了，看来问题并不在浮点计算。
1 I( L1 c2 g- r1 x. s8 Y
速度优化问题真的很有意思啊。

. k, G/ {! J* h% v' _1 [欢迎大家继续讨论

数值分析

拉下来？拉多少？
# m# z' p% N: c' Q0 t, ^把代码贴上来看看？

7 Y2 K! t, Z( b7 p1 E' `" A7 M7 |难道分支预测不准破坏流水线执行？不该啊。

沉宝

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

风雨无阻

Maybe Debug mode?

雷达

4 T8 k( {3 X1 r

数值分析 发表于 2022-9-24 23:04
拉下来？拉多少？
把代码贴上来看看？

- y5 H% o6 w! `( x7 ovoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
8 e& Z+ S- }  @; u/ S# q{
5 ^$ r1 G, r8 y        comp temp, xtimesy;
        xtimesy.re = 0;
        xtimesy.im = 0;
        int j0 = lenB - 1;
        int    i, j, i1, reali;
( T! w- N9 g0 \- ~. n& i9 d" p/ \% U        if (lenA % 2 == 1)
                reali = lenA + 1;
        else
                reali = lenA;
& U' P9 i& k$ l! J& {/ i5 M        reali /= 2;
* t* n  F- h( I4 {" Z
0 r$ ~0 V0 y! {: B$ h        int nconv = reali + lenB;
        //#pragma omp parallel for
# D& P# t3 N& l& }7 y4 @        for (i = reali; i < nconv; i++)
& T! r4 @  ~) K        {
                temp.re = 0;
                temp.im = 0;
                i1 = i;
1 I7 O: i; u" i( w                for (j = j0; j >= 0; j--)
                {
                        /* floating date operation */
                }
, S, W! o/ W* B4 U, z: O+ \, k        }
  s* R7 H( u: _1 I5 d( `}

xcorr函数代码如上，comp是复数struct, 做过长度为11、19两个矢量的测试，和octave结果完全一样
" g" P4 a. C6 |
红色部分是内循环，现在其内部操作都comment out 了, j0大概是 6000。
现在call xcorr 100次，耗时78s.

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

: p( e. x* Q) x1 U& b

雷达

风雨无阻 发表于 2022-9-24 23:33
/ [/ Y* i' t, o: b- R' K5 oMaybe Debug mode?

% v5 p# C5 M  T" w. Z7 ]' K5 Z
不应该，看我上面的回复。

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

数值分析

/ `' d9 W. d" O1 }

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

: |0 W) U" S+ _& P/ M; T这个不是这么比的吧。。。
: G; f+ C+ v* ^+ q
$ p/ }: Y' U  U) @您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。

6 e& }9 K$ J% G/ c而加上内循环，光jmp和dec指令就至少多执行了6000个，慢个几十倍不是正常的么？

雷达

. U# w. ^) w3 a

数值分析 发表于 2022-9-25 00:20
; Q% t$ o1 W% c) ]. a9 o这个不是这么比的吧。。。

& k2 x2 T8 z4 @$ s9 x您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。

4 w7 C9 K% S8 j9 k) ?有道理。
所以存在内循环速度就上不去，把内循环取消，改成两个向量直接点乘再求和应该就会好得多，记得 numeric 库里有算向量内积的，我回头试试。
8 o7 Y* R% N1 o% D. G9 Q
我先尝试尽量用标准库，一个小程序，不想搞得太复杂。多谢了

沉宝

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

& H8 Z$ U% J3 a0 z你两个试验之间就差了一个空循环， call 1000次按理不会有秒级差异，可能还是编译器优化的问题。举个例子，把循环本身翻译成机器指令loop或dec/jnz，两者速度上会差很多
/ j2 i( F- }+ M, |. M$ s* XWhy is the loop instruction slow? Couldn't Intel have implemented it efficiently?

沉宝

数值分析 发表于 2022-9-25 00:20
这个不是这么比的吧。。。
2 m' v4 _/ q+ Y1 f. D. Z$ f7 c# `
  a* s6 h) k7 C1 k) L0 I6 \您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。

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

+ c9 x3 R7 m7 ^6 N  @6 A  Q
现在的CPU，可以把判断、jmp和dec指令全部融合进一个µOp（微操作，CPU内部流水线上的执行单位）。如果循环这样跑，花不了多少时间。

数值分析

  m, X: H3 Q2 u

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

& L& S6 @# F: ^: ]
$ g6 N+ Q& ]; r; ~是的，兄台说的对。

& P( J: L: ?+ }. H& L; T4 ?其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。

9 z3 ^+ n+ N" f. C% x* _8 y: z$ }6 C/ H雷达兄构造测试用例的时候，屏蔽掉了所有计算的部分，使得剩下的都是overhead，这样run time比较的结果就显得好像不合理了。如果把计算加回去，计算部分的run time会dominate，结果就不那么离谱了。因为不好说，所以用指令数对比的方式试图直观地说明这一点。

  \: K3 X+ T1 X( N# t3 T比如说，如果有计算，那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做，另一边是六千个循环，那六千个循环比什么都不做慢几十倍了，就不是那么不合理了。
+ G) F, u; R- ~
! @6 x* m/ s3 ^$ L* O: p当然也有可能像兄台说的，是优化参数的问题，但我觉得更多地是测试用例设计的不合理。

雷达

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

又写了个小实验，没有调用子函数，双层循环，外层6千次，内循环30万次空转，有或没有空转内循环，时间差一倍，我上面这个差的太多了。

9 a8 e1 T4 _; X; A我已经完全懵了。

沉宝

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

时间差一倍的结果可以接受。
4 N& a1 }* B9 Z/ z2 X' k
你还是用profile工具看看吧。现在大家都主观瞎猜。

数值分析

% k5 y* P  I0 e& E) K0 v

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

. r! S2 o3 M* W, C3 S  u9 o
% d1 J6 F5 h! A9 D2 }+ @! R/ A

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

雷达

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

理了理思路，重新做了一个测试。
做了两个 vector 和 两个 float *, 都长 100000
7 ~! T) n0 d5 ?) `( A外循环 6000，里面先做随机数生成，模拟真实环境，避免数据的 cache.
8 o5 ?( n! Z: ?( G- r9 {
内循环试了4种方法，
1. 直接调用 vector inner_product 247s
+ N* y8 A& F7 b! ^: a1 m: Y0 O2. vector 循环点乘累加 237s
" ^" }; M" s6 v4 C3. float * 循环点乘累加 204s
% H" [' m% E2 S# K% F4 }4. 空循环 100000 次 202s

# I( q8 P& [2 f不做内循环 200s
- K3 u0 A" S2 L# }
  C- b$ b* s6 a/ l6 w) s你昨天说的对，内循环本身占比是很小的，大头在其他处理。
% {8 f0 F: h% T- J/ H另外可以看到， float * 循环点乘累加 并不差，比用vector 还更快。
; x% r  \7 m* Z9 s% \% b% ]# |
0 ^5 k7 {0 s7 e9 i6 v9 y# [至于我那个原始程序，还有一些疑问，见5楼，其他都不变仅仅是有无空的内循环就有很大不同，这是不对的，也许有一些其他缺陷我没有看到。（也许可以改成 while 试试）

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

        std::vector < float > vec1(N);
( u- b# [6 ?7 d) I; r6 [9 R        std::vector < float > vec2(N);
        float* b1 = new float[N];
        float* b2 = new float[N];

! Z3 G) o4 g8 A        for (int j = 0; j < 6000; j++)
* S4 H- J" P8 U3 Q# q9 s- c2 |1 t        {
                std::generate(vec1.begin(), vec1.end(), []() {
                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;
0 [  d3 _5 L& P  z                        });

                std::generate(vec2.begin(), vec2.end(), []() {
                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;
: q/ A  L  D8 v, W3 }2 i/ v                        });

3 o: G, F) U% [) Y3 n: f                for (size_t jj = 0; jj < vec1.size(); jj++)
                {
                        b1[jj] = vec1[jj];
                }

* n6 Q8 n' c* b                for (size_t jj = 0; jj < vec2.size(); jj++)
                {
2 \( \. L( R  c' d' K" B                        b2[jj] = vec2[jj];
                }
# [8 x8 H2 g5 Y
                //Method - 1  N=100000 247s  
4 c2 H6 }( |, p                //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);
/ W0 L: t& }. H                                
                //Method - 2  N=100000  237s
                /*
                for (int jj = 0; jj < N ; jj++)
                {
                        fresult += vec1[jj] * vec2[jj];
; j4 ^4 E3 m, h# v! H; u* l                }
                */
                                
5 E5 }3 X$ v- L' K8 D                //Method - 3  N=100000 204s
( c4 t) S3 _) ~2 }5 `- c; z6 o                /*
1 q3 n# C" `( G5 R3 \: g+ R                for (int jj = 0; jj < N; jj++)
                {
                        fresult += b1[jj] * b2[jj];
                }
% K& _/ R% f+ b& j2 Y2 G$ p$ m                */

( w. d4 {6 _8 N2 d4 _                //Method - 4   202s
                /*
                for (int jj = 0; jj < N; jj++)
0 L8 ^# }: h- w& Z                {
                        
                }
: R5 n& k) e8 \4 L                */
2 ^( Z+ o) j4 q" d( R- E# d                //comment out all methods, N=100000  202s               
0 _( W# Z0 g8 u3 D* a4 S        }
- `9 S) I& _( J
        delete []b1;
        delete []b2;

, Z& F& R7 g, U8 T, r, u: v

机器猫

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

0 s2 |4 w$ @6 M$ F" r  b$ P& [你第二个试验里面的j在循环里面又重新定义了啊，你确定真的跑了6000次？

雷达

机器猫 发表于 2022-9-27 00:15
% _: l' j  C7 d. F# f' b3 q瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同？
+ |' ?2 P) B5 `7 e3 G
1 t7 U& D' q& b- U* q. E你第二个试验里面的j在循环里面又重新定义 ...

9 A* s% e! g4 U) H内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
9 Z  {  R  Y3 U0 H+ \) Y- q
不和它较劲了，瞎耽误工夫，我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。

机器猫

雷达 发表于 2022-9-27 01:16
2 \3 z/ g0 n9 M% J" |& l' |内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL

7 _. X9 m& t, @7 B不和它 ...

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

opensrc

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

雷声

雷达 发表于 2022-9-24 23:54
3 W& B  W7 O* H: ~void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
{
# T/ l0 n: D% I+ D1 i% d        comp temp, xtimesy;

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