爱吱声

标题: C++ 提速的新发现 [打印本页]
作者: 雷达    时间: 2022-9-24 22:54
标题: C++ 提速的新发现
C++ 比 Octave 慢好多，怎么破？
8 |3 D' d3 p) f! d* Z
, W! ?5 G& Z2 Z+ K% z5 A) S& ]6 ]5 y自相关两层循环，内层循环涉及浮点数计算，试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了，看来问题并不在浮点计算。: D8 r6 g1 G" K" _* j5 J- P

' r6 `" r0 E! M" C% F5 N速度优化问题真的很有意思啊。) n! I, ^8 s$ z* l: W* j

4 ~: z0 o& }: R- ?" T& _欢迎大家继续讨论
作者: 数值分析    时间: 2022-9-24 23:04
拉下来？拉多少？, J/ I5 j0 ^( i% U
把代码贴上来看看？: c! D" g7 O3 j0 J

* e+ p8 W' E" U2 n, i% M* f+ V+ t3 U2 R难道分支预测不准破坏流水线执行？不该啊。
作者: 沉宝    时间: 2022-9-24 23:15
会不会代码本身的缺陷阻止了自动优化？另外，硬件配置和开发环境可能也有关系。
作者: 风雨无阻    时间: 2022-9-24 23:33
Maybe Debug mode?
作者: 雷达    时间: 2022-9-24 23:54
本帖最后由 雷达 于 2022-9-24 23:57 编辑
$ k5 h' E7 ^, \- _: i* h
数值分析 发表于 2022-9-24 23:04
. W+ W; _/ Y4 }* u  H3 X  @7 ^拉下来？拉多少？
' I( _9 O1 P6 `0 Q) q( G$ q0 o5 s把代码贴上来看看？
; z; H6 u. I/ m

  I7 p# L( k2 Z, w! T+ h1 V) hvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)9 h1 q/ [& `1 |+ O; |& u6 P
{
! \8 Y0 v+ b5 X' `# O0 d: z8 @; I        comp temp, xtimesy;
' Z0 Z* b. d3 p4 A        xtimesy.re = 0;
) K$ Y% f7 c/ f0 P$ J" F        xtimesy.im = 0;/ g3 \+ P$ a$ A. c! G0 [" v! T6 ~
        int j0 = lenB - 1;* y7 S) M' k7 \, i4 u
        int    i, j, i1, reali;
4 X. v6 Y- ~( y- j0 v( h5 U        if (lenA % 2 == 1)
/ R% F, l1 Q8 @. x                reali = lenA + 1;& u  x$ b2 d: r/ r8 U: I' g
        else
7 y/ U1 X2 N  n1 b* y6 B3 H+ a                reali = lenA;
9 v# \0 }) C" [+ Q, c        reali /= 2;
7 U- A$ v1 Q, u. H; ~1 ~3 X; B
1 p$ y* t4 z1 `, y        int nconv = reali + lenB;
4 a# ~$ y% a, x7 ^1 P. |        //#pragma omp parallel for
, L( E1 F* }6 a$ Y$ {6 X% Y+ W        for (i = reali; i < nconv; i++)  v0 t5 l1 u% V3 F# A
        {
  t& i6 v) V( K# l                temp.re = 0;, y" l$ ~# O5 M3 e
                temp.im = 0;
. K) E  C; J( m                i1 = i;6 J, @& L: e2 \/ ]
                for (j = j0; j >= 0; j--)
- ^6 ?) r% D" Q- ~/ T4 D! J9 A- |! n                {- Q) N& X) \1 A6 ~
                        /* floating date operation */5 N9 E, W6 K5 y0 N# f9 l
                }1 }2 c1 x/ j" l/ w5 n" H2 v2 E# @
        }
: r) Y" D! U* [& b4 L; L3 J# \. W4 [" U}4 m" x) t: E* r. C4 C

2 ?0 ]( h$ r& V, Hxcorr函数代码如上，comp是复数struct, 做过长度为11、19两个矢量的测试，和octave结果完全一样# l4 r! C9 u# B6 D4 V$ h$ n+ H
( K& p$ Y7 o0 C2 V
红色部分是内循环，现在其内部操作都comment out 了, j0大概是 6000。
+ J0 |; D8 ^! X4 A3 b现在call xcorr 100次，耗时78s.2 L' x& ?) |# l" [1 e

# u3 ~8 o  N  \* n) V* r4 n如果把红色部分内循环本身完全comment out， call xcorr 1000次，耗时 <1s.   f$ |7 Z9 h) y, |

- ~6 K$ H5 O1 x9 L' U# S
作者: 雷达    时间: 2022-9-25 00:17
风雨无阻 发表于 2022-9-24 23:339 Q/ Z* X( [% N: X3 C
Maybe Debug mode?

9 k6 q* V: Q8 t, R* ~  C. K& ?4 K. w0 g' I
不应该，看我上面的回复。
( ]5 z( J$ p/ s3 H8 Q1 s! r, U" F) F) g
我更怀疑是 VS 社区版的问题
作者: 数值分析    时间: 2022-9-25 00:20
本帖最后由 数值分析 于 2022-9-25 00:24 编辑 7 J- \( h- ~0 ?, I- C" U
雷达 发表于 2022-9-24 23:544 G9 K7 H9 \9 ?! O- V% B
void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)$ z; X$ Q/ L- r4 f
{. t0 [' I7 G- n% |. U) Z' L2 u- G
        comp temp, xtimesy;
9 H7 J- g/ c& v8 @2 A

% Y4 y, ~. w3 M+ P9 A$ Y这个不是这么比的吧。。。
. }# [+ j! e$ G5 p2 [0 Q0 h- ?+ {$ \1 V- I
您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。
* \, H- h3 }3 G0 W% M  V  ^0 d( {+ w4 B. u8 O3 n2 c
而加上内循环，光jmp和dec指令就至少多执行了6000个，慢个几十倍不是正常的么？
作者: 雷达    时间: 2022-9-25 00:46
本帖最后由 雷达 于 2022-9-25 01:09 编辑 ' ~) a7 T) q7 y# W
数值分析 发表于 2022-9-25 00:20' u8 v3 V+ ^/ m  d6 _( y( B
这个不是这么比的吧。。。5 H2 |! j) m; u  ?/ ]
, X2 V+ ?, E; k. D# w$ W
您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。
: f1 S' F  ]8 f* _2 Y6 S7 x

0 s, A" n) w$ H. \9 I& x有道理。. ]: j- u* x- J9 Y8 h
所以存在内循环速度就上不去，把内循环取消，改成两个向量直接点乘再求和应该就会好得多，记得 numeric 库里有算向量内积的，我回头试试。
7 w4 m/ U- f  _2 J0 y8 k4 n6 \4 Y
: }: d; K9 X  `7 R9 d我先尝试尽量用标准库，一个小程序，不想搞得太复杂。多谢了
作者: 沉宝    时间: 2022-9-25 01:27
雷达 发表于 2022-9-25 00:46) c6 J% t# E+ ]3 g4 o* {* m
有道理。
1 _9 {1 W/ ]8 w' E7 @所以存在内循环速度就上不去，把内循环取消，改成两个向量直接点乘再求和应该就会好得多，这大 ...

1 O' S: F$ }9 H- X; A你两个试验之间就差了一个空循环， call 1000次按理不会有秒级差异，可能还是编译器优化的问题。举个例子，把循环本身翻译成机器指令loop或dec/jnz，两者速度上会差很多
1 W! r2 H* f" J) E6 j- y# xWhy is the loop instruction slow? Couldn't Intel have implemented it efficiently?
作者: 沉宝    时间: 2022-9-25 01:48
数值分析 发表于 2022-9-25 00:20
* K  y# F# }  J6 N1 o) ^% D这个不是这么比的吧。。。
2 ]) b! X& J* k- ^  H' h8 j9 w
" z: k' y: a6 P/ R, Z您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。
而加上内循环，光jmp和dec指令就至少多执行了6000个

6 B( |/ R2 k$ [& }( O; x
+ t- \* e) O8 h  l, T9 |- c, K: ]现在的CPU，可以把判断、jmp和dec指令全部融合进一个µOp（微操作，CPU内部流水线上的执行单位）。如果循环这样跑，花不了多少时间。
作者: 数值分析    时间: 2022-9-25 02:06
本帖最后由 数值分析 于 2022-9-25 02:16 编辑
8 x/ p: [7 u& V- S; `- M7 M
沉宝 发表于 2022-9-25 01:48
% V) H# o: Z$ l# p. ~0 l2 [现在的CPU，可以把判断、jmp和dec指令全部融合进一个µOp（微操作，CPU内部流水线上的执行单位）。如果 ...
. s# B- `( F' B+ I" V/ Q  x

9 z. r4 }3 P( ~' B  V  b是的，兄台说的对。, K$ h$ X" a$ i  W, }5 J

! @/ \$ t( j. C. B6 x# g% k其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。& V3 {$ c% N: m
' @4 m$ g2 j* }8 I0 W
雷达兄构造测试用例的时候，屏蔽掉了所有计算的部分，使得剩下的都是overhead，这样run time比较的结果就显得好像不合理了。如果把计算加回去，计算部分的run time会dominate，结果就不那么离谱了。因为不好说，所以用指令数对比的方式试图直观地说明这一点。
, Q  [, w& V1 N1 A% p
/ A: N+ m9 h4 q3 \% D比如说，如果有计算，那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做，另一边是六千个循环，那六千个循环比什么都不做慢几十倍了，就不是那么不合理了。
* _9 s0 L4 }" [+ z0 n
1 W; y+ u: \+ n+ p  B; y6 F' Q" ^' [9 n当然也有可能像兄台说的，是优化参数的问题，但我觉得更多地是测试用例设计的不合理。
作者: 雷达    时间: 2022-9-25 04:47
本帖最后由 雷达 于 2022-9-25 04:49 编辑
2 m% M3 t" B/ S
沉宝 发表于 2022-9-25 01:27. \' Q( [+ v8 c& T
你两个试验之间就差了一个空循环， call 1000次按理不会有秒级差异，可能还是编译器优化的问题。举个例子 ...

) ^& s- F. H  r7 J5 f: B$ Y' K3 p4 d% j; u  X9 }1 R; |  _
又写了个小实验，没有调用子函数，双层循环，外层6千次，内循环30万次空转，有或没有空转内循环，时间差一倍，我上面这个差的太多了。/ s6 W" c6 M& g8 a! X! a

& y4 y; o+ R* Y# F' |' o. j我已经完全懵了。
作者: 沉宝    时间: 2022-9-25 05:51
雷达 发表于 2022-9-25 04:474 I/ z2 @& O: ~. h% j* R3 ^
又写了个小实验，没有调用子函数，双层循环，外层6千次，内循环30万次空转，有或没有空转内循环，时间差 ...

8 F6 W3 l: m3 a' D/ o0 G# k时间差一倍的结果可以接受。% E, k/ N, M* A0 Y9 R5 d* W
, w5 f! V1 C1 w$ h* W  U, k; ?" p/ r
你还是用profile工具看看吧。现在大家都主观瞎猜。
作者: 数值分析    时间: 2022-9-25 14:58
本帖最后由 数值分析 于 2022-9-25 15:38 编辑   o! H: o9 |8 E, i* w4 g9 K. n
雷达 发表于 2022-9-25 04:47
* S( {) w9 K6 c! V, Y又写了个小实验，没有调用子函数，双层循环，外层6千次，内循环30万次空转，有或没有空转内循环，时间差 ...
( Z6 p5 ~0 h3 B5 r
$ H: d. x8 d  z. e, V8 S' ~

7 }. ^3 y, I' h0 j
6 _% |, m. U& U  b. o7 W7 E/ S能不能把这个也贴上来，看看和上一个有什么不同？
作者: 雷达    时间: 2022-9-26 01:30
本帖最后由 雷达 于 2022-9-27 01:17 编辑 ! c3 f* k' W& m& q8 x+ c  X+ ]
数值分析 发表于 2022-9-25 14:58# j. b% N. |& m* A. X$ \$ M
能不能把这个也贴上来，看看和上一个有什么不同？
0 M- }4 p! }! Z8 H
理了理思路，重新做了一个测试。
7 E" X& |: L5 D% m做了两个 vector 和 两个 float *, 都长 100000
1 c# u4 j, V) r7 M外循环 6000，里面先做随机数生成，模拟真实环境，避免数据的 cache.
; q/ R9 G- K7 f0 b; s* b5 x: M: D! ~: g3 n& X; c# k
内循环试了4种方法，; o' Q8 J; R+ J* t4 P3 O$ @
1. 直接调用 vector inner_product 247s / R3 R& M3 o* [) k9 `3 n6 X# F* P
2. vector 循环点乘累加 237s
1 E. C9 ?* ]" Q% C, b3. float * 循环点乘累加 204s
( s$ \1 A" L* `0 Q4. 空循环 100000 次 202s. I5 E/ m+ c0 N

2 {2 ~+ ]4 d+ Z9 B, k/ q不做内循环 200s
; @0 O, V6 @6 G$ x1 z) C) \( t8 ]+ k. S+ X3 ]& D+ x
你昨天说的对，内循环本身占比是很小的，大头在其他处理。
3 j9 `3 \7 y! B0 Y另外可以看到， float * 循环点乘累加 并不差，比用vector 还更快。4 s: U# Z0 H. U" A

% \5 B- X) t  t" D9 D# w: S2 ^" u至于我那个原始程序，还有一些疑问，见5楼，其他都不变仅仅是有无空的内循环就有很大不同，这是不对的，也许有一些其他缺陷我没有看到。（也许可以改成 while 试试）% j  d: I7 g6 ^2 Z0 f/ S) _5 H
2 d" m' h9 l9 K! N* O
（为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ？方括号 i 消失了。 LOL . 改成  jj 好了，原来 方括号里的 i 是斜体标志  LOL）: E$ W8 |% q6 a) ?3 b% e! F& r

9 A( ~) Q9 X1 o7 C' E$ y
        std::vector < float > vec1(N);) J7 A! q) X9 z2 |( ]
        std::vector < float > vec2(N);, v: G9 E7 T" K4 w9 [' c+ _- M% d1 F
        float* b1 = new float[N];
  T% E$ F: d7 z        float* b2 = new float[N];
/ H2 }! S( Q* L; G: U4 E3 G7 ~$ ^! U" |
        for (int j = 0; j < 6000; j++)9 n; k" ~1 @, N% f' T# Z+ D
        {* C/ S) L2 X( }, c- D. f
                std::generate(vec1.begin(), vec1.end(), []() {
7 Z6 t4 B5 Q: z* @" J                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;1 W6 n; m$ M* G" I
                        });
$ f/ ^) B$ x) ~$ }1 P0 S$ Z
( {& t1 Z* h5 F/ {( I. |                std::generate(vec2.begin(), vec2.end(), []() {
9 {. E$ k" w  F3 S* f& u$ g' l                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;2 |' \0 ?7 M0 ~, T$ K+ J' c
                        });
) K/ N) ~4 S& I% C% G
% N4 J+ ~5 R0 j( a" q2 }) M) x! O" h8 D                for (size_t jj = 0; jj < vec1.size(); jj++)( V# p( f6 P% }! x; v
                {
" v5 U( h% F: l$ H                        b1[jj] = vec1[jj];" T2 m' t0 [! t) n' k/ Q
                }
9 F9 i7 {2 g) n0 [
3 @  x. R" R* j. k                for (size_t jj = 0; jj < vec2.size(); jj++)( D0 Y7 _% c* @9 n1 q. W
                {  I4 Q! V8 y( p: y, |: I, R0 f
                        b2[jj] = vec2[jj];
/ s! m" |% T4 |% l                }( G2 b& x( V- o7 h% s9 d
& H# V0 \9 [0 |
                //Method - 1  N=100000 247s  " r' s4 n4 d/ Z" J
                //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);
( D4 t% W3 T* f0 h; ~) w/ A0 d                                
2 H+ l. R* o0 \7 d$ [1 |! ~2 H) ~                //Method - 2  N=100000  237s
. I% J* o8 {, `8 u                /*; I4 v0 Y# ^$ N
                for (int jj = 0; jj < N ; jj++)# a% ]' r5 [* p& d
                {
* S* d6 q3 E  U3 k                        fresult += vec1[jj] * vec2[jj];8 C  t7 X+ T, J
                }$ A9 O7 q/ m7 ~0 f
                */
/ V( j" i% C. E3 g                                2 C2 R7 _+ @0 n- E
                //Method - 3  N=100000 204s$ N7 v" a" c& r/ b0 z
                /*
/ F$ M3 v& S/ R% }/ f+ e                for (int jj = 0; jj < N; jj++)
3 h$ t  e8 \1 u! y( F) T6 j                {
3 P8 v4 H  q2 [0 m; G6 U- \- ?% z                        fresult += b1[jj] * b2[jj];' a! c; A; F+ L4 f0 M
                }7 L+ \" e1 m' [+ E0 z& ~$ X3 F
                */1 n% L( {7 G3 k0 O6 D
- `( s  `7 r4 K3 x0 [5 J
                //Method - 4   202s
' J! {; ]; G% |# q* s/ p                /*
5 l, f6 ?7 X: J7 ~& u# P                for (int jj = 0; jj < N; jj++)3 h' {; l  {9 J3 D3 f
                {( k7 G9 a4 P& b. C
                        
. j0 G& h" V  y8 v. r# T                }
. G& v: h* m* R                */3 v9 R5 p9 g$ d+ H3 W
                //comment out all methods, N=100000  202s                5 c- f; r- m: }" Q6 f# f
        }" O. B9 r3 L& h- N4 T

/ f: h$ b; q. V3 h, ^( a        delete []b1;5 D% ?# t$ l6 e
        delete []b2;

9 B) b" F& `% |6 N5 {/ \6 U
作者: 机器猫    时间: 2022-9-27 00:15
瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同？- ^) y* W/ m; [& T) l

+ f4 o3 t! M5 X, a/ W. ]你第二个试验里面的j在循环里面又重新定义了啊，你确定真的跑了6000次？
( Q( W5 N0 u  G- @% T
作者: 雷达    时间: 2022-9-27 01:16
机器猫 发表于 2022-9-27 00:15. d0 c' a6 F2 g: I
瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同？
+ z1 I4 ?6 j' e1 }, A' }+ D3 N0 k4 V4 [" `7 U, \
你第二个试验里面的j在循环里面又重新定义 ...
8 d  s+ m0 r2 `% t% [! r
内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL' A  A8 Z" x- H/ {6 D

. ?* \6 K# B9 g+ j2 r6 q/ V不和它较劲了，瞎耽误工夫，我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。
作者: 机器猫    时间: 2022-9-27 02:06
雷达 发表于 2022-9-27 01:16
5 q& d7 m2 Q/ R& D4 s内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
. a& {: Z* @* O& Q, c& {& m! g, W& G1 j1 b( g! l
不和它 ...
1 b. c: e2 k+ c
6 d0 d, r7 K. A* r/ P
不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的，很有可能是在stack上，这样内存读写会更多，要是再碰上每次都需要加载cache就更慢了。
9 L8 |; N: m* g$ }& K后面一个是在循环那里定义的，说不定编译器就把它优化成register变量了
作者: opensrc    时间: 2022-9-27 07:25
一个无关问题，为什么爱坛的帖子里在我这里有好些奇怪的东东在里面，是防拷贝措施吗？
作者: 雷声    时间: 2022-9-27 20:29
雷达 发表于 2022-9-24 23:54! n2 \) R0 n% o& u  I# y( z" ]
void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
- V3 @6 F" D" t6 j& Z$ x5 x{* A5 P2 U; t$ z' K' W( \( X
        comp temp, xtimesy;
5 @; R: P1 ~* |
这个code里面如果Openmp没有被注释掉的话，那么temp那个变量应该是定义在循环里面，否则线程之间会存在争夺写入那个temp的风险。
" ?* `; P- c4 \' G. H: c内层for循环如果没有内部操作的话，编译时应该被优化掉了，和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化？
1 g* h) r! `, F9 L, s2 }# aVS社区版没有问题，我工作用的就是社区版，设置正常的话不会比商业版差。以前游说头头用Intel Compiler，他说不想花钱，而且差不了多少，就一直用到现在。
作者: 雷声    时间: 2022-9-27 20:39
雷达 发表于 2022-9-26 01:30+ F6 Y; ~- X" l4 f4 E, [
理了理思路，重新做了一个测试。6 J& L8 Z' z) X7 Y/ n
做了两个 vector 和 两个 float *, 都长 100000
+ D; G; L' d! {; P* u# q6 b外循环 6000，里面先做随 ...
2 n/ ]' F# ]4 I, `+ p" D
这个时间是从哪里开始算的？% h5 Y0 @  N* b/ n6 ?4 t
我怀疑这个200多秒里面有200秒花在产生随机数上了，真正计算大概只用了2秒， 用了vector那个因为有vector的额外开销，多了几十秒。
$ U1 O9 ^4 G4 l9 e1 V# Y按照两个10万个数字的相关计算的规模来估计的话，两秒都算很长很长了。这个结果真的很奇怪。
作者: 雷达    时间: 2022-9-27 22:41
雷声 发表于 2022-9-27 20:39
2 _0 z, p2 Q' z; Q: T* Y3 q这个时间是从哪里开始算的？
+ g) I5 Y- I. p3 v: |2 w& t我怀疑这个200多秒里面有200秒花在产生随机数上了，真正计算大概只用了2秒， ...
) O5 k2 a/ o7 B5 ]+ I
我不管它了，回头 linux 下换g++重新编译，顺便加上你们建议的向量化。
作者: 四处张望    时间: 2022-9-28 00:12
你这个循环主要的计算时间是那个rand，这个循环本身占用时间微乎其微。6 f: m4 q7 e  N5 `% \6 E
你的空循环，如果是现在的代码，编译器很可能完全不生成对应代码，因为没有任何输出或者修改变量，所以可以看到时间都是202S。你可以认为啥都不干的时间就是那么多。
3 J) D: v( L! B! k% F5 o( J与此对应用数组（指针）花了2S* D: f/ s& Q4 O
你用vec1[jj]*vec2[jj]理论上不应该差30多秒，这里很可能是你对vector的操作带来了内存操作，你可以试试把初始化挪出循环然后再比较，理论上vector的随机访问和数组应该几乎没什么区别。
作者: opensrc    时间: 2022-9-28 00:29
雷达 发表于 2022-9-24 23:54: f" d- s$ X, N
void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
: _2 y  e( o8 T8 S9 a. X{) c* |3 y' p* Y% _
        comp temp, xtimesy;
% |4 i# [1 ]6 ]" g
我有些迷糊，这样的code，难道不就应该时间差很多吗？也做了个简单的实验，你看看我做的有错吗; \/ A: G& R2 |2 R

. y; a( @' f) N# g1 [
作者: 雷达    时间: 2022-9-28 00:49
opensrc 发表于 2022-9-28 00:29
$ G) R$ O" X+ ~& _我有些迷糊，这样的code，难道不就应该时间差很多吗？也做了个简单的实验，你看看我做的有错吗
( H( ~5 P- W: {/ {% L3 b: {5 A& q* ^: v. c& S- S
...

0 I* {, m; G$ @" @0 [你是对的，是我搞错了。确实没有优化的情况下，空循环如果次数够长本来就应该耗时较大。我搞错的原因是在不自觉得与 octave 比较，而实际上 octave 是优化过的，和是不是空循环没关系，这种不同条件的比较是没意义的。9 Z- o5 Y! H8 T, q
8 V- D/ Z5 A& b6 v  d7 g# g, O
雷声网友说的也对，空循环应该被编译器优化掉，我的编译器设置有问题。
作者: 雷达    时间: 2022-9-28 00:56
本帖最后由 雷达 于 2022-9-28 01:09 编辑
) ]9 @  t5 n" Q, U& t0 g1 W( T. b* G+ h
是我自己的理解有误，没有优化的情况下，空循环如果次数够长本来就应该耗时较大。
3 [4 w) [0 y% J" ^有空时我会试试 SIMD和并行，看看能提高多少。
; }. Z& Z  z# U4 o$ c* h1 [6 g) _. U0 _过去7、8 年没有正经用C++ 写过东西，没有 sense 了 。
( J% Z; l- p2 x7 X3 b2 u. O谢谢大家的讨论，I learded a lot.  红包已发  3 [+ D/ i' H: k4 w) J. v2 q5 N

6 X( S, W5 H/ B3 T6 O( V4 S6 U& D- r' K1 t$ _2 c' I% I, `
  ]8 B, v% E' g' r
9 `+ d' x2 k: s




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