设为首页收藏本站

爱吱声

 找回密码
 注册
搜索
查看: 4606|回复: 25
打印 上一主题 下一主题

[信息技术] C++ 提速的新发现

[复制链接]
  • TA的每日心情
    擦汗
    2024-12-25 23:22
  • 签到天数: 1182 天

    [LV.10]大乘

    跳转到指定楼层
    楼主
     楼主| 发表于 2022-9-24 22:54:26 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
    C++ 比 Octave 慢好多,怎么破?( g# E0 c& A+ k

      |, ^+ \+ D' q自相关两层循环,内层循环涉及浮点数计算,试验了一下把内层循环内部全都 comment out 只留个壳子,  但空的内层循环本身就把速度拉下来了,看来问题并不在浮点计算。# C' K& |  p( ~5 W, t
    & `6 U3 l1 q3 X& \+ B2 r, x
    速度优化问题真的很有意思啊。
    ' A7 b+ K7 ^) _2 E9 R, z2 s
    , m$ @9 Z) [( G- x: u5 j欢迎大家继续讨论

    评分

    参与人数 2爱元 +8 收起 理由
    helloworld + 4
    住在乡下 + 4 涨姿势

    查看全部评分

  • TA的每日心情

    5 小时前
  • 签到天数: 1809 天

    [LV.Master]无

    沙发
    发表于 2022-9-24 23:04:16 | 只看该作者
    拉下来?拉多少?
    2 b. H6 o& `3 T- M) b5 ]把代码贴上来看看?
    ! \  d) R; r$ P
    1 u# z% t- G4 L- U. d$ t9 {9 ~难道分支预测不准破坏流水线执行?不该啊。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    板凳
    发表于 2022-9-24 23:15:41 | 只看该作者
    会不会代码本身的缺陷阻止了自动优化?另外,硬件配置和开发环境可能也有关系。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    2024-4-22 03:36
  • 签到天数: 120 天

    [LV.7]分神

    地板
    发表于 2022-9-24 23:33:02 | 只看该作者
    Maybe Debug mode?
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    擦汗
    2024-12-25 23:22
  • 签到天数: 1182 天

    [LV.10]大乘

    5#
     楼主| 发表于 2022-9-24 23:54:10 | 只看该作者
    本帖最后由 雷达 于 2022-9-24 23:57 编辑
    4 Q& ]8 }$ {4 D1 Q1 R
    数值分析 发表于 2022-9-24 23:04( F) P0 G! q* o/ ]1 p
    拉下来?拉多少?2 j; D) k5 O% @- b5 U' R# V4 t- Z- u
    把代码贴上来看看?
    + R, ?( M+ u( @8 [" h
    % {7 {7 p8 B9 `
    void xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)" b  F3 o  X- T' l/ U# a
    {+ J1 g1 y/ {' K0 J; ?
            comp temp, xtimesy;/ n1 t6 a9 W) F
            xtimesy.re = 0;. P/ h) [! r( W' o5 z1 J
            xtimesy.im = 0;2 \9 ]4 U2 C- ]* D7 I6 q
            int j0 = lenB - 1;1 S& l3 ^5 }8 e
            int    i, j, i1, reali;7 r8 q$ G+ E1 O& h( y( f* H
            if (lenA % 2 == 1)4 x: y$ t' m; t. W. T  j
                    reali = lenA + 1;
    $ \3 B5 ]2 z2 p/ _        else
    2 H1 u& ?  W, d. `& f/ L$ M, K* E                reali = lenA;* v6 Z3 [& L! |/ m2 Z3 Z4 M/ \. n  B
            reali /= 2;
    1 l% U1 x4 Y8 |# O
    : s+ s' E/ f0 K9 a  m6 @3 }        int nconv = reali + lenB;
    0 @% c2 e, x* m: c4 p/ B        //#pragma omp parallel for
    , t9 I4 H% ?& z: Q0 M        for (i = reali; i < nconv; i++)
    4 Z5 W! w$ d% t* p' Y        {$ C& }  Z* E) X/ L# k
                    temp.re = 0;
    7 d: v5 O  F; t- v+ y                temp.im = 0;
    - p: M/ y) F0 V: n                i1 = i;
    . H4 n5 V. |7 E- O; H: q0 Y                for (j = j0; j >= 0; j--): m" d2 Z! G' u9 s6 V; T
                    {* x- o1 I+ F% s8 ?/ u9 _
                            /* floating date operation */) c1 P- ~- u. s8 X; o3 w+ M3 C0 u
                    }
    8 o3 S; T. a; F# z( e/ S
            }- _$ Q& U. ?8 \( ]4 g
    }5 q3 k1 j) f$ Z3 W0 g2 ]
    4 o; y8 v# |) z& I" }: T6 }" p. t
    xcorr函数代码如上,comp是复数struct, 做过长度为11、19两个矢量的测试,和octave结果完全一样
    7 [4 \8 P8 {) F  Z& T
    9 d& P" u; ]% y+ J$ Z6 {/ Y红色部分是内循环,现在其内部操作都comment out 了, j0大概是 6000。
    ( q3 H. V2 [  B* k+ z2 w5 n现在call xcorr 100次,耗时78s./ A2 t) k4 n+ E5 A5 }

    $ b5 D8 D7 l5 H& w$ h3 r如果把红色部分内循环本身完全comment out, call xcorr 1000次,耗时 <1s.
    & z: j4 X& r1 d+ |* [" P& h* z2 q1 s8 J. ?  }
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    擦汗
    2024-12-25 23:22
  • 签到天数: 1182 天

    [LV.10]大乘

    6#
     楼主| 发表于 2022-9-25 00:17:17 | 只看该作者
    风雨无阻 发表于 2022-9-24 23:33" G- [) |: D+ `& a
    Maybe Debug mode?

    , R! s! V) C8 G
    ( y+ B# R: }, Z8 w: m8 q0 s不应该,看我上面的回复。
    # n& g: L4 s1 X" h- P% ^1 B7 \* ?4 Q, z- C9 @
    我更怀疑是 VS 社区版的问题
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    5 小时前
  • 签到天数: 1809 天

    [LV.Master]无

    7#
    发表于 2022-9-25 00:20:10 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 00:24 编辑
    & N/ r& {( `8 X; T8 g2 [8 d
    雷达 发表于 2022-9-24 23:54
      j! J7 \/ y9 Svoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)
    ; k6 j- w, L/ h/ e{" V! H3 P; F  O( O% z  ?
            comp temp, xtimesy;

    3 \$ x/ G9 J; K% [7 d4 s
    % b  ]5 b9 @/ f0 @* \8 V. C- o这个不是这么比的吧。。。% v& d3 N" T( D
    - s; F& R' b$ n, I1 O* T
    您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。5 J& k2 O, Z% o) g/ v: p7 q
    ' y4 X, C8 o' h" n; W/ d9 Q
    而加上内循环,光jmp和dec指令就至少多执行了6000个,慢个几十倍不是正常的么?
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    擦汗
    2024-12-25 23:22
  • 签到天数: 1182 天

    [LV.10]大乘

    8#
     楼主| 发表于 2022-9-25 00:46:56 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 01:09 编辑 , {: ?: Z6 z) n& i$ c
    数值分析 发表于 2022-9-25 00:20/ @: P* `7 L% k" H$ ?
    这个不是这么比的吧。。。
    : \* T2 C9 }& K9 _0 N1 d
    5 B4 Y  z( t: G) a* M您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    * V- ]8 C- o' z& s, R& Q- Q8 N

    " z* ]) V/ z- T0 g7 z有道理。
    ) W& @, Y; D% V6 E! ^8 ]+ q所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,记得 numeric 库里有算向量内积的,我回头试试。
    9 S3 Y5 k  N& F; j! v! f
    ! ]: A) I1 S6 B我先尝试尽量用标准库,一个小程序,不想搞得太复杂。多谢了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    9#
    发表于 2022-9-25 01:27:53 | 只看该作者
    雷达 发表于 2022-9-25 00:465 {6 c0 _4 J$ I5 V# S
    有道理。: C0 t4 u5 \- Z4 C) a  j: t$ J
    所以存在内循环速度就上不去,把内循环取消,改成两个向量直接点乘再求和应该就会好得多,这大 ...

    + X$ x, e# ]/ t$ M你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子,把循环本身翻译成机器指令loop或dec/jnz,两者速度上会差很多& c1 G$ t- P% E, `) \8 `  v7 A, D
    Why is the loop instruction slow? Couldn't Intel have implemented it efficiently?
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    10#
    发表于 2022-9-25 01:48:51 | 只看该作者
    数值分析 发表于 2022-9-25 00:20
      S, T; N/ M& v这个不是这么比的吧。。。
    , r- d7 b3 m  @& \: j
    $ K6 M" _% `8 E- X您这个函数,不带内循环的话,汇编完总共操作也没几个(不到100个)。
    而加上内循环,光jmp和dec指令就至少多执行了6000个
    2 u* g3 o* Y. j' G+ q( a2 Z

    6 @, Y; v! b5 F1 [5 v  k8 r# c$ r# D6 W现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果循环这样跑,花不了多少时间。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    5 小时前
  • 签到天数: 1809 天

    [LV.Master]无

    11#
    发表于 2022-9-25 02:06:44 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 02:16 编辑 ) W6 l! ~2 \7 e5 {; `5 I/ N# ]' K* n
    沉宝 发表于 2022-9-25 01:48
    1 R" o& k# m- `4 ~现在的CPU,可以把判断、jmp和dec指令全部融合进一个µOp(微操作,CPU内部流水线上的执行单位)。如果 ...
    3 ]" v4 S! O5 Z) o, @; h6 ~. K

    : D  [' t) ^9 Q* [! V/ R  w是的,兄台说的对。
    4 q' q/ G* h7 Z: t5 K  l# ?" J, ~8 ~1 G( L2 k1 U
    其实我想说的是 真正数值计算部分和代码中其他不直接计算的overhead的比值这个事儿。& z. \- Q% t# I) {2 i

    , ^5 _+ n  }! n+ U6 [: k0 p雷达兄构造测试用例的时候,屏蔽掉了所有计算的部分,使得剩下的都是overhead,这样run time比较的结果就显得好像不合理了。如果把计算加回去,计算部分的run time会dominate,结果就不那么离谱了。因为不好说,所以用指令数对比的方式试图直观地说明这一点。$ U1 H& z8 b( n( w( m( p% }/ c* f$ G

    ) n) {4 Q% v+ f. e8 i4 p( E比如说,如果有计算,那么跑六千个循环相对于计算应该用不了多少时间。但是如果一边是什么都不做,另一边是六千个循环,那六千个循环比什么都不做慢几十倍了,就不是那么不合理了。
    ; }- ?7 s& A! f' I" r: O: v; U; A% G- _# [6 ^2 _! c  o+ `* I
    当然也有可能像兄台说的,是优化参数的问题,但我觉得更多地是测试用例设计的不合理。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    擦汗
    2024-12-25 23:22
  • 签到天数: 1182 天

    [LV.10]大乘

    12#
     楼主| 发表于 2022-9-25 04:47:43 | 只看该作者
    本帖最后由 雷达 于 2022-9-25 04:49 编辑
    / s5 V/ \$ w6 O
    沉宝 发表于 2022-9-25 01:27
    ) ~7 [2 @# N( `3 k1 B/ ^; ~' P& B你两个试验之间就差了一个空循环, call 1000次按理不会有秒级差异,可能还是编译器优化的问题。举个例子 ...
    , F, I1 V7 m2 P0 C

    : K  s% i0 q* F+ Y又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差一倍,我上面这个差的太多了。
    + q: [0 a  ]) i7 {: p  L2 O' L
    1 n& }/ B7 @  A" e, {0 v我已经完全懵了。
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    13#
    发表于 2022-9-25 05:51:23 | 只看该作者
    雷达 发表于 2022-9-25 04:47# K1 E8 S3 Y% T9 Y
    又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...

    8 o* a  M5 Q6 m时间差一倍的结果可以接受。7 x+ q8 F3 t% l2 |1 ~
    ' x3 R$ ]+ W, c; b" e/ Y- X
    你还是用profile工具看看吧。现在大家都主观瞎猜。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    5 小时前
  • 签到天数: 1809 天

    [LV.Master]无

    14#
    发表于 2022-9-25 14:58:59 | 只看该作者
    本帖最后由 数值分析 于 2022-9-25 15:38 编辑
    9 L$ ~- [; [7 b
    雷达 发表于 2022-9-25 04:47
    . X7 v# n+ w" u* S( e0 }又写了个小实验,没有调用子函数,双层循环,外层6千次,内循环30万次空转,有或没有空转内循环,时间差 ...
    5 X8 D3 O  Q! V8 B* y
    $ [$ t2 G  H  x. S

    & d6 v: S) c  i( ]
    % s2 p) v% Q, P) E, n" X& f( T能不能把这个也贴上来,看看和上一个有什么不同?
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    擦汗
    2024-12-25 23:22
  • 签到天数: 1182 天

    [LV.10]大乘

    15#
     楼主| 发表于 2022-9-26 01:30:03 | 只看该作者
    本帖最后由 雷达 于 2022-9-27 01:17 编辑
    & _1 T9 j# ~$ ]
    数值分析 发表于 2022-9-25 14:586 F% E. A4 b0 n  Q" q+ N
    能不能把这个也贴上来,看看和上一个有什么不同?

    ! u& H! {8 o& ~# E3 _5 ?6 D理了理思路,重新做了一个测试。; |' K# J1 u" g/ D' ]. W5 \! H
    做了两个 vector 和 两个 float *, 都长 100000! ^; F) N6 }7 G
    外循环 6000,里面先做随机数生成,模拟真实环境,避免数据的 cache.
    + V! w! p# Y6 Z! t6 R2 J8 H6 D$ Y9 ?. C; c$ [0 _0 B
    内循环试了4种方法,
    , ^" y+ t" I$ R4 N$ P/ C7 t& J1. 直接调用 vector inner_product 247s 8 v1 E" I, }+ z+ e# c2 X! z! L( i
    2. vector 循环点乘累加 237s8 f- A& c! b' L9 A( v5 M
    3. float * 循环点乘累加 204s: y. c3 n& l  o# W) M9 b+ r( }6 \
    4. 空循环 100000 次 202s
    ( f( p' W. M- ?1 h% w
    6 U( F! p# t  f( `不做内循环 200s
      [7 J8 c, z) X% R3 {" Z
    , T8 C) e  D: |+ T. }, A! @你昨天说的对,内循环本身占比是很小的,大头在其他处理。
    4 i. Y/ u2 V; F  N' s: T5 S另外可以看到, float * 循环点乘累加 并不差,比用vector 还更快。
    9 X! R: \; I+ v: }/ h
    - [: x: b. f- D& U至于我那个原始程序,还有一些疑问,见5楼,其他都不变仅仅是有无空的内循环就有很大不同,这是不对的,也许有一些其他缺陷我没有看到。(也许可以改成 while 试试)' ]' k4 F" P7 Y8 d$ I

    / T" L( Z8 v+ D6 I3 \, m4 m3 h(为什么下面我贴的  b1 加 方括号里的 i , 显示出来却是 b1 ?方括号 i 消失了。 LOL . 改成  jj 好了,原来 方括号里的 i 是斜体标志  LOL)/ W6 O* \( ]9 `9 v8 C$ o9 B. Q+ K6 G

    . c' F  ?, y4 c, U
            std::vector < float > vec1(N);
    4 W% E; B' n, Z4 \* o$ ]# Y& F2 G        std::vector < float > vec2(N);
    & z5 }: S7 w) Z/ K        float* b1 = new float[N];
    - L& j- ~6 Y% B/ [- ^- d1 ]        float* b2 = new float[N];
    + _' U6 }/ ?7 r* {/ q3 z2 ]* U) P1 s& ]! T- i6 B
            for (int j = 0; j < 6000; j++)  @! k2 l9 Q/ P' b. D9 L
            {' }! T/ i4 ?; o
                    std::generate(vec1.begin(), vec1.end(), []() {0 f! J  @2 p6 \3 o0 e
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 23.23));;
    . y( T# A# Q! b/ t# p                        });
    9 S1 c# q  ~6 v2 d# s
    4 _2 b2 x5 B  D0 J                std::generate(vec2.begin(), vec2.end(), []() {1 E0 W+ [: n  Q: W6 z
                            return static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 24.31));;
    2 Q2 s% s6 \( T6 O: W/ N/ e                        });
    & r% D2 E2 N7 z6 T/ _8 {3 ]" ~. H5 `; P6 l1 }+ i( x  N
                    for (size_t jj = 0; jj < vec1.size(); jj++)' Y. ~2 {* n$ Y, ?( u
                    {+ @) v* V0 }% _, O+ \1 b- o1 T
                            b1[jj] = vec1[jj];5 X* A: T* }& ]- M
                    }
    ' z5 f* X+ T: F$ i8 \
    ( v" \2 O- _0 U9 {/ \- p                for (size_t jj = 0; jj < vec2.size(); jj++)' C: P- N9 W4 m! z5 ?9 R5 ~, R
                    {
    9 f' ]. E! S3 e/ U. f! V                        b2[jj] = vec2[jj];
    ; I. K. ~- ?' g9 h                }
    ( R4 `, ^; V5 l" x1 Y" m) `  p6 c1 F% G. [
                    //Method - 1  N=100000 247s  
    9 c! G. C) c/ H( w& Y                //fresult = inner_product(vec1.begin(), vec1.end(), vec2.begin(), 0);5 L( L# P& O& g! j6 R
                                    
    ! `; r& m7 }! W+ S                //Method - 2  N=100000  237s8 j& [8 h6 _5 F$ H' v) O9 `
                    /*
    / b* t6 O" `+ D, `+ P& O' z                for (int jj = 0; jj < N ; jj++)
    ; }. o7 N0 H; h# u                {
    9 [- z; l3 l: x3 _* n( c  {! p                        fresult += vec1[jj] * vec2[jj];$ @& b1 i4 A% }9 k6 ]5 ]! F
                    }# k0 a' o; e- p  N7 J  w
                    */
    ( U# A6 G' \! M, E" h/ I3 h( I' @                                
    . ]! |7 ^5 F& Q% }4 W# z                //Method - 3  N=100000 204s( K# o2 o' i% n
                    /*
    * v) U# q) T% A& o4 m. d                for (int jj = 0; jj < N; jj++)) `1 ?. J7 O0 F7 \
                    {
    . o( A3 d$ S: ]+ o' v+ h: D3 s                        fresult += b1[jj] * b2[jj];
    7 |" F# w! r9 V( y; q                }
    ( X: s) ~! B$ ~                */* V" B7 @  R! a4 w
    6 O: \' {! b! Q& G; k
                    //Method - 4   202s7 _2 X0 Z% ]% T# c+ R- K
                    /*
    / M8 I- \5 `# c& T2 a5 z                for (int jj = 0; jj < N; jj++)" J  q3 a# Y7 a# _
                    {& G2 d2 s( }4 ~
                            
    * q1 |4 l1 \- @                }
    ' P3 H- [  h" U8 B, n                */1 T/ x1 E" F6 \0 D
                    //comment out all methods, N=100000  202s                . Z$ y3 Z3 R' s  @9 E. z
            }
    0 s. z( T* v3 X* d: M6 q! t
    3 H" |# {6 G7 \        delete []b1;/ c. M, N2 I" E
            delete []b2;

    0 W' Q% B+ C$ M# ?
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    奋斗
    2020-2-8 10:08
  • 签到天数: 2 天

    [LV.1]炼气

    16#
    发表于 2022-9-27 00:15:38 | 只看该作者
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?
    " }+ q' z( |# j; i( d: a% y5 `* x3 Q$ @; @1 ?$ P
    你第二个试验里面的j在循环里面又重新定义了啊,你确定真的跑了6000次?
    8 k9 |1 W# ~% D0 R8 c/ O4 K) v: p2 z
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    擦汗
    2024-12-25 23:22
  • 签到天数: 1182 天

    [LV.10]大乘

    17#
     楼主| 发表于 2022-9-27 01:16:03 | 只看该作者
    机器猫 发表于 2022-9-27 00:153 Y9 b0 o8 ^. B
    瞎猜一下啊。把第一个的那个j定义成register变量会不会有不同?: g/ j! a! U* r4 \- \
    % h; F+ I$ A  q  \" y0 s
    你第二个试验里面的j在循环里面又重新定义 ...

    " j& D9 i; ~# D内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL) S5 V$ t3 W( G$ {  ?8 l; K

    $ ?" V! G! p- D不和它较劲了,瞎耽误工夫,我已经转到 ubuntu, 也准备顺便试试 avx2 向量化。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    奋斗
    2020-2-8 10:08
  • 签到天数: 2 天

    [LV.1]炼气

    18#
    发表于 2022-9-27 02:06:58 | 只看该作者
    雷达 发表于 2022-9-27 01:16' J- C3 x  v/ L' j9 b
    内循环里面的 j 实际是 i, 为了规避爱坛显示的冲突帖子里临时改成了j, 现在是 jj 了。好累 、LOL
    - C# q: P" I: o! \2 u9 J& A
    " u( f4 B" Z5 [  U9 a0 |不和它 ...
    2 ?; s. Y; G) D, ]# t& b9 A
    ' l+ R' w0 x* K  `
    不过可以试试我说的register变量。前一个试验j是混在一堆其它变量里一起定义的,很有可能是在stack上,这样内存读写会更多,要是再碰上每次都需要加载cache就更慢了。
    7 ^4 h! x8 G, u# B后面一个是在循环那里定义的,说不定编译器就把它优化成register变量了
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    19#
    发表于 2022-9-27 07:25:57 | 只看该作者
    一个无关问题,为什么爱坛的帖子里在我这里有好些奇怪的东东在里面,是防拷贝措施吗?
    回复 支持 反对

    使用道具 举报

    该用户从未签到

    20#
    发表于 2022-9-27 20:29:50 | 只看该作者
    雷达 发表于 2022-9-24 23:54
    8 @  {0 x, T8 s: w) bvoid xcorr(comp* outcomp, comp* A, int lenA, comp* B, int lenB)% S# P5 g5 c, e% Y
    {( p& l; v! j2 H, i
            comp temp, xtimesy;
    & B3 o: H( P2 p
    这个code里面如果Openmp没有被注释掉的话,那么temp那个变量应该是定义在循环里面,否则线程之间会存在争夺写入那个temp的风险。
    8 c3 C; F7 n. ^# I1 Y6 g% s内层for循环如果没有内部操作的话,编译时应该被优化掉了,和你完全注册掉整个循环是一回事。可能你的编译设置没有打开优化?2 S/ ^( \0 w: J7 P, f5 z
    VS社区版没有问题,我工作用的就是社区版,设置正常的话不会比商业版差。以前游说头头用Intel Compiler,他说不想花钱,而且差不了多少,就一直用到现在。
    回复 支持 反对

    使用道具 举报

    手机版|小黑屋|Archiver|网站错误报告|爱吱声   

    GMT+8, 2025-2-19 06:16 , Processed in 0.043067 second(s), 19 queries , Gzip On.

    Powered by Discuz! X3.2

    © 2001-2013 Comsenz Inc.

    快速回复 返回顶部 返回列表