爱吱声

标题: C++ 提速的新发现 [打印本页]
作者: 雷达    时间: 2022-9-24 22:54
标题: C++ 提速的新发现
C++ 比 Octave 慢好多，怎么破？8 I  W6 z8 n. f  ~) v. r% e
# D, E+ e  ]$ j$ U5 }
自相关两层循环，内层循环涉及浮点数计算，试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了，看来问题并不在浮点计算。
3 ?4 a9 J7 E6 K6 N" {8 y
/ v) i( G2 S( K& S1 M; c6 t速度优化问题真的很有意思啊。: _, j- K6 o/ q8 }

) e; g, {' E, U欢迎大家继续讨论
作者: 数值分析    时间: 2022-9-24 23:04
拉下来？拉多少？! z7 M' c& d$ ~, ?7 L' t8 x
把代码贴上来看看？9 L! N( D1 A' G* U

" w- ]. J, `2 R1 ^0 ?4 |难道分支预测不准破坏流水线执行？不该啊。
作者: 沉宝    时间: 2022-9-24 23:15
会不会代码本身的缺陷阻止了自动优化？另外，硬件配置和开发环境可能也有关系。
作者: 风雨无阻    时间: 2022-9-24 23:33
Maybe Debug mode?
作者: 雷达    时间: 2022-9-24 23:54
本帖最后由 雷达 于 2022-9-24 23:57 编辑 % n1 j6 T  b$ d( J/ w9 G! Q) H1 K
数值分析 发表于 2022-9-24 23:04" \( I. w$ y; }! T: k; l0 ?
拉下来？拉多少？
  y/ z* k1 `. r' n/ I! [8 d把代码贴上来看看？

! J- ^: X& \) ]- a* Z
3 i) Q0 `* R4 G2 Hvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
* L( D( l  h  w  w3 m{5 T7 Q+ ~) G8 y/ s9 x" y
        comp temp, xtimesy;) o  h+ I  c4 d8 E% d
        xtimesy.re = 0;
( C6 Q( c' y4 ~+ D2 A; r        xtimesy.im = 0;
! H4 v# Q9 I/ P4 K9 U& ]        int j0 = lenB - 1;- g! ~7 g+ s, j( I7 D" Y
        int    i, j, i1, reali;
# B- P" a5 S. `& w2 |        if (lenA % 2 == 1)
, c3 M2 G; a2 a0 ]                reali = lenA + 1;
# o: Z2 o0 v/ x7 h        else
$ H, B: k1 u- J                reali = lenA;
% v" L% O+ e, _# |4 x  _/ ?$ x        reali /= 2;5 J6 I: I  Z# K+ c/ M* h! }/ D3 a6 ~
& W& }/ P( Y' V. ^0 D3 X0 {
        int nconv = reali + lenB;
! v) @: N/ n& R5 [+ b        //#pragma omp parallel for# w. t( `6 t& H! y
        for (i = reali; i < nconv; i++)5 s4 g4 N/ h! u8 a( b. n9 R% N
        {) i1 C3 l! q7 [" p. j7 Y+ Y
                temp.re = 0;9 {: [! ~7 T5 R4 S. a& p" K
                temp.im = 0;
( P/ W4 N3 k# D  H                i1 = i;% Q1 F9 `0 X6 H6 X
                for (j = j0; j >= 0; j--)) x3 C/ _+ l9 R2 T
                {+ d; e. X$ _: b
                        /* floating date operation */  c& Q" _: b* ?: T7 \. z
                }
; D: z6 \! g4 d5 B2 b        }
( s% v. E$ U+ @0 X}( T" n0 R" h  P5 m9 A. N+ O
' \& }. Z) \# K. ^1 S
xcorr函数代码如上，comp是复数struct, 做过长度为11、19两个矢量的测试，和octave结果完全一样
' p% b+ u: b; V9 d1 d, ~: l# Y" w- Q5 E$ w
红色部分是内循环，现在其内部操作都comment out 了, j0大概是 6000。
* J0 {# j+ v* j6 J现在call xcorr 100次，耗时78s.( J0 |+ s& s  p4 \- ~) U

# F. v2 }' `7 ?) X8 M9 j如果把红色部分内循环本身完全comment out， call xcorr 1000次，耗时 <1s.
# @, R% f. W  U
0 V# g/ X3 ^6 c! D: T/ A- C$ E
作者: 雷达    时间: 2022-9-25 00:17
风雨无阻 发表于 2022-9-24 23:33
* p) w* F/ u7 E$ Y1 eMaybe Debug mode?

0 Z4 H/ A8 N4 O
+ o! g" e( `/ r" ~不应该，看我上面的回复。
  J+ b/ I. E# I5 k
( G! h' t0 f( v$ V我更怀疑是 VS 社区版的问题
作者: 数值分析    时间: 2022-9-25 00:20
本帖最后由 数值分析 于 2022-9-25 00:24 编辑
! C$ \' z& ?. T9 U4 J: f
雷达 发表于 2022-9-24 23:54+ g) ^9 |3 \6 |8 ~0 \  A) Y! X
void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)3 l6 \. m! i3 W( A& u% F) S, h; h# ]
{  ~. S+ `" E. W7 ]+ h5 d6 a$ T
        comp temp, xtimesy;
+ W1 N% J4 J( e$ {8 m- {- x

. f/ c  U$ l# D% {; S这个不是这么比的吧。。。
' \  S2 k& j# S6 x! X, c, c
$ S: {, I  K7 G+ r# N6 Z' F您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。
5 j7 b9 |% @7 [4 n7 N. G+ L  d2 j( E' x& @: G
而加上内循环，光jmp和dec指令就至少多执行了6000个，慢个几十倍不是正常的么？
作者: 雷达    时间: 2022-9-25 00:46
本帖最后由 雷达 于 2022-9-25 01:09 编辑 + O. n+ @9 b5 \- ?1 F8 S; R
数值分析 发表于 2022-9-25 00:208 l/ ~: n, v9 L$ {+ F$ Y
这个不是这么比的吧。。。
# q% U$ |2 h% ]3 l- f+ Z
9 L& E" _9 |. U3 q  v( z* Z您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。
% W  b# V; ~4 ~. R4 }: H- R6 _" _
# w3 m8 f' r2 F7 n% Q0 i
有道理。2 N0 L, M& m& z$ ^4 R* J" l- Y
所以存在内循环速度就上不去，把内循环取消，改成两个向量直接点乘再求和应该就会好得多，记得 numeric 库里有算向量内积的，我回头试试。$ D% n% h: n' \; R4 Z9 Z% M

9 ^. o- k1 g2 _# S5 K( C我先尝试尽量用标准库，一个小程序，不想搞得太复杂。多谢了
作者: 沉宝    时间: 2022-9-25 01:27
雷达 发表于 2022-9-25 00:467 ?5 q( g; i) K" h
有道理。" J  c* y  T- O
所以存在内循环速度就上不去，把内循环取消，改成两个向量直接点乘再求和应该就会好得多，这大 ...
) p* z3 g; Q5 n7 v: z
你两个试验之间就差了一个空循环， call 1000次按理不会有秒级差异，可能还是编译器优化的问题。举个例子，把循环本身翻译成机器指令loop或dec/jnz，两者速度上会差很多5 \* h" W" e, {+ N9 b
Why is the loop instruction slow? Couldn't Intel have implemented it efficiently?
作者: 沉宝    时间: 2022-9-25 01:48
数值分析 发表于 2022-9-25 00:20
' p# `& Q  W; }, C9 Z0 f- x这个不是这么比的吧。。。
  H; g: g+ l2 D9 k5 N% f# i8 P8 p" F2 P$ P' B
您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。
而加上内循环，光jmp和dec指令就至少多执行了6000个

2 D  I! u$ B( p$ j7 e5 N4 O: r
& t4 L5 ]) I8 _4 U- G* c6 c% m/ p现在的CPU，可以把判断、jmp和dec指令全部融合进一个µOp（微操作，CPU内部流水线上的执行单位）。如果循环这样跑，花不了多少时间。
作者: 数值分析    时间: 2022-9-25 02:06
本帖最后由 数值分析 于 2022-9-25 02:16 编辑
( D& `  j% C- o3 t; P% H
沉宝 发表于 2022-9-25 01:486 ^/ G9 Q" I3 l% j: K
现在的CPU，可以把判断、jmp和dec指令全部融合进一个µOp（微操作，CPU内部流水线上的执行单位）。如果 ...

& F: i1 d, J* h. I
0 @3 A* A  ]/ D4 W+ U  g9 g; C是的，兄台说的对。/ ^! R* e' S! q, v4 l$ M
4 Y1 {6 ~' M+ S
其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。
8 e; m1 z- F# x  l; J5 c
; p- S/ ~8 g6 x  w+ Y) m: p7 j8 F雷达兄构造测试用例的时候，屏蔽掉了所有计算的部分，使得剩下的都是overhead，这样run time比较的结果就显得好像不合理了。如果把计算加回去，计算部分的run time会dominate，结果就不那么离谱了。因为不好说，所以用指令数对比的方式试图直观地说明这一点。# W0 H6 b' x) J9 A* _4 S
/ Y* G2 t3 e# a: ?( a
比如说，如果有计算，那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做，另一边是六千个循环，那六千个循环比什么都不做慢几十倍了，就不是那么不合理了。
2 S" P% U3 f; j! _( t) Y8 X& |' H- F! b5 N4 z
当然也有可能像兄台说的，是优化参数的问题，但我觉得更多地是测试用例设计的不合理。
作者: 雷达    时间: 2022-9-25 04:47
本帖最后由 雷达 于 2022-9-25 04:49 编辑 : o+ j3 \6 S* o3 z! S5 z: H1 z
沉宝 发表于 2022-9-25 01:27
' ?/ S$ B, E) o3 ?你两个试验之间就差了一个空循环， call 1000次按理不会有秒级差异，可能还是编译器优化的问题。举个例子 ...
+ P. V* X' x# v4 M0 `

$ H1 u) `- c( O9 [( p又写了个小实验，没有调用子函数，双层循环，外层6千次，内循环30万次空转，有或没有空转内循环，时间差一倍，我上面这个差的太多了。
8 D/ n5 r3 V, f  \; w8 @* f- Y0 v* ^% W, B* E
我已经完全懵了。
作者: 沉宝    时间: 2022-9-25 05:51
雷达 发表于 2022-9-25 04:47
2 O, d. s2 s3 _- C又写了个小实验，没有调用子函数，双层循环，外层6千次，内循环30万次空转，有或没有空转内循环，时间差 ...
' u; Z; z- T* m! @0 y
时间差一倍的结果可以接受。5 f! A* Y5 E0 W& R6 a  _
. l7 _% r: ~9 _8 W1 {* w8 s% g) Z
你还是用profile工具看看吧。现在大家都主观瞎猜。
作者: 数值分析    时间: 2022-9-25 14:58
本帖最后由 数值分析 于 2022-9-25 15:38 编辑 5 v3 P# s7 ]" c
雷达 发表于 2022-9-25 04:47
) {# M0 t0 z! \) r' p# I又写了个小实验，没有调用子函数，双层循环，外层6千次，内循环30万次空转，有或没有空转内循环，时间差 ...
7 e2 ?# d1 T( T  ~  I- i
: K  x- S3 y# t. H# t0 m
  k, X" K  Z; C0 e9 m! p

1 r0 }: t9 c: m$ e9 S能不能把这个也贴上来，看看和上一个有什么不同？
作者: 雷达    时间: 2022-9-26 01:30
本帖最后由 雷达 于 2022-9-27 01:17 编辑 + z3 @2 t+ Q" y5 \" P
数值分析 发表于 2022-9-25 14:58
4 k6 m& S2 }+ h* n+ O: i/ A5 k能不能把这个也贴上来，看看和上一个有什么不同？
1 v2 U2 ?& A' _4 X9 c4 E
理了理思路，重新做了一个测试。
- q2 Z- c) L0 s; X* c做了两个 vector 和 两个 float *, 都长 100000
; e! B5 q: u( @/ j外循环 6000，里面先做随机数生成，模拟真实环境，避免数据的 cache.3 U  T6 J/ }+ I; E, Y

' d* `* b' k2 S; P8 l6 p7 T内循环试了4种方法，
! l0 u) `7 l+ t* `1. 直接调用 vector inner_product 247s
7 J  ~$ l& P$ O9 J5 _9 k1 f2. vector 循环点乘累加 237s
( S; B% ]" I1 H$ {7 G3. float * 循环点乘累加 204s: H9 r* n2 I) ?! Y5 Q3 R
4. 空循环 100000 次 202s' I4 |2 u; \# @, [
0 i7 O5 y) l) O* ]6 G- H, j
不做内循环 200s2 Q! B: S$ P: c* H! `
$ s# T! s; a7 a- ~+ [
你昨天说的对，内循环本身占比是很小的，大头在其他处理。
1 K$ g: [- t! b) W2 ?1 u另外可以看到， float * 循环点乘累加 并不差，比用vector 还更快。
6 {) \  ~' V1 S7 K& M  i
' o  C. T: u1 ], u至于我那个原始程序，还有一些疑问，见5楼，其他都不变仅仅是有无空的内循环就有很大不同，这是不对的，也许有一些其他缺陷我没有看到。（也许可以改成 while 试试）& C& a6 w$ Q- V' e  p

, T) `) Q* b7 K7 T7 ]' [（为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ？方括号 i 消失了。 LOL . 改成  jj 好了，原来 方括号里的 i 是斜体标志  LOL）7 Y  y/ r' s2 f" P3 g

; @! h. u! ?& e( `6 o
        std::vector < float > vec1(N);, y( N2 x/ Z8 O! c+ U8 z- f
        std::vector < float > vec2(N);
  F" H1 w: _7 j" b$ |        float* b1 = new float[N];
2 T4 G/ a4 u. d6 k  r4 R4 ^1 X3 v        float* b2 = new float[N];
/ [+ C( V( l% x6 f
8 R3 @( F6 i( j8 d+ \, B        for (int j = 0; j < 6000; j++)
% Q" F) l7 X2 _; t        {7 H' l, Y# B- z
                std::generate(vec1.begin(), vec1.end(), []() {
& ~9 X# h) _# F+ d3 ~                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;
, y2 o# |2 \3 O& B. ?/ i( q                        });
& ~: C0 A5 v6 ~2 L/ @' H; Q8 n2 b' Y, a8 V! j  m( m
                std::generate(vec2.begin(), vec2.end(), []() {' c4 }4 M# G$ g- H; G
                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;  _8 \+ k+ R; Y  [; M  p
                        });' z3 f3 C5 I0 }4 j6 h
2 g$ g2 \! ]: J+ i# d1 C
                for (size_t jj = 0; jj < vec1.size(); jj++)! q- ~. T1 x* y
                {7 \* |) Z3 Q) }9 x" I3 I
                        b1[jj] = vec1[jj];+ X) q$ T8 `+ y; J' Y
                }
- B9 P7 w4 }1 c; i( ^( I/ F: z  r! J* T' b9 Z' u* x, d
                for (size_t jj = 0; jj < vec2.size(); jj++)1 j- j  G9 Y' D+ X" t/ ~
                {' o8 ?1 f4 Z0 ~5 H7 i4 }0 h2 k( C* C
                        b2[jj] = vec2[jj];+ @! V5 ]/ H- h- k. J% a
                }4 ?7 D5 d+ A2 A& k" J9 J! y9 i

7 i3 @& Z$ G5 E0 f; K/ \1 p  ?# |                //Method - 1  N=100000 247s  % G+ N$ f$ X. u9 U9 o2 t
                //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);
% e( A+ d  e2 @                                
; w% R: q- R, l' ~! a                //Method - 2  N=100000  237s
$ K$ _# Y, [- u2 q, Z9 w                /*
3 H6 E& T% M2 |' C7 S2 R, z                for (int jj = 0; jj < N ; jj++)3 O6 B& k+ I' I- f7 t  R8 _
                {, \, ^; |, ]0 u) k8 t! l
                        fresult += vec1[jj] * vec2[jj];
- b! a6 J) _/ E& e1 J                }
* Z; a$ C" T: Y                */
5 O3 j7 u/ c  t! E$ x9 A) r                                
9 p( l+ a7 f8 V3 V# u& ?# |4 f! Q                //Method - 3  N=100000 204s0 Y& c7 y5 ^) o7 n- p2 @: z
                /*- L( z( T0 n5 [
                for (int jj = 0; jj < N; jj++)- ^+ d' p8 |* x' u8 J  F2 U
                {
! s% [/ E3 S0 r" F                        fresult += b1[jj] * b2[jj];9 J: u2 B! i0 \/ J. _) N, B$ ~, \
                }
- w$ M, N( I# j                */
/ H( M' \: \6 Q/ }3 L( W+ I2 c+ a6 G7 t) _2 T* Z+ ]6 H
                //Method - 4   202s# Y  Q1 Z. @! e8 t0 @
                /*
7 N" a$ y  h& c( Y4 W                for (int jj = 0; jj < N; jj++)3 q( k# d( o$ g2 g3 S2 a& P
                {
, R) E& U: t) V- B0 a' I                        
6 ~5 x) f! R3 S                }+ o/ C  q6 P" K7 [" p* O) @0 A
                */
2 b" Y" @3 \& |! s, G8 n/ s$ s+ u' X: l                //comment out all methods, N=100000  202s                5 P  c# e% a5 z" ^! U2 i
        }
6 W3 N% O2 d1 X) J, b& _3 H* D1 v0 u; V8 }' [( o" ?
        delete []b1;
% v9 ~3 c4 q; }% C/ w  m& O7 q        delete []b2;
4 q5 I- h: c$ }, m1 d4 V
作者: 机器猫    时间: 2022-9-27 00:15
瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同？
0 S1 P9 U/ t+ K) _
7 w0 H5 t; f$ _你第二个试验里面的j在循环里面又重新定义了啊，你确定真的跑了6000次？
3 L0 t& y; J- i4 J& n( p8 n3 k- j' A
作者: 雷达    时间: 2022-9-27 01:16
机器猫 发表于 2022-9-27 00:15+ V7 N$ U  W: i/ d0 F6 @- c" k; W4 U
瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同？( t' a2 R4 t$ M

0 C5 @6 f# |7 v& n  P8 \; H你第二个试验里面的j在循环里面又重新定义 ...

5 f$ `3 H, o- T  |( p( K内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL9 E' w; t+ D/ Z

$ K- K! C; C* X3 e不和它较劲了，瞎耽误工夫，我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。
作者: 机器猫    时间: 2022-9-27 02:06
雷达 发表于 2022-9-27 01:161 k( ~; j5 _5 G6 I; B9 k1 ]6 M- ]9 |
内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
+ @1 R. ?: P: l* ?1 D# _0 Y3 d: A( x- }" [3 Y1 S2 J# r
不和它 ...

( L0 Q! v3 M$ S/ k
9 ?4 f; K: U0 v, Y% m& x不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的，很有可能是在stack上，这样内存读写会更多，要是再碰上每次都需要加载cache就更慢了。
( C' I9 g' M4 Z& n  u# i后面一个是在循环那里定义的，说不定编译器就把它优化成register变量了
作者: opensrc    时间: 2022-9-27 07:25
一个无关问题，为什么爱坛的帖子里在我这里有好些奇怪的东东在里面，是防拷贝措施吗？
作者: 雷声    时间: 2022-9-27 20:29
雷达 发表于 2022-9-24 23:54
1 E2 w6 h  W8 Cvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)# h" n/ |! D2 N$ G
{
8 r% z6 G- ]/ n3 N. d+ U        comp temp, xtimesy;
6 P1 m! R! D; [
这个code里面如果Openmp没有被注释掉的话，那么temp那个变量应该是定义在循环里面，否则线程之间会存在争夺写入那个temp的风险。
5 `2 t5 `0 \4 o) J* {内层for循环如果没有内部操作的话，编译时应该被优化掉了，和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化？
4 l- D, _- H& i6 t# T$ NVS社区版没有问题，我工作用的就是社区版，设置正常的话不会比商业版差。以前游说头头用Intel Compiler，他说不想花钱，而且差不了多少，就一直用到现在。
作者: 雷声    时间: 2022-9-27 20:39
雷达 发表于 2022-9-26 01:30
& c1 F; k/ ^. }: H1 n理了理思路，重新做了一个测试。
4 W( G3 Q8 B: }& V做了两个 vector 和 两个 float *, 都长 100000/ \" a  d" A: m$ E0 o% n9 y2 \
外循环 6000，里面先做随 ...

  }2 w% G( F  n( L这个时间是从哪里开始算的？
+ g; }% d2 R7 w+ V我怀疑这个200多秒里面有200秒花在产生随机数上了，真正计算大概只用了2秒， 用了vector那个因为有vector的额外开销，多了几十秒。  Q: `& e0 y& f  O/ Z" J( ]2 \
按照两个10万个数字的相关计算的规模来估计的话，两秒都算很长很长了。这个结果真的很奇怪。
作者: 雷达    时间: 2022-9-27 22:41
雷声 发表于 2022-9-27 20:39, O1 |8 y+ k5 k0 \% X4 ]
这个时间是从哪里开始算的？
8 K3 C& i2 x8 F( p# A我怀疑这个200多秒里面有200秒花在产生随机数上了，真正计算大概只用了2秒， ...

( q3 M7 z( f. _% K) f/ s我不管它了，回头 linux 下换g++重新编译，顺便加上你们建议的向量化。
作者: 四处张望    时间: 2022-9-28 00:12
你这个循环主要的计算时间是那个rand，这个循环本身占用时间微乎其微。
; q" {5 Z2 |: {1 l+ R& O  J- O你的空循环，如果是现在的代码，编译器很可能完全不生成对应代码，因为没有任何输出或者修改变量，所以可以看到时间都是202S。你可以认为啥都不干的时间就是那么多。5 H0 a, ]! ^. x3 R6 X. d+ _
与此对应用数组（指针）花了2S% y/ ?/ K+ X# ^
你用vec1[jj]*vec2[jj]理论上不应该差30多秒，这里很可能是你对vector的操作带来了内存操作，你可以试试把初始化挪出循环然后再比较，理论上vector的随机访问和数组应该几乎没什么区别。
作者: opensrc    时间: 2022-9-28 00:29
雷达 发表于 2022-9-24 23:54& `! p) R+ e$ i8 d$ _$ r2 g% h% [
void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)+ \. G- Y* H' S. n( i  Q
{
- Q8 C  V% y5 S% s- d% a        comp temp, xtimesy;

7 A- @$ Q8 w, q; }' U' |我有些迷糊，这样的code，难道不就应该时间差很多吗？也做了个简单的实验，你看看我做的有错吗
8 i* P7 n' p0 ^4 M2 k$ O# `+ G4 u; t. w
作者: 雷达    时间: 2022-9-28 00:49
opensrc 发表于 2022-9-28 00:29: L, e) n4 n: v9 y7 F3 x9 m
我有些迷糊，这样的code，难道不就应该时间差很多吗？也做了个简单的实验，你看看我做的有错吗
4 f* f9 ^% f$ n: D: `8 q3 }- y' t5 L' z; g5 ~. F
...

- T2 Q  w4 v' h9 y2 W1 d+ J; G你是对的，是我搞错了。确实没有优化的情况下，空循环如果次数够长本来就应该耗时较大。我搞错的原因是在不自觉得与 octave 比较，而实际上 octave 是优化过的，和是不是空循环没关系，这种不同条件的比较是没意义的。
2 Q- ^  Y' Z& k) C
, E+ [, i) p- H9 ^4 u雷声网友说的也对，空循环应该被编译器优化掉，我的编译器设置有问题。
作者: 雷达    时间: 2022-9-28 00:56
本帖最后由 雷达 于 2022-9-28 01:09 编辑
% k1 f; m; U0 N5 f% F& f
% q0 W# E& _8 Q) ]) s6 A8 E1 M: `是我自己的理解有误，没有优化的情况下，空循环如果次数够长本来就应该耗时较大。. Q% N: e; g% Y5 W
有空时我会试试 SIMD和并行，看看能提高多少。
& w, t3 H! P. y$ a( e( m( j过去7、8 年没有正经用C++ 写过东西，没有 sense 了 。
' l; x: r  t' E( v) ?谢谢大家的讨论，I learded a lot.  红包已发  : ~  P' F$ x) i0 M& F
2 A) C+ t/ _; z
" j" ?5 B) r) W  _, Q# q
+ d5 }0 F# k& S4 u% n
/ Y5 p3 q  b+ E8 c$ |9 c  j




欢迎光临 爱吱声 (http://129.226.69.186/bbs/) Powered by Discuz! X3.2