爱吱声

标题: C++ 提速的新发现 [打印本页]
作者: 雷达    时间: 2022-9-24 22:54
标题: C++ 提速的新发现
C++ 比 Octave 慢好多，怎么破？
1 Q0 _, |* u* t$ N, v3 O' @3 s  W3 j, c
自相关两层循环，内层循环涉及浮点数计算，试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了，看来问题并不在浮点计算。
$ v% C. N4 M0 T  \1 V% h( r
3 K" @0 {) x; \: b. X' E速度优化问题真的很有意思啊。
( c& o. N. |% s) M) k. _7 M
0 q* K3 q9 Y. [. L) b欢迎大家继续讨论
作者: 数值分析    时间: 2022-9-24 23:04
拉下来？拉多少？7 H0 A) O; G  K' A: c
把代码贴上来看看？
6 |- P& P& t: D4 f
/ z7 R, D$ L9 |2 t4 ^难道分支预测不准破坏流水线执行？不该啊。
作者: 沉宝    时间: 2022-9-24 23:15
会不会代码本身的缺陷阻止了自动优化？另外，硬件配置和开发环境可能也有关系。
作者: 风雨无阻    时间: 2022-9-24 23:33
Maybe Debug mode?
作者: 雷达    时间: 2022-9-24 23:54
本帖最后由 雷达 于 2022-9-24 23:57 编辑 + a; ]  _$ h: n# v/ L
数值分析 发表于 2022-9-24 23:04' w0 C$ e3 f/ n% Q, ~' R
拉下来？拉多少？
' m# O5 K4 t+ \把代码贴上来看看？
% N, _# x0 [" c4 G  m

; s1 L1 p$ R) evoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
1 \! R% |! Z8 c0 u5 E{
: r& H- \& A2 w6 u+ Y8 j# B        comp temp, xtimesy;3 L- {/ u: X- p4 S8 i' d5 g% L
        xtimesy.re = 0;9 C2 q8 ]( w* |1 b$ B) u/ ^2 C
        xtimesy.im = 0;
- U+ X' k- \# c( ?, |( g        int j0 = lenB - 1;4 x1 k3 E+ X/ y! b; t
        int    i, j, i1, reali;8 ~2 }- I. T, ?* E
        if (lenA % 2 == 1)9 |" \9 O1 c1 d+ ^
                reali = lenA + 1;& J# Y7 o; P, h4 R7 ]/ w) M
        else
: S+ K$ Q$ X) E                reali = lenA;3 M4 ]: Y: [( X
        reali /= 2;. y& g2 V8 N" K: n$ s
! q4 E. \5 A* f  p3 y; S: ]$ c
        int nconv = reali + lenB;9 D  F' B$ F  w# b
        //#pragma omp parallel for6 S$ o2 \& n% s4 r
        for (i = reali; i < nconv; i++)
, L1 [" l1 R) J/ @! e8 w        {
. `- N5 ^% Z$ o6 I# F, h6 A7 M                temp.re = 0;% Z* W' b7 ]3 v$ a. }. S& S) C
                temp.im = 0;
/ u5 Q0 ?8 i4 P8 H' C9 L  V8 U                i1 = i;9 w) s6 ]7 P* N# W, K
                for (j = j0; j >= 0; j--)6 j. J- E6 s- ~( c. w6 M5 [1 T2 p1 |1 n
                {
% Y* `/ V+ i! A                        /* floating date operation */
  i# y+ |" j$ z8 B                }
# {3 x' g1 b5 C' ?        }# J0 F  B6 I5 T0 v
}
0 l6 G; \# I4 ?* G2 `
1 _& C" T1 E9 n  z6 Ixcorr函数代码如上，comp是复数struct, 做过长度为11、19两个矢量的测试，和octave结果完全一样, @: Q+ r: B4 W4 U) U  w

! N# k* @5 Z7 o) R& S红色部分是内循环，现在其内部操作都comment out 了, j0大概是 6000。
4 L" N. P! m/ E5 u+ i现在call xcorr 100次，耗时78s.
4 [; l. y3 y( ]; @# ^( a. w) A4 Z, J  l% n, ~; b' a4 ]$ K
如果把红色部分内循环本身完全comment out， call xcorr 1000次，耗时 <1s. + h3 C8 k, t& W% t* X5 w( E. d
4 Q, C+ t* O- e
作者: 雷达    时间: 2022-9-25 00:17
风雨无阻 发表于 2022-9-24 23:33
/ t) c6 h$ Q1 L& SMaybe Debug mode?
9 }5 x. r! z. y, H0 D1 Y

& g% z' a; Q# W不应该，看我上面的回复。( p! k$ j' V: r: U/ P1 u" e

7 m- X' M$ U$ K$ X我更怀疑是 VS 社区版的问题
作者: 数值分析    时间: 2022-9-25 00:20
本帖最后由 数值分析 于 2022-9-25 00:24 编辑
6 I+ l+ F: c: f+ z& [7 T
雷达 发表于 2022-9-24 23:54
. S3 I4 h: r) ?void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB), L& _7 ^' E! `  f8 l+ N
{% B7 S& T2 Y! A( k% W4 ]: t1 \
        comp temp, xtimesy;

$ P" b+ d$ K- ], R# N3 S5 u! P: X8 c, `6 H9 c0 n5 L( L
这个不是这么比的吧。。。
' t' ~/ e" I" s0 G) |5 E
! s1 f1 V" U( Q$ e) r/ g* j您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。4 C* D+ x  H  u9 b# g9 h8 s! A0 r
3 q' }$ f/ M. _" _+ @# p; f3 r
而加上内循环，光jmp和dec指令就至少多执行了6000个，慢个几十倍不是正常的么？
作者: 雷达    时间: 2022-9-25 00:46
本帖最后由 雷达 于 2022-9-25 01:09 编辑
" f+ _3 W4 L, b) i
数值分析 发表于 2022-9-25 00:20
/ h# u& ]. T, B, |; I7 I这个不是这么比的吧。。。7 D+ G  }: Q. K9 G: D" w# a: A6 ~& i

' z0 S7 p5 W1 E& e3 _% e. o/ ~- Z您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。
) `/ ]/ x8 l9 N3 Y7 P& N

  H! h% G, }5 f2 V$ U! C有道理。
) l- _! G5 u( |6 v9 c所以存在内循环速度就上不去，把内循环取消，改成两个向量直接点乘再求和应该就会好得多，记得 numeric 库里有算向量内积的，我回头试试。
0 A4 j+ l' b4 i$ b8 g
9 I" ^8 l9 i, M3 L# L% k5 ?( k我先尝试尽量用标准库，一个小程序，不想搞得太复杂。多谢了
作者: 沉宝    时间: 2022-9-25 01:27
雷达 发表于 2022-9-25 00:46
9 Q$ q$ @0 _  t$ T" M' A有道理。
9 |  v6 b3 j6 t. E2 r1 c6 v所以存在内循环速度就上不去，把内循环取消，改成两个向量直接点乘再求和应该就会好得多，这大 ...

" z$ ~' ]( h' k# y9 b1 y你两个试验之间就差了一个空循环， call 1000次按理不会有秒级差异，可能还是编译器优化的问题。举个例子，把循环本身翻译成机器指令loop或dec/jnz，两者速度上会差很多' U, {, R0 O+ h0 k4 x
Why is the loop instruction slow? Couldn't Intel have implemented it efficiently?
作者: 沉宝    时间: 2022-9-25 01:48
数值分析 发表于 2022-9-25 00:20
8 g5 v) O; o2 N+ F$ r$ o) S  h这个不是这么比的吧。。。' t. ?- _8 z$ t
/ ~. y% j; y% n; v2 ?# Q3 w
您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。
而加上内循环，光jmp和dec指令就至少多执行了6000个
  _. R; B1 k5 O2 c1 z

+ P; E- t: L9 Z0 f! v6 L7 I现在的CPU，可以把判断、jmp和dec指令全部融合进一个µOp（微操作，CPU内部流水线上的执行单位）。如果循环这样跑，花不了多少时间。
作者: 数值分析    时间: 2022-9-25 02:06
本帖最后由 数值分析 于 2022-9-25 02:16 编辑
  F  _! f" h' G" [7 I# ]
沉宝 发表于 2022-9-25 01:48, R+ r$ a+ s; K9 H1 ]) g5 \) f: i
现在的CPU，可以把判断、jmp和dec指令全部融合进一个µOp（微操作，CPU内部流水线上的执行单位）。如果 ...

5 K" O9 u% Q  B+ p
2 P$ T" O# b9 }) s) c* s是的，兄台说的对。1 b8 \- j* y7 _# Y) p

1 F5 `+ f, k3 @& K其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。
: f$ J( Z, l# T( p+ Z" `! i1 T9 n; J, X) b$ H
雷达兄构造测试用例的时候，屏蔽掉了所有计算的部分，使得剩下的都是overhead，这样run time比较的结果就显得好像不合理了。如果把计算加回去，计算部分的run time会dominate，结果就不那么离谱了。因为不好说，所以用指令数对比的方式试图直观地说明这一点。7 ?0 r1 ]" t5 y" C/ d3 Z; ~

7 y; `+ M8 b2 C  N# C比如说，如果有计算，那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做，另一边是六千个循环，那六千个循环比什么都不做慢几十倍了，就不是那么不合理了。
  I3 k6 y0 B  H' r1 K% E) |  l: S0 S" \
当然也有可能像兄台说的，是优化参数的问题，但我觉得更多地是测试用例设计的不合理。
作者: 雷达    时间: 2022-9-25 04:47
本帖最后由 雷达 于 2022-9-25 04:49 编辑 1 \# E% |8 I6 h4 K
沉宝 发表于 2022-9-25 01:272 H" |3 }% ]" V5 v8 l! f9 L, T
你两个试验之间就差了一个空循环， call 1000次按理不会有秒级差异，可能还是编译器优化的问题。举个例子 ...

2 i- }$ y; w9 j  H4 V7 u8 r9 `- l
/ j% Y2 w) ]1 K- Y又写了个小实验，没有调用子函数，双层循环，外层6千次，内循环30万次空转，有或没有空转内循环，时间差一倍，我上面这个差的太多了。7 v) w& f: t  I4 F8 u3 _$ x9 t0 g
7 C, h, I4 j" j! _; p
我已经完全懵了。
作者: 沉宝    时间: 2022-9-25 05:51
雷达 发表于 2022-9-25 04:47/ w. j3 |5 P1 a2 d' }, [
又写了个小实验，没有调用子函数，双层循环，外层6千次，内循环30万次空转，有或没有空转内循环，时间差 ...

' n. }' Y1 t0 [5 u! ?" t9 @/ Q( W* n( v8 K时间差一倍的结果可以接受。
( `; g" H' W! [9 f$ h3 H
2 o* u$ \: s2 P- M5 k. e你还是用profile工具看看吧。现在大家都主观瞎猜。
作者: 数值分析    时间: 2022-9-25 14:58
本帖最后由 数值分析 于 2022-9-25 15:38 编辑 + s1 F  H2 y* R3 i6 |
雷达 发表于 2022-9-25 04:47' C4 q% M/ [( O# T
又写了个小实验，没有调用子函数，双层循环，外层6千次，内循环30万次空转，有或没有空转内循环，时间差 ...

+ i; a0 W  {, ], l% J0 V
' G% [! }* e5 y8 M6 f7 _' X6 ~9 O  A3 U" x- `
  q; \; t5 v2 @3 e3 ?
能不能把这个也贴上来，看看和上一个有什么不同？
作者: 雷达    时间: 2022-9-26 01:30
本帖最后由 雷达 于 2022-9-27 01:17 编辑 , V" p0 a1 T% X$ k. E) {
数值分析 发表于 2022-9-25 14:58, @( g2 ?) G4 i
能不能把这个也贴上来，看看和上一个有什么不同？

7 A6 M/ c, d+ \! J, u* F理了理思路，重新做了一个测试。
' F$ X% F% z, C7 ^, ?# G做了两个 vector 和 两个 float *, 都长 100000
, o  p) T, o5 q外循环 6000，里面先做随机数生成，模拟真实环境，避免数据的 cache.
  L+ N1 |/ V* V5 n9 c* h
2 y2 s. E: N! E- D2 ^内循环试了4种方法，
" F( y% o, E2 c2 S+ C5 B1. 直接调用 vector inner_product 247s
0 M, R; A1 {/ }2. vector 循环点乘累加 237s
) {7 ~; C1 j' I4 g3. float * 循环点乘累加 204s
" o! p0 j% C- T4. 空循环 100000 次 202s
3 e+ \8 o! p9 j
& }! F2 a7 B% \' t3 _不做内循环 200s
4 ?& A, g* z# G. P) [( f# s% s- l9 X' F0 U
你昨天说的对，内循环本身占比是很小的，大头在其他处理。7 {2 M( ~) s/ f7 q: g9 n$ L0 U
另外可以看到， float * 循环点乘累加 并不差，比用vector 还更快。3 I1 G; G. {8 \- g9 d9 p

: M- E* k; W  w4 i至于我那个原始程序，还有一些疑问，见5楼，其他都不变仅仅是有无空的内循环就有很大不同，这是不对的，也许有一些其他缺陷我没有看到。（也许可以改成 while 试试）
6 i+ J6 S1 J" B$ s4 u
& w- Z6 j& Q0 ]7 R. g- V（为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ？方括号 i 消失了。 LOL . 改成  jj 好了，原来 方括号里的 i 是斜体标志  LOL）
( B" k5 s! U/ y/ R9 K
' O1 f3 y% |; n# d' ~( O
        std::vector < float > vec1(N);/ d, {# B% _7 k/ O6 P
        std::vector < float > vec2(N);1 Y$ ^" V" V# }+ n3 v  R7 Q" m
        float* b1 = new float[N];
" n7 j' b2 k$ n8 e) b. Q        float* b2 = new float[N];1 n4 q: p, i6 |  p1 ~( d% G* l

7 L' o, j8 ~, A, p% {" P        for (int j = 0; j < 6000; j++)7 Q3 i) u5 K* S. y7 N9 N! D2 S6 y
        {
( K$ b1 i3 e3 F3 j  N0 A. J                std::generate(vec1.begin(), vec1.end(), []() {
- p. j# _. r. N7 H8 @                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;
3 V0 Q6 t) w, K, z/ [7 p                        });! \+ H6 h! _; J9 e( K4 _

7 @- y) s( M9 p. ~4 P" ~                std::generate(vec2.begin(), vec2.end(), []() {
3 L+ Q# y- K  x                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;
- O1 @1 z# {/ ~7 _! q  \                        });# v% d/ m* r3 c+ ]# h+ R. n8 m$ r* J" @
$ k8 N; _4 b2 K6 T, s* I& q7 ?
                for (size_t jj = 0; jj < vec1.size(); jj++)
+ q4 Z& y$ [( q3 U% E                {
4 j' B7 M9 |4 {2 h% g" Q1 \+ ]" E                        b1[jj] = vec1[jj];6 N( A- q( P0 T# W: E
                }- A4 o# G# h+ _" ]' c

* S" N0 \6 C* A4 G. X$ S8 W9 x2 |) H4 R                for (size_t jj = 0; jj < vec2.size(); jj++)$ l6 C6 Z: q5 W3 a9 E
                {' C7 }' Y- Z! V* T$ t
                        b2[jj] = vec2[jj];
" r3 j* ~  A# K- G. C8 y                }
3 D; u5 b6 A4 ^1 o6 g* m5 U* |. z6 [. ~/ `0 _0 W
                //Method - 1  N=100000 247s  
- K1 O. p+ E& H  g                //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);& `+ _0 z$ A& D. c! q+ L
                                
: y3 e% O0 G+ B# e  k# q3 f$ S1 n                //Method - 2  N=100000  237s" d7 q& S6 s7 R
                /*
: b! g  Z* P) W4 e2 b3 V' b1 d! M% q                for (int jj = 0; jj < N ; jj++)9 F! k7 [5 c' z  |5 w
                {9 f' r0 T5 H+ g  f% @" J# D: [
                        fresult += vec1[jj] * vec2[jj];8 Y; b. V; k6 u, }0 F3 V, W3 ?$ L* N
                }
+ G. l7 O% k8 @+ b# y7 ~6 ~% N; E                */: z4 g6 c1 b  {* X2 {6 x
                                
% j9 |$ m/ I# u" R( @8 c                //Method - 3  N=100000 204s
/ {! d$ d6 ?1 N/ O  ]* ~, n                /*9 g. B# c/ J" f, x
                for (int jj = 0; jj < N; jj++)
2 {1 Q+ W$ L5 {3 t# l' a0 B' ]                {
9 H1 n( `( {: c: U" w                        fresult += b1[jj] * b2[jj];# W; L$ d1 I/ h5 W0 @" T
                }, |2 n: v* p7 J6 p
                */
. L: j! L4 V1 N
2 R8 h3 ?& ]4 @+ \  I7 @                //Method - 4   202s  [  T  X! b- b# r8 f! _& O% B9 i
                /*
* k! h0 Z* `3 k; q0 ~; c4 F                for (int jj = 0; jj < N; jj++)9 q" Q( C' X  ~% Z1 P4 Q$ L3 I
                {
' l$ n( R# j; F/ a                        
0 z0 h$ E9 b$ @- e& n                }
9 y+ ?$ t" x; v/ [# e3 d) o8 u                */
6 }6 f% {  \  Y4 v8 x4 F                //comment out all methods, N=100000  202s                1 b$ b3 t1 l: g2 d% v1 ]# U# ]
        }
1 ?4 {6 q8 v& M0 D; K
7 G8 p8 x# o4 a. j4 a        delete []b1;( i2 \) ]4 }4 Z) P2 T* Z
        delete []b2;

. X. a/ t  N( I$ ]
作者: 机器猫    时间: 2022-9-27 00:15
瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同？- i+ v5 B$ A" D- o) q; z+ H1 v

" Q: g% |) n1 [) k2 \; F3 x你第二个试验里面的j在循环里面又重新定义了啊，你确定真的跑了6000次？; y) P& ]+ U3 G* Q* _
作者: 雷达    时间: 2022-9-27 01:16
机器猫 发表于 2022-9-27 00:155 C# l- i* N9 U/ l
瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同？. p- u# c# d8 f% ?
. n9 T* S; A+ y- U/ h! `
你第二个试验里面的j在循环里面又重新定义 ...
4 _- {4 w7 I: N: v! n, p6 g
内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
# P- J+ k/ l, g5 w0 a; w$ P7 ]* M4 \$ B$ I9 ]) K6 ~2 ~  o
不和它较劲了，瞎耽误工夫，我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。
作者: 机器猫    时间: 2022-9-27 02:06
雷达 发表于 2022-9-27 01:16& U* \$ V* Z0 {6 e" ~4 J3 d
内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL# \2 f" c' n2 }: S  F. p: t! r& ~# }

0 P+ ?" m2 C4 m  y; g. M不和它 ...
7 i2 f2 R* f2 z( t- {( [/ ?8 P! F
( w- q$ f7 M6 _7 }* t6 w5 ]
不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的，很有可能是在stack上，这样内存读写会更多，要是再碰上每次都需要加载cache就更慢了。% g& D' l5 ]( F+ ]8 y, K+ e
后面一个是在循环那里定义的，说不定编译器就把它优化成register变量了
作者: opensrc    时间: 2022-9-27 07:25
一个无关问题，为什么爱坛的帖子里在我这里有好些奇怪的东东在里面，是防拷贝措施吗？
作者: 雷声    时间: 2022-9-27 20:29
雷达 发表于 2022-9-24 23:54% W  E7 |5 S& a8 Q. {3 y
void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
) j( |8 B1 W/ l( U& ?{9 J; ~: U) _# H" V% a! h
        comp temp, xtimesy;
! J; `( y' x' e- C* Z
这个code里面如果Openmp没有被注释掉的话，那么temp那个变量应该是定义在循环里面，否则线程之间会存在争夺写入那个temp的风险。
9 J: K( `& h8 l! x+ k+ d; y* d内层for循环如果没有内部操作的话，编译时应该被优化掉了，和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化？
* _" G* T& v# O3 WVS社区版没有问题，我工作用的就是社区版，设置正常的话不会比商业版差。以前游说头头用Intel Compiler，他说不想花钱，而且差不了多少，就一直用到现在。
作者: 雷声    时间: 2022-9-27 20:39
雷达 发表于 2022-9-26 01:30) N- E* ]( x, h; a8 X, V
理了理思路，重新做了一个测试。
- w& v. M! w. M做了两个 vector 和 两个 float *, 都长 100000+ Z( x( a2 F5 A) @& n
外循环 6000，里面先做随 ...
  |1 x. c4 D, G2 _# O
这个时间是从哪里开始算的？: a# r. a8 Z+ Y) T5 @' R3 Q
我怀疑这个200多秒里面有200秒花在产生随机数上了，真正计算大概只用了2秒， 用了vector那个因为有vector的额外开销，多了几十秒。
" q7 c1 k$ j5 O8 M5 J% N" ]按照两个10万个数字的相关计算的规模来估计的话，两秒都算很长很长了。这个结果真的很奇怪。
作者: 雷达    时间: 2022-9-27 22:41
雷声 发表于 2022-9-27 20:39
% r' B. |* m, B) h1 [这个时间是从哪里开始算的？
7 C0 z0 B4 f6 N) b0 Q我怀疑这个200多秒里面有200秒花在产生随机数上了，真正计算大概只用了2秒， ...

- P+ Z: e3 c5 k: N# E" v' F! u我不管它了，回头 linux 下换g++重新编译，顺便加上你们建议的向量化。
作者: 四处张望    时间: 2022-9-28 00:12
你这个循环主要的计算时间是那个rand，这个循环本身占用时间微乎其微。
* _; [" M" G% f# L+ J: M你的空循环，如果是现在的代码，编译器很可能完全不生成对应代码，因为没有任何输出或者修改变量，所以可以看到时间都是202S。你可以认为啥都不干的时间就是那么多。$ x1 A1 r" O3 u' [: w3 v' N
与此对应用数组（指针）花了2S6 C& w$ f5 a! U2 Q' V# I% F7 _
你用vec1[jj]*vec2[jj]理论上不应该差30多秒，这里很可能是你对vector的操作带来了内存操作，你可以试试把初始化挪出循环然后再比较，理论上vector的随机访问和数组应该几乎没什么区别。
作者: opensrc    时间: 2022-9-28 00:29
雷达 发表于 2022-9-24 23:54
" Q4 B1 o  |" Y0 _) K. Cvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
, o6 q0 C( [) {( w{) P% ?9 D. N) {8 n
        comp temp, xtimesy;

: p7 E, H5 q; ~! Z: u我有些迷糊，这样的code，难道不就应该时间差很多吗？也做了个简单的实验，你看看我做的有错吗8 J# b, h& b0 L( ]/ X6 ?
+ |$ o( y" ^9 l  N1 W4 D5 T3 Y( |
作者: 雷达    时间: 2022-9-28 00:49
opensrc 发表于 2022-9-28 00:29, m, i5 @  S2 S
我有些迷糊，这样的code，难道不就应该时间差很多吗？也做了个简单的实验，你看看我做的有错吗- Y4 K6 h; A1 I4 G. q. O8 k

9 ~9 v! U$ t: h5 }& Y8 x7 \/ Y ...

$ L  n  s' ]# `你是对的，是我搞错了。确实没有优化的情况下，空循环如果次数够长本来就应该耗时较大。我搞错的原因是在不自觉得与 octave 比较，而实际上 octave 是优化过的，和是不是空循环没关系，这种不同条件的比较是没意义的。
' G+ I! F. c9 T  K$ P. F$ F3 x  L0 O. K9 I3 ^3 m
雷声网友说的也对，空循环应该被编译器优化掉，我的编译器设置有问题。
作者: 雷达    时间: 2022-9-28 00:56
本帖最后由 雷达 于 2022-9-28 01:09 编辑
5 D4 O! e: W, m7 ?$ _3 h8 Z& y* ?  J% @4 \
是我自己的理解有误，没有优化的情况下，空循环如果次数够长本来就应该耗时较大。; d% T* H/ D  x1 j
有空时我会试试 SIMD和并行，看看能提高多少。
+ _9 ]8 ?* T* ^, T1 z' S过去7、8 年没有正经用C++ 写过东西，没有 sense 了 。
& ?8 {" }/ m: n, @谢谢大家的讨论，I learded a lot.  红包已发  ( u. d( `$ ?" }6 ~* {( i
% U7 o7 \, @; p" b/ ?
9 m9 d! e8 G% \! @+ ~4 O7 x
- v: M. Y$ e+ I6 d4 y, u
. N& Q- E% X8 a  e. b9 r




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