爱吱声

标题: C++ 提速的新发现 [打印本页]
作者: 雷达    时间: 2022-9-24 22:54
标题: C++ 提速的新发现
C++ 比 Octave 慢好多，怎么破？9 w0 m! G3 ^0 q8 y2 i! d1 S

  S; U0 v, h6 h  H. n8 R3 K自相关两层循环，内层循环涉及浮点数计算，试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了，看来问题并不在浮点计算。
" |/ n! U4 b% \$ S* O/ u" N
( }& @4 I, C7 h; n  b速度优化问题真的很有意思啊。) [. M0 c' H8 v+ m  }
! U( }% P" u# f+ f) E/ Q* f$ e
欢迎大家继续讨论
作者: 数值分析    时间: 2022-9-24 23:04
拉下来？拉多少？
; s, J3 Y  B! f% E3 w# n把代码贴上来看看？; B" \2 D/ `! B
8 l' v7 b- I/ w
难道分支预测不准破坏流水线执行？不该啊。
作者: 沉宝    时间: 2022-9-24 23:15
会不会代码本身的缺陷阻止了自动优化？另外，硬件配置和开发环境可能也有关系。
作者: 风雨无阻    时间: 2022-9-24 23:33
Maybe Debug mode?
作者: 雷达    时间: 2022-9-24 23:54
本帖最后由 雷达 于 2022-9-24 23:57 编辑
; ?2 o7 T4 F: J" o/ K$ ?; c
数值分析 发表于 2022-9-24 23:04
% R8 M. p/ Z# k8 C' H) d拉下来？拉多少？) @, H' [! ?. h+ C2 V2 e) D9 Q0 @/ D# B
把代码贴上来看看？

# M; R3 V+ P$ ~: `' \' g. G$ N! k4 o; l5 a5 n& v
void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)) s& ^( h1 S. C$ `5 y
{
, k. v9 I; I; @2 `5 B- V' A0 Q        comp temp, xtimesy;
7 |' s3 U6 _( J( S3 n( f. V, Y: O8 V$ `        xtimesy.re = 0;/ D/ Z1 s. W2 P5 q+ v! x4 |, G
        xtimesy.im = 0;
  \% g  [9 a- D        int j0 = lenB - 1;4 g* [. [: c* @: ?. i
        int    i, j, i1, reali;3 S3 ~. K& c4 Z
        if (lenA % 2 == 1)% v0 V8 {* ?# E5 a# Q' @; c7 D
                reali = lenA + 1;
. }4 G; N: ^8 J1 p4 w1 o1 ?        else
! g8 R$ H9 v0 @8 y: v5 u% N                reali = lenA;
& R* R0 l- O$ b" U8 `+ M        reali /= 2;
, M! i. c' L* Z# \9 _/ g8 {, x, [# S4 G+ ?
        int nconv = reali + lenB;) D" E6 m5 G, w
        //#pragma omp parallel for
( a1 S% p; X4 \) w+ m1 J  h' _4 u* Y        for (i = reali; i < nconv; i++)
, c+ x+ y) n& \+ D! h  f1 e        {# O/ z9 K; X# g2 j6 f0 c3 |4 W7 B
                temp.re = 0;% }; x5 b$ H; j! n+ f& d
                temp.im = 0;$ J* F7 ~0 g, T4 J- `2 ^
                i1 = i;
& g: H* Z7 Y1 ^& N8 |9 A                for (j = j0; j >= 0; j--)
, R8 C/ u5 t, m' W. w                {
  u+ E5 b- }9 W9 ~+ d; I$ z. k                        /* floating date operation */  q/ j4 C0 l5 j8 H
                }
) _1 z" o8 l) X        }, H9 B% p$ N, a0 w* K
}
  l/ ?* j; i5 G. Z" I. G% F& t1 u" Q: x
xcorr函数代码如上，comp是复数struct, 做过长度为11、19两个矢量的测试，和octave结果完全一样0 C$ U9 E2 E3 P8 D; @6 |- W
5 T# e, z7 Q5 i9 `
红色部分是内循环，现在其内部操作都comment out 了, j0大概是 6000。
* m8 F) S% V( c7 b' E  A2 {' N现在call xcorr 100次，耗时78s.6 s5 Y$ V. ?( \* E% ?: P
7 D3 k+ S! m( B: W8 p4 J
如果把红色部分内循环本身完全comment out， call xcorr 1000次，耗时 <1s.
# }0 ^! P) V7 ]6 V0 M" Y/ N3 I/ B- N0 d" n" _) E* {; [
作者: 雷达    时间: 2022-9-25 00:17
风雨无阻 发表于 2022-9-24 23:33; e4 L, K1 Z0 }; g% Z
Maybe Debug mode?

0 i% c# R& z  x- W0 H2 Z; @
8 A0 F$ F* w3 j0 }不应该，看我上面的回复。  }# {9 b/ p% K/ r: s2 N
4 }- B. o# Q5 t1 Z# P& O% x  d
我更怀疑是 VS 社区版的问题
作者: 数值分析    时间: 2022-9-25 00:20
本帖最后由 数值分析 于 2022-9-25 00:24 编辑
% H7 T4 k, m7 {3 I0 y
雷达 发表于 2022-9-24 23:54) O1 g8 A" z* M  m
void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
: v" A# X' {$ \! ^: `{& {1 R: P: M; N4 {1 o- Z
        comp temp, xtimesy;
$ T; N5 `/ k. V2 z
: z- y3 ~! z2 C6 }" p* y4 L
这个不是这么比的吧。。。
/ s' E" P5 l/ q: f% p! W) r2 I1 t: K
您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。
% b$ E8 O. N; W3 F- T# T6 T; \( k& b3 G
而加上内循环，光jmp和dec指令就至少多执行了6000个，慢个几十倍不是正常的么？
作者: 雷达    时间: 2022-9-25 00:46
本帖最后由 雷达 于 2022-9-25 01:09 编辑
, m: x$ X$ `: A8 }0 {8 U
数值分析 发表于 2022-9-25 00:201 K$ x' w& S/ {$ t, y
这个不是这么比的吧。。。- e1 s! @1 f! H

+ W1 Q9 _2 ]" Q您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。
$ X. F: X' k2 f. C. I) ^3 {
5 ]8 I1 s4 t) P
有道理。
0 a0 C) v# v% }2 }所以存在内循环速度就上不去，把内循环取消，改成两个向量直接点乘再求和应该就会好得多，记得 numeric 库里有算向量内积的，我回头试试。
* O; n& P* E2 S: _/ Z/ m7 f$ O! S% d9 Q5 ~, L5 w. ?, _
我先尝试尽量用标准库，一个小程序，不想搞得太复杂。多谢了
作者: 沉宝    时间: 2022-9-25 01:27
雷达 发表于 2022-9-25 00:46
" `8 v( Q9 L" H有道理。
0 t8 N9 d/ ^, V* o所以存在内循环速度就上不去，把内循环取消，改成两个向量直接点乘再求和应该就会好得多，这大 ...

- w$ Z: q/ k; g; Y# F你两个试验之间就差了一个空循环， call 1000次按理不会有秒级差异，可能还是编译器优化的问题。举个例子，把循环本身翻译成机器指令loop或dec/jnz，两者速度上会差很多$ o( R7 [* k" v8 Z
Why is the loop instruction slow? Couldn't Intel have implemented it efficiently?
作者: 沉宝    时间: 2022-9-25 01:48
数值分析 发表于 2022-9-25 00:20
) P) R  I, v6 w$ g这个不是这么比的吧。。。
6 n. Y8 @, ?/ M( W  z8 z
/ Q6 s1 u6 b9 ~* M& D; g您这个函数，不带内循环的话，汇编完总共操作也没几个（不到100个）。
而加上内循环，光jmp和dec指令就至少多执行了6000个
; P' ^3 X5 U* ]9 g
' x2 T- F6 p# f% g+ {( k
现在的CPU，可以把判断、jmp和dec指令全部融合进一个µOp（微操作，CPU内部流水线上的执行单位）。如果循环这样跑，花不了多少时间。
作者: 数值分析    时间: 2022-9-25 02:06
本帖最后由 数值分析 于 2022-9-25 02:16 编辑
3 o+ n: K. ?' d$ g, F8 q
沉宝 发表于 2022-9-25 01:486 v" w0 P  L( n- A$ c2 l
现在的CPU，可以把判断、jmp和dec指令全部融合进一个µOp（微操作，CPU内部流水线上的执行单位）。如果 ...

: R4 S& x& u! t5 H$ X) J2 ~4 d' @, ]' B& o) O
是的，兄台说的对。& Y! d% h4 h$ r& G3 D
! e( R2 p& F$ @- t# }$ M3 Z
其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。/ N5 I9 v9 X2 E& h
. y' T+ ~; {  R% `' w. H
雷达兄构造测试用例的时候，屏蔽掉了所有计算的部分，使得剩下的都是overhead，这样run time比较的结果就显得好像不合理了。如果把计算加回去，计算部分的run time会dominate，结果就不那么离谱了。因为不好说，所以用指令数对比的方式试图直观地说明这一点。: {* [: d; d, a+ W& D

% ]/ R" T5 W: @: T4 B) f6 l比如说，如果有计算，那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做，另一边是六千个循环，那六千个循环比什么都不做慢几十倍了，就不是那么不合理了。; @) r: h4 S9 I% M0 m

' Q- N- A  x. A当然也有可能像兄台说的，是优化参数的问题，但我觉得更多地是测试用例设计的不合理。
作者: 雷达    时间: 2022-9-25 04:47
本帖最后由 雷达 于 2022-9-25 04:49 编辑 2 Z* r0 b: y: P% ^
沉宝 发表于 2022-9-25 01:27
# U7 v, v8 @9 h6 P4 k; t- g你两个试验之间就差了一个空循环， call 1000次按理不会有秒级差异，可能还是编译器优化的问题。举个例子 ...

* X) F, g; W/ X' l4 D( M3 Y* W9 K. E: O/ y
又写了个小实验，没有调用子函数，双层循环，外层6千次，内循环30万次空转，有或没有空转内循环，时间差一倍，我上面这个差的太多了。# u1 V$ h  R: }9 n

7 W9 j  _+ ~& B7 [$ Q) k我已经完全懵了。
作者: 沉宝    时间: 2022-9-25 05:51
雷达 发表于 2022-9-25 04:47( H" L/ h. r: M) Q0 x5 i7 Z$ E
又写了个小实验，没有调用子函数，双层循环，外层6千次，内循环30万次空转，有或没有空转内循环，时间差 ...

9 E  c, |' e- ]; a/ E! j时间差一倍的结果可以接受。
- @3 v' l1 D8 {  n8 Z
- x5 K+ P& o( T+ Y你还是用profile工具看看吧。现在大家都主观瞎猜。
作者: 数值分析    时间: 2022-9-25 14:58
本帖最后由 数值分析 于 2022-9-25 15:38 编辑
1 y; j' d8 c# o" U
雷达 发表于 2022-9-25 04:475 K# e; ], ]+ |& F2 t
又写了个小实验，没有调用子函数，双层循环，外层6千次，内循环30万次空转，有或没有空转内循环，时间差 ...
# o9 V' |3 A" V; Z1 r3 O/ O

# h6 k. h; D, B" c# Q- x3 Z# O6 _  ^2 I8 t4 r5 V: h

# @( \" R1 E9 {  o' {7 r; P能不能把这个也贴上来，看看和上一个有什么不同？
作者: 雷达    时间: 2022-9-26 01:30
本帖最后由 雷达 于 2022-9-27 01:17 编辑
$ I$ H1 {8 D5 f0 ^
数值分析 发表于 2022-9-25 14:581 V0 x6 y$ h" n/ X( ]: R1 M2 P
能不能把这个也贴上来，看看和上一个有什么不同？

! O. B7 O: g; b0 n. v. p& {. J理了理思路，重新做了一个测试。( d" H8 z' o% h' n
做了两个 vector 和 两个 float *, 都长 1000006 y2 j, B- ^! R! H& t" V
外循环 6000，里面先做随机数生成，模拟真实环境，避免数据的 cache.
: M" x; a7 \5 |- q1 ?
( l$ D! F* g0 I7 M内循环试了4种方法，; Y) u% }2 f+ V" O" [
1. 直接调用 vector inner_product 247s $ z& }* R; Q* m. f) [8 g* e3 c! |
2. vector 循环点乘累加 237s* ?4 P; P' F0 @8 d) t
3. float * 循环点乘累加 204s
5 D, w5 A% ~5 K) P3 p% b4. 空循环 100000 次 202s
/ V' w/ _# J% Z
1 e( e8 t, K8 h, r( c3 a不做内循环 200s! M6 ~. D; I% l7 O" P# z
8 i$ ]0 ~, D0 I, F, F5 J1 Q; J
你昨天说的对，内循环本身占比是很小的，大头在其他处理。
/ b, U, ]) x/ z! h% w! ~3 t4 f另外可以看到， float * 循环点乘累加 并不差，比用vector 还更快。
( U1 W7 j2 L+ Z) L" c. |+ C7 O( z  X1 {/ L" w
至于我那个原始程序，还有一些疑问，见5楼，其他都不变仅仅是有无空的内循环就有很大不同，这是不对的，也许有一些其他缺陷我没有看到。（也许可以改成 while 试试）! F6 F2 z8 b$ u. g
! k; y% V3 I* Z- t# S
（为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ？方括号 i 消失了。 LOL . 改成  jj 好了，原来 方括号里的 i 是斜体标志  LOL）+ X3 l3 i; o' F: A

. X0 x3 _7 ^: N2 U% r& m
        std::vector < float > vec1(N);
0 E( n+ z" `0 i" F' h* c9 {2 f        std::vector < float > vec2(N);
, T' O9 u* r- [+ h: u( W        float* b1 = new float[N];# ^$ Q6 K3 I. f9 X0 c) w& g/ v/ K
        float* b2 = new float[N];
2 O3 i) T3 B- q0 a/ w/ x4 u; g
! t2 C& P% E/ w; |        for (int j = 0; j < 6000; j++)- e& C' L. j2 \& s" c& X
        {
* o1 B# b  S  l/ K6 t8 v6 e) U4 R                std::generate(vec1.begin(), vec1.end(), []() {
1 m' Y9 B$ a$ \! u5 s& a' ^/ R1 j                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;7 q3 \" \7 e: j; E/ }0 w  r3 y9 m+ }
                        });# d3 e) ~" L4 u! |
& A* y8 L2 x3 `7 }9 @. V
                std::generate(vec2.begin(), vec2.end(), []() {3 O: @2 _" |! V
                        return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;
7 [+ w  R1 ]- u                        });* j% L/ U6 h5 y" f6 e5 O
3 [5 G; F% L) E( k; `% F- r
                for (size_t jj = 0; jj < vec1.size(); jj++)5 R8 V7 j1 O3 w  W" w( e
                {
. t! W4 Y: A$ @1 w                        b1[jj] = vec1[jj];6 ]  r6 d: j. J2 j/ I3 m
                }
3 f( a  R) d/ F$ d- p8 C) L7 {) P5 w4 c; X
                for (size_t jj = 0; jj < vec2.size(); jj++)& }7 o# R: l9 r9 d
                {7 x( x* i. j6 ?; u: S3 P, ~  d  `
                        b2[jj] = vec2[jj];
; D6 a: r1 Z$ j6 m                }5 b$ Q+ B4 b5 K- s- }/ s
3 R- ?9 H$ c0 M/ M
                //Method - 1  N=100000 247s  ) s. p5 [2 }. p
                //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);) A3 @* O0 x! i) T
                                ' q8 L# j% _8 q2 B5 M
                //Method - 2  N=100000  237s
$ }, v- I+ v4 U0 b: ?                /*
- O! c7 K  y) c                for (int jj = 0; jj < N ; jj++)/ J/ m4 ~% s; i, B, G4 G
                {
6 B/ O: U& \. }9 ?4 x/ Y                        fresult += vec1[jj] * vec2[jj];2 G4 j# `' p! E) m) @% E7 I1 r; k
                }& L* V! v% C2 D4 S  t
                */
! x* j" e& `4 o                                
+ q- C% @# A" X5 `                //Method - 3  N=100000 204s
9 r9 [- G0 W1 D6 k" u                /*
/ u) D7 J9 ~$ @1 e0 E4 E/ X' I                for (int jj = 0; jj < N; jj++)1 s" {. l0 h" |/ {' f, Q" f
                {3 K& C4 V/ V, N
                        fresult += b1[jj] * b2[jj];
1 @' a/ D6 k  F2 o5 F2 G5 B* z                }
- g6 G5 u6 v7 D  f5 x9 O% @( ~2 Z7 B                */" Z* c: B8 f. o& K8 O

$ X1 b- ~2 p+ b, b                //Method - 4   202s
9 S/ B6 A# ^3 K: {                /*
2 [) X6 G$ k% o& @* h& D8 N                for (int jj = 0; jj < N; jj++)3 b- A( h; ?1 U/ L% q
                {
$ F8 {' E! m- \0 Y6 c                        
1 d7 K2 _4 \  d- ^' d, }) d                }
  |3 i5 L* o/ G9 l9 \* `9 h- \                */" T$ L  i! t) f, m0 H5 E1 s
                //comment out all methods, N=100000  202s               
; D+ {" R( N% R& i' k) u        }* C% k! [; O/ |6 G" I* i! W
& [: }" e# U, O
        delete []b1;
! r& s# A' U" P# m  O( o( d. E) k7 n        delete []b2;

4 K$ H5 @% D/ H$ |& d6 E9 u
作者: 机器猫    时间: 2022-9-27 00:15
瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同？- G' {% n2 P; c! z6 T  L. m3 R
! `/ ~* `4 I% A9 j6 L
你第二个试验里面的j在循环里面又重新定义了啊，你确定真的跑了6000次？( W# {2 ~# N/ e: L9 {3 I
作者: 雷达    时间: 2022-9-27 01:16
机器猫 发表于 2022-9-27 00:15
4 Y, m" @/ l. F/ ]' ^2 _瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同？
) m! F  W: t4 t' r- m4 M: X, ]( G3 k7 f  m
你第二个试验里面的j在循环里面又重新定义 ...
( `; a1 H: ~0 k+ J
内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL# B! M9 _- [- O8 w- \; \9 ^

. m2 _! D1 n0 H" S- G2 g不和它较劲了，瞎耽误工夫，我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。
作者: 机器猫    时间: 2022-9-27 02:06
雷达 发表于 2022-9-27 01:16, M* F# N9 V  o# P5 c. p/ G
内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL8 n8 ^4 ]3 @2 l2 A  }  x! M
3 O4 M* Q' c  T1 U
不和它 ...
, s' ^" r9 E0 C1 N# `/ T9 p# B

% P& E! O( D8 H  l% \; F不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的，很有可能是在stack上，这样内存读写会更多，要是再碰上每次都需要加载cache就更慢了。
8 j* a- o/ C1 s3 x后面一个是在循环那里定义的，说不定编译器就把它优化成register变量了
作者: opensrc    时间: 2022-9-27 07:25
一个无关问题，为什么爱坛的帖子里在我这里有好些奇怪的东东在里面，是防拷贝措施吗？
作者: 雷声    时间: 2022-9-27 20:29
雷达 发表于 2022-9-24 23:54
. v* O! B5 i2 e4 k$ pvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)( c- w9 `7 O) q9 J8 L6 D
{
) S' S: B, W6 F" `* P        comp temp, xtimesy;

' D5 J, Z: S3 t7 `这个code里面如果Openmp没有被注释掉的话，那么temp那个变量应该是定义在循环里面，否则线程之间会存在争夺写入那个temp的风险。* A/ m( ?/ \; E
内层for循环如果没有内部操作的话，编译时应该被优化掉了，和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化？6 C. E; X% j# F4 `
VS社区版没有问题，我工作用的就是社区版，设置正常的话不会比商业版差。以前游说头头用Intel Compiler，他说不想花钱，而且差不了多少，就一直用到现在。
作者: 雷声    时间: 2022-9-27 20:39
雷达 发表于 2022-9-26 01:30
6 u6 [2 z  r4 C4 }理了理思路，重新做了一个测试。
8 j6 N- P; j: _- o* }* E9 c做了两个 vector 和 两个 float *, 都长 100000
* o2 R0 X3 R; i% S外循环 6000，里面先做随 ...
9 Z- N) a& `/ U
这个时间是从哪里开始算的？- R! ^+ R& y( S1 V" p
我怀疑这个200多秒里面有200秒花在产生随机数上了，真正计算大概只用了2秒， 用了vector那个因为有vector的额外开销，多了几十秒。9 K! h& B& w0 b( z1 R( t
按照两个10万个数字的相关计算的规模来估计的话，两秒都算很长很长了。这个结果真的很奇怪。
作者: 雷达    时间: 2022-9-27 22:41
雷声 发表于 2022-9-27 20:390 p% \& ^/ x: q8 P
这个时间是从哪里开始算的？
6 |, x. \3 p) I. B# n我怀疑这个200多秒里面有200秒花在产生随机数上了，真正计算大概只用了2秒， ...

( O# O; N5 W+ b+ Z: Y9 I4 f; r我不管它了，回头 linux 下换g++重新编译，顺便加上你们建议的向量化。
作者: 四处张望    时间: 2022-9-28 00:12
你这个循环主要的计算时间是那个rand，这个循环本身占用时间微乎其微。
- W$ h! B* [1 o& k5 I* ^, A+ k" ]你的空循环，如果是现在的代码，编译器很可能完全不生成对应代码，因为没有任何输出或者修改变量，所以可以看到时间都是202S。你可以认为啥都不干的时间就是那么多。% u% e! m  V- s$ Z0 D7 U
与此对应用数组（指针）花了2S
, u1 g; X+ O7 s/ W/ d你用vec1[jj]*vec2[jj]理论上不应该差30多秒，这里很可能是你对vector的操作带来了内存操作，你可以试试把初始化挪出循环然后再比较，理论上vector的随机访问和数组应该几乎没什么区别。
作者: opensrc    时间: 2022-9-28 00:29
雷达 发表于 2022-9-24 23:54
3 b3 |. s1 R, mvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)( U# F- k: u  a' r) p" S0 t
{1 h  Y, M0 G5 D% r
        comp temp, xtimesy;
" Z* o" \7 i3 F. U$ a
我有些迷糊，这样的code，难道不就应该时间差很多吗？也做了个简单的实验，你看看我做的有错吗
" i  q  F7 U& }- Q+ z+ L5 A% y( d: v( n) l0 x2 C, M4 M
作者: 雷达    时间: 2022-9-28 00:49
opensrc 发表于 2022-9-28 00:29: E% z1 l0 _8 w. K
我有些迷糊，这样的code，难道不就应该时间差很多吗？也做了个简单的实验，你看看我做的有错吗
4 D# Y# Y' P3 q3 P1 W
) J9 g1 }# v( G: P5 d7 Z7 d' j ...
6 ^% s, A4 n" T6 O- D1 Q) [. E* h
你是对的，是我搞错了。确实没有优化的情况下，空循环如果次数够长本来就应该耗时较大。我搞错的原因是在不自觉得与 octave 比较，而实际上 octave 是优化过的，和是不是空循环没关系，这种不同条件的比较是没意义的。
+ R3 s! L( B' k0 M& l2 F
2 P; e7 n& F) U3 V* q  U) j雷声网友说的也对，空循环应该被编译器优化掉，我的编译器设置有问题。
作者: 雷达    时间: 2022-9-28 00:56
本帖最后由 雷达 于 2022-9-28 01:09 编辑
1 z$ Z: P* Y+ L
% _$ I$ P9 d" G8 T是我自己的理解有误，没有优化的情况下，空循环如果次数够长本来就应该耗时较大。
. w: D* R, W) k有空时我会试试 SIMD和并行，看看能提高多少。8 e9 a2 ^. d, e, k4 @
过去7、8 年没有正经用C++ 写过东西，没有 sense 了 。
/ C6 b4 W. g4 N5 i, B谢谢大家的讨论，I learded a lot.  红包已发  
! L2 s5 N) [2 v+ K9 d$ e: @5 M. U$ I* U+ j$ {0 u1 ?4 g9 ?# ^; _! |5 I+ K

# A- \, b9 Q  h$ x) x3 W8 z$ p# N* d" j. F# t+ m0 f. Z" _( _

, u( A7 f! e2 K1 w* y$ R* E# y  r



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