C++ 提速的新发现

雷达

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

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

* O: @9 ]* h9 C" f1 |1 h( G速度优化问题真的很有意思啊。
+ G- w( |1 g+ T: p7 G+ |- A
0 [. w& q/ w6 w9 A* T欢迎大家继续讨论

数值分析

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

难道分支预测不准破坏流水线执行？不该啊。

沉宝

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

风雨无阻

Maybe Debug mode?

雷达

# ]- L+ D3 Y# x

数值分析 发表于 2022-9-24 23:04
/ b! k$ i- t6 C6 J1 ?" B5 V拉下来？拉多少？
; w" }5 M" l. ^( l+ _, D把代码贴上来看看？

: A! ^# ~+ Q2 l
$ k% }& k( o: |7 X% fvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
  L' U  L5 {& }# B8 |) R5 |{
        comp temp, xtimesy;
        xtimesy.re = 0;
        xtimesy.im = 0;
7 o" S3 A, ^5 t. `: C        int j0 = lenB - 1;
        int    i, j, i1, reali;
        if (lenA % 2 == 1)
                reali = lenA + 1;
! x  M" o" F2 x* ^$ ?9 Z  }+ n        else
                reali = lenA;
        reali /= 2;
9 K- R0 Z+ W; c9 O& }
% D' J+ s% _1 @+ j) ?4 C( F        int nconv = reali + lenB;
        //#pragma omp parallel for
        for (i = reali; i < nconv; i++)
$ B1 w0 [/ b& {, m+ ~2 f5 E! p        {
* Q+ l  D- A! F( ]. |5 n5 O                temp.re = 0;
& A, R: p* @" w9 T                temp.im = 0;
8 f) K* [4 }3 Z, j                i1 = i;
                for (j = j0; j >= 0; j--)
& k) P* ?. T5 v7 u                {
                        /* floating date operation */
                }
. Q+ p8 I6 ]" p6 c& H$ t" v        }
/ [% a$ X. K) Z( T+ d! [}

) i4 G) ]: L9 m) zxcorr函数代码如上，comp是复数struct, 做过长度为11、19两个矢量的测试，和octave结果完全一样

' L& @# g) o4 ^$ y红色部分是内循环，现在其内部操作都comment out 了, j0大概是 6000。
0 R# G; Z8 m! ]8 V2 m% L, U现在call xcorr 100次，耗时78s.

" m2 Q) q$ g. I/ O4 F" M如果把红色部分内循环本身完全comment out， call xcorr 1000次，耗时 <1s.
6 i( G9 Q3 p& d8 c6 J: G
! W5 Q1 R8 [1 N& _, n! A- V9 Y+ N

雷达

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

* u) B  d: `' }, K不应该，看我上面的回复。
$ c& M3 x9 X1 u0 a) p$ p
我更怀疑是 VS 社区版的问题

数值分析

1 X+ ^& v/ S  \

雷达 发表于 2022-9-24 23:54
void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
) d, c- `9 F4 P+ n4 i) v  I{
        comp temp, xtimesy;

这个不是这么比的吧。。。

您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。
! i0 b# n" s1 w* e
而加上内循环，光jmp和dec指令就至少多执行了6000个，慢个几十倍不是正常的么？

雷达

数值分析 发表于 2022-9-25 00:20
9 R" n7 W0 g+ x9 b这个不是这么比的吧。。。
5 c8 B7 {: X% q1 l
您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。

/ q$ I, y6 |6 u- n
有道理。
7 |. H. A3 i( C4 M: ~- b所以存在内循环速度就上不去，把内循环取消，改成两个向量直接点乘再求和应该就会好得多，记得 numeric 库里有算向量内积的，我回头试试。
9 s/ E) |& r. Y
$ s/ b# f4 c# ]" i我先尝试尽量用标准库，一个小程序，不想搞得太复杂。多谢了

沉宝

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

' A* n$ e& u) q6 }  A: N你两个试验之间就差了一个空循环， call 1000次按理不会有秒级差异，可能还是编译器优化的问题。举个例子，把循环本身翻译成机器指令loop或dec/jnz，两者速度上会差很多
/ s4 f- |) ]9 k* g+ @Why is the loop instruction slow? Couldn't Intel have implemented it efficiently?

沉宝

数值分析 发表于 2022-9-25 00:20
这个不是这么比的吧。。。
" v: E+ q* G5 ~; P+ S3 V9 G
# [+ ?% C$ B  `" @您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。

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

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

数值分析

% o+ q6 B! [( v; Y

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

3 g$ W2 U) i" w0 U" t& M4 S8 R( L是的，兄台说的对。

其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。

* A5 j" ?5 \  q雷达兄构造测试用例的时候，屏蔽掉了所有计算的部分，使得剩下的都是overhead，这样run time比较的结果就显得好像不合理了。如果把计算加回去，计算部分的run time会dominate，结果就不那么离谱了。因为不好说，所以用指令数对比的方式试图直观地说明这一点。
1 M$ V& H1 v7 W; T5 ~
比如说，如果有计算，那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做，另一边是六千个循环，那六千个循环比什么都不做慢几十倍了，就不是那么不合理了。
! y6 V6 J! T) N( h" h. Y  {8 D( K
& E& U; E6 o; t1 T( }当然也有可能像兄台说的，是优化参数的问题，但我觉得更多地是测试用例设计的不合理。

雷达

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

$ O$ A) Z- `: c7 r6 u1 F" u又写了个小实验，没有调用子函数，双层循环，外层6千次，内循环30万次空转，有或没有空转内循环，时间差一倍，我上面这个差的太多了。
5 g" @8 [8 s* s- B5 g6 |& R
我已经完全懵了。

沉宝

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

时间差一倍的结果可以接受。

/ z9 o9 `4 N/ n" C9 L( a你还是用profile工具看看吧。现在大家都主观瞎猜。

数值分析

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

9 v5 e+ w; @0 o5 j


) ^, ?( c3 q* Q8 Z2 v: J2 I  m能不能把这个也贴上来，看看和上一个有什么不同？

雷达

数值分析 发表于 2022-9-25 14:58
+ a7 d, o$ U9 [1 n9 q能不能把这个也贴上来，看看和上一个有什么不同？

* N$ V; u) \+ e' v" s3 l理了理思路，重新做了一个测试。
做了两个 vector 和 两个 float *, 都长 100000
外循环 6000，里面先做随机数生成，模拟真实环境，避免数据的 cache.
) z% s, w/ p/ a) H9 A9 |  Z
) v' a# B) o) {+ K0 y, B- L内循环试了4种方法，
1. 直接调用 vector inner_product 247s
! L- C' R6 Y1 x; W2. vector 循环点乘累加 237s
3. float * 循环点乘累加 204s
! ^6 [  @) e& ?& i/ K" |/ {4. 空循环 100000 次 202s

不做内循环 200s

  M0 t6 ~( |# T; w你昨天说的对，内循环本身占比是很小的，大头在其他处理。
另外可以看到， float * 循环点乘累加 并不差，比用vector 还更快。

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

% X( M6 m6 g" C: P! Z4 V7 d2 q（为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ？方括号 i 消失了。 LOL . 改成  jj 好了，原来 方括号里的 i 是斜体标志  LOL）
6 Z' o# D" j: f
! R, y# g3 W$ F6 T

        std::vector < float > vec1(N);
  r1 x0 g1 V( b1 r+ m        std::vector < float > vec2(N);
$ h+ G0 n8 E( B        float* b1 = new float[N];
: r9 ]" m5 o3 Y2 K: c( }( W, Z        float* b2 = new float[N];

        for (int j = 0; j < 6000; j++)
8 o& |$ ]& w! _% y        {
                std::generate(vec1.begin(), vec1.end(), []() {
: u4 L, B+ Z1 M+ o* J. n                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;
( S  P; [# X/ C% U; j- ^8 I                        });
  w5 l$ M- H/ j3 O3 a2 h6 f. `
                std::generate(vec2.begin(), vec2.end(), []() {
                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;
                        });
2 T) U" K$ d" U$ |) O2 }& u6 ~
; K: o6 ^- T" ~- h                for (size_t jj = 0; jj < vec1.size(); jj++)
3 `  p# D( S& U) z! h                {
+ {+ c  r0 M! X. S& o- v                        b1[jj] = vec1[jj];
% u! @. A: ~' W% p                }

                for (size_t jj = 0; jj < vec2.size(); jj++)
                {
                        b2[jj] = vec2[jj];
                }

& c( J% G- B* [                //Method - 1  N=100000 247s  
                //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);
                                
! y% Y# r6 A4 T+ L" C' l9 j5 M                //Method - 2  N=100000  237s
                /*
                for (int jj = 0; jj < N ; jj++)
; d# z" Y+ L( V! `; G8 u                {
                        fresult += vec1[jj] * vec2[jj];
                }
                */
1 s# V& N+ y& N/ d: v- T+ g2 c                                
                //Method - 3  N=100000 204s
: r9 r9 C; ^$ |2 ?                /*
                for (int jj = 0; jj < N; jj++)
% d6 p$ [7 x0 w& N                {
/ L: p) b6 V3 A1 W6 t: G4 C+ Z                        fresult += b1[jj] * b2[jj];
                }
                */
" ]; H3 m% j5 H# d7 I( i/ m
4 Y/ C/ T4 N. s$ ~+ {, J  U                //Method - 4   202s
2 P2 R- U3 W( J4 }                /*
$ M5 |  P' K/ E/ i4 [                for (int jj = 0; jj < N; jj++)
                {
                        
- l% w& w$ v3 D7 g) l2 I9 J9 O                }
                */
! L0 X7 w- `- }" W                //comment out all methods, N=100000  202s               
        }

        delete []b1;
% g% i; M# ?. c* }        delete []b2;

+ [5 }  q* r0 ^% b" X. [% x! M

机器猫

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

) T# {0 `  H! t2 W你第二个试验里面的j在循环里面又重新定义了啊，你确定真的跑了6000次？

雷达

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

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

7 t( p1 U, s# O内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL

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

机器猫

雷达 发表于 2022-9-27 01:16
内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
( r$ P( }1 @9 O+ \1 c1 A* k3 F% U
" D8 G) S1 k+ c- B$ l4 z7 K0 |% Q" z不和它 ...

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

opensrc

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

雷声

雷达 发表于 2022-9-24 23:54
$ D3 A9 }3 Q( B5 h- `; Yvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
$ a+ T2 D  [) W. U9 `! t{
) H6 ~  @9 Z8 _- p" B        comp temp, xtimesy;

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