C++ 提速的新发现

雷达

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

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

速度优化问题真的很有意思啊。
* b  w( [( I$ {9 R
欢迎大家继续讨论

数值分析

拉下来？拉多少？
把代码贴上来看看？
0 }6 |# c5 u2 j$ c
难道分支预测不准破坏流水线执行？不该啊。

沉宝

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

风雨无阻

Maybe Debug mode?

雷达

% z" L$ \3 j, X  V

数值分析 发表于 2022-9-24 23:04
) v0 b2 d5 U  G$ e4 \2 Y' l拉下来？拉多少？
把代码贴上来看看？

; o! J2 g. O3 S
void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
{
        comp temp, xtimesy;
9 Y) ~! v9 ~9 D7 L; z/ o# r3 `        xtimesy.re = 0;
        xtimesy.im = 0;
  ~, i# h" J" R: \' q" M        int j0 = lenB - 1;
- G5 `3 }: A! [. F        int    i, j, i1, reali;
' h) R8 r) m, u, [: @! u, v; V( l9 R        if (lenA % 2 == 1)
& S) m& M. _' g+ B! H                reali = lenA + 1;
( l; z3 p$ B8 r; W% r6 H" a        else
                reali = lenA;
        reali /= 2;
$ L; g* l$ ?! J/ @" d, x. W
        int nconv = reali + lenB;
/ {4 W% W/ l5 ~& F) F$ r7 x        //#pragma omp parallel for
        for (i = reali; i < nconv; i++)
        {
4 B. ~. m2 e7 Q5 h, v                temp.re = 0;
                temp.im = 0;
" \9 {3 N) L5 L  C                i1 = i;
0 H! y7 C6 W. R/ R7 O2 l& V$ U                for (j = j0; j >= 0; j--)
% f( \) ?! N& v; u7 i                {
                        /* floating date operation */
' I$ o9 x8 p. ~( ?                }
        }
}

xcorr函数代码如上，comp是复数struct, 做过长度为11、19两个矢量的测试，和octave结果完全一样
) \  n$ T/ Q- m$ y, D
红色部分是内循环，现在其内部操作都comment out 了, j0大概是 6000。
现在call xcorr 100次，耗时78s.
: ?8 I: i9 Y( H+ z
: M; T- t- _2 y1 R5 x$ ]如果把红色部分内循环本身完全comment out， call xcorr 1000次，耗时 <1s.

1 z5 ~( _% Y; l# }, R# `

雷达

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

# `) e2 I4 `# n9 o% W* _( ~+ e. G
不应该，看我上面的回复。
' r& i: e9 B/ f& l& F3 y7 k
我更怀疑是 VS 社区版的问题

数值分析

雷达 发表于 2022-9-24 23:54
void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
' c, Q0 M- W) c' y9 j# l{
        comp temp, xtimesy;

! {  u3 B. j; o& C这个不是这么比的吧。。。

您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。
* V- f: [7 x' o$ H9 z( v7 G7 D
* {: \7 P/ ?: ]2 X5 V! Q$ W而加上内循环，光jmp和dec指令就至少多执行了6000个，慢个几十倍不是正常的么？

雷达

$ a' ]" Q' C. w7 P. k% O' M- R

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

+ w7 F% F# ]$ n  L# o6 l2 l% R您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。

+ N6 }$ D" l8 E3 Q+ `# U有道理。
所以存在内循环速度就上不去，把内循环取消，改成两个向量直接点乘再求和应该就会好得多，记得 numeric 库里有算向量内积的，我回头试试。

0 P* C4 v' i5 j3 C我先尝试尽量用标准库，一个小程序，不想搞得太复杂。多谢了

沉宝

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

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

沉宝

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

% Y) `: _% M/ [$ i您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。

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

5 i% Y; c2 A; d* N0 _
- l; K- {: H0 j( B8 m7 N9 [2 {现在的CPU，可以把判断、jmp和dec指令全部融合进一个µOp（微操作，CPU内部流水线上的执行单位）。如果循环这样跑，花不了多少时间。

数值分析

0 f% w$ E$ y# o) `# `: K, |$ a

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

是的，兄台说的对。
2 \, k2 _- u' k3 F
其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。

雷达兄构造测试用例的时候，屏蔽掉了所有计算的部分，使得剩下的都是overhead，这样run time比较的结果就显得好像不合理了。如果把计算加回去，计算部分的run time会dominate，结果就不那么离谱了。因为不好说，所以用指令数对比的方式试图直观地说明这一点。
: A+ K9 U# v+ S# H
比如说，如果有计算，那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做，另一边是六千个循环，那六千个循环比什么都不做慢几十倍了，就不是那么不合理了。

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

雷达

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

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

1 }$ v' x$ h2 F$ v- N- f0 X: A- O我已经完全懵了。

沉宝

雷达 发表于 2022-9-25 04:47
, y$ u4 d: ~1 Z* s2 f  c$ I又写了个小实验，没有调用子函数，双层循环，外层6千次，内循环30万次空转，有或没有空转内循环，时间差 ...

时间差一倍的结果可以接受。
% q! y. ~: a& }, z) [: W+ O- H7 j- J
你还是用profile工具看看吧。现在大家都主观瞎猜。

数值分析

% W/ u3 @, t/ P, K4 i$ V

雷达 发表于 2022-9-25 04:47
& n( E% R) ^# @# r! S4 P又写了个小实验，没有调用子函数，双层循环，外层6千次，内循环30万次空转，有或没有空转内循环，时间差 ...

: L  T! q" t) b

  U' n* L8 h5 n0 r4 v; m2 }7 J6 I能不能把这个也贴上来，看看和上一个有什么不同？

雷达

数值分析 发表于 2022-9-25 14:58
: S/ I" t# ~- [, r能不能把这个也贴上来，看看和上一个有什么不同？

$ F' y$ P3 Z  `2 c# {理了理思路，重新做了一个测试。
做了两个 vector 和 两个 float *, 都长 100000
- k% i) o& `# S外循环 6000，里面先做随机数生成，模拟真实环境，避免数据的 cache.

内循环试了4种方法，
1. 直接调用 vector inner_product 247s
3 {/ c. ~$ |/ \9 p' u. R2. vector 循环点乘累加 237s
" @; @# U# D- H# F! \. m3. float * 循环点乘累加 204s
4. 空循环 100000 次 202s
. J3 K) s+ f7 N, c7 [9 s+ G
不做内循环 200s
8 g& R+ Z+ o4 E  p  m( F
5 w- \  `1 [1 f& ?& e) e" H你昨天说的对，内循环本身占比是很小的，大头在其他处理。
另外可以看到， float * 循环点乘累加 并不差，比用vector 还更快。

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

4 Y" Z) c  j2 ]- i/ H* j8 K（为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ？方括号 i 消失了。 LOL . 改成  jj 好了，原来 方括号里的 i 是斜体标志  LOL）

        std::vector < float > vec1(N);
        std::vector < float > vec2(N);
        float* b1 = new float[N];
        float* b2 = new float[N];
) k# x/ x9 i( b. A$ K
% j+ k- t: @1 B$ n1 S        for (int j = 0; j < 6000; j++)
        {
                std::generate(vec1.begin(), vec1.end(), []() {
0 k. H" F" w% X1 C" M7 M/ F& I                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;
                        });
: ^  Q7 h. t' P9 g7 f0 O
2 ~1 s! z1 D! \- x) t/ w                std::generate(vec2.begin(), vec2.end(), []() {
9 k' P0 w! P7 }. B6 ?8 k# C, q                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;
4 r  i5 N$ O/ R                        });

                for (size_t jj = 0; jj < vec1.size(); jj++)
                {
                        b1[jj] = vec1[jj];
, ?0 Y, Y6 u4 u4 {% }5 h                }

0 r6 t) r& d8 ~( ~                for (size_t jj = 0; jj < vec2.size(); jj++)
                {
" c( @% f1 m* G                        b2[jj] = vec2[jj];
/ V1 X. C, D: _                }
- ^5 i' a; f5 C$ D/ [5 Y# K  J4 J: B
                //Method - 1  N=100000 247s  
                //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);
% F. L2 |+ a: z0 Q" @" ^                                
  a$ o6 C! K6 H6 a  R; b1 Q: ^                //Method - 2  N=100000  237s
                /*
                for (int jj = 0; jj < N ; jj++)
                {
                        fresult += vec1[jj] * vec2[jj];
& c7 [) _7 {# U" L1 ]/ G                }
5 f. V% d% n7 ~# i                */
: R/ Y6 \) o% ^3 W3 _                                
                //Method - 3  N=100000 204s
                /*
4 D( {# P# u8 M# ], K, u8 J" I                for (int jj = 0; jj < N; jj++)
                {
                        fresult += b1[jj] * b2[jj];
( c$ Q4 J0 k, P$ w- D                }
9 E0 `+ `/ L8 v" [                */
' B9 n  ^; P6 V: ~
6 i: P  h- `2 v* ^5 w6 a                //Method - 4   202s
5 w2 q  W) m# C: u7 Y  k! w                /*
                for (int jj = 0; jj < N; jj++)
1 K" k' D7 P' d1 ]2 V. g' [9 U& J                {
$ r8 o3 C1 L* K, E) q                        
$ w' |: \/ L% d/ k5 n8 ?                }
* `! D9 j# L; k# A                */
( C: Q/ |/ {" g1 k& {3 {                //comment out all methods, N=100000  202s               
  h+ S7 j) s$ e. z. a, p7 ~        }

        delete []b1;
' L5 |3 _8 n1 ?        delete []b2;

/ B& N0 A; m" `( u# g: w

机器猫

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

/ n- k+ h0 q  L& B7 P, z你第二个试验里面的j在循环里面又重新定义了啊，你确定真的跑了6000次？
$ V% F, W) Q0 l5 n7 ^) y  P$ w3 E" P: d

雷达

机器猫 发表于 2022-9-27 00:15
" i3 y  y* A' s/ U+ G! n( i% ~瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同？

6 u) g1 F1 P9 I- t7 l) Y你第二个试验里面的j在循环里面又重新定义 ...

% z5 V: g) j' p$ V内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL

不和它较劲了，瞎耽误工夫，我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。

机器猫

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

不和它 ...

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

opensrc

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

雷声

雷达 发表于 2022-9-24 23:54
void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
{
. [& w' l3 A3 ~' e3 `  u1 v' |        comp temp, xtimesy;

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