C++ 提速的新发现

雷达

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

3 N7 o5 U1 Q$ E6 L) \$ c0 {7 B0 J自相关两层循环，内层循环涉及浮点数计算，试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了，看来问题并不在浮点计算。

4 N+ \) b5 W% B. [  \) G速度优化问题真的很有意思啊。
3 L' c8 @9 D% I* d) Y: Y& }
欢迎大家继续讨论

数值分析

拉下来？拉多少？
把代码贴上来看看？
2 x" @2 ^( R, R/ u8 Z/ X; n
难道分支预测不准破坏流水线执行？不该啊。

沉宝

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

风雨无阻

Maybe Debug mode?

雷达

数值分析 发表于 2022-9-24 23:04
拉下来？拉多少？
4 W9 J2 a7 L. y. L把代码贴上来看看？

5 ~4 e; ~, n& g# g5 B/ \
2 R( R5 s6 [  {: t; g4 svoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
{
& @' B' t/ b' P& q        comp temp, xtimesy;
        xtimesy.re = 0;
9 w6 z* V! C' z% |0 K& L        xtimesy.im = 0;
        int j0 = lenB - 1;
        int    i, j, i1, reali;
        if (lenA % 2 == 1)
3 e- N+ o2 ^7 O& M                reali = lenA + 1;
        else
                reali = lenA;
        reali /= 2;

  C) L0 U( D. C" I5 O/ v9 i7 @        int nconv = reali + lenB;
/ Y- L1 @! |/ e6 o8 f% T: {; e& C, Q        //#pragma omp parallel for
        for (i = reali; i < nconv; i++)
7 W& t! t5 [- V        {
                temp.re = 0;
" M) w9 k  e; m" F+ H, y9 e/ F                temp.im = 0;
: ^) {0 o: X, E- o5 F: O- f                i1 = i;
                for (j = j0; j >= 0; j--)
                {
                        /* floating date operation */
                }
# G. ~; [% h/ g3 d" \, I  y        }
}
/ I* y, P4 ^2 x: t, E
xcorr函数代码如上，comp是复数struct, 做过长度为11、19两个矢量的测试，和octave结果完全一样
# l; Y: Z0 t) s) ^) R: X
. ^" ^5 e: V8 n$ ^  I, D红色部分是内循环，现在其内部操作都comment out 了, j0大概是 6000。
现在call xcorr 100次，耗时78s.
- {+ q& c* o# Z# |/ a( t4 X
如果把红色部分内循环本身完全comment out， call xcorr 1000次，耗时 <1s.

1 T. e/ o. W) U. X9 _

雷达

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

  F. o/ D) m# a
) u" q& ~( `3 F9 R) |; G不应该，看我上面的回复。

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

数值分析

+ c1 U" S. i8 T( G

雷达 发表于 2022-9-24 23:54
# |8 s1 P+ p1 Y( ]4 Yvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
1 }5 _- H6 K: k7 A0 [% ~" J{
# C& R+ G7 z3 n; ?; l/ `- q        comp temp, xtimesy;

" T" M3 ]$ \$ X/ |1 E
这个不是这么比的吧。。。

您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。

而加上内循环，光jmp和dec指令就至少多执行了6000个，慢个几十倍不是正常的么？

雷达

$ n# G8 J( h8 X  Y

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

% E( D- x' w. }! R/ I您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。

3 p# J5 X; H3 t5 x& @7 B: L有道理。
所以存在内循环速度就上不去，把内循环取消，改成两个向量直接点乘再求和应该就会好得多，记得 numeric 库里有算向量内积的，我回头试试。

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

沉宝

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

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

沉宝

数值分析 发表于 2022-9-25 00:20
这个不是这么比的吧。。。
, b  q7 q$ r" X9 {
您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。

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

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

数值分析

9 L3 k( a2 b0 @: J& a

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

$ R! q" K) k- \
7 W! K* u% H$ E是的，兄台说的对。
" W% {0 K  V( Z7 V
其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。
3 ]; n+ U" |$ h4 |& `  P2 e+ r1 E4 k
( E6 `" B) C7 G0 T雷达兄构造测试用例的时候，屏蔽掉了所有计算的部分，使得剩下的都是overhead，这样run time比较的结果就显得好像不合理了。如果把计算加回去，计算部分的run time会dominate，结果就不那么离谱了。因为不好说，所以用指令数对比的方式试图直观地说明这一点。
7 O6 K" F& m0 a8 G" T# n
比如说，如果有计算，那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做，另一边是六千个循环，那六千个循环比什么都不做慢几十倍了，就不是那么不合理了。

) H6 W& `) M# S6 O) @8 M当然也有可能像兄台说的，是优化参数的问题，但我觉得更多地是测试用例设计的不合理。

雷达

  T5 ]# k) E& u2 J

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

又写了个小实验，没有调用子函数，双层循环，外层6千次，内循环30万次空转，有或没有空转内循环，时间差一倍，我上面这个差的太多了。
! @' g+ J! X' ?3 s
我已经完全懵了。

沉宝

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

2 `6 ~" }% G/ |! w  R3 g4 i& P% \; w时间差一倍的结果可以接受。
: t. I5 f$ y: E; @+ e. D
你还是用profile工具看看吧。现在大家都主观瞎猜。

数值分析

雷达 发表于 2022-9-25 04:47
- p, C% s% o" ]. Q$ n5 B又写了个小实验，没有调用子函数，双层循环，外层6千次，内循环30万次空转，有或没有空转内循环，时间差 ...

* K+ h+ T+ Z* w1 h$ Q+ \


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

雷达

9 z% n: k7 o) ~+ s  A- d2 E

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

: h' u" q! t/ j3 `8 M2 I+ Y理了理思路，重新做了一个测试。
3 y+ X" d9 d4 X" K( V) l做了两个 vector 和 两个 float *, 都长 100000
外循环 6000，里面先做随机数生成，模拟真实环境，避免数据的 cache.

' ]+ f5 s6 k- U- Y, ?内循环试了4种方法，
1. 直接调用 vector inner_product 247s
% N# w$ M" x/ d  g: n+ V# P6 ~7 l2. vector 循环点乘累加 237s
3. float * 循环点乘累加 204s
$ f; Y  v; |1 X% B4. 空循环 100000 次 202s
5 H8 Y$ y+ H$ Z  z
% t9 i/ l1 N2 ?6 [3 }( Y不做内循环 200s

: O& ?# J; X% F5 i你昨天说的对，内循环本身占比是很小的，大头在其他处理。
另外可以看到， float * 循环点乘累加 并不差，比用vector 还更快。
$ s1 I5 G2 M6 P/ M) h" Y9 w
. j- [( ^! s' f至于我那个原始程序，还有一些疑问，见5楼，其他都不变仅仅是有无空的内循环就有很大不同，这是不对的，也许有一些其他缺陷我没有看到。（也许可以改成 while 试试）

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

        std::vector < float > vec1(N);
        std::vector < float > vec2(N);
        float* b1 = new float[N];
: k& Z/ v, |( k% E! {+ U        float* b2 = new float[N];

: ~! S) O& {  x8 `        for (int j = 0; j < 6000; j++)
        {
8 ~3 r8 S3 K: _! |0 t% A$ e+ s6 X( H                std::generate(vec1.begin(), vec1.end(), []() {
% _4 ~( O2 U" C                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;
                        });
) X* w7 _+ K7 ~/ Y
( W4 e; ~) q% ]1 L9 T! l                std::generate(vec2.begin(), vec2.end(), []() {
                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;
# ~$ h0 [7 O3 e8 b) [                        });
' K, p$ I3 f6 R' |
                for (size_t jj = 0; jj < vec1.size(); jj++)
                {
+ R9 }8 D6 p/ F1 s3 c                        b1[jj] = vec1[jj];
) l. P" k% a/ X  `0 J1 _                }

                for (size_t jj = 0; jj < vec2.size(); jj++)
* E9 L/ b  N/ b                {
: Q# d5 Z2 ^- o9 S                        b2[jj] = vec2[jj];
2 G* B5 u" L/ o* a2 J$ w8 c$ s                }
  C) c$ l" y6 A. U; Q; r7 [- W# U
( `8 w: w1 }( s* i: r. r( D                //Method - 1  N=100000 247s  
; h+ e( _3 y  \: A                //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);
4 ]6 J0 |9 S  a5 P, r7 L: ?                                
& a2 _9 @& {& D0 H                //Method - 2  N=100000  237s
                /*
8 F3 |! \, I" i' `0 H                for (int jj = 0; jj < N ; jj++)
+ v  u: t4 D0 m1 q9 M! U                {
0 ~4 s6 K! Y7 ^! I1 m                        fresult += vec1[jj] * vec2[jj];
                }
                */
' {: V4 E' {) O  a/ i7 c                                
( _& T# U3 l! |7 _2 x                //Method - 3  N=100000 204s
! P) o, `. ?, @; l                /*
                for (int jj = 0; jj < N; jj++)
                {
                        fresult += b1[jj] * b2[jj];
                }
: ?3 ]. u+ s, e. s                */
6 u: J) ?5 F4 F" I( W
                //Method - 4   202s
                /*
                for (int jj = 0; jj < N; jj++)
                {
3 T; \7 n* x2 q2 v; G                        
                }
2 ^3 y3 k3 D" e. e/ u5 X                */
; K* ~" ?$ A5 o: Y3 X: W9 @                //comment out all methods, N=100000  202s               
        }

* Q* O; _/ r: l  N; |7 V6 z( \3 F        delete []b1;
        delete []b2;

机器猫

瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同？
; I& @  O" f! V, P8 p
你第二个试验里面的j在循环里面又重新定义了啊，你确定真的跑了6000次？
/ P. g, D! M( r5 v& s. E3 g

雷达

机器猫 发表于 2022-9-27 00:15
- j7 v- B0 i# G& F瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同？
, l) j8 R# g) g& x5 @
' p# t6 c1 t8 ~: O! L( H% r你第二个试验里面的j在循环里面又重新定义 ...

内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
4 q$ Q& _2 ?7 C# {9 C. f
$ C+ N# V8 D- g  C5 ~1 l不和它较劲了，瞎耽误工夫，我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。

机器猫

雷达 发表于 2022-9-27 01:16
/ u9 M+ [. j/ F: w内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
& J  F  b5 z' S& ?: t
+ P# P( k1 V# P& i不和它 ...

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

opensrc

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

雷声

雷达 发表于 2022-9-24 23:54
void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
9 q2 Q  h0 l0 V1 Z0 u{
        comp temp, xtimesy;

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